@coze/realtime-api
Version:
A powerful real-time communication SDK for voice interactions with Coze AI bots | 扣子官方实时通信 SDK，用于与 Coze AI bots 进行语音交互
1,401 lines • 5.45 MB
JavaScript
/*! For license information please see index.js.LICENSE.txt */
var __webpack_modules__ = {
"?e272": function() {
/* (ignored) */ },
"?5742": function() {
/* (ignored) */ },
"?9caf": function() {
/* (ignored) */ }
};
/************************************************************************/ // The module cache
var __webpack_module_cache__ = {};
// The require function
function __webpack_require__(moduleId) {
// Check if module is in cache
var cachedModule = __webpack_module_cache__[moduleId];
if (void 0 !== cachedModule) return cachedModule.exports;
// Create a new module (and put it into the cache)
var module = __webpack_module_cache__[moduleId] = {
exports: {}
};
// Execute the module function
__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
// Return the exports of the module
return module.exports;
}
/************************************************************************/ // webpack/runtime/define_property_getters
(()=>{
__webpack_require__.d = function(exports, definition) {
for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
enumerable: true,
get: definition[key]
});
};
})();
// webpack/runtime/global
(()=>{
__webpack_require__.g = function() {
if ('object' == typeof globalThis) return globalThis;
try {
return this || new Function('return this')();
} catch (e) {
if ('object' == typeof window) return window;
}
}();
})();
// webpack/runtime/has_own_property
(()=>{
__webpack_require__.o = function(obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop);
};
})();
// webpack/runtime/make_namespace_object
(()=>{
// define __esModule on exports
__webpack_require__.r = function(exports) {
if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
value: 'Module'
});
Object.defineProperty(exports, '__esModule', {
value: true
});
};
})();
/************************************************************************/ // NAMESPACE OBJECT: ../../common/temp/default/node_modules/.pnpm/axios@1.7.7_debug@4.3.7/node_modules/axios/lib/platform/common/utils.js
var common_utils_namespaceObject = {};
__webpack_require__.r(common_utils_namespaceObject);
__webpack_require__.d(common_utils_namespaceObject, {
hasBrowserEnv: ()=>hasBrowserEnv,
hasStandardBrowserEnv: ()=>hasStandardBrowserEnv,
hasStandardBrowserWebWorkerEnv: ()=>hasStandardBrowserWebWorkerEnv,
navigator: ()=>utils_navigator,
origin: ()=>origin
});
// NAMESPACE OBJECT: ./src/utils.ts
var src_utils_namespaceObject = {};
__webpack_require__.r(src_utils_namespaceObject);
__webpack_require__.d(src_utils_namespaceObject, {
checkDevicePermission: ()=>checkDevicePermission,
checkPermission: ()=>checkPermission,
getAudioDevices: ()=>getAudioDevices,
isScreenShareDevice: ()=>isScreenShareDevice,
isScreenShareSupported: ()=>isScreenShareSupported,
sleep: ()=>utils_sleep
});
function bind(fn, thisArg) {
return function() {
return fn.apply(thisArg, arguments);
};
}
// utils is a library of generic helper functions non-specific to axios
const { toString: utils_toString } = Object.prototype;
const { getPrototypeOf } = Object;
const kindOf = ((cache)=>(thing)=>{
const str = utils_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 an Array
*
* @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 null !== val && !isUndefined(val) && null !== val.constructor && !isUndefined(val.constructor) && isFunction(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;
result = 'undefined' != typeof ArrayBuffer && ArrayBuffer.isView ? ArrayBuffer.isView(val) : 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 = 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)=>null !== thing && 'object' == typeof thing;
/**
* 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)=>true === thing || false === thing;
/**
* 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 ('object' !== kindOf(val)) return false;
const prototype = getPrototypeOf(val);
return (null === prototype || prototype === Object.prototype || null === Object.getPrototypeOf(prototype)) && !(Symbol.toStringTag in val) && !(Symbol.iterator in val);
};
/**
* 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 Blob
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a Blob, otherwise false
*/ const isBlob = kindOfTest('Blob');
/**
* Determine if a value is a FileList
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a File, otherwise false
*/ const utils_isFileList = kindOfTest('FileList');
/**
* Determine if a value is a Stream
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a Stream, otherwise false
*/ const utils_isStream = (val)=>isObject(val) && isFunction(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
*/ const utils_isFormData = (thing)=>{
let kind;
return thing && ('function' == typeof FormData && thing instanceof FormData || isFunction(thing.append) && ('formdata' === (kind = kindOf(thing)) || // detect form-data instance
'object' === kind && isFunction(thing.toString) && '[object FormData]' === thing.toString()));
};
/**
* 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)=>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} obj The object to iterate
* @param {Function} fn The callback to invoke for each item
*
* @param {Boolean} [allOwnKeys = false]
* @returns {any}
*/ function forEach(obj, fn, { allOwnKeys = false } = {}) {
// Don't bother if no value provided
if (null == obj) return;
let i;
let l;
// Force an array if not already something iterable
if ('object' != typeof obj) /*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 {
// 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);
}
}
}
function findKey(obj, key) {
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 ("undefined" != typeof globalThis) return globalThis;
return "undefined" != typeof self ? self : 'undefined' != typeof window ? 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
* var 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 utils_merge() {
const { caseless } = isContextDefined(this) && this || {};
const result = {};
const assignValue = (val, key)=>{
const targetKey = caseless && findKey(result, key) || key;
if (isPlainObject(result[targetKey]) && isPlainObject(val)) result[targetKey] = utils_merge(result[targetKey], val);
else if (isPlainObject(val)) result[targetKey] = utils_merge({}, val);
else if (isArray(val)) result[targetKey] = val.slice();
else result[targetKey] = val;
};
for(let i = 0, l = arguments.length; i < l; i++)arguments[i] && forEach(arguments[i], assignValue);
return result;
}
/**
* Extends object a by mutably adding to it the properties of object b.
*
* @param {Object} a The object to be extended
* @param {Object} b The object to copy properties from
* @param {Object} thisArg The object to bind function to
*
* @param {Boolean} [allOwnKeys]
* @returns {Object} The resulting value of object a
*/ const extend = (a, b, thisArg, { allOwnKeys } = {})=>{
forEach(b, (val, key)=>{
if (thisArg && isFunction(val)) a[key] = bind(val, thisArg);
else a[key] = val;
}, {
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 (0xFEFF === content.charCodeAt(0)) 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);
constructor.prototype.constructor = constructor;
Object.defineProperty(constructor, 'super', {
value: superConstructor.prototype
});
props && Object.assign(constructor.prototype, props);
};
/**
* Resolve object with deep prototype chain to a flat object
* @param {Object} sourceObj source object
* @param {Object} [destObj]
* @param {Function|Boolean} [filter]
* @param {Function} [propFilter]
*
* @returns {Object}
*/ const toFlatObject = (sourceObj, destObj, filter, propFilter)=>{
let props;
let i;
let prop;
const merged = {};
destObj = destObj || {};
// eslint-disable-next-line no-eq-null,eqeqeq
if (null == sourceObj) 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 = false !== filter && 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 (void 0 === position || position > str.length) position = str.length;
position -= searchString.length;
const lastIndex = str.indexOf(searchString, position);
return -1 !== lastIndex && 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-names
const isTypedArray = ((TypedArray)=>(thing)=>TypedArray && thing instanceof TypedArray)('undefined' != typeof Uint8Array && 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[Symbol.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(null !== (matches = regExp.exec(str)))arr.push(matches);
return arr;
};
/* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */ const isHTMLForm = kindOfTest('HTMLFormElement');
const toCamelCase = (str)=>str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function(m, p1, p2) {
return p1.toUpperCase() + p2;
});
/* Creating a function that will check if an object has a property. */ const utils_hasOwnProperty = (({ hasOwnProperty })=>(obj, prop)=>hasOwnProperty.call(obj, prop))(Object.prototype);
/**
* Determine if a value is a RegExp object
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a RegExp object, otherwise false
*/ const isRegExp = kindOfTest('RegExp');
const reduceDescriptors = (obj, reducer)=>{
const descriptors = Object.getOwnPropertyDescriptors(obj);
const reducedDescriptors = {};
forEach(descriptors, (descriptor, name)=>{
let ret;
if (false !== (ret = reducer(descriptor, name, obj))) 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(obj) && -1 !== [
'arguments',
'caller',
'callee'
].indexOf(name)) return false;
const value = obj[name];
if (!isFunction(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 + '\'');
};
});
};
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)=>null != value && Number.isFinite(value = +value) ? value : defaultValue;
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;
while(size--)str += alphabet[Math.random() * length | 0];
return str;
};
/**
* 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(thing.append) && 'FormData' === thing[Symbol.toStringTag] && thing[Symbol.iterator]);
}
const toJSONObject = (obj)=>{
const stack = new Array(10);
const visit = (source, i)=>{
if (isObject(source)) {
if (stack.indexOf(source) >= 0) return;
if (!('toJSON' in source)) {
stack[i] = source;
const target = isArray(source) ? [] : {};
forEach(source, (value, key)=>{
const reducedValue = visit(value, i + 1);
isUndefined(reducedValue) || (target[key] = reducedValue);
});
stack[i] = void 0;
return target;
}
}
return source;
};
return visit(obj, 0);
};
const isAsyncFn = kindOfTest('AsyncFunction');
const isThenable = (thing)=>thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);
// original code
// https://github.com/DigitalBrainJS/AxiosPromise/blob/16deab13710ec09779922131f3fa5954320f83ab/lib/utils.js#L11-L34
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);
})('function' == typeof setImmediate, isFunction(_global.postMessage));
const asap = 'undefined' != typeof queueMicrotask ? queueMicrotask.bind(_global) : 'undefined' != typeof process && process.nextTick || _setImmediate;
// *********************
/* ESM default export */ const utils = {
isArray,
isArrayBuffer,
isBuffer,
isFormData: utils_isFormData,
isArrayBufferView,
isString,
isNumber,
isBoolean,
isObject,
isPlainObject,
isReadableStream,
isRequest,
isResponse,
isHeaders,
isUndefined,
isDate,
isFile,
isBlob,
isRegExp,
isFunction,
isStream: utils_isStream,
isURLSearchParams,
isTypedArray,
isFileList: utils_isFileList,
forEach,
merge: utils_merge,
extend,
trim,
stripBOM,
inherits,
toFlatObject,
kindOf,
kindOfTest,
endsWith,
toArray,
forEachEntry,
matchAll,
isHTMLForm,
hasOwnProperty: utils_hasOwnProperty,
hasOwnProp: utils_hasOwnProperty,
reduceDescriptors,
freezeMethods,
toObjectSet,
toCamelCase,
noop,
toFiniteNumber,
findKey,
global: _global,
isContextDefined,
ALPHABET,
generateString,
isSpecCompliantForm,
toJSONObject,
isAsyncFn,
isThenable,
setImmediate: _setImmediate,
asap
};
/**
* Create an Error with the specified message, config, error code, request and response.
*
* @param {string} message The error message.
* @param {string} [code] The error code (for example, 'ECONNABORTED').
* @param {Object} [config] The config.
* @param {Object} [request] The request.
* @param {Object} [response] The response.
*
* @returns {Error} The created error.
*/ function AxiosError(message, code, config, request, response) {
Error.call(this);
if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
else this.stack = new Error().stack;
this.message = message;
this.name = 'AxiosError';
code && (this.code = code);
config && (this.config = config);
request && (this.request = request);
if (response) {
this.response = response;
this.status = response.status ? response.status : null;
}
}
utils.inherits(AxiosError, Error, {
toJSON: function() {
return {
// Standard
message: this.message,
name: this.name,
// Microsoft
description: this.description,
number: this.number,
// Mozilla
fileName: this.fileName,
lineNumber: this.lineNumber,
columnNumber: this.columnNumber,
stack: this.stack,
// Axios
config: utils.toJSONObject(this.config),
code: this.code,
status: this.status
};
}
});
const AxiosError_prototype = AxiosError.prototype;
const AxiosError_descriptors = {};
[
'ERR_BAD_OPTION_VALUE',
'ERR_BAD_OPTION',
'ECONNABORTED',
'ETIMEDOUT',
'ERR_NETWORK',
'ERR_FR_TOO_MANY_REDIRECTS',
'ERR_DEPRECATED',
'ERR_BAD_RESPONSE',
'ERR_BAD_REQUEST',
'ERR_CANCELED',
'ERR_NOT_SUPPORT',
'ERR_INVALID_URL'
].forEach((code)=>{
AxiosError_descriptors[code] = {
value: code
};
});
Object.defineProperties(AxiosError, AxiosError_descriptors);
Object.defineProperty(AxiosError_prototype, 'isAxiosError', {
value: true
});
// eslint-disable-next-line func-names
AxiosError.from = (error, code, config, request, response, customProps)=>{
const axiosError = Object.create(AxiosError_prototype);
utils.toFlatObject(error, axiosError, function(obj) {
return obj !== Error.prototype;
}, (prop)=>'isAxiosError' !== prop);
AxiosError.call(axiosError, error.message, code, config, request, response);
axiosError.cause = error;
axiosError.name = error.name;
customProps && Object.assign(axiosError, customProps);
return axiosError;
};
/* ESM default export */ const core_AxiosError = AxiosError;
// eslint-disable-next-line strict
/* ESM default export */ const helpers_null = null;
// temporary hotfix to avoid circular references until AxiosURLSearchParams is refactored
/**
* 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.isPlainObject(thing) || utils.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.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(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.isArray(arr) && !arr.some(isVisitable);
}
const predicates = utils.toFlatObject(utils, {}, null, function(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_toFormData(obj, formData, options) {
if (!utils.isObject(obj)) throw new TypeError('target must be an object');
// eslint-disable-next-line no-param-reassign
formData = formData || new (helpers_null || FormData)();
// eslint-disable-next-line no-param-reassign
options = utils.toFlatObject(options, {
metaTokens: true,
dots: false,
indexes: false
}, false, function(option, source) {
// eslint-disable-next-line no-eq-null,eqeqeq
return !utils.isUndefined(source[option]);
});
const metaTokens = options.metaTokens;
// eslint-disable-next-line no-use-before-define
const visitor = options.visitor || defaultVisitor;
const dots = options.dots;
const indexes = options.indexes;
const _Blob = options.Blob || 'undefined' != typeof Blob && Blob;
const useBlob = _Blob && utils.isSpecCompliantForm(formData);
if (!utils.isFunction(visitor)) throw new TypeError('visitor must be a function');
function convertValue(value) {
if (null === value) return '';
if (utils.isDate(value)) return value.toISOString();
if (!useBlob && utils.isBlob(value)) throw new core_AxiosError('Blob is not supported. Use a Buffer instead.');
if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) return useBlob && 'function' == typeof Blob ? new Blob([
value
]) : Buffer.from(value);
return value;
}
/**
* Default visitor.
*
* @param {*} value
* @param {String|Number} key
* @param {Array<String|Number>} path
* @this {FormData}
*
* @returns {boolean} return true to visit the each prop of the value recursively
*/ function defaultVisitor(value, key, path) {
let arr = value;
if (value && !path && 'object' == typeof value) {
if (utils.endsWith(key, '{}')) {
// eslint-disable-next-line no-param-reassign
key = metaTokens ? key : key.slice(0, -2);
// eslint-disable-next-line no-param-reassign
value = JSON.stringify(value);
} else if (utils.isArray(value) && isFlatArray(value) || (utils.isFileList(value) || utils.endsWith(key, '[]')) && (arr = utils.toArray(value))) {
// eslint-disable-next-line no-param-reassign
key = removeBrackets(key);
arr.forEach(function(el, index) {
utils.isUndefined(el) || null === el || formData.append(// eslint-disable-next-line no-nested-ternary
true === indexes ? renderKey([
key
], index, dots) : null === indexes ? key : key + '[]', convertValue(el));
});
return false;
}
}
if (isVisitable(value)) return true;
formData.append(renderKey(path, key, dots), convertValue(value));
return false;
}
const stack = [];
const exposedHelpers = Object.assign(predicates, {
defaultVisitor,
convertValue,
isVisitable
});
function build(value, path) {
if (utils.isUndefined(value)) return;
if (-1 !== stack.indexOf(value)) throw Error('Circular reference detected in ' + path.join('.'));
stack.push(value);
utils.forEach(value, function(el, key) {
const result = !(utils.isUndefined(el) || null === el) && visitor.call(formData, el, utils.isString(key) ? key.trim() : key, path, exposedHelpers);
if (true === result) build(el, path ? path.concat(key) : [
key
]);
});
stack.pop();
}
if (!utils.isObject(obj)) throw new TypeError('data must be an object');
build(obj);
return formData;
}
/* ESM default export */ const toFormData = toFormData_toFormData;
/**
* 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(str) {
const charMap = {
'!': '%21',
"'": '%27',
'(': '%28',
')': '%29',
'~': '%7E',
'%20': '+',
'%00': '\x00'
};
return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function(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 AxiosURLSearchParams_prototype = AxiosURLSearchParams.prototype;
AxiosURLSearchParams_prototype.append = function(name, value) {
this._pairs.push([
name,
value
]);
};
AxiosURLSearchParams_prototype.toString = function(encoder) {
const _encode = encoder ? function(value) {
return encoder.call(this, value, encode);
} : encode;
return this._pairs.map(function(pair) {
return _encode(pair[0]) + '=' + _encode(pair[1]);
}, '').join('&');
};
/* ESM default export */ const helpers_AxiosURLSearchParams = AxiosURLSearchParams;
/**
* It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their
* URI encoded counterparts
*
* @param {string} val The value to be encoded.
*
* @returns {string} The encoded value.
*/ function buildURL_encode(val) {
return encodeURIComponent(val).replace(/%3A/gi, ':').replace(/%24/g, '$').replace(/%2C/gi, ',').replace(/%20/g, '+').replace(/%5B/gi, '[').replace(/%5D/gi, ']');
}
/**
* 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} options
*
* @returns {string} The formatted url
*/ function buildURL(url, params, options) {
/*eslint no-param-reassign:0*/ if (!params) return url;
const _encode = options && options.encode || buildURL_encode;
const serializeFn = options && options.serialize;
let serializedParams;
serializedParams = serializeFn ? serializeFn(params, options) : utils.isURLSearchParams(params) ? params.toString() : new helpers_AxiosURLSearchParams(params, options).toString(_encode);
if (serializedParams) {
const hashmarkIndex = url.indexOf("#");
if (-1 !== hashmarkIndex) url = url.slice(0, hashmarkIndex);
url += (-1 === url.indexOf('?') ? '?' : '&') + serializedParams;
}
return url;
}
class InterceptorManager_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`
*
* @return {Number} An ID used to remove interceptor later
*/ use(fulfilled, rejected, options) {
this.handlers.push({
fulfilled,
rejected,
synchronous: !!options && options.synchronous,
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 {Boolean} `true` if the interceptor was removed, `false` otherwise
*/ 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.forEach(this.handlers, function(h) {
if (null !== h) fn(h);
});
}
}
/* ESM default export */ const InterceptorManager = InterceptorManager_InterceptorManager;
/* ESM default export */ const defaults_transitional = {
silentJSONParsing: true,
forcedJSONParsing: true,
clarifyTimeoutError: false
};
/* ESM default export */ const classes_URLSearchParams = 'undefined' != typeof URLSearchParams ? URLSearchParams : helpers_AxiosURLSearchParams;
/* ESM default export */ const classes_FormData = 'undefined' != typeof FormData ? FormData : null;
/* ESM default export */ const classes_Blob = 'undefined' != typeof Blob ? Blob : null;
/* ESM default export */ const browser = {
isBrowser: true,
classes: {
URLSearchParams: classes_URLSearchParams,
FormData: classes_FormData,
Blob: classes_Blob
},
protocols: [
'http',
'https',
'file',
'blob',
'url',
'data'
]
};
const hasBrowserEnv = 'undefined' != typeof window && 'undefined' != typeof document;
const utils_navigator = 'object' == typeof navigator && navigator || void 0;
/**
* 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 && (!utils_navigator || [
'ReactNative',
'NativeScript',
'NS'
].indexOf(utils_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 = (()=>'undefined' != typeof WorkerGlobalScope && // eslint-disable-next-line no-undef
self instanceof WorkerGlobalScope && 'function' == typeof self.importScripts)();
const origin = hasBrowserEnv && window.location.href || 'http://localhost';
/* ESM default export */ const lib_platform = {
...common_utils_namespaceObject,
...browser
};
function toURLEncodedForm(data, options) {
return toFormData(data, new lib_platform.classes.URLSearchParams(), Object.assign({
visitor: function(value, key, path, helpers) {
if (lib_platform.isNode && utils.isBuffer(value)) {
this.append(key, value.toString('base64'));
return false;
}
return helpers.defaultVisitor.apply(this, arguments);
}
}, options));
}
/**
* It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']
*
* @param {string} name - The name of the property to get.
*
* @returns An array of strings.
*/ function parsePropPath(name) {
// foo[x][y][z]
// foo.x.y.z
// foo-x-y-z
// foo x y z
return utils.matchAll(/\w+|\[(\w*)]/g, name).map((match)=>'[]' === match[0] ? '' : match[1] || match[0]);
}
/**
* Convert an array to an object.
*
* @param {Array<any>} arr - The array to convert to an object.
*
* @returns An object with the same keys and values as the array.
*/ function arrayToObject(arr) {
const obj = {};
const keys = Object.keys(arr);
let i;
const len = keys.length;
let key;
for(i = 0; i < len; i++){
key = keys[i];
obj[key] = arr[key];
}
return obj;
}
/**
* It takes a FormData object and returns a JavaScript object
*
* @param {string} formData The FormData object to convert to JSON.
*
* @returns {Object<string, any> | null} The converted object.
*/ function formDataToJSON_formDataToJSON(formData) {
function buildPath(path, value, target, index) {
let name = path[index++];
if ('__proto__' === name) return true;
const isNumericKey = Number.isFinite(+name);
const isLast = index >= path.length;
name = !name && utils.isArray(target) ? target.length : name;
if (isLast) {
if (utils.hasOwnProp(target, name)) target[name] = [
target[name],
value
];
else target[name] = value;
return !isNumericKey;
}
if (!target[name] || !utils.isObject(target[name])) target[name] = [];
const result = buildPath(path, value, target[name], index);
if (result && utils.isArray(target[name])) target[name] = arrayToObject(target[name]);
return !isNumericKey;
}
if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {
const obj = {};
utils.forEachEntry(formData, (name, value)=>{
buildPath(parsePropPath(name), value, obj, 0);
});
return obj;
}
return null;
}
/* ESM default export */ const formDataToJSON = formDataToJSON_formDataToJSON;
/**
* 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.isString(rawValue)) try {
(parser || JSON.parse)(rawValue);
return utils.trim(rawValue);
} catch (e) {
if ('SyntaxError' !== e.name) throw e;
}
return (encoder || JSON.stringify)(rawValue);
}
const defaults_defaults = {
transitional: defaults_transitional,
adapter: [
'xhr',
'http',
'fetch'
],
transformRequest: [
function(data, headers) {
const contentType = headers.getContentType() || '';
const hasJSONContentType = contentType.indexOf('application/json') > -1;
const isObjectPayload = utils.isObject(data);
if (isObjectPayload && utils.isHTMLForm(data)) data = new FormData(data);
const isFormData = utils.isFormData(data);
if (isFormData) return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
if (utils.isArrayBuffer(data) || utils.isBuffer(data) || utils.isStream(data) || utils.isFile(data) || utils.isBlob(data) || utils.isReadableStream(data)) return data;
if (utils.isArrayBufferView(data)) return data.buffer;
if (utils.isURLSearchParams(data)) {
headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);
return data.toString();
}
let isFileList;
if (isObjectPayload) {
if (contentType.indexOf('application/x-www-form-urlencoded') > -1) return toURLEncodedForm(data, this.formSerializer).toString();
if ((isFileList = utils.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {
const _FormData = this.env && this.env.FormData;
return toFormData(isFileList ? {
'files[]': data
} : data, _FormData && new _FormData(), this.formSerializer);
}
}
if (isObjectPayload || hasJSONContentType) {
headers.setContentType('application/json', false);
return stringifySafely(data);
}
return data;
}
],
transformResponse: [
function(data) {
const transitional = this.transitional || defaults_defaults.transitional;
const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
const JSONRequested = 'json' === this.responseType;
if (utils.isResponse(data) || utils.isReadableStream(data)) return data;
if (data && utils.isString(data) && (forcedJSONParsing && !this.responseType || JSONRequested)) {
const silentJSONParsing = transitional && transitional.silentJSONParsing;
const strictJSONParsing = !silentJSONParsing && JSONRequested;
try {
return JSON.parse(data);
} catch (e) {
if (strictJSONParsing) {
if ('SyntaxError' === e.name) throw core_AxiosError.from(e, core_AxiosError.ERR_BAD_RESPONSE, this, null, 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: lib_platform.classes.FormData,
Blob: lib_platform.classes.Blob
},
validateStatus: function(status) {
return status >= 200 && status < 300;
},
headers: {
common: {
Accept: 'application/json, text/plain, */*',
'Content-Type': void 0
}
}
};
utils.forEach([
'delete',
'get',
'head',
'post',
'put',
'patch'
], (method)=>{
defaults_defaults.headers[method] = {};
});
/* ESM default export */ const defaults = defaults_defaults;
// RawAxiosHeaders whose duplicates are ignored by node
// c.f. https://nodejs.org/api/http.html#http_message_headers
const ignoreDuplicateOf = utils.toObjectSet([
'age',
'authorization',
'content-length',
'content-type',
'etag',
'expires',
'from',
'host',
'if-modified-since',
'if-unmodified-since',
'last-modified',
'location',
'max-forwards',
'proxy-authorization',
'referer',
'retry-after',
'user-agent'
]);
/**
* 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
*/ /* ESM default export */ const parseHeaders = (rawHeaders)=>{
const parsed = {};
let key;
let val;
let i;
rawHeaders && rawHeaders.split('\n').forEach(function(line) {
i = line.indexOf(':');
key = line.substring(0, i).trim().toLowerCase();
val = line.substring(i + 1).trim();
if (!key || parsed[key] && ignoreDuplicateOf[key]) return;
if ('set-cookie' === key) {
if (parsed[key]) parsed[key].push(val);
else parsed[key] = [
val
];
} else parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
});
return parsed;
};
const $internals = Symbol('internals');
function normalizeHeader(header) {
return header && String(header).trim().toLowerCase();
}
function normalizeValue(value) {
if (false === value || null == value) return value;
return utils.isArray(value) ? value.map(normalizeValue) : String(value);
}
function parseTokens(str) {
const tokens = Object.create(null);
const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
let match;
while(match = tokensRE.exec(str))tokens[match[1]] = match[2];
return tokens;
}
const isValidHeaderName = (str)=>/^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
if (utils.isFunction(filter)) return filter.call(this, value, header);
if (isHeaderNameFilter) value = header;
if (!utils.isString(value)) return;
if (utils.isString(filter)) return -1 !== value.indexOf(filter);
if (utils.isRegExp(filter)) return filter.test(value);
}
function formatHeader(header) {
return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str)=>char.toUpperCase() + str);
}
function buildAccessors(obj, header) {
const accessorName = utils.toCamelCase(' ' + header);
[
'get',
'set',
'has'
].forEach((methodName)=>{
Object.defineProperty(obj, methodName + accessorName, {
value: function(arg1, arg2, arg3) {
return this[methodName].call(this, header, arg1, arg2, arg3);
},
configurable: true
});
});
}
class AxiosHeaders_AxiosHeaders {
constructor(headers){
headers && this.set(headers);
}
set(header, valueOrRewrite, rewrite) {
const self1 = this;
function setHeader(_value, _header, _rewrite) {
const lHeader = normalizeHeader(_header);
if (!lHeader) throw new Error('header name must be a non-empty string');
const key = utils.findKey(self1, lHeader);
if (!key || void 0 === self1[key] || true === _rewrite || void 0 === _rewrite && false !== self1[key]) self1[key || _header] = normalizeValue(_value);
}
const setHeaders = (headers, _rewrite)=>utils.forEach(headers, (_value, _header)=>setHeader(_value, _header, _rewrite));
if (utils.isPlainObject(header) || header instanceof this.constructor) setHeaders(header, valueOrRewrite);
else if (utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) setHeaders(parseHeaders(header), valueOrRewrite);
else if (utils.isHeaders(header)) for (const [key, value] of header.entries())setHeader(value, key, rewrite);
else null != header && setHeader(valueOrRewrite, header, rewrite);
return this;
}
get(header, parser) {
header = normalizeHeader(header);
if (header) {
const key = utils.findKey(this, header);
if (key) {
const value = this[key];
if (!parser) return value;
if (true === parser) return parseTokens(value);
if (utils.isFunction(parser)) return parser.call(this, value, key);
if (utils.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.findKey(this, header);
return !!(key && void 0 !== this[key] && (!matcher || matchHeaderValue(this, this