You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2431 lines
77 KiB
2431 lines
77 KiB
import { |
|
__export |
|
} from "./chunk-4YJPEX7N.js"; |
|
|
|
// node_modules/axios/lib/helpers/bind.js |
|
"use strict"; |
|
function bind(fn, thisArg) { |
|
return function wrap() { |
|
return fn.apply(thisArg, arguments); |
|
}; |
|
} |
|
|
|
// node_modules/axios/lib/utils.js |
|
"use strict"; |
|
var { toString } = Object.prototype; |
|
var { getPrototypeOf } = Object; |
|
var kindOf = ((cache) => (thing) => { |
|
const str = toString.call(thing); |
|
return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase()); |
|
})(Object.create(null)); |
|
var kindOfTest = (type) => { |
|
type = type.toLowerCase(); |
|
return (thing) => kindOf(thing) === type; |
|
}; |
|
var typeOfTest = (type) => (thing) => typeof thing === type; |
|
var { isArray } = Array; |
|
var isUndefined = typeOfTest("undefined"); |
|
function isBuffer(val) { |
|
return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val); |
|
} |
|
var isArrayBuffer = kindOfTest("ArrayBuffer"); |
|
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; |
|
} |
|
var isString = typeOfTest("string"); |
|
var isFunction = typeOfTest("function"); |
|
var isNumber = typeOfTest("number"); |
|
var isObject = (thing) => thing !== null && typeof thing === "object"; |
|
var isBoolean = (thing) => thing === true || thing === false; |
|
var isPlainObject = (val) => { |
|
if (kindOf(val) !== "object") { |
|
return false; |
|
} |
|
const prototype3 = getPrototypeOf(val); |
|
return (prototype3 === null || prototype3 === Object.prototype || Object.getPrototypeOf(prototype3) === null) && !(Symbol.toStringTag in val) && !(Symbol.iterator in val); |
|
}; |
|
var isDate = kindOfTest("Date"); |
|
var isFile = kindOfTest("File"); |
|
var isBlob = kindOfTest("Blob"); |
|
var isFileList = kindOfTest("FileList"); |
|
var isStream = (val) => isObject(val) && isFunction(val.pipe); |
|
var isFormData = (thing) => { |
|
let kind; |
|
return thing && (typeof FormData === "function" && thing instanceof FormData || isFunction(thing.append) && ((kind = kindOf(thing)) === "formdata" || kind === "object" && isFunction(thing.toString) && thing.toString() === "[object FormData]")); |
|
}; |
|
var isURLSearchParams = kindOfTest("URLSearchParams"); |
|
var [isReadableStream, isRequest, isResponse, isHeaders] = ["ReadableStream", "Request", "Response", "Headers"].map(kindOfTest); |
|
var trim = (str) => str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ""); |
|
function forEach(obj, fn, { allOwnKeys = false } = {}) { |
|
if (obj === null || typeof obj === "undefined") { |
|
return; |
|
} |
|
let i; |
|
let l; |
|
if (typeof obj !== "object") { |
|
obj = [obj]; |
|
} |
|
if (isArray(obj)) { |
|
for (i = 0, l = obj.length; i < l; i++) { |
|
fn.call(null, obj[i], i, obj); |
|
} |
|
} else { |
|
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; |
|
} |
|
var _global = (() => { |
|
if (typeof globalThis !== "undefined") |
|
return globalThis; |
|
return typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : global; |
|
})(); |
|
var isContextDefined = (context) => !isUndefined(context) && context !== _global; |
|
function 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] = merge(result[targetKey], val); |
|
} else if (isPlainObject(val)) { |
|
result[targetKey] = 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; |
|
} |
|
var 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; |
|
}; |
|
var stripBOM = (content) => { |
|
if (content.charCodeAt(0) === 65279) { |
|
content = content.slice(1); |
|
} |
|
return content; |
|
}; |
|
var inherits = (constructor, superConstructor, props, descriptors2) => { |
|
constructor.prototype = Object.create(superConstructor.prototype, descriptors2); |
|
constructor.prototype.constructor = constructor; |
|
Object.defineProperty(constructor, "super", { |
|
value: superConstructor.prototype |
|
}); |
|
props && Object.assign(constructor.prototype, props); |
|
}; |
|
var toFlatObject = (sourceObj, destObj, filter2, propFilter) => { |
|
let props; |
|
let i; |
|
let prop; |
|
const merged = {}; |
|
destObj = destObj || {}; |
|
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 = filter2 !== false && getPrototypeOf(sourceObj); |
|
} while (sourceObj && (!filter2 || filter2(sourceObj, destObj)) && sourceObj !== Object.prototype); |
|
return destObj; |
|
}; |
|
var endsWith = (str, searchString, position) => { |
|
str = String(str); |
|
if (position === void 0 || position > str.length) { |
|
position = str.length; |
|
} |
|
position -= searchString.length; |
|
const lastIndex = str.indexOf(searchString, position); |
|
return lastIndex !== -1 && lastIndex === position; |
|
}; |
|
var 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; |
|
}; |
|
var isTypedArray = ((TypedArray) => { |
|
return (thing) => { |
|
return TypedArray && thing instanceof TypedArray; |
|
}; |
|
})(typeof Uint8Array !== "undefined" && getPrototypeOf(Uint8Array)); |
|
var 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]); |
|
} |
|
}; |
|
var matchAll = (regExp, str) => { |
|
let matches; |
|
const arr = []; |
|
while ((matches = regExp.exec(str)) !== null) { |
|
arr.push(matches); |
|
} |
|
return arr; |
|
}; |
|
var isHTMLForm = kindOfTest("HTMLFormElement"); |
|
var toCamelCase = (str) => { |
|
return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function replacer(m, p1, p2) { |
|
return p1.toUpperCase() + p2; |
|
}); |
|
}; |
|
var hasOwnProperty = (({ hasOwnProperty: hasOwnProperty2 }) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype); |
|
var isRegExp = kindOfTest("RegExp"); |
|
var reduceDescriptors = (obj, reducer) => { |
|
const descriptors2 = Object.getOwnPropertyDescriptors(obj); |
|
const reducedDescriptors = {}; |
|
forEach(descriptors2, (descriptor, name) => { |
|
let ret; |
|
if ((ret = reducer(descriptor, name, obj)) !== false) { |
|
reducedDescriptors[name] = ret || descriptor; |
|
} |
|
}); |
|
Object.defineProperties(obj, reducedDescriptors); |
|
}; |
|
var freezeMethods = (obj) => { |
|
reduceDescriptors(obj, (descriptor, name) => { |
|
if (isFunction(obj) && ["arguments", "caller", "callee"].indexOf(name) !== -1) { |
|
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 + "'"); |
|
}; |
|
} |
|
}); |
|
}; |
|
var 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; |
|
}; |
|
var noop = () => { |
|
}; |
|
var toFiniteNumber = (value, defaultValue) => { |
|
return value != null && Number.isFinite(value = +value) ? value : defaultValue; |
|
}; |
|
var ALPHA = "abcdefghijklmnopqrstuvwxyz"; |
|
var DIGIT = "0123456789"; |
|
var ALPHABET = { |
|
DIGIT, |
|
ALPHA, |
|
ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT |
|
}; |
|
var generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => { |
|
let str = ""; |
|
const { length } = alphabet; |
|
while (size--) { |
|
str += alphabet[Math.random() * length | 0]; |
|
} |
|
return str; |
|
}; |
|
function isSpecCompliantForm(thing) { |
|
return !!(thing && isFunction(thing.append) && thing[Symbol.toStringTag] === "FormData" && thing[Symbol.iterator]); |
|
} |
|
var 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); |
|
}; |
|
var isAsyncFn = kindOfTest("AsyncFunction"); |
|
var isThenable = (thing) => thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch); |
|
var _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(_global.postMessage)); |
|
var asap = typeof queueMicrotask !== "undefined" ? queueMicrotask.bind(_global) : typeof process !== "undefined" && process.nextTick || _setImmediate; |
|
var utils_default = { |
|
isArray, |
|
isArrayBuffer, |
|
isBuffer, |
|
isFormData, |
|
isArrayBufferView, |
|
isString, |
|
isNumber, |
|
isBoolean, |
|
isObject, |
|
isPlainObject, |
|
isReadableStream, |
|
isRequest, |
|
isResponse, |
|
isHeaders, |
|
isUndefined, |
|
isDate, |
|
isFile, |
|
isBlob, |
|
isRegExp, |
|
isFunction, |
|
isStream, |
|
isURLSearchParams, |
|
isTypedArray, |
|
isFileList, |
|
forEach, |
|
merge, |
|
extend, |
|
trim, |
|
stripBOM, |
|
inherits, |
|
toFlatObject, |
|
kindOf, |
|
kindOfTest, |
|
endsWith, |
|
toArray, |
|
forEachEntry, |
|
matchAll, |
|
isHTMLForm, |
|
hasOwnProperty, |
|
hasOwnProp: hasOwnProperty, |
|
reduceDescriptors, |
|
freezeMethods, |
|
toObjectSet, |
|
toCamelCase, |
|
noop, |
|
toFiniteNumber, |
|
findKey, |
|
global: _global, |
|
isContextDefined, |
|
ALPHABET, |
|
generateString, |
|
isSpecCompliantForm, |
|
toJSONObject, |
|
isAsyncFn, |
|
isThenable, |
|
setImmediate: _setImmediate, |
|
asap |
|
}; |
|
|
|
// node_modules/axios/lib/core/AxiosError.js |
|
"use strict"; |
|
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_default.inherits(AxiosError, Error, { |
|
toJSON: function toJSON() { |
|
return { |
|
message: this.message, |
|
name: this.name, |
|
description: this.description, |
|
number: this.number, |
|
fileName: this.fileName, |
|
lineNumber: this.lineNumber, |
|
columnNumber: this.columnNumber, |
|
stack: this.stack, |
|
config: utils_default.toJSONObject(this.config), |
|
code: this.code, |
|
status: this.status |
|
}; |
|
} |
|
}); |
|
var prototype = AxiosError.prototype; |
|
var 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) => { |
|
descriptors[code] = { value: code }; |
|
}); |
|
Object.defineProperties(AxiosError, descriptors); |
|
Object.defineProperty(prototype, "isAxiosError", { value: true }); |
|
AxiosError.from = (error, code, config, request, response, customProps) => { |
|
const axiosError = Object.create(prototype); |
|
utils_default.toFlatObject(error, axiosError, function filter2(obj) { |
|
return obj !== Error.prototype; |
|
}, (prop) => { |
|
return prop !== "isAxiosError"; |
|
}); |
|
AxiosError.call(axiosError, error.message, code, config, request, response); |
|
axiosError.cause = error; |
|
axiosError.name = error.name; |
|
customProps && Object.assign(axiosError, customProps); |
|
return axiosError; |
|
}; |
|
var AxiosError_default = AxiosError; |
|
|
|
// node_modules/axios/lib/helpers/null.js |
|
var null_default = null; |
|
|
|
// node_modules/axios/lib/helpers/toFormData.js |
|
"use strict"; |
|
function isVisitable(thing) { |
|
return utils_default.isPlainObject(thing) || utils_default.isArray(thing); |
|
} |
|
function removeBrackets(key) { |
|
return utils_default.endsWith(key, "[]") ? key.slice(0, -2) : key; |
|
} |
|
function renderKey(path, key, dots) { |
|
if (!path) |
|
return key; |
|
return path.concat(key).map(function each(token, i) { |
|
token = removeBrackets(token); |
|
return !dots && i ? "[" + token + "]" : token; |
|
}).join(dots ? "." : ""); |
|
} |
|
function isFlatArray(arr) { |
|
return utils_default.isArray(arr) && !arr.some(isVisitable); |
|
} |
|
var predicates = utils_default.toFlatObject(utils_default, {}, null, function filter(prop) { |
|
return /^is[A-Z]/.test(prop); |
|
}); |
|
function toFormData(obj, formData, options) { |
|
if (!utils_default.isObject(obj)) { |
|
throw new TypeError("target must be an object"); |
|
} |
|
formData = formData || new (null_default || FormData)(); |
|
options = utils_default.toFlatObject(options, { |
|
metaTokens: true, |
|
dots: false, |
|
indexes: false |
|
}, false, function defined(option, source) { |
|
return !utils_default.isUndefined(source[option]); |
|
}); |
|
const metaTokens = options.metaTokens; |
|
const visitor = options.visitor || defaultVisitor; |
|
const dots = options.dots; |
|
const indexes = options.indexes; |
|
const _Blob = options.Blob || typeof Blob !== "undefined" && Blob; |
|
const useBlob = _Blob && utils_default.isSpecCompliantForm(formData); |
|
if (!utils_default.isFunction(visitor)) { |
|
throw new TypeError("visitor must be a function"); |
|
} |
|
function convertValue(value) { |
|
if (value === null) |
|
return ""; |
|
if (utils_default.isDate(value)) { |
|
return value.toISOString(); |
|
} |
|
if (!useBlob && utils_default.isBlob(value)) { |
|
throw new AxiosError_default("Blob is not supported. Use a Buffer instead."); |
|
} |
|
if (utils_default.isArrayBuffer(value) || utils_default.isTypedArray(value)) { |
|
return useBlob && typeof Blob === "function" ? new Blob([value]) : Buffer.from(value); |
|
} |
|
return value; |
|
} |
|
function defaultVisitor(value, key, path) { |
|
let arr = value; |
|
if (value && !path && typeof value === "object") { |
|
if (utils_default.endsWith(key, "{}")) { |
|
key = metaTokens ? key : key.slice(0, -2); |
|
value = JSON.stringify(value); |
|
} else if (utils_default.isArray(value) && isFlatArray(value) || (utils_default.isFileList(value) || utils_default.endsWith(key, "[]")) && (arr = utils_default.toArray(value))) { |
|
key = removeBrackets(key); |
|
arr.forEach(function each(el, index) { |
|
!(utils_default.isUndefined(el) || el === null) && formData.append(indexes === true ? renderKey([key], index, dots) : indexes === null ? key : key + "[]", convertValue(el)); |
|
}); |
|
return false; |
|
} |
|
} |
|
if (isVisitable(value)) { |
|
return true; |
|
} |
|
formData.append(renderKey(path, key, dots), convertValue(value)); |
|
return false; |
|
} |
|
const stack = []; |
|
const exposedHelpers = Object.assign(predicates, { |
|
defaultVisitor, |
|
convertValue, |
|
isVisitable |
|
}); |
|
function build(value, path) { |
|
if (utils_default.isUndefined(value)) |
|
return; |
|
if (stack.indexOf(value) !== -1) { |
|
throw Error("Circular reference detected in " + path.join(".")); |
|
} |
|
stack.push(value); |
|
utils_default.forEach(value, function each(el, key) { |
|
const result = !(utils_default.isUndefined(el) || el === null) && visitor.call(formData, el, utils_default.isString(key) ? key.trim() : key, path, exposedHelpers); |
|
if (result === true) { |
|
build(el, path ? path.concat(key) : [key]); |
|
} |
|
}); |
|
stack.pop(); |
|
} |
|
if (!utils_default.isObject(obj)) { |
|
throw new TypeError("data must be an object"); |
|
} |
|
build(obj); |
|
return formData; |
|
} |
|
var toFormData_default = toFormData; |
|
|
|
// node_modules/axios/lib/helpers/AxiosURLSearchParams.js |
|
"use strict"; |
|
function encode(str) { |
|
const charMap = { |
|
"!": "%21", |
|
"'": "%27", |
|
"(": "%28", |
|
")": "%29", |
|
"~": "%7E", |
|
"%20": "+", |
|
"%00": "\0" |
|
}; |
|
return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) { |
|
return charMap[match]; |
|
}); |
|
} |
|
function AxiosURLSearchParams(params, options) { |
|
this._pairs = []; |
|
params && toFormData_default(params, this, options); |
|
} |
|
var prototype2 = AxiosURLSearchParams.prototype; |
|
prototype2.append = function append(name, value) { |
|
this._pairs.push([name, value]); |
|
}; |
|
prototype2.toString = function toString2(encoder) { |
|
const _encode = encoder ? function(value) { |
|
return encoder.call(this, value, encode); |
|
} : encode; |
|
return this._pairs.map(function each(pair) { |
|
return _encode(pair[0]) + "=" + _encode(pair[1]); |
|
}, "").join("&"); |
|
}; |
|
var AxiosURLSearchParams_default = AxiosURLSearchParams; |
|
|
|
// node_modules/axios/lib/helpers/buildURL.js |
|
"use strict"; |
|
function encode2(val) { |
|
return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]"); |
|
} |
|
function buildURL(url, params, options) { |
|
if (!params) { |
|
return url; |
|
} |
|
const _encode = options && options.encode || encode2; |
|
const serializeFn = options && options.serialize; |
|
let serializedParams; |
|
if (serializeFn) { |
|
serializedParams = serializeFn(params, options); |
|
} else { |
|
serializedParams = utils_default.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams_default(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; |
|
} |
|
|
|
// node_modules/axios/lib/core/InterceptorManager.js |
|
"use strict"; |
|
var InterceptorManager = class { |
|
constructor() { |
|
this.handlers = []; |
|
} |
|
use(fulfilled, rejected, options) { |
|
this.handlers.push({ |
|
fulfilled, |
|
rejected, |
|
synchronous: options ? options.synchronous : false, |
|
runWhen: options ? options.runWhen : null |
|
}); |
|
return this.handlers.length - 1; |
|
} |
|
eject(id) { |
|
if (this.handlers[id]) { |
|
this.handlers[id] = null; |
|
} |
|
} |
|
clear() { |
|
if (this.handlers) { |
|
this.handlers = []; |
|
} |
|
} |
|
forEach(fn) { |
|
utils_default.forEach(this.handlers, function forEachHandler(h) { |
|
if (h !== null) { |
|
fn(h); |
|
} |
|
}); |
|
} |
|
}; |
|
var InterceptorManager_default = InterceptorManager; |
|
|
|
// node_modules/axios/lib/defaults/transitional.js |
|
"use strict"; |
|
var transitional_default = { |
|
silentJSONParsing: true, |
|
forcedJSONParsing: true, |
|
clarifyTimeoutError: false |
|
}; |
|
|
|
// node_modules/axios/lib/platform/browser/classes/URLSearchParams.js |
|
"use strict"; |
|
var URLSearchParams_default = typeof URLSearchParams !== "undefined" ? URLSearchParams : AxiosURLSearchParams_default; |
|
|
|
// node_modules/axios/lib/platform/browser/classes/FormData.js |
|
"use strict"; |
|
var FormData_default = typeof FormData !== "undefined" ? FormData : null; |
|
|
|
// node_modules/axios/lib/platform/browser/classes/Blob.js |
|
"use strict"; |
|
var Blob_default = typeof Blob !== "undefined" ? Blob : null; |
|
|
|
// node_modules/axios/lib/platform/browser/index.js |
|
var browser_default = { |
|
isBrowser: true, |
|
classes: { |
|
URLSearchParams: URLSearchParams_default, |
|
FormData: FormData_default, |
|
Blob: Blob_default |
|
}, |
|
protocols: ["http", "https", "file", "blob", "url", "data"] |
|
}; |
|
|
|
// node_modules/axios/lib/platform/common/utils.js |
|
var utils_exports = {}; |
|
__export(utils_exports, { |
|
hasBrowserEnv: () => hasBrowserEnv, |
|
hasStandardBrowserEnv: () => hasStandardBrowserEnv, |
|
hasStandardBrowserWebWorkerEnv: () => hasStandardBrowserWebWorkerEnv, |
|
navigator: () => _navigator, |
|
origin: () => origin |
|
}); |
|
var hasBrowserEnv = typeof window !== "undefined" && typeof document !== "undefined"; |
|
var _navigator = typeof navigator === "object" && navigator || void 0; |
|
var hasStandardBrowserEnv = hasBrowserEnv && (!_navigator || ["ReactNative", "NativeScript", "NS"].indexOf(_navigator.product) < 0); |
|
var hasStandardBrowserWebWorkerEnv = (() => { |
|
return typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope && typeof self.importScripts === "function"; |
|
})(); |
|
var origin = hasBrowserEnv && window.location.href || "http://localhost"; |
|
|
|
// node_modules/axios/lib/platform/index.js |
|
var platform_default = { |
|
...utils_exports, |
|
...browser_default |
|
}; |
|
|
|
// node_modules/axios/lib/helpers/toURLEncodedForm.js |
|
"use strict"; |
|
function toURLEncodedForm(data, options) { |
|
return toFormData_default(data, new platform_default.classes.URLSearchParams(), Object.assign({ |
|
visitor: function(value, key, path, helpers) { |
|
if (platform_default.isNode && utils_default.isBuffer(value)) { |
|
this.append(key, value.toString("base64")); |
|
return false; |
|
} |
|
return helpers.defaultVisitor.apply(this, arguments); |
|
} |
|
}, options)); |
|
} |
|
|
|
// node_modules/axios/lib/helpers/formDataToJSON.js |
|
"use strict"; |
|
function parsePropPath(name) { |
|
return utils_default.matchAll(/\w+|\[(\w*)]/g, name).map((match) => { |
|
return match[0] === "[]" ? "" : match[1] || match[0]; |
|
}); |
|
} |
|
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; |
|
} |
|
function formDataToJSON(formData) { |
|
function buildPath(path, value, target, index) { |
|
let name = path[index++]; |
|
if (name === "__proto__") |
|
return true; |
|
const isNumericKey = Number.isFinite(+name); |
|
const isLast = index >= path.length; |
|
name = !name && utils_default.isArray(target) ? target.length : name; |
|
if (isLast) { |
|
if (utils_default.hasOwnProp(target, name)) { |
|
target[name] = [target[name], value]; |
|
} else { |
|
target[name] = value; |
|
} |
|
return !isNumericKey; |
|
} |
|
if (!target[name] || !utils_default.isObject(target[name])) { |
|
target[name] = []; |
|
} |
|
const result = buildPath(path, value, target[name], index); |
|
if (result && utils_default.isArray(target[name])) { |
|
target[name] = arrayToObject(target[name]); |
|
} |
|
return !isNumericKey; |
|
} |
|
if (utils_default.isFormData(formData) && utils_default.isFunction(formData.entries)) { |
|
const obj = {}; |
|
utils_default.forEachEntry(formData, (name, value) => { |
|
buildPath(parsePropPath(name), value, obj, 0); |
|
}); |
|
return obj; |
|
} |
|
return null; |
|
} |
|
var formDataToJSON_default = formDataToJSON; |
|
|
|
// node_modules/axios/lib/defaults/index.js |
|
"use strict"; |
|
function stringifySafely(rawValue, parser, encoder) { |
|
if (utils_default.isString(rawValue)) { |
|
try { |
|
(parser || JSON.parse)(rawValue); |
|
return utils_default.trim(rawValue); |
|
} catch (e) { |
|
if (e.name !== "SyntaxError") { |
|
throw e; |
|
} |
|
} |
|
} |
|
return (encoder || JSON.stringify)(rawValue); |
|
} |
|
var defaults = { |
|
transitional: transitional_default, |
|
adapter: ["xhr", "http", "fetch"], |
|
transformRequest: [function transformRequest(data, headers) { |
|
const contentType = headers.getContentType() || ""; |
|
const hasJSONContentType = contentType.indexOf("application/json") > -1; |
|
const isObjectPayload = utils_default.isObject(data); |
|
if (isObjectPayload && utils_default.isHTMLForm(data)) { |
|
data = new FormData(data); |
|
} |
|
const isFormData2 = utils_default.isFormData(data); |
|
if (isFormData2) { |
|
return hasJSONContentType ? JSON.stringify(formDataToJSON_default(data)) : data; |
|
} |
|
if (utils_default.isArrayBuffer(data) || utils_default.isBuffer(data) || utils_default.isStream(data) || utils_default.isFile(data) || utils_default.isBlob(data) || utils_default.isReadableStream(data)) { |
|
return data; |
|
} |
|
if (utils_default.isArrayBufferView(data)) { |
|
return data.buffer; |
|
} |
|
if (utils_default.isURLSearchParams(data)) { |
|
headers.setContentType("application/x-www-form-urlencoded;charset=utf-8", false); |
|
return data.toString(); |
|
} |
|
let isFileList2; |
|
if (isObjectPayload) { |
|
if (contentType.indexOf("application/x-www-form-urlencoded") > -1) { |
|
return toURLEncodedForm(data, this.formSerializer).toString(); |
|
} |
|
if ((isFileList2 = utils_default.isFileList(data)) || contentType.indexOf("multipart/form-data") > -1) { |
|
const _FormData = this.env && this.env.FormData; |
|
return toFormData_default(isFileList2 ? { "files[]": data } : data, _FormData && new _FormData(), this.formSerializer); |
|
} |
|
} |
|
if (isObjectPayload || hasJSONContentType) { |
|
headers.setContentType("application/json", false); |
|
return stringifySafely(data); |
|
} |
|
return data; |
|
}], |
|
transformResponse: [function transformResponse(data) { |
|
const transitional2 = this.transitional || defaults.transitional; |
|
const forcedJSONParsing = transitional2 && transitional2.forcedJSONParsing; |
|
const JSONRequested = this.responseType === "json"; |
|
if (utils_default.isResponse(data) || utils_default.isReadableStream(data)) { |
|
return data; |
|
} |
|
if (data && utils_default.isString(data) && (forcedJSONParsing && !this.responseType || JSONRequested)) { |
|
const silentJSONParsing = transitional2 && transitional2.silentJSONParsing; |
|
const strictJSONParsing = !silentJSONParsing && JSONRequested; |
|
try { |
|
return JSON.parse(data); |
|
} catch (e) { |
|
if (strictJSONParsing) { |
|
if (e.name === "SyntaxError") { |
|
throw AxiosError_default.from(e, AxiosError_default.ERR_BAD_RESPONSE, this, null, this.response); |
|
} |
|
throw e; |
|
} |
|
} |
|
} |
|
return data; |
|
}], |
|
timeout: 0, |
|
xsrfCookieName: "XSRF-TOKEN", |
|
xsrfHeaderName: "X-XSRF-TOKEN", |
|
maxContentLength: -1, |
|
maxBodyLength: -1, |
|
env: { |
|
FormData: platform_default.classes.FormData, |
|
Blob: platform_default.classes.Blob |
|
}, |
|
validateStatus: function validateStatus(status) { |
|
return status >= 200 && status < 300; |
|
}, |
|
headers: { |
|
common: { |
|
"Accept": "application/json, text/plain, */*", |
|
"Content-Type": void 0 |
|
} |
|
} |
|
}; |
|
utils_default.forEach(["delete", "get", "head", "post", "put", "patch"], (method) => { |
|
defaults.headers[method] = {}; |
|
}); |
|
var defaults_default = defaults; |
|
|
|
// node_modules/axios/lib/helpers/parseHeaders.js |
|
"use strict"; |
|
var ignoreDuplicateOf = utils_default.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" |
|
]); |
|
var parseHeaders_default = (rawHeaders) => { |
|
const parsed = {}; |
|
let key; |
|
let val; |
|
let i; |
|
rawHeaders && rawHeaders.split("\n").forEach(function parser(line) { |
|
i = line.indexOf(":"); |
|
key = line.substring(0, i).trim().toLowerCase(); |
|
val = line.substring(i + 1).trim(); |
|
if (!key || parsed[key] && ignoreDuplicateOf[key]) { |
|
return; |
|
} |
|
if (key === "set-cookie") { |
|
if (parsed[key]) { |
|
parsed[key].push(val); |
|
} else { |
|
parsed[key] = [val]; |
|
} |
|
} else { |
|
parsed[key] = parsed[key] ? parsed[key] + ", " + val : val; |
|
} |
|
}); |
|
return parsed; |
|
}; |
|
|
|
// node_modules/axios/lib/core/AxiosHeaders.js |
|
"use strict"; |
|
var $internals = Symbol("internals"); |
|
function normalizeHeader(header) { |
|
return header && String(header).trim().toLowerCase(); |
|
} |
|
function normalizeValue(value) { |
|
if (value === false || value == null) { |
|
return value; |
|
} |
|
return utils_default.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; |
|
} |
|
var isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim()); |
|
function matchHeaderValue(context, value, header, filter2, isHeaderNameFilter) { |
|
if (utils_default.isFunction(filter2)) { |
|
return filter2.call(this, value, header); |
|
} |
|
if (isHeaderNameFilter) { |
|
value = header; |
|
} |
|
if (!utils_default.isString(value)) |
|
return; |
|
if (utils_default.isString(filter2)) { |
|
return value.indexOf(filter2) !== -1; |
|
} |
|
if (utils_default.isRegExp(filter2)) { |
|
return filter2.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_default.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 |
|
}); |
|
}); |
|
} |
|
var AxiosHeaders = class { |
|
constructor(headers) { |
|
headers && this.set(headers); |
|
} |
|
set(header, valueOrRewrite, rewrite) { |
|
const self2 = 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_default.findKey(self2, lHeader); |
|
if (!key || self2[key] === void 0 || _rewrite === true || _rewrite === void 0 && self2[key] !== false) { |
|
self2[key || _header] = normalizeValue(_value); |
|
} |
|
} |
|
const setHeaders = (headers, _rewrite) => utils_default.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite)); |
|
if (utils_default.isPlainObject(header) || header instanceof this.constructor) { |
|
setHeaders(header, valueOrRewrite); |
|
} else if (utils_default.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) { |
|
setHeaders(parseHeaders_default(header), valueOrRewrite); |
|
} else if (utils_default.isHeaders(header)) { |
|
for (const [key, value] of header.entries()) { |
|
setHeader(value, key, rewrite); |
|
} |
|
} else { |
|
header != null && setHeader(valueOrRewrite, header, rewrite); |
|
} |
|
return this; |
|
} |
|
get(header, parser) { |
|
header = normalizeHeader(header); |
|
if (header) { |
|
const key = utils_default.findKey(this, header); |
|
if (key) { |
|
const value = this[key]; |
|
if (!parser) { |
|
return value; |
|
} |
|
if (parser === true) { |
|
return parseTokens(value); |
|
} |
|
if (utils_default.isFunction(parser)) { |
|
return parser.call(this, value, key); |
|
} |
|
if (utils_default.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_default.findKey(this, header); |
|
return !!(key && this[key] !== void 0 && (!matcher || matchHeaderValue(this, this[key], key, matcher))); |
|
} |
|
return false; |
|
} |
|
delete(header, matcher) { |
|
const self2 = this; |
|
let deleted = false; |
|
function deleteHeader(_header) { |
|
_header = normalizeHeader(_header); |
|
if (_header) { |
|
const key = utils_default.findKey(self2, _header); |
|
if (key && (!matcher || matchHeaderValue(self2, self2[key], key, matcher))) { |
|
delete self2[key]; |
|
deleted = true; |
|
} |
|
} |
|
} |
|
if (utils_default.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 self2 = this; |
|
const headers = {}; |
|
utils_default.forEach(this, (value, header) => { |
|
const key = utils_default.findKey(headers, header); |
|
if (key) { |
|
self2[key] = normalizeValue(value); |
|
delete self2[header]; |
|
return; |
|
} |
|
const normalized = format ? formatHeader(header) : String(header).trim(); |
|
if (normalized !== header) { |
|
delete self2[header]; |
|
} |
|
self2[normalized] = normalizeValue(value); |
|
headers[normalized] = true; |
|
}); |
|
return this; |
|
} |
|
concat(...targets) { |
|
return this.constructor.concat(this, ...targets); |
|
} |
|
toJSON(asStrings) { |
|
const obj = Object.create(null); |
|
utils_default.forEach(this, (value, header) => { |
|
value != null && value !== false && (obj[header] = asStrings && utils_default.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"); |
|
} |
|
get [Symbol.toStringTag]() { |
|
return "AxiosHeaders"; |
|
} |
|
static from(thing) { |
|
return thing instanceof this ? thing : new this(thing); |
|
} |
|
static concat(first, ...targets) { |
|
const computed = new this(first); |
|
targets.forEach((target) => computed.set(target)); |
|
return computed; |
|
} |
|
static accessor(header) { |
|
const internals = this[$internals] = this[$internals] = { |
|
accessors: {} |
|
}; |
|
const accessors = internals.accessors; |
|
const prototype3 = this.prototype; |
|
function defineAccessor(_header) { |
|
const lHeader = normalizeHeader(_header); |
|
if (!accessors[lHeader]) { |
|
buildAccessors(prototype3, _header); |
|
accessors[lHeader] = true; |
|
} |
|
} |
|
utils_default.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header); |
|
return this; |
|
} |
|
}; |
|
AxiosHeaders.accessor(["Content-Type", "Content-Length", "Accept", "Accept-Encoding", "User-Agent", "Authorization"]); |
|
utils_default.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key) => { |
|
let mapped = key[0].toUpperCase() + key.slice(1); |
|
return { |
|
get: () => value, |
|
set(headerValue) { |
|
this[mapped] = headerValue; |
|
} |
|
}; |
|
}); |
|
utils_default.freezeMethods(AxiosHeaders); |
|
var AxiosHeaders_default = AxiosHeaders; |
|
|
|
// node_modules/axios/lib/core/transformData.js |
|
"use strict"; |
|
function transformData(fns, response) { |
|
const config = this || defaults_default; |
|
const context = response || config; |
|
const headers = AxiosHeaders_default.from(context.headers); |
|
let data = context.data; |
|
utils_default.forEach(fns, function transform(fn) { |
|
data = fn.call(config, data, headers.normalize(), response ? response.status : void 0); |
|
}); |
|
headers.normalize(); |
|
return data; |
|
} |
|
|
|
// node_modules/axios/lib/cancel/isCancel.js |
|
"use strict"; |
|
function isCancel(value) { |
|
return !!(value && value.__CANCEL__); |
|
} |
|
|
|
// node_modules/axios/lib/cancel/CanceledError.js |
|
"use strict"; |
|
function CanceledError(message, config, request) { |
|
AxiosError_default.call(this, message == null ? "canceled" : message, AxiosError_default.ERR_CANCELED, config, request); |
|
this.name = "CanceledError"; |
|
} |
|
utils_default.inherits(CanceledError, AxiosError_default, { |
|
__CANCEL__: true |
|
}); |
|
var CanceledError_default = CanceledError; |
|
|
|
// node_modules/axios/lib/core/settle.js |
|
"use strict"; |
|
function settle(resolve, reject, response) { |
|
const validateStatus2 = response.config.validateStatus; |
|
if (!response.status || !validateStatus2 || validateStatus2(response.status)) { |
|
resolve(response); |
|
} else { |
|
reject(new AxiosError_default("Request failed with status code " + response.status, [AxiosError_default.ERR_BAD_REQUEST, AxiosError_default.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4], response.config, response.request, response)); |
|
} |
|
} |
|
|
|
// node_modules/axios/lib/helpers/parseProtocol.js |
|
"use strict"; |
|
function parseProtocol(url) { |
|
const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url); |
|
return match && match[1] || ""; |
|
} |
|
|
|
// node_modules/axios/lib/helpers/speedometer.js |
|
"use strict"; |
|
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 !== void 0 ? min : 1e3; |
|
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 * 1e3 / passed) : void 0; |
|
}; |
|
} |
|
var speedometer_default = speedometer; |
|
|
|
// node_modules/axios/lib/helpers/throttle.js |
|
function throttle(fn, freq) { |
|
let timestamp = 0; |
|
let threshold = 1e3 / freq; |
|
let lastArgs; |
|
let timer; |
|
const invoke = (args, now = Date.now()) => { |
|
timestamp = now; |
|
lastArgs = null; |
|
if (timer) { |
|
clearTimeout(timer); |
|
timer = null; |
|
} |
|
fn.apply(null, 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]; |
|
} |
|
var throttle_default = throttle; |
|
|
|
// node_modules/axios/lib/helpers/progressEventReducer.js |
|
var progressEventReducer = (listener, isDownloadStream, freq = 3) => { |
|
let bytesNotified = 0; |
|
const _speedometer = speedometer_default(50, 250); |
|
return throttle_default((e) => { |
|
const loaded = e.loaded; |
|
const total = e.lengthComputable ? e.total : void 0; |
|
const progressBytes = loaded - bytesNotified; |
|
const rate = _speedometer(progressBytes); |
|
const inRange = loaded <= total; |
|
bytesNotified = loaded; |
|
const data = { |
|
loaded, |
|
total, |
|
progress: total ? loaded / total : void 0, |
|
bytes: progressBytes, |
|
rate: rate ? rate : void 0, |
|
estimated: rate && total && inRange ? (total - loaded) / rate : void 0, |
|
event: e, |
|
lengthComputable: total != null, |
|
[isDownloadStream ? "download" : "upload"]: true |
|
}; |
|
listener(data); |
|
}, freq); |
|
}; |
|
var progressEventDecorator = (total, throttled) => { |
|
const lengthComputable = total != null; |
|
return [(loaded) => throttled[0]({ |
|
lengthComputable, |
|
total, |
|
loaded |
|
}), throttled[1]]; |
|
}; |
|
var asyncDecorator = (fn) => (...args) => utils_default.asap(() => fn(...args)); |
|
|
|
// node_modules/axios/lib/helpers/isURLSameOrigin.js |
|
"use strict"; |
|
var isURLSameOrigin_default = platform_default.hasStandardBrowserEnv ? function standardBrowserEnv() { |
|
const msie = platform_default.navigator && /(msie|trident)/i.test(platform_default.navigator.userAgent); |
|
const urlParsingNode = document.createElement("a"); |
|
let originURL; |
|
function resolveURL(url) { |
|
let href = url; |
|
if (msie) { |
|
urlParsingNode.setAttribute("href", href); |
|
href = urlParsingNode.href; |
|
} |
|
urlParsingNode.setAttribute("href", href); |
|
return { |
|
href: urlParsingNode.href, |
|
protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, "") : "", |
|
host: urlParsingNode.host, |
|
search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, "") : "", |
|
hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, "") : "", |
|
hostname: urlParsingNode.hostname, |
|
port: urlParsingNode.port, |
|
pathname: urlParsingNode.pathname.charAt(0) === "/" ? urlParsingNode.pathname : "/" + urlParsingNode.pathname |
|
}; |
|
} |
|
originURL = resolveURL(window.location.href); |
|
return function isURLSameOrigin(requestURL) { |
|
const parsed = utils_default.isString(requestURL) ? resolveURL(requestURL) : requestURL; |
|
return parsed.protocol === originURL.protocol && parsed.host === originURL.host; |
|
}; |
|
}() : function nonStandardBrowserEnv() { |
|
return function isURLSameOrigin() { |
|
return true; |
|
}; |
|
}(); |
|
|
|
// node_modules/axios/lib/helpers/cookies.js |
|
var cookies_default = platform_default.hasStandardBrowserEnv ? { |
|
write(name, value, expires, path, domain, secure) { |
|
const cookie = [name + "=" + encodeURIComponent(value)]; |
|
utils_default.isNumber(expires) && cookie.push("expires=" + new Date(expires).toGMTString()); |
|
utils_default.isString(path) && cookie.push("path=" + path); |
|
utils_default.isString(domain) && cookie.push("domain=" + domain); |
|
secure === true && cookie.push("secure"); |
|
document.cookie = cookie.join("; "); |
|
}, |
|
read(name) { |
|
const match = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)")); |
|
return match ? decodeURIComponent(match[3]) : null; |
|
}, |
|
remove(name) { |
|
this.write(name, "", Date.now() - 864e5); |
|
} |
|
} : { |
|
write() { |
|
}, |
|
read() { |
|
return null; |
|
}, |
|
remove() { |
|
} |
|
}; |
|
|
|
// node_modules/axios/lib/helpers/isAbsoluteURL.js |
|
"use strict"; |
|
function isAbsoluteURL(url) { |
|
return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url); |
|
} |
|
|
|
// node_modules/axios/lib/helpers/combineURLs.js |
|
"use strict"; |
|
function combineURLs(baseURL, relativeURL) { |
|
return relativeURL ? baseURL.replace(/\/?\/$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL; |
|
} |
|
|
|
// node_modules/axios/lib/core/buildFullPath.js |
|
"use strict"; |
|
function buildFullPath(baseURL, requestedURL) { |
|
if (baseURL && !isAbsoluteURL(requestedURL)) { |
|
return combineURLs(baseURL, requestedURL); |
|
} |
|
return requestedURL; |
|
} |
|
|
|
// node_modules/axios/lib/core/mergeConfig.js |
|
"use strict"; |
|
var headersToObject = (thing) => thing instanceof AxiosHeaders_default ? { ...thing } : thing; |
|
function mergeConfig(config1, config2) { |
|
config2 = config2 || {}; |
|
const config = {}; |
|
function getMergedValue(target, source, caseless) { |
|
if (utils_default.isPlainObject(target) && utils_default.isPlainObject(source)) { |
|
return utils_default.merge.call({ caseless }, target, source); |
|
} else if (utils_default.isPlainObject(source)) { |
|
return utils_default.merge({}, source); |
|
} else if (utils_default.isArray(source)) { |
|
return source.slice(); |
|
} |
|
return source; |
|
} |
|
function mergeDeepProperties(a, b, caseless) { |
|
if (!utils_default.isUndefined(b)) { |
|
return getMergedValue(a, b, caseless); |
|
} else if (!utils_default.isUndefined(a)) { |
|
return getMergedValue(void 0, a, caseless); |
|
} |
|
} |
|
function valueFromConfig2(a, b) { |
|
if (!utils_default.isUndefined(b)) { |
|
return getMergedValue(void 0, b); |
|
} |
|
} |
|
function defaultToConfig2(a, b) { |
|
if (!utils_default.isUndefined(b)) { |
|
return getMergedValue(void 0, b); |
|
} else if (!utils_default.isUndefined(a)) { |
|
return getMergedValue(void 0, a); |
|
} |
|
} |
|
function mergeDirectKeys(a, b, prop) { |
|
if (prop in config2) { |
|
return getMergedValue(a, b); |
|
} else if (prop in config1) { |
|
return getMergedValue(void 0, 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, |
|
responseEncoding: defaultToConfig2, |
|
validateStatus: mergeDirectKeys, |
|
headers: (a, b) => mergeDeepProperties(headersToObject(a), headersToObject(b), true) |
|
}; |
|
utils_default.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) { |
|
const merge2 = mergeMap[prop] || mergeDeepProperties; |
|
const configValue = merge2(config1[prop], config2[prop], prop); |
|
utils_default.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue); |
|
}); |
|
return config; |
|
} |
|
|
|
// node_modules/axios/lib/helpers/resolveConfig.js |
|
var resolveConfig_default = (config) => { |
|
const newConfig = mergeConfig({}, config); |
|
let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig; |
|
newConfig.headers = headers = AxiosHeaders_default.from(headers); |
|
newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url), config.params, config.paramsSerializer); |
|
if (auth) { |
|
headers.set("Authorization", "Basic " + btoa((auth.username || "") + ":" + (auth.password ? unescape(encodeURIComponent(auth.password)) : ""))); |
|
} |
|
let contentType; |
|
if (utils_default.isFormData(data)) { |
|
if (platform_default.hasStandardBrowserEnv || platform_default.hasStandardBrowserWebWorkerEnv) { |
|
headers.setContentType(void 0); |
|
} else if ((contentType = headers.getContentType()) !== false) { |
|
const [type, ...tokens] = contentType ? contentType.split(";").map((token) => token.trim()).filter(Boolean) : []; |
|
headers.setContentType([type || "multipart/form-data", ...tokens].join("; ")); |
|
} |
|
} |
|
if (platform_default.hasStandardBrowserEnv) { |
|
withXSRFToken && utils_default.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig)); |
|
if (withXSRFToken || withXSRFToken !== false && isURLSameOrigin_default(newConfig.url)) { |
|
const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies_default.read(xsrfCookieName); |
|
if (xsrfValue) { |
|
headers.set(xsrfHeaderName, xsrfValue); |
|
} |
|
} |
|
} |
|
return newConfig; |
|
}; |
|
|
|
// node_modules/axios/lib/adapters/xhr.js |
|
var isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined"; |
|
var xhr_default = isXHRAdapterSupported && function(config) { |
|
return new Promise(function dispatchXhrRequest(resolve, reject) { |
|
const _config = resolveConfig_default(config); |
|
let requestData = _config.data; |
|
const requestHeaders = AxiosHeaders_default.from(_config.headers).normalize(); |
|
let { responseType, onUploadProgress, onDownloadProgress } = _config; |
|
let onCanceled; |
|
let uploadThrottled, downloadThrottled; |
|
let flushUpload, flushDownload; |
|
function done() { |
|
flushUpload && flushUpload(); |
|
flushDownload && flushDownload(); |
|
_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); |
|
request.timeout = _config.timeout; |
|
function onloadend() { |
|
if (!request) { |
|
return; |
|
} |
|
const responseHeaders = AxiosHeaders_default.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); |
|
request = null; |
|
} |
|
if ("onloadend" in request) { |
|
request.onloadend = onloadend; |
|
} else { |
|
request.onreadystatechange = function handleLoad() { |
|
if (!request || request.readyState !== 4) { |
|
return; |
|
} |
|
if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0)) { |
|
return; |
|
} |
|
setTimeout(onloadend); |
|
}; |
|
} |
|
request.onabort = function handleAbort() { |
|
if (!request) { |
|
return; |
|
} |
|
reject(new AxiosError_default("Request aborted", AxiosError_default.ECONNABORTED, config, request)); |
|
request = null; |
|
}; |
|
request.onerror = function handleError() { |
|
reject(new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config, request)); |
|
request = null; |
|
}; |
|
request.ontimeout = function handleTimeout() { |
|
let timeoutErrorMessage = _config.timeout ? "timeout of " + _config.timeout + "ms exceeded" : "timeout exceeded"; |
|
const transitional2 = _config.transitional || transitional_default; |
|
if (_config.timeoutErrorMessage) { |
|
timeoutErrorMessage = _config.timeoutErrorMessage; |
|
} |
|
reject(new AxiosError_default(timeoutErrorMessage, transitional2.clarifyTimeoutError ? AxiosError_default.ETIMEDOUT : AxiosError_default.ECONNABORTED, config, request)); |
|
request = null; |
|
}; |
|
requestData === void 0 && requestHeaders.setContentType(null); |
|
if ("setRequestHeader" in request) { |
|
utils_default.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) { |
|
request.setRequestHeader(key, val); |
|
}); |
|
} |
|
if (!utils_default.isUndefined(_config.withCredentials)) { |
|
request.withCredentials = !!_config.withCredentials; |
|
} |
|
if (responseType && responseType !== "json") { |
|
request.responseType = _config.responseType; |
|
} |
|
if (onDownloadProgress) { |
|
[downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true); |
|
request.addEventListener("progress", downloadThrottled); |
|
} |
|
if (onUploadProgress && request.upload) { |
|
[uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress); |
|
request.upload.addEventListener("progress", uploadThrottled); |
|
request.upload.addEventListener("loadend", flushUpload); |
|
} |
|
if (_config.cancelToken || _config.signal) { |
|
onCanceled = (cancel) => { |
|
if (!request) { |
|
return; |
|
} |
|
reject(!cancel || cancel.type ? new CanceledError_default(null, config, request) : cancel); |
|
request.abort(); |
|
request = null; |
|
}; |
|
_config.cancelToken && _config.cancelToken.subscribe(onCanceled); |
|
if (_config.signal) { |
|
_config.signal.aborted ? onCanceled() : _config.signal.addEventListener("abort", onCanceled); |
|
} |
|
} |
|
const protocol = parseProtocol(_config.url); |
|
if (protocol && platform_default.protocols.indexOf(protocol) === -1) { |
|
reject(new AxiosError_default("Unsupported protocol " + protocol + ":", AxiosError_default.ERR_BAD_REQUEST, config)); |
|
return; |
|
} |
|
request.send(requestData || null); |
|
}); |
|
}; |
|
|
|
// node_modules/axios/lib/helpers/composeSignals.js |
|
var composeSignals = (signals, timeout) => { |
|
const { length } = signals = signals ? signals.filter(Boolean) : []; |
|
if (timeout || length) { |
|
let controller = new AbortController(); |
|
let aborted; |
|
const onabort = function(reason) { |
|
if (!aborted) { |
|
aborted = true; |
|
unsubscribe(); |
|
const err = reason instanceof Error ? reason : this.reason; |
|
controller.abort(err instanceof AxiosError_default ? err : new CanceledError_default(err instanceof Error ? err.message : err)); |
|
} |
|
}; |
|
let timer = timeout && setTimeout(() => { |
|
timer = null; |
|
onabort(new AxiosError_default(`timeout ${timeout} of ms exceeded`, AxiosError_default.ETIMEDOUT)); |
|
}, timeout); |
|
const unsubscribe = () => { |
|
if (signals) { |
|
timer && clearTimeout(timer); |
|
timer = null; |
|
signals.forEach((signal2) => { |
|
signal2.unsubscribe ? signal2.unsubscribe(onabort) : signal2.removeEventListener("abort", onabort); |
|
}); |
|
signals = null; |
|
} |
|
}; |
|
signals.forEach((signal2) => signal2.addEventListener("abort", onabort)); |
|
const { signal } = controller; |
|
signal.unsubscribe = () => utils_default.asap(unsubscribe); |
|
return signal; |
|
} |
|
}; |
|
var composeSignals_default = composeSignals; |
|
|
|
// node_modules/axios/lib/helpers/trackStream.js |
|
var streamChunk = function* (chunk, chunkSize) { |
|
let len = chunk.byteLength; |
|
if (!chunkSize || len < chunkSize) { |
|
yield chunk; |
|
return; |
|
} |
|
let pos = 0; |
|
let end; |
|
while (pos < len) { |
|
end = pos + chunkSize; |
|
yield chunk.slice(pos, end); |
|
pos = end; |
|
} |
|
}; |
|
var readBytes = async function* (iterable, chunkSize) { |
|
for await (const chunk of readStream(iterable)) { |
|
yield* streamChunk(chunk, chunkSize); |
|
} |
|
}; |
|
var 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(); |
|
} |
|
}; |
|
var 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: done2, value } = await iterator.next(); |
|
if (done2) { |
|
_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 |
|
}); |
|
}; |
|
|
|
// node_modules/axios/lib/adapters/fetch.js |
|
var isFetchSupported = typeof fetch === "function" && typeof Request === "function" && typeof Response === "function"; |
|
var isReadableStreamSupported = isFetchSupported && typeof ReadableStream === "function"; |
|
var encodeText = isFetchSupported && (typeof TextEncoder === "function" ? ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) : async (str) => new Uint8Array(await new Response(str).arrayBuffer())); |
|
var test = (fn, ...args) => { |
|
try { |
|
return !!fn(...args); |
|
} catch (e) { |
|
return false; |
|
} |
|
}; |
|
var supportsRequestStream = isReadableStreamSupported && test(() => { |
|
let duplexAccessed = false; |
|
const hasContentType = new Request(platform_default.origin, { |
|
body: new ReadableStream(), |
|
method: "POST", |
|
get duplex() { |
|
duplexAccessed = true; |
|
return "half"; |
|
} |
|
}).headers.has("Content-Type"); |
|
return duplexAccessed && !hasContentType; |
|
}); |
|
var DEFAULT_CHUNK_SIZE = 64 * 1024; |
|
var supportsResponseStream = isReadableStreamSupported && test(() => utils_default.isReadableStream(new Response("").body)); |
|
var resolvers = { |
|
stream: supportsResponseStream && ((res) => res.body) |
|
}; |
|
isFetchSupported && ((res) => { |
|
["text", "arrayBuffer", "blob", "formData", "stream"].forEach((type) => { |
|
!resolvers[type] && (resolvers[type] = utils_default.isFunction(res[type]) ? (res2) => res2[type]() : (_, config) => { |
|
throw new AxiosError_default(`Response type '${type}' is not supported`, AxiosError_default.ERR_NOT_SUPPORT, config); |
|
}); |
|
}); |
|
})(new Response()); |
|
var getBodyLength = async (body) => { |
|
if (body == null) { |
|
return 0; |
|
} |
|
if (utils_default.isBlob(body)) { |
|
return body.size; |
|
} |
|
if (utils_default.isSpecCompliantForm(body)) { |
|
const _request = new Request(platform_default.origin, { |
|
method: "POST", |
|
body |
|
}); |
|
return (await _request.arrayBuffer()).byteLength; |
|
} |
|
if (utils_default.isArrayBufferView(body) || utils_default.isArrayBuffer(body)) { |
|
return body.byteLength; |
|
} |
|
if (utils_default.isURLSearchParams(body)) { |
|
body = body + ""; |
|
} |
|
if (utils_default.isString(body)) { |
|
return (await encodeText(body)).byteLength; |
|
} |
|
}; |
|
var resolveBodyLength = async (headers, body) => { |
|
const length = utils_default.toFiniteNumber(headers.getContentLength()); |
|
return length == null ? getBodyLength(body) : length; |
|
}; |
|
var fetch_default = isFetchSupported && (async (config) => { |
|
let { |
|
url, |
|
method, |
|
data, |
|
signal, |
|
cancelToken, |
|
timeout, |
|
onDownloadProgress, |
|
onUploadProgress, |
|
responseType, |
|
headers, |
|
withCredentials = "same-origin", |
|
fetchOptions |
|
} = resolveConfig_default(config); |
|
responseType = responseType ? (responseType + "").toLowerCase() : "text"; |
|
let composedSignal = composeSignals_default([signal, cancelToken && cancelToken.toAbortSignal()], timeout); |
|
let request; |
|
const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => { |
|
composedSignal.unsubscribe(); |
|
}); |
|
let requestContentLength; |
|
try { |
|
if (onUploadProgress && supportsRequestStream && method !== "get" && method !== "head" && (requestContentLength = await resolveBodyLength(headers, data)) !== 0) { |
|
let _request = new Request(url, { |
|
method: "POST", |
|
body: data, |
|
duplex: "half" |
|
}); |
|
let contentTypeHeader; |
|
if (utils_default.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) { |
|
headers.setContentType(contentTypeHeader); |
|
} |
|
if (_request.body) { |
|
const [onProgress, flush] = progressEventDecorator(requestContentLength, progressEventReducer(asyncDecorator(onUploadProgress))); |
|
data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush); |
|
} |
|
} |
|
if (!utils_default.isString(withCredentials)) { |
|
withCredentials = withCredentials ? "include" : "omit"; |
|
} |
|
const isCredentialsSupported = "credentials" in Request.prototype; |
|
request = new Request(url, { |
|
...fetchOptions, |
|
signal: composedSignal, |
|
method: method.toUpperCase(), |
|
headers: headers.normalize().toJSON(), |
|
body: data, |
|
duplex: "half", |
|
credentials: isCredentialsSupported ? withCredentials : void 0 |
|
}); |
|
let response = await fetch(request); |
|
const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response"); |
|
if (supportsResponseStream && (onDownloadProgress || isStreamResponse && unsubscribe)) { |
|
const options = {}; |
|
["status", "statusText", "headers"].forEach((prop) => { |
|
options[prop] = response[prop]; |
|
}); |
|
const responseContentLength = utils_default.toFiniteNumber(response.headers.get("content-length")); |
|
const [onProgress, flush] = onDownloadProgress && progressEventDecorator(responseContentLength, progressEventReducer(asyncDecorator(onDownloadProgress), true)) || []; |
|
response = new Response(trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => { |
|
flush && flush(); |
|
unsubscribe && unsubscribe(); |
|
}), options); |
|
} |
|
responseType = responseType || "text"; |
|
let responseData = await resolvers[utils_default.findKey(resolvers, responseType) || "text"](response, config); |
|
!isStreamResponse && unsubscribe && unsubscribe(); |
|
return await new Promise((resolve, reject) => { |
|
settle(resolve, reject, { |
|
data: responseData, |
|
headers: AxiosHeaders_default.from(response.headers), |
|
status: response.status, |
|
statusText: response.statusText, |
|
config, |
|
request |
|
}); |
|
}); |
|
} catch (err) { |
|
unsubscribe && unsubscribe(); |
|
if (err && err.name === "TypeError" && /fetch/i.test(err.message)) { |
|
throw Object.assign(new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config, request), { |
|
cause: err.cause || err |
|
}); |
|
} |
|
throw AxiosError_default.from(err, err && err.code, config, request); |
|
} |
|
}); |
|
|
|
// node_modules/axios/lib/adapters/adapters.js |
|
var knownAdapters = { |
|
http: null_default, |
|
xhr: xhr_default, |
|
fetch: fetch_default |
|
}; |
|
utils_default.forEach(knownAdapters, (fn, value) => { |
|
if (fn) { |
|
try { |
|
Object.defineProperty(fn, "name", { value }); |
|
} catch (e) { |
|
} |
|
Object.defineProperty(fn, "adapterName", { value }); |
|
} |
|
}); |
|
var renderReason = (reason) => `- ${reason}`; |
|
var isResolvedHandle = (adapter) => utils_default.isFunction(adapter) || adapter === null || adapter === false; |
|
var adapters_default = { |
|
getAdapter: (adapters) => { |
|
adapters = utils_default.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 === void 0) { |
|
throw new AxiosError_default(`Unknown adapter '${id}'`); |
|
} |
|
} |
|
if (adapter) { |
|
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_default(`There is no suitable adapter to dispatch the request ` + s, "ERR_NOT_SUPPORT"); |
|
} |
|
return adapter; |
|
}, |
|
adapters: knownAdapters |
|
}; |
|
|
|
// node_modules/axios/lib/core/dispatchRequest.js |
|
"use strict"; |
|
function throwIfCancellationRequested(config) { |
|
if (config.cancelToken) { |
|
config.cancelToken.throwIfRequested(); |
|
} |
|
if (config.signal && config.signal.aborted) { |
|
throw new CanceledError_default(null, config); |
|
} |
|
} |
|
function dispatchRequest(config) { |
|
throwIfCancellationRequested(config); |
|
config.headers = AxiosHeaders_default.from(config.headers); |
|
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_default.getAdapter(config.adapter || defaults_default.adapter); |
|
return adapter(config).then(function onAdapterResolution(response) { |
|
throwIfCancellationRequested(config); |
|
response.data = transformData.call(config, config.transformResponse, response); |
|
response.headers = AxiosHeaders_default.from(response.headers); |
|
return response; |
|
}, function onAdapterRejection(reason) { |
|
if (!isCancel(reason)) { |
|
throwIfCancellationRequested(config); |
|
if (reason && reason.response) { |
|
reason.response.data = transformData.call(config, config.transformResponse, reason.response); |
|
reason.response.headers = AxiosHeaders_default.from(reason.response.headers); |
|
} |
|
} |
|
return Promise.reject(reason); |
|
}); |
|
} |
|
|
|
// node_modules/axios/lib/env/data.js |
|
var VERSION = "1.7.7"; |
|
|
|
// node_modules/axios/lib/helpers/validator.js |
|
"use strict"; |
|
var validators = {}; |
|
["object", "boolean", "number", "function", "string", "symbol"].forEach((type, i) => { |
|
validators[type] = function validator(thing) { |
|
return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type; |
|
}; |
|
}); |
|
var deprecatedWarnings = {}; |
|
validators.transitional = function transitional(validator, version, message) { |
|
function formatMessage(opt, desc) { |
|
return "[Axios v" + VERSION + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : ""); |
|
} |
|
return (value, opt, opts) => { |
|
if (validator === false) { |
|
throw new AxiosError_default(formatMessage(opt, " has been removed" + (version ? " in " + version : "")), AxiosError_default.ERR_DEPRECATED); |
|
} |
|
if (version && !deprecatedWarnings[opt]) { |
|
deprecatedWarnings[opt] = true; |
|
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; |
|
}; |
|
}; |
|
function assertOptions(options, schema, allowUnknown) { |
|
if (typeof options !== "object") { |
|
throw new AxiosError_default("options must be an object", AxiosError_default.ERR_BAD_OPTION_VALUE); |
|
} |
|
const keys = Object.keys(options); |
|
let i = keys.length; |
|
while (i-- > 0) { |
|
const opt = keys[i]; |
|
const validator = schema[opt]; |
|
if (validator) { |
|
const value = options[opt]; |
|
const result = value === void 0 || validator(value, opt, options); |
|
if (result !== true) { |
|
throw new AxiosError_default("option " + opt + " must be " + result, AxiosError_default.ERR_BAD_OPTION_VALUE); |
|
} |
|
continue; |
|
} |
|
if (allowUnknown !== true) { |
|
throw new AxiosError_default("Unknown option " + opt, AxiosError_default.ERR_BAD_OPTION); |
|
} |
|
} |
|
} |
|
var validator_default = { |
|
assertOptions, |
|
validators |
|
}; |
|
|
|
// node_modules/axios/lib/core/Axios.js |
|
"use strict"; |
|
var validators2 = validator_default.validators; |
|
var Axios = class { |
|
constructor(instanceConfig) { |
|
this.defaults = instanceConfig; |
|
this.interceptors = { |
|
request: new InterceptorManager_default(), |
|
response: new InterceptorManager_default() |
|
}; |
|
} |
|
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(); |
|
const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, "") : ""; |
|
try { |
|
if (!err.stack) { |
|
err.stack = stack; |
|
} else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ""))) { |
|
err.stack += "\n" + stack; |
|
} |
|
} catch (e) { |
|
} |
|
} |
|
throw err; |
|
} |
|
} |
|
_request(configOrUrl, config) { |
|
if (typeof configOrUrl === "string") { |
|
config = config || {}; |
|
config.url = configOrUrl; |
|
} else { |
|
config = configOrUrl || {}; |
|
} |
|
config = mergeConfig(this.defaults, config); |
|
const { transitional: transitional2, paramsSerializer, headers } = config; |
|
if (transitional2 !== void 0) { |
|
validator_default.assertOptions(transitional2, { |
|
silentJSONParsing: validators2.transitional(validators2.boolean), |
|
forcedJSONParsing: validators2.transitional(validators2.boolean), |
|
clarifyTimeoutError: validators2.transitional(validators2.boolean) |
|
}, false); |
|
} |
|
if (paramsSerializer != null) { |
|
if (utils_default.isFunction(paramsSerializer)) { |
|
config.paramsSerializer = { |
|
serialize: paramsSerializer |
|
}; |
|
} else { |
|
validator_default.assertOptions(paramsSerializer, { |
|
encode: validators2.function, |
|
serialize: validators2.function |
|
}, true); |
|
} |
|
} |
|
config.method = (config.method || this.defaults.method || "get").toLowerCase(); |
|
let contextHeaders = headers && utils_default.merge(headers.common, headers[config.method]); |
|
headers && utils_default.forEach(["delete", "get", "head", "post", "put", "patch", "common"], (method) => { |
|
delete headers[method]; |
|
}); |
|
config.headers = AxiosHeaders_default.concat(contextHeaders, headers); |
|
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; |
|
requestInterceptorChain.unshift(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), void 0]; |
|
chain.unshift.apply(chain, requestInterceptorChain); |
|
chain.push.apply(chain, 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; |
|
i = 0; |
|
while (i < len) { |
|
const onFulfilled = requestInterceptorChain[i++]; |
|
const onRejected = requestInterceptorChain[i++]; |
|
try { |
|
newConfig = onFulfilled(newConfig); |
|
} catch (error) { |
|
onRejected.call(this, error); |
|
break; |
|
} |
|
} |
|
try { |
|
promise = dispatchRequest.call(this, newConfig); |
|
} catch (error) { |
|
return Promise.reject(error); |
|
} |
|
i = 0; |
|
len = responseInterceptorChain.length; |
|
while (i < len) { |
|
promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]); |
|
} |
|
return promise; |
|
} |
|
getUri(config) { |
|
config = mergeConfig(this.defaults, config); |
|
const fullPath = buildFullPath(config.baseURL, config.url); |
|
return buildURL(fullPath, config.params, config.paramsSerializer); |
|
} |
|
}; |
|
utils_default.forEach(["delete", "get", "head", "options"], function forEachMethodNoData(method) { |
|
Axios.prototype[method] = function(url, config) { |
|
return this.request(mergeConfig(config || {}, { |
|
method, |
|
url, |
|
data: (config || {}).data |
|
})); |
|
}; |
|
}); |
|
utils_default.forEach(["post", "put", "patch"], function forEachMethodWithData(method) { |
|
function generateHTTPMethod(isForm) { |
|
return function httpMethod(url, data, config) { |
|
return this.request(mergeConfig(config || {}, { |
|
method, |
|
headers: isForm ? { |
|
"Content-Type": "multipart/form-data" |
|
} : {}, |
|
url, |
|
data |
|
})); |
|
}; |
|
} |
|
Axios.prototype[method] = generateHTTPMethod(); |
|
Axios.prototype[method + "Form"] = generateHTTPMethod(true); |
|
}); |
|
var Axios_default = Axios; |
|
|
|
// node_modules/axios/lib/cancel/CancelToken.js |
|
"use strict"; |
|
var CancelToken = class { |
|
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; |
|
this.promise.then((cancel) => { |
|
if (!token._listeners) |
|
return; |
|
let i = token._listeners.length; |
|
while (i-- > 0) { |
|
token._listeners[i](cancel); |
|
} |
|
token._listeners = null; |
|
}); |
|
this.promise.then = (onfulfilled) => { |
|
let _resolve; |
|
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) { |
|
return; |
|
} |
|
token.reason = new CanceledError_default(message, config, request); |
|
resolvePromise(token.reason); |
|
}); |
|
} |
|
throwIfRequested() { |
|
if (this.reason) { |
|
throw this.reason; |
|
} |
|
} |
|
subscribe(listener) { |
|
if (this.reason) { |
|
listener(this.reason); |
|
return; |
|
} |
|
if (this._listeners) { |
|
this._listeners.push(listener); |
|
} else { |
|
this._listeners = [listener]; |
|
} |
|
} |
|
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; |
|
} |
|
static source() { |
|
let cancel; |
|
const token = new CancelToken(function executor(c) { |
|
cancel = c; |
|
}); |
|
return { |
|
token, |
|
cancel |
|
}; |
|
} |
|
}; |
|
var CancelToken_default = CancelToken; |
|
|
|
// node_modules/axios/lib/helpers/spread.js |
|
"use strict"; |
|
function spread(callback) { |
|
return function wrap(arr) { |
|
return callback.apply(null, arr); |
|
}; |
|
} |
|
|
|
// node_modules/axios/lib/helpers/isAxiosError.js |
|
"use strict"; |
|
function isAxiosError(payload) { |
|
return utils_default.isObject(payload) && payload.isAxiosError === true; |
|
} |
|
|
|
// node_modules/axios/lib/helpers/HttpStatusCode.js |
|
var 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 |
|
}; |
|
Object.entries(HttpStatusCode).forEach(([key, value]) => { |
|
HttpStatusCode[value] = key; |
|
}); |
|
var HttpStatusCode_default = HttpStatusCode; |
|
|
|
// node_modules/axios/lib/axios.js |
|
"use strict"; |
|
function createInstance(defaultConfig) { |
|
const context = new Axios_default(defaultConfig); |
|
const instance = bind(Axios_default.prototype.request, context); |
|
utils_default.extend(instance, Axios_default.prototype, context, { allOwnKeys: true }); |
|
utils_default.extend(instance, context, null, { allOwnKeys: true }); |
|
instance.create = function create(instanceConfig) { |
|
return createInstance(mergeConfig(defaultConfig, instanceConfig)); |
|
}; |
|
return instance; |
|
} |
|
var axios = createInstance(defaults_default); |
|
axios.Axios = Axios_default; |
|
axios.CanceledError = CanceledError_default; |
|
axios.CancelToken = CancelToken_default; |
|
axios.isCancel = isCancel; |
|
axios.VERSION = VERSION; |
|
axios.toFormData = toFormData_default; |
|
axios.AxiosError = AxiosError_default; |
|
axios.Cancel = axios.CanceledError; |
|
axios.all = function all(promises) { |
|
return Promise.all(promises); |
|
}; |
|
axios.spread = spread; |
|
axios.isAxiosError = isAxiosError; |
|
axios.mergeConfig = mergeConfig; |
|
axios.AxiosHeaders = AxiosHeaders_default; |
|
axios.formToJSON = (thing) => formDataToJSON_default(utils_default.isHTMLForm(thing) ? new FormData(thing) : thing); |
|
axios.getAdapter = adapters_default.getAdapter; |
|
axios.HttpStatusCode = HttpStatusCode_default; |
|
axios.default = axios; |
|
var axios_default = axios; |
|
|
|
// node_modules/axios/index.js |
|
var { |
|
Axios: Axios2, |
|
AxiosError: AxiosError2, |
|
CanceledError: CanceledError2, |
|
isCancel: isCancel2, |
|
CancelToken: CancelToken2, |
|
VERSION: VERSION2, |
|
all: all2, |
|
Cancel, |
|
isAxiosError: isAxiosError2, |
|
spread: spread2, |
|
toFormData: toFormData2, |
|
AxiosHeaders: AxiosHeaders2, |
|
HttpStatusCode: HttpStatusCode2, |
|
formToJSON, |
|
getAdapter, |
|
mergeConfig: mergeConfig2 |
|
} = axios_default; |
|
|
|
// dep:axios |
|
var axios_default2 = axios_default; |
|
export { |
|
Axios2 as Axios, |
|
AxiosError2 as AxiosError, |
|
AxiosHeaders2 as AxiosHeaders, |
|
Cancel, |
|
CancelToken2 as CancelToken, |
|
CanceledError2 as CanceledError, |
|
HttpStatusCode2 as HttpStatusCode, |
|
VERSION2 as VERSION, |
|
all2 as all, |
|
axios_default2 as default, |
|
formToJSON, |
|
getAdapter, |
|
isAxiosError2 as isAxiosError, |
|
isCancel2 as isCancel, |
|
mergeConfig2 as mergeConfig, |
|
spread2 as spread, |
|
toFormData2 as toFormData |
|
}; |
|
//# sourceMappingURL=axios.js.map
|
|
|