@coze/realtime-api
Version:
A powerful real-time communication SDK for voice interactions with Coze AI bots | 扣子官方实时通信 SDK，用于与 Coze AI bots 进行语音交互
1,221 lines (1,220 loc) • 5.78 MB
JavaScript
/*! For license information please see index.js.LICENSE.txt */
(function(root, factory) {
if ('object' == typeof exports && 'object' == typeof module) module.exports = factory();
else if ('function' == typeof define && define.amd) define([], factory);
else if ('object' == typeof exports) exports["CozeRealtimeApi"] = factory();
else root["CozeRealtimeApi"] = factory();
})(self, ()=>(()=>{
"use strict";
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 module1 = __webpack_module_cache__[moduleId] = {
exports: {}
};
// Execute the module function
__webpack_modules__[moduleId](module1, module1.exports, __webpack_require__);
// Return the exports of the module
return module1.exports;
}
/************************************************************************/ // webpack/runtime/define_property_getters
(()=>{
__webpack_require__.d = function(exports1, definition) {
for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, 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(exports1) {
if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
value: 'Module'
});
Object.defineProperty(exports1, '__esModule', {
value: true
});
};
})();
/************************************************************************/ var __webpack_exports__ = {};
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);
// EXPORTS
__webpack_require__.d(__webpack_exports__, {
RealtimeAPIError: ()=>/* reexport */ RealtimeAPIError,
RealtimeUtils: ()=>/* reexport */ src_utils_namespaceObject,
RealtimeError: ()=>/* reexport */ error_RealtimeError,
EventNames: ()=>/* reexport */ event_handler_EventNames,
RealtimeClient: ()=>/* binding */ RealtimeClient
});
// 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 define1 = (arr)=>{
arr.forEach((value)=>{
obj[value] = true;
});
};
isArray(arrayOrString) ? define1(arrayOrString) : define1(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) {