diff --git a/index.html b/index.html index ee33c50b..9c6a1389 100644 --- a/index.html +++ b/index.html @@ -4,7 +4,7 @@ - Vite App + 洛阳百姓问政 @@ -13,4 +13,4 @@ - \ No newline at end of file + diff --git a/node_modules/.vite/_metadata.json b/node_modules/.vite/_metadata.json index 7a9d7e73..414ea710 100644 --- a/node_modules/.vite/_metadata.json +++ b/node_modules/.vite/_metadata.json @@ -1,7 +1,12 @@ { "hash": "fa4efea0", - "browserHash": "4777f668", + "browserHash": "c6181f89", "optimized": { + "axios": { + "file": "E:/小程序/百姓问政PC/pc/node_modules/.vite/axios.js", + "src": "E:/小程序/百姓问政PC/pc/node_modules/axios/index.js", + "needsInterop": false + }, "vue": { "file": "E:/小程序/百姓问政PC/pc/node_modules/.vite/vue.js", "src": "E:/小程序/百姓问政PC/pc/node_modules/vue/dist/vue.runtime.esm-bundler.js", diff --git a/node_modules/.vite/axios.js b/node_modules/.vite/axios.js new file mode 100644 index 00000000..c50dbb84 --- /dev/null +++ b/node_modules/.vite/axios.js @@ -0,0 +1,2062 @@ +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 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) => { + value = +value; + return Number.isFinite(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 utils_default = { + isArray, + isArrayBuffer, + isBuffer, + isFormData, + isArrayBufferView, + isString, + isNumber, + isBoolean, + isObject, + isPlainObject, + 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 +}; + +// 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); + response && (this.response = response); +} +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.response && this.response.status ? this.response.status : null + }; + } +}); +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 +}); +var hasBrowserEnv = typeof window !== "undefined" && typeof document !== "undefined"; +var hasStandardBrowserEnv = ((product) => { + return hasBrowserEnv && ["ReactNative", "NativeScript", "NS"].indexOf(product) < 0; +})(typeof navigator !== "undefined" && navigator.product); +var hasStandardBrowserWebWorkerEnv = (() => { + return typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope && typeof self.importScripts === "function"; +})(); + +// 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"], + 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)) { + 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 (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 { + 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/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/helpers/isURLSameOrigin.js +"use strict"; +var isURLSameOrigin_default = platform_default.hasStandardBrowserEnv ? function standardBrowserEnv() { + const msie = /(msie|trident)/i.test(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/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/adapters/xhr.js +"use strict"; +function progressEventReducer(listener, isDownloadStream) { + let bytesNotified = 0; + const _speedometer = speedometer_default(50, 250); + return (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 + }; + data[isDownloadStream ? "download" : "upload"] = true; + listener(data); + }; +} +var isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined"; +var xhr_default = isXHRAdapterSupported && function(config) { + return new Promise(function dispatchXhrRequest(resolve, reject) { + let requestData = config.data; + const requestHeaders = AxiosHeaders_default.from(config.headers).normalize(); + let { responseType, withXSRFToken } = config; + let onCanceled; + function done() { + if (config.cancelToken) { + config.cancelToken.unsubscribe(onCanceled); + } + if (config.signal) { + config.signal.removeEventListener("abort", onCanceled); + } + } + let contentType; + if (utils_default.isFormData(requestData)) { + if (platform_default.hasStandardBrowserEnv || platform_default.hasStandardBrowserWebWorkerEnv) { + requestHeaders.setContentType(false); + } else if ((contentType = requestHeaders.getContentType()) !== false) { + const [type, ...tokens] = contentType ? contentType.split(";").map((token) => token.trim()).filter(Boolean) : []; + requestHeaders.setContentType([type || "multipart/form-data", ...tokens].join("; ")); + } + } + let request = new XMLHttpRequest(); + if (config.auth) { + const username = config.auth.username || ""; + const password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : ""; + requestHeaders.set("Authorization", "Basic " + btoa(username + ":" + password)); + } + const fullPath = buildFullPath(config.baseURL, config.url); + request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), 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; + }; + if (platform_default.hasStandardBrowserEnv) { + withXSRFToken && utils_default.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(config)); + if (withXSRFToken || withXSRFToken !== false && isURLSameOrigin_default(fullPath)) { + const xsrfValue = config.xsrfHeaderName && config.xsrfCookieName && cookies_default.read(config.xsrfCookieName); + if (xsrfValue) { + requestHeaders.set(config.xsrfHeaderName, xsrfValue); + } + } + } + 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 (typeof config.onDownloadProgress === "function") { + request.addEventListener("progress", progressEventReducer(config.onDownloadProgress, true)); + } + if (typeof config.onUploadProgress === "function" && request.upload) { + request.upload.addEventListener("progress", progressEventReducer(config.onUploadProgress)); + } + 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(fullPath); + 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/adapters/adapters.js +var knownAdapters = { + http: null_default, + xhr: xhr_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/core/mergeConfig.js +"use strict"; +var headersToObject = (thing) => thing instanceof AxiosHeaders_default ? thing.toJSON() : 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/env/data.js +var VERSION = "1.6.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/, "") : ""; + if (!err.stack) { + err.stack = stack; + } else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ""))) { + err.stack += "\n" + stack; + } + } + 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); + } + } + 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 diff --git a/node_modules/.vite/axios.js.map b/node_modules/.vite/axios.js.map new file mode 100644 index 00000000..87169f16 --- /dev/null +++ b/node_modules/.vite/axios.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../axios/lib/helpers/bind.js", "../axios/lib/utils.js", "../axios/lib/core/AxiosError.js", "../axios/lib/helpers/null.js", "../axios/lib/helpers/toFormData.js", "../axios/lib/helpers/AxiosURLSearchParams.js", "../axios/lib/helpers/buildURL.js", "../axios/lib/core/InterceptorManager.js", "../axios/lib/defaults/transitional.js", "../axios/lib/platform/browser/classes/URLSearchParams.js", "../axios/lib/platform/browser/classes/FormData.js", "../axios/lib/platform/browser/classes/Blob.js", "../axios/lib/platform/browser/index.js", "../axios/lib/platform/common/utils.js", "../axios/lib/platform/index.js", "../axios/lib/helpers/toURLEncodedForm.js", "../axios/lib/helpers/formDataToJSON.js", "../axios/lib/defaults/index.js", "../axios/lib/helpers/parseHeaders.js", "../axios/lib/core/AxiosHeaders.js", "../axios/lib/core/transformData.js", "../axios/lib/cancel/isCancel.js", "../axios/lib/cancel/CanceledError.js", "../axios/lib/core/settle.js", "../axios/lib/helpers/cookies.js", "../axios/lib/helpers/isAbsoluteURL.js", "../axios/lib/helpers/combineURLs.js", "../axios/lib/core/buildFullPath.js", "../axios/lib/helpers/isURLSameOrigin.js", "../axios/lib/helpers/parseProtocol.js", "../axios/lib/helpers/speedometer.js", "../axios/lib/adapters/xhr.js", "../axios/lib/adapters/adapters.js", "../axios/lib/core/dispatchRequest.js", "../axios/lib/core/mergeConfig.js", "../axios/lib/env/data.js", "../axios/lib/helpers/validator.js", "../axios/lib/core/Axios.js", "../axios/lib/cancel/CancelToken.js", "../axios/lib/helpers/spread.js", "../axios/lib/helpers/isAxiosError.js", "../axios/lib/helpers/HttpStatusCode.js", "../axios/lib/axios.js", "../axios/index.js", "dep:axios"], + "sourcesContent": ["'use strict';\n\nexport default function bind(fn, thisArg) {\n return function wrap() {\n return fn.apply(thisArg, arguments);\n };\n}\n", "'use strict';\n\nimport bind from './helpers/bind.js';\n\n// utils is a library of generic helper functions non-specific to axios\n\nconst {toString} = Object.prototype;\nconst {getPrototypeOf} = Object;\n\nconst kindOf = (cache => thing => {\n const str = toString.call(thing);\n return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());\n})(Object.create(null));\n\nconst kindOfTest = (type) => {\n type = type.toLowerCase();\n return (thing) => kindOf(thing) === type\n}\n\nconst typeOfTest = type => thing => typeof thing === type;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n *\n * @returns {boolean} True if value is an Array, otherwise false\n */\nconst {isArray} = Array;\n\n/**\n * Determine if a value is undefined\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nconst isUndefined = typeOfTest('undefined');\n\n/**\n * Determine if a value is a Buffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Buffer, otherwise false\n */\nfunction isBuffer(val) {\n return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)\n && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nconst isArrayBuffer = kindOfTest('ArrayBuffer');\n\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n let result;\n if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n result = ArrayBuffer.isView(val);\n } else {\n result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));\n }\n return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a String, otherwise false\n */\nconst isString = typeOfTest('string');\n\n/**\n * Determine if a value is a Function\n *\n * @param {*} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nconst isFunction = typeOfTest('function');\n\n/**\n * Determine if a value is a Number\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Number, otherwise false\n */\nconst isNumber = typeOfTest('number');\n\n/**\n * Determine if a value is an Object\n *\n * @param {*} thing The value to test\n *\n * @returns {boolean} True if value is an Object, otherwise false\n */\nconst isObject = (thing) => thing !== null && typeof thing === 'object';\n\n/**\n * Determine if a value is a Boolean\n *\n * @param {*} thing The value to test\n * @returns {boolean} True if value is a Boolean, otherwise false\n */\nconst isBoolean = thing => thing === true || thing === false;\n\n/**\n * Determine if a value is a plain Object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a plain Object, otherwise false\n */\nconst isPlainObject = (val) => {\n if (kindOf(val) !== 'object') {\n return false;\n }\n\n const prototype = getPrototypeOf(val);\n return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in val) && !(Symbol.iterator in val);\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Date, otherwise false\n */\nconst isDate = kindOfTest('Date');\n\n/**\n * Determine if a value is a File\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a File, otherwise false\n */\nconst isFile = kindOfTest('File');\n\n/**\n * Determine if a value is a Blob\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nconst isBlob = kindOfTest('Blob');\n\n/**\n * Determine if a value is a FileList\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a File, otherwise false\n */\nconst isFileList = kindOfTest('FileList');\n\n/**\n * Determine if a value is a Stream\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nconst isStream = (val) => isObject(val) && isFunction(val.pipe);\n\n/**\n * Determine if a value is a FormData\n *\n * @param {*} thing The value to test\n *\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nconst isFormData = (thing) => {\n let kind;\n return thing && (\n (typeof FormData === 'function' && thing instanceof FormData) || (\n isFunction(thing.append) && (\n (kind = kindOf(thing)) === 'formdata' ||\n // detect form-data instance\n (kind === 'object' && isFunction(thing.toString) && thing.toString() === '[object FormData]')\n )\n )\n )\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nconst isURLSearchParams = kindOfTest('URLSearchParams');\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n *\n * @returns {String} The String freed of excess whitespace\n */\nconst trim = (str) => str.trim ?\n str.trim() : str.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n *\n * @param {Boolean} [allOwnKeys = false]\n * @returns {any}\n */\nfunction forEach(obj, fn, {allOwnKeys = false} = {}) {\n // Don't bother if no value provided\n if (obj === null || typeof obj === 'undefined') {\n return;\n }\n\n let i;\n let l;\n\n // Force an array if not already something iterable\n if (typeof obj !== 'object') {\n /*eslint no-param-reassign:0*/\n obj = [obj];\n }\n\n if (isArray(obj)) {\n // Iterate over array values\n for (i = 0, l = obj.length; i < l; i++) {\n fn.call(null, obj[i], i, obj);\n }\n } else {\n // Iterate over object keys\n const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);\n const len = keys.length;\n let key;\n\n for (i = 0; i < len; i++) {\n key = keys[i];\n fn.call(null, obj[key], key, obj);\n }\n }\n}\n\nfunction findKey(obj, key) {\n key = key.toLowerCase();\n const keys = Object.keys(obj);\n let i = keys.length;\n let _key;\n while (i-- > 0) {\n _key = keys[i];\n if (key === _key.toLowerCase()) {\n return _key;\n }\n }\n return null;\n}\n\nconst _global = (() => {\n /*eslint no-undef:0*/\n if (typeof globalThis !== \"undefined\") return globalThis;\n return typeof self !== \"undefined\" ? self : (typeof window !== 'undefined' ? window : global)\n})();\n\nconst isContextDefined = (context) => !isUndefined(context) && context !== _global;\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n *\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n const {caseless} = isContextDefined(this) && this || {};\n const result = {};\n const assignValue = (val, key) => {\n const targetKey = caseless && findKey(result, key) || key;\n if (isPlainObject(result[targetKey]) && isPlainObject(val)) {\n result[targetKey] = merge(result[targetKey], val);\n } else if (isPlainObject(val)) {\n result[targetKey] = merge({}, val);\n } else if (isArray(val)) {\n result[targetKey] = val.slice();\n } else {\n result[targetKey] = val;\n }\n }\n\n for (let i = 0, l = arguments.length; i < l; i++) {\n arguments[i] && forEach(arguments[i], assignValue);\n }\n return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n *\n * @param {Boolean} [allOwnKeys]\n * @returns {Object} The resulting value of object a\n */\nconst extend = (a, b, thisArg, {allOwnKeys}= {}) => {\n forEach(b, (val, key) => {\n if (thisArg && isFunction(val)) {\n a[key] = bind(val, thisArg);\n } else {\n a[key] = val;\n }\n }, {allOwnKeys});\n return a;\n}\n\n/**\n * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)\n *\n * @param {string} content with BOM\n *\n * @returns {string} content value without BOM\n */\nconst stripBOM = (content) => {\n if (content.charCodeAt(0) === 0xFEFF) {\n content = content.slice(1);\n }\n return content;\n}\n\n/**\n * Inherit the prototype methods from one constructor into another\n * @param {function} constructor\n * @param {function} superConstructor\n * @param {object} [props]\n * @param {object} [descriptors]\n *\n * @returns {void}\n */\nconst inherits = (constructor, superConstructor, props, descriptors) => {\n constructor.prototype = Object.create(superConstructor.prototype, descriptors);\n constructor.prototype.constructor = constructor;\n Object.defineProperty(constructor, 'super', {\n value: superConstructor.prototype\n });\n props && Object.assign(constructor.prototype, props);\n}\n\n/**\n * Resolve object with deep prototype chain to a flat object\n * @param {Object} sourceObj source object\n * @param {Object} [destObj]\n * @param {Function|Boolean} [filter]\n * @param {Function} [propFilter]\n *\n * @returns {Object}\n */\nconst toFlatObject = (sourceObj, destObj, filter, propFilter) => {\n let props;\n let i;\n let prop;\n const merged = {};\n\n destObj = destObj || {};\n // eslint-disable-next-line no-eq-null,eqeqeq\n if (sourceObj == null) return destObj;\n\n do {\n props = Object.getOwnPropertyNames(sourceObj);\n i = props.length;\n while (i-- > 0) {\n prop = props[i];\n if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {\n destObj[prop] = sourceObj[prop];\n merged[prop] = true;\n }\n }\n sourceObj = filter !== false && getPrototypeOf(sourceObj);\n } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);\n\n return destObj;\n}\n\n/**\n * Determines whether a string ends with the characters of a specified string\n *\n * @param {String} str\n * @param {String} searchString\n * @param {Number} [position= 0]\n *\n * @returns {boolean}\n */\nconst endsWith = (str, searchString, position) => {\n str = String(str);\n if (position === undefined || position > str.length) {\n position = str.length;\n }\n position -= searchString.length;\n const lastIndex = str.indexOf(searchString, position);\n return lastIndex !== -1 && lastIndex === position;\n}\n\n\n/**\n * Returns new array from array like object or null if failed\n *\n * @param {*} [thing]\n *\n * @returns {?Array}\n */\nconst toArray = (thing) => {\n if (!thing) return null;\n if (isArray(thing)) return thing;\n let i = thing.length;\n if (!isNumber(i)) return null;\n const arr = new Array(i);\n while (i-- > 0) {\n arr[i] = thing[i];\n }\n return arr;\n}\n\n/**\n * Checking if the Uint8Array exists and if it does, it returns a function that checks if the\n * thing passed in is an instance of Uint8Array\n *\n * @param {TypedArray}\n *\n * @returns {Array}\n */\n// eslint-disable-next-line func-names\nconst isTypedArray = (TypedArray => {\n // eslint-disable-next-line func-names\n return thing => {\n return TypedArray && thing instanceof TypedArray;\n };\n})(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array));\n\n/**\n * For each entry in the object, call the function with the key and value.\n *\n * @param {Object} obj - The object to iterate over.\n * @param {Function} fn - The function to call for each entry.\n *\n * @returns {void}\n */\nconst forEachEntry = (obj, fn) => {\n const generator = obj && obj[Symbol.iterator];\n\n const iterator = generator.call(obj);\n\n let result;\n\n while ((result = iterator.next()) && !result.done) {\n const pair = result.value;\n fn.call(obj, pair[0], pair[1]);\n }\n}\n\n/**\n * It takes a regular expression and a string, and returns an array of all the matches\n *\n * @param {string} regExp - The regular expression to match against.\n * @param {string} str - The string to search.\n *\n * @returns {Array}\n */\nconst matchAll = (regExp, str) => {\n let matches;\n const arr = [];\n\n while ((matches = regExp.exec(str)) !== null) {\n arr.push(matches);\n }\n\n return arr;\n}\n\n/* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */\nconst isHTMLForm = kindOfTest('HTMLFormElement');\n\nconst toCamelCase = str => {\n return str.toLowerCase().replace(/[-_\\s]([a-z\\d])(\\w*)/g,\n function replacer(m, p1, p2) {\n return p1.toUpperCase() + p2;\n }\n );\n};\n\n/* Creating a function that will check if an object has a property. */\nconst hasOwnProperty = (({hasOwnProperty}) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype);\n\n/**\n * Determine if a value is a RegExp object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a RegExp object, otherwise false\n */\nconst isRegExp = kindOfTest('RegExp');\n\nconst reduceDescriptors = (obj, reducer) => {\n const descriptors = Object.getOwnPropertyDescriptors(obj);\n const reducedDescriptors = {};\n\n forEach(descriptors, (descriptor, name) => {\n let ret;\n if ((ret = reducer(descriptor, name, obj)) !== false) {\n reducedDescriptors[name] = ret || descriptor;\n }\n });\n\n Object.defineProperties(obj, reducedDescriptors);\n}\n\n/**\n * Makes all methods read-only\n * @param {Object} obj\n */\n\nconst freezeMethods = (obj) => {\n reduceDescriptors(obj, (descriptor, name) => {\n // skip restricted props in strict mode\n if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {\n return false;\n }\n\n const value = obj[name];\n\n if (!isFunction(value)) return;\n\n descriptor.enumerable = false;\n\n if ('writable' in descriptor) {\n descriptor.writable = false;\n return;\n }\n\n if (!descriptor.set) {\n descriptor.set = () => {\n throw Error('Can not rewrite read-only method \\'' + name + '\\'');\n };\n }\n });\n}\n\nconst toObjectSet = (arrayOrString, delimiter) => {\n const obj = {};\n\n const define = (arr) => {\n arr.forEach(value => {\n obj[value] = true;\n });\n }\n\n isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));\n\n return obj;\n}\n\nconst noop = () => {}\n\nconst toFiniteNumber = (value, defaultValue) => {\n value = +value;\n return Number.isFinite(value) ? value : defaultValue;\n}\n\nconst ALPHA = 'abcdefghijklmnopqrstuvwxyz'\n\nconst DIGIT = '0123456789';\n\nconst ALPHABET = {\n DIGIT,\n ALPHA,\n ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT\n}\n\nconst generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {\n let str = '';\n const {length} = alphabet;\n while (size--) {\n str += alphabet[Math.random() * length|0]\n }\n\n return str;\n}\n\n/**\n * If the thing is a FormData object, return true, otherwise return false.\n *\n * @param {unknown} thing - The thing to check.\n *\n * @returns {boolean}\n */\nfunction isSpecCompliantForm(thing) {\n return !!(thing && isFunction(thing.append) && thing[Symbol.toStringTag] === 'FormData' && thing[Symbol.iterator]);\n}\n\nconst toJSONObject = (obj) => {\n const stack = new Array(10);\n\n const visit = (source, i) => {\n\n if (isObject(source)) {\n if (stack.indexOf(source) >= 0) {\n return;\n }\n\n if(!('toJSON' in source)) {\n stack[i] = source;\n const target = isArray(source) ? [] : {};\n\n forEach(source, (value, key) => {\n const reducedValue = visit(value, i + 1);\n !isUndefined(reducedValue) && (target[key] = reducedValue);\n });\n\n stack[i] = undefined;\n\n return target;\n }\n }\n\n return source;\n }\n\n return visit(obj, 0);\n}\n\nconst isAsyncFn = kindOfTest('AsyncFunction');\n\nconst isThenable = (thing) =>\n thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);\n\nexport default {\n isArray,\n isArrayBuffer,\n isBuffer,\n isFormData,\n isArrayBufferView,\n isString,\n isNumber,\n isBoolean,\n isObject,\n isPlainObject,\n isUndefined,\n isDate,\n isFile,\n isBlob,\n isRegExp,\n isFunction,\n isStream,\n isURLSearchParams,\n isTypedArray,\n isFileList,\n forEach,\n merge,\n extend,\n trim,\n stripBOM,\n inherits,\n toFlatObject,\n kindOf,\n kindOfTest,\n endsWith,\n toArray,\n forEachEntry,\n matchAll,\n isHTMLForm,\n hasOwnProperty,\n hasOwnProp: hasOwnProperty, // an alias to avoid ESLint no-prototype-builtins detection\n reduceDescriptors,\n freezeMethods,\n toObjectSet,\n toCamelCase,\n noop,\n toFiniteNumber,\n findKey,\n global: _global,\n isContextDefined,\n ALPHABET,\n generateString,\n isSpecCompliantForm,\n toJSONObject,\n isAsyncFn,\n isThenable\n};\n", "'use strict';\n\nimport utils from '../utils.js';\n\n/**\n * Create an Error with the specified message, config, error code, request and response.\n *\n * @param {string} message The error message.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n * @param {Object} [config] The config.\n * @param {Object} [request] The request.\n * @param {Object} [response] The response.\n *\n * @returns {Error} The created error.\n */\nfunction AxiosError(message, code, config, request, response) {\n Error.call(this);\n\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, this.constructor);\n } else {\n this.stack = (new Error()).stack;\n }\n\n this.message = message;\n this.name = 'AxiosError';\n code && (this.code = code);\n config && (this.config = config);\n request && (this.request = request);\n response && (this.response = response);\n}\n\nutils.inherits(AxiosError, Error, {\n toJSON: function toJSON() {\n return {\n // Standard\n message: this.message,\n name: this.name,\n // Microsoft\n description: this.description,\n number: this.number,\n // Mozilla\n fileName: this.fileName,\n lineNumber: this.lineNumber,\n columnNumber: this.columnNumber,\n stack: this.stack,\n // Axios\n config: utils.toJSONObject(this.config),\n code: this.code,\n status: this.response && this.response.status ? this.response.status : null\n };\n }\n});\n\nconst prototype = AxiosError.prototype;\nconst descriptors = {};\n\n[\n 'ERR_BAD_OPTION_VALUE',\n 'ERR_BAD_OPTION',\n 'ECONNABORTED',\n 'ETIMEDOUT',\n 'ERR_NETWORK',\n 'ERR_FR_TOO_MANY_REDIRECTS',\n 'ERR_DEPRECATED',\n 'ERR_BAD_RESPONSE',\n 'ERR_BAD_REQUEST',\n 'ERR_CANCELED',\n 'ERR_NOT_SUPPORT',\n 'ERR_INVALID_URL'\n// eslint-disable-next-line func-names\n].forEach(code => {\n descriptors[code] = {value: code};\n});\n\nObject.defineProperties(AxiosError, descriptors);\nObject.defineProperty(prototype, 'isAxiosError', {value: true});\n\n// eslint-disable-next-line func-names\nAxiosError.from = (error, code, config, request, response, customProps) => {\n const axiosError = Object.create(prototype);\n\n utils.toFlatObject(error, axiosError, function filter(obj) {\n return obj !== Error.prototype;\n }, prop => {\n return prop !== 'isAxiosError';\n });\n\n AxiosError.call(axiosError, error.message, code, config, request, response);\n\n axiosError.cause = error;\n\n axiosError.name = error.name;\n\n customProps && Object.assign(axiosError, customProps);\n\n return axiosError;\n};\n\nexport default AxiosError;\n", "// eslint-disable-next-line strict\nexport default null;\n", "'use strict';\n\nimport utils from '../utils.js';\nimport AxiosError from '../core/AxiosError.js';\n// temporary hotfix to avoid circular references until AxiosURLSearchParams is refactored\nimport PlatformFormData from '../platform/node/classes/FormData.js';\n\n/**\n * Determines if the given thing is a array or js object.\n *\n * @param {string} thing - The object or array to be visited.\n *\n * @returns {boolean}\n */\nfunction isVisitable(thing) {\n return utils.isPlainObject(thing) || utils.isArray(thing);\n}\n\n/**\n * It removes the brackets from the end of a string\n *\n * @param {string} key - The key of the parameter.\n *\n * @returns {string} the key without the brackets.\n */\nfunction removeBrackets(key) {\n return utils.endsWith(key, '[]') ? key.slice(0, -2) : key;\n}\n\n/**\n * It takes a path, a key, and a boolean, and returns a string\n *\n * @param {string} path - The path to the current key.\n * @param {string} key - The key of the current object being iterated over.\n * @param {string} dots - If true, the key will be rendered with dots instead of brackets.\n *\n * @returns {string} The path to the current key.\n */\nfunction renderKey(path, key, dots) {\n if (!path) return key;\n return path.concat(key).map(function each(token, i) {\n // eslint-disable-next-line no-param-reassign\n token = removeBrackets(token);\n return !dots && i ? '[' + token + ']' : token;\n }).join(dots ? '.' : '');\n}\n\n/**\n * If the array is an array and none of its elements are visitable, then it's a flat array.\n *\n * @param {Array} arr - The array to check\n *\n * @returns {boolean}\n */\nfunction isFlatArray(arr) {\n return utils.isArray(arr) && !arr.some(isVisitable);\n}\n\nconst predicates = utils.toFlatObject(utils, {}, null, function filter(prop) {\n return /^is[A-Z]/.test(prop);\n});\n\n/**\n * Convert a data object to FormData\n *\n * @param {Object} obj\n * @param {?Object} [formData]\n * @param {?Object} [options]\n * @param {Function} [options.visitor]\n * @param {Boolean} [options.metaTokens = true]\n * @param {Boolean} [options.dots = false]\n * @param {?Boolean} [options.indexes = false]\n *\n * @returns {Object}\n **/\n\n/**\n * It converts an object into a FormData object\n *\n * @param {Object} obj - The object to convert to form data.\n * @param {string} formData - The FormData object to append to.\n * @param {Object} options\n *\n * @returns\n */\nfunction toFormData(obj, formData, options) {\n if (!utils.isObject(obj)) {\n throw new TypeError('target must be an object');\n }\n\n // eslint-disable-next-line no-param-reassign\n formData = formData || new (PlatformFormData || FormData)();\n\n // eslint-disable-next-line no-param-reassign\n options = utils.toFlatObject(options, {\n metaTokens: true,\n dots: false,\n indexes: false\n }, false, function defined(option, source) {\n // eslint-disable-next-line no-eq-null,eqeqeq\n return !utils.isUndefined(source[option]);\n });\n\n const metaTokens = options.metaTokens;\n // eslint-disable-next-line no-use-before-define\n const visitor = options.visitor || defaultVisitor;\n const dots = options.dots;\n const indexes = options.indexes;\n const _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;\n const useBlob = _Blob && utils.isSpecCompliantForm(formData);\n\n if (!utils.isFunction(visitor)) {\n throw new TypeError('visitor must be a function');\n }\n\n function convertValue(value) {\n if (value === null) return '';\n\n if (utils.isDate(value)) {\n return value.toISOString();\n }\n\n if (!useBlob && utils.isBlob(value)) {\n throw new AxiosError('Blob is not supported. Use a Buffer instead.');\n }\n\n if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) {\n return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);\n }\n\n return value;\n }\n\n /**\n * Default visitor.\n *\n * @param {*} value\n * @param {String|Number} key\n * @param {Array} path\n * @this {FormData}\n *\n * @returns {boolean} return true to visit the each prop of the value recursively\n */\n function defaultVisitor(value, key, path) {\n let arr = value;\n\n if (value && !path && typeof value === 'object') {\n if (utils.endsWith(key, '{}')) {\n // eslint-disable-next-line no-param-reassign\n key = metaTokens ? key : key.slice(0, -2);\n // eslint-disable-next-line no-param-reassign\n value = JSON.stringify(value);\n } else if (\n (utils.isArray(value) && isFlatArray(value)) ||\n ((utils.isFileList(value) || utils.endsWith(key, '[]')) && (arr = utils.toArray(value))\n )) {\n // eslint-disable-next-line no-param-reassign\n key = removeBrackets(key);\n\n arr.forEach(function each(el, index) {\n !(utils.isUndefined(el) || el === null) && formData.append(\n // eslint-disable-next-line no-nested-ternary\n indexes === true ? renderKey([key], index, dots) : (indexes === null ? key : key + '[]'),\n convertValue(el)\n );\n });\n return false;\n }\n }\n\n if (isVisitable(value)) {\n return true;\n }\n\n formData.append(renderKey(path, key, dots), convertValue(value));\n\n return false;\n }\n\n const stack = [];\n\n const exposedHelpers = Object.assign(predicates, {\n defaultVisitor,\n convertValue,\n isVisitable\n });\n\n function build(value, path) {\n if (utils.isUndefined(value)) return;\n\n if (stack.indexOf(value) !== -1) {\n throw Error('Circular reference detected in ' + path.join('.'));\n }\n\n stack.push(value);\n\n utils.forEach(value, function each(el, key) {\n const result = !(utils.isUndefined(el) || el === null) && visitor.call(\n formData, el, utils.isString(key) ? key.trim() : key, path, exposedHelpers\n );\n\n if (result === true) {\n build(el, path ? path.concat(key) : [key]);\n }\n });\n\n stack.pop();\n }\n\n if (!utils.isObject(obj)) {\n throw new TypeError('data must be an object');\n }\n\n build(obj);\n\n return formData;\n}\n\nexport default toFormData;\n", "'use strict';\n\nimport toFormData from './toFormData.js';\n\n/**\n * It encodes a string by replacing all characters that are not in the unreserved set with\n * their percent-encoded equivalents\n *\n * @param {string} str - The string to encode.\n *\n * @returns {string} The encoded string.\n */\nfunction encode(str) {\n const charMap = {\n '!': '%21',\n \"'\": '%27',\n '(': '%28',\n ')': '%29',\n '~': '%7E',\n '%20': '+',\n '%00': '\\x00'\n };\n return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {\n return charMap[match];\n });\n}\n\n/**\n * It takes a params object and converts it to a FormData object\n *\n * @param {Object} params - The parameters to be converted to a FormData object.\n * @param {Object} options - The options object passed to the Axios constructor.\n *\n * @returns {void}\n */\nfunction AxiosURLSearchParams(params, options) {\n this._pairs = [];\n\n params && toFormData(params, this, options);\n}\n\nconst prototype = AxiosURLSearchParams.prototype;\n\nprototype.append = function append(name, value) {\n this._pairs.push([name, value]);\n};\n\nprototype.toString = function toString(encoder) {\n const _encode = encoder ? function(value) {\n return encoder.call(this, value, encode);\n } : encode;\n\n return this._pairs.map(function each(pair) {\n return _encode(pair[0]) + '=' + _encode(pair[1]);\n }, '').join('&');\n};\n\nexport default AxiosURLSearchParams;\n", "'use strict';\n\nimport utils from '../utils.js';\nimport AxiosURLSearchParams from '../helpers/AxiosURLSearchParams.js';\n\n/**\n * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their\n * URI encoded counterparts\n *\n * @param {string} val The value to be encoded.\n *\n * @returns {string} The encoded value.\n */\nfunction encode(val) {\n return encodeURIComponent(val).\n replace(/%3A/gi, ':').\n replace(/%24/g, '$').\n replace(/%2C/gi, ',').\n replace(/%20/g, '+').\n replace(/%5B/gi, '[').\n replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @param {?object} options\n *\n * @returns {string} The formatted url\n */\nexport default function buildURL(url, params, options) {\n /*eslint no-param-reassign:0*/\n if (!params) {\n return url;\n }\n \n const _encode = options && options.encode || encode;\n\n const serializeFn = options && options.serialize;\n\n let serializedParams;\n\n if (serializeFn) {\n serializedParams = serializeFn(params, options);\n } else {\n serializedParams = utils.isURLSearchParams(params) ?\n params.toString() :\n new AxiosURLSearchParams(params, options).toString(_encode);\n }\n\n if (serializedParams) {\n const hashmarkIndex = url.indexOf(\"#\");\n\n if (hashmarkIndex !== -1) {\n url = url.slice(0, hashmarkIndex);\n }\n url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n }\n\n return url;\n}\n", "'use strict';\n\nimport utils from './../utils.js';\n\nclass InterceptorManager {\n constructor() {\n this.handlers = [];\n }\n\n /**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\n use(fulfilled, rejected, options) {\n this.handlers.push({\n fulfilled,\n rejected,\n synchronous: options ? options.synchronous : false,\n runWhen: options ? options.runWhen : null\n });\n return this.handlers.length - 1;\n }\n\n /**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n *\n * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise\n */\n eject(id) {\n if (this.handlers[id]) {\n this.handlers[id] = null;\n }\n }\n\n /**\n * Clear all interceptors from the stack\n *\n * @returns {void}\n */\n clear() {\n if (this.handlers) {\n this.handlers = [];\n }\n }\n\n /**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n *\n * @returns {void}\n */\n forEach(fn) {\n utils.forEach(this.handlers, function forEachHandler(h) {\n if (h !== null) {\n fn(h);\n }\n });\n }\n}\n\nexport default InterceptorManager;\n", "'use strict';\n\nexport default {\n silentJSONParsing: true,\n forcedJSONParsing: true,\n clarifyTimeoutError: false\n};\n", "'use strict';\n\nimport AxiosURLSearchParams from '../../../helpers/AxiosURLSearchParams.js';\nexport default typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;\n", "'use strict';\n\nexport default typeof FormData !== 'undefined' ? FormData : null;\n", "'use strict'\n\nexport default typeof Blob !== 'undefined' ? Blob : null\n", "import URLSearchParams from './classes/URLSearchParams.js'\nimport FormData from './classes/FormData.js'\nimport Blob from './classes/Blob.js'\n\nexport default {\n isBrowser: true,\n classes: {\n URLSearchParams,\n FormData,\n Blob\n },\n protocols: ['http', 'https', 'file', 'blob', 'url', 'data']\n};\n", "const hasBrowserEnv = typeof window !== 'undefined' && typeof document !== 'undefined';\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n * typeof window -> undefined\n * typeof document -> undefined\n *\n * react-native:\n * navigator.product -> 'ReactNative'\n * nativescript\n * navigator.product -> 'NativeScript' or 'NS'\n *\n * @returns {boolean}\n */\nconst hasStandardBrowserEnv = (\n (product) => {\n return hasBrowserEnv && ['ReactNative', 'NativeScript', 'NS'].indexOf(product) < 0\n })(typeof navigator !== 'undefined' && navigator.product);\n\n/**\n * Determine if we're running in a standard browser webWorker environment\n *\n * Although the `isStandardBrowserEnv` method indicates that\n * `allows axios to run in a web worker`, the WebWorker will still be\n * filtered out due to its judgment standard\n * `typeof window !== 'undefined' && typeof document !== 'undefined'`.\n * This leads to a problem when axios post `FormData` in webWorker\n */\nconst hasStandardBrowserWebWorkerEnv = (() => {\n return (\n typeof WorkerGlobalScope !== 'undefined' &&\n // eslint-disable-next-line no-undef\n self instanceof WorkerGlobalScope &&\n typeof self.importScripts === 'function'\n );\n})();\n\nexport {\n hasBrowserEnv,\n hasStandardBrowserWebWorkerEnv,\n hasStandardBrowserEnv\n}\n", "import platform from './node/index.js';\nimport * as utils from './common/utils.js';\n\nexport default {\n ...utils,\n ...platform\n}\n", "'use strict';\n\nimport utils from '../utils.js';\nimport toFormData from './toFormData.js';\nimport platform from '../platform/index.js';\n\nexport default function toURLEncodedForm(data, options) {\n return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({\n visitor: function(value, key, path, helpers) {\n if (platform.isNode && utils.isBuffer(value)) {\n this.append(key, value.toString('base64'));\n return false;\n }\n\n return helpers.defaultVisitor.apply(this, arguments);\n }\n }, options));\n}\n", "'use strict';\n\nimport utils from '../utils.js';\n\n/**\n * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']\n *\n * @param {string} name - The name of the property to get.\n *\n * @returns An array of strings.\n */\nfunction parsePropPath(name) {\n // foo[x][y][z]\n // foo.x.y.z\n // foo-x-y-z\n // foo x y z\n return utils.matchAll(/\\w+|\\[(\\w*)]/g, name).map(match => {\n return match[0] === '[]' ? '' : match[1] || match[0];\n });\n}\n\n/**\n * Convert an array to an object.\n *\n * @param {Array} arr - The array to convert to an object.\n *\n * @returns An object with the same keys and values as the array.\n */\nfunction arrayToObject(arr) {\n const obj = {};\n const keys = Object.keys(arr);\n let i;\n const len = keys.length;\n let key;\n for (i = 0; i < len; i++) {\n key = keys[i];\n obj[key] = arr[key];\n }\n return obj;\n}\n\n/**\n * It takes a FormData object and returns a JavaScript object\n *\n * @param {string} formData The FormData object to convert to JSON.\n *\n * @returns {Object | null} The converted object.\n */\nfunction formDataToJSON(formData) {\n function buildPath(path, value, target, index) {\n let name = path[index++];\n\n if (name === '__proto__') return true;\n\n const isNumericKey = Number.isFinite(+name);\n const isLast = index >= path.length;\n name = !name && utils.isArray(target) ? target.length : name;\n\n if (isLast) {\n if (utils.hasOwnProp(target, name)) {\n target[name] = [target[name], value];\n } else {\n target[name] = value;\n }\n\n return !isNumericKey;\n }\n\n if (!target[name] || !utils.isObject(target[name])) {\n target[name] = [];\n }\n\n const result = buildPath(path, value, target[name], index);\n\n if (result && utils.isArray(target[name])) {\n target[name] = arrayToObject(target[name]);\n }\n\n return !isNumericKey;\n }\n\n if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {\n const obj = {};\n\n utils.forEachEntry(formData, (name, value) => {\n buildPath(parsePropPath(name), value, obj, 0);\n });\n\n return obj;\n }\n\n return null;\n}\n\nexport default formDataToJSON;\n", "'use strict';\n\nimport utils from '../utils.js';\nimport AxiosError from '../core/AxiosError.js';\nimport transitionalDefaults from './transitional.js';\nimport toFormData from '../helpers/toFormData.js';\nimport toURLEncodedForm from '../helpers/toURLEncodedForm.js';\nimport platform from '../platform/index.js';\nimport formDataToJSON from '../helpers/formDataToJSON.js';\n\n/**\n * It takes a string, tries to parse it, and if it fails, it returns the stringified version\n * of the input\n *\n * @param {any} rawValue - The value to be stringified.\n * @param {Function} parser - A function that parses a string into a JavaScript object.\n * @param {Function} encoder - A function that takes a value and returns a string.\n *\n * @returns {string} A stringified version of the rawValue.\n */\nfunction stringifySafely(rawValue, parser, encoder) {\n if (utils.isString(rawValue)) {\n try {\n (parser || JSON.parse)(rawValue);\n return utils.trim(rawValue);\n } catch (e) {\n if (e.name !== 'SyntaxError') {\n throw e;\n }\n }\n }\n\n return (encoder || JSON.stringify)(rawValue);\n}\n\nconst defaults = {\n\n transitional: transitionalDefaults,\n\n adapter: ['xhr', 'http'],\n\n transformRequest: [function transformRequest(data, headers) {\n const contentType = headers.getContentType() || '';\n const hasJSONContentType = contentType.indexOf('application/json') > -1;\n const isObjectPayload = utils.isObject(data);\n\n if (isObjectPayload && utils.isHTMLForm(data)) {\n data = new FormData(data);\n }\n\n const isFormData = utils.isFormData(data);\n\n if (isFormData) {\n return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;\n }\n\n if (utils.isArrayBuffer(data) ||\n utils.isBuffer(data) ||\n utils.isStream(data) ||\n utils.isFile(data) ||\n utils.isBlob(data)\n ) {\n return data;\n }\n if (utils.isArrayBufferView(data)) {\n return data.buffer;\n }\n if (utils.isURLSearchParams(data)) {\n headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);\n return data.toString();\n }\n\n let isFileList;\n\n if (isObjectPayload) {\n if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {\n return toURLEncodedForm(data, this.formSerializer).toString();\n }\n\n if ((isFileList = utils.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {\n const _FormData = this.env && this.env.FormData;\n\n return toFormData(\n isFileList ? {'files[]': data} : data,\n _FormData && new _FormData(),\n this.formSerializer\n );\n }\n }\n\n if (isObjectPayload || hasJSONContentType ) {\n headers.setContentType('application/json', false);\n return stringifySafely(data);\n }\n\n return data;\n }],\n\n transformResponse: [function transformResponse(data) {\n const transitional = this.transitional || defaults.transitional;\n const forcedJSONParsing = transitional && transitional.forcedJSONParsing;\n const JSONRequested = this.responseType === 'json';\n\n if (data && utils.isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) {\n const silentJSONParsing = transitional && transitional.silentJSONParsing;\n const strictJSONParsing = !silentJSONParsing && JSONRequested;\n\n try {\n return JSON.parse(data);\n } catch (e) {\n if (strictJSONParsing) {\n if (e.name === 'SyntaxError') {\n throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);\n }\n throw e;\n }\n }\n }\n\n return data;\n }],\n\n /**\n * A timeout in milliseconds to abort a request. If set to 0 (default) a\n * timeout is not created.\n */\n timeout: 0,\n\n xsrfCookieName: 'XSRF-TOKEN',\n xsrfHeaderName: 'X-XSRF-TOKEN',\n\n maxContentLength: -1,\n maxBodyLength: -1,\n\n env: {\n FormData: platform.classes.FormData,\n Blob: platform.classes.Blob\n },\n\n validateStatus: function validateStatus(status) {\n return status >= 200 && status < 300;\n },\n\n headers: {\n common: {\n 'Accept': 'application/json, text/plain, */*',\n 'Content-Type': undefined\n }\n }\n};\n\nutils.forEach(['delete', 'get', 'head', 'post', 'put', 'patch'], (method) => {\n defaults.headers[method] = {};\n});\n\nexport default defaults;\n", "'use strict';\n\nimport utils from './../utils.js';\n\n// RawAxiosHeaders whose duplicates are ignored by node\n// c.f. https://nodejs.org/api/http.html#http_message_headers\nconst ignoreDuplicateOf = utils.toObjectSet([\n 'age', 'authorization', 'content-length', 'content-type', 'etag',\n 'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',\n 'last-modified', 'location', 'max-forwards', 'proxy-authorization',\n 'referer', 'retry-after', 'user-agent'\n]);\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} rawHeaders Headers needing to be parsed\n *\n * @returns {Object} Headers parsed into an object\n */\nexport default rawHeaders => {\n const parsed = {};\n let key;\n let val;\n let i;\n\n rawHeaders && rawHeaders.split('\\n').forEach(function parser(line) {\n i = line.indexOf(':');\n key = line.substring(0, i).trim().toLowerCase();\n val = line.substring(i + 1).trim();\n\n if (!key || (parsed[key] && ignoreDuplicateOf[key])) {\n return;\n }\n\n if (key === 'set-cookie') {\n if (parsed[key]) {\n parsed[key].push(val);\n } else {\n parsed[key] = [val];\n }\n } else {\n parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n }\n });\n\n return parsed;\n};\n", "'use strict';\n\nimport utils from '../utils.js';\nimport parseHeaders from '../helpers/parseHeaders.js';\n\nconst $internals = Symbol('internals');\n\nfunction normalizeHeader(header) {\n return header && String(header).trim().toLowerCase();\n}\n\nfunction normalizeValue(value) {\n if (value === false || value == null) {\n return value;\n }\n\n return utils.isArray(value) ? value.map(normalizeValue) : String(value);\n}\n\nfunction parseTokens(str) {\n const tokens = Object.create(null);\n const tokensRE = /([^\\s,;=]+)\\s*(?:=\\s*([^,;]+))?/g;\n let match;\n\n while ((match = tokensRE.exec(str))) {\n tokens[match[1]] = match[2];\n }\n\n return tokens;\n}\n\nconst isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());\n\nfunction matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {\n if (utils.isFunction(filter)) {\n return filter.call(this, value, header);\n }\n\n if (isHeaderNameFilter) {\n value = header;\n }\n\n if (!utils.isString(value)) return;\n\n if (utils.isString(filter)) {\n return value.indexOf(filter) !== -1;\n }\n\n if (utils.isRegExp(filter)) {\n return filter.test(value);\n }\n}\n\nfunction formatHeader(header) {\n return header.trim()\n .toLowerCase().replace(/([a-z\\d])(\\w*)/g, (w, char, str) => {\n return char.toUpperCase() + str;\n });\n}\n\nfunction buildAccessors(obj, header) {\n const accessorName = utils.toCamelCase(' ' + header);\n\n ['get', 'set', 'has'].forEach(methodName => {\n Object.defineProperty(obj, methodName + accessorName, {\n value: function(arg1, arg2, arg3) {\n return this[methodName].call(this, header, arg1, arg2, arg3);\n },\n configurable: true\n });\n });\n}\n\nclass AxiosHeaders {\n constructor(headers) {\n headers && this.set(headers);\n }\n\n set(header, valueOrRewrite, rewrite) {\n const self = this;\n\n function setHeader(_value, _header, _rewrite) {\n const lHeader = normalizeHeader(_header);\n\n if (!lHeader) {\n throw new Error('header name must be a non-empty string');\n }\n\n const key = utils.findKey(self, lHeader);\n\n if(!key || self[key] === undefined || _rewrite === true || (_rewrite === undefined && self[key] !== false)) {\n self[key || _header] = normalizeValue(_value);\n }\n }\n\n const setHeaders = (headers, _rewrite) =>\n utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));\n\n if (utils.isPlainObject(header) || header instanceof this.constructor) {\n setHeaders(header, valueOrRewrite)\n } else if(utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {\n setHeaders(parseHeaders(header), valueOrRewrite);\n } else {\n header != null && setHeader(valueOrRewrite, header, rewrite);\n }\n\n return this;\n }\n\n get(header, parser) {\n header = normalizeHeader(header);\n\n if (header) {\n const key = utils.findKey(this, header);\n\n if (key) {\n const value = this[key];\n\n if (!parser) {\n return value;\n }\n\n if (parser === true) {\n return parseTokens(value);\n }\n\n if (utils.isFunction(parser)) {\n return parser.call(this, value, key);\n }\n\n if (utils.isRegExp(parser)) {\n return parser.exec(value);\n }\n\n throw new TypeError('parser must be boolean|regexp|function');\n }\n }\n }\n\n has(header, matcher) {\n header = normalizeHeader(header);\n\n if (header) {\n const key = utils.findKey(this, header);\n\n return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));\n }\n\n return false;\n }\n\n delete(header, matcher) {\n const self = this;\n let deleted = false;\n\n function deleteHeader(_header) {\n _header = normalizeHeader(_header);\n\n if (_header) {\n const key = utils.findKey(self, _header);\n\n if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {\n delete self[key];\n\n deleted = true;\n }\n }\n }\n\n if (utils.isArray(header)) {\n header.forEach(deleteHeader);\n } else {\n deleteHeader(header);\n }\n\n return deleted;\n }\n\n clear(matcher) {\n const keys = Object.keys(this);\n let i = keys.length;\n let deleted = false;\n\n while (i--) {\n const key = keys[i];\n if(!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {\n delete this[key];\n deleted = true;\n }\n }\n\n return deleted;\n }\n\n normalize(format) {\n const self = this;\n const headers = {};\n\n utils.forEach(this, (value, header) => {\n const key = utils.findKey(headers, header);\n\n if (key) {\n self[key] = normalizeValue(value);\n delete self[header];\n return;\n }\n\n const normalized = format ? formatHeader(header) : String(header).trim();\n\n if (normalized !== header) {\n delete self[header];\n }\n\n self[normalized] = normalizeValue(value);\n\n headers[normalized] = true;\n });\n\n return this;\n }\n\n concat(...targets) {\n return this.constructor.concat(this, ...targets);\n }\n\n toJSON(asStrings) {\n const obj = Object.create(null);\n\n utils.forEach(this, (value, header) => {\n value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value);\n });\n\n return obj;\n }\n\n [Symbol.iterator]() {\n return Object.entries(this.toJSON())[Symbol.iterator]();\n }\n\n toString() {\n return Object.entries(this.toJSON()).map(([header, value]) => header + ': ' + value).join('\\n');\n }\n\n get [Symbol.toStringTag]() {\n return 'AxiosHeaders';\n }\n\n static from(thing) {\n return thing instanceof this ? thing : new this(thing);\n }\n\n static concat(first, ...targets) {\n const computed = new this(first);\n\n targets.forEach((target) => computed.set(target));\n\n return computed;\n }\n\n static accessor(header) {\n const internals = this[$internals] = (this[$internals] = {\n accessors: {}\n });\n\n const accessors = internals.accessors;\n const prototype = this.prototype;\n\n function defineAccessor(_header) {\n const lHeader = normalizeHeader(_header);\n\n if (!accessors[lHeader]) {\n buildAccessors(prototype, _header);\n accessors[lHeader] = true;\n }\n }\n\n utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);\n\n return this;\n }\n}\n\nAxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);\n\n// reserved names hotfix\nutils.reduceDescriptors(AxiosHeaders.prototype, ({value}, key) => {\n let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`\n return {\n get: () => value,\n set(headerValue) {\n this[mapped] = headerValue;\n }\n }\n});\n\nutils.freezeMethods(AxiosHeaders);\n\nexport default AxiosHeaders;\n", "'use strict';\n\nimport utils from './../utils.js';\nimport defaults from '../defaults/index.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Array|Function} fns A single function or Array of functions\n * @param {?Object} response The response object\n *\n * @returns {*} The resulting transformed data\n */\nexport default function transformData(fns, response) {\n const config = this || defaults;\n const context = response || config;\n const headers = AxiosHeaders.from(context.headers);\n let data = context.data;\n\n utils.forEach(fns, function transform(fn) {\n data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);\n });\n\n headers.normalize();\n\n return data;\n}\n", "'use strict';\n\nexport default function isCancel(value) {\n return !!(value && value.__CANCEL__);\n}\n", "'use strict';\n\nimport AxiosError from '../core/AxiosError.js';\nimport utils from '../utils.js';\n\n/**\n * A `CanceledError` is an object that is thrown when an operation is canceled.\n *\n * @param {string=} message The message.\n * @param {Object=} config The config.\n * @param {Object=} request The request.\n *\n * @returns {CanceledError} The created error.\n */\nfunction CanceledError(message, config, request) {\n // eslint-disable-next-line no-eq-null,eqeqeq\n AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);\n this.name = 'CanceledError';\n}\n\nutils.inherits(CanceledError, AxiosError, {\n __CANCEL__: true\n});\n\nexport default CanceledError;\n", "'use strict';\n\nimport AxiosError from './AxiosError.js';\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n *\n * @returns {object} The response.\n */\nexport default function settle(resolve, reject, response) {\n const validateStatus = response.config.validateStatus;\n if (!response.status || !validateStatus || validateStatus(response.status)) {\n resolve(response);\n } else {\n reject(new AxiosError(\n 'Request failed with status code ' + response.status,\n [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],\n response.config,\n response.request,\n response\n ));\n }\n}\n", "import utils from './../utils.js';\nimport platform from '../platform/index.js';\n\nexport default platform.hasStandardBrowserEnv ?\n\n // Standard browser envs support document.cookie\n {\n write(name, value, expires, path, domain, secure) {\n const cookie = [name + '=' + encodeURIComponent(value)];\n\n utils.isNumber(expires) && cookie.push('expires=' + new Date(expires).toGMTString());\n\n utils.isString(path) && cookie.push('path=' + path);\n\n utils.isString(domain) && cookie.push('domain=' + domain);\n\n secure === true && cookie.push('secure');\n\n document.cookie = cookie.join('; ');\n },\n\n read(name) {\n const match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n return (match ? decodeURIComponent(match[3]) : null);\n },\n\n remove(name) {\n this.write(name, '', Date.now() - 86400000);\n }\n }\n\n :\n\n // Non-standard browser env (web workers, react-native) lack needed support.\n {\n write() {},\n read() {\n return null;\n },\n remove() {}\n };\n\n", "'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n *\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nexport default function isAbsoluteURL(url) {\n // A URL is considered absolute if it begins with \"://\" or \"//\" (protocol-relative URL).\n // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n // by any combination of letters, digits, plus, period, or hyphen.\n return /^([a-z][a-z\\d+\\-.]*:)?\\/\\//i.test(url);\n}\n", "'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n *\n * @returns {string} The combined URL\n */\nexport default function combineURLs(baseURL, relativeURL) {\n return relativeURL\n ? baseURL.replace(/\\/?\\/$/, '') + '/' + relativeURL.replace(/^\\/+/, '')\n : baseURL;\n}\n", "'use strict';\n\nimport isAbsoluteURL from '../helpers/isAbsoluteURL.js';\nimport combineURLs from '../helpers/combineURLs.js';\n\n/**\n * Creates a new URL by combining the baseURL with the requestedURL,\n * only when the requestedURL is not already an absolute URL.\n * If the requestURL is absolute, this function returns the requestedURL untouched.\n *\n * @param {string} baseURL The base URL\n * @param {string} requestedURL Absolute or relative URL to combine\n *\n * @returns {string} The combined full path\n */\nexport default function buildFullPath(baseURL, requestedURL) {\n if (baseURL && !isAbsoluteURL(requestedURL)) {\n return combineURLs(baseURL, requestedURL);\n }\n return requestedURL;\n}\n", "'use strict';\n\nimport utils from './../utils.js';\nimport platform from '../platform/index.js';\n\nexport default platform.hasStandardBrowserEnv ?\n\n// Standard browser envs have full support of the APIs needed to test\n// whether the request URL is of the same origin as current location.\n (function standardBrowserEnv() {\n const msie = /(msie|trident)/i.test(navigator.userAgent);\n const urlParsingNode = document.createElement('a');\n let originURL;\n\n /**\n * Parse a URL to discover its components\n *\n * @param {String} url The URL to be parsed\n * @returns {Object}\n */\n function resolveURL(url) {\n let href = url;\n\n if (msie) {\n // IE needs attribute set twice to normalize properties\n urlParsingNode.setAttribute('href', href);\n href = urlParsingNode.href;\n }\n\n urlParsingNode.setAttribute('href', href);\n\n // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n return {\n href: urlParsingNode.href,\n protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n host: urlParsingNode.host,\n search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n hostname: urlParsingNode.hostname,\n port: urlParsingNode.port,\n pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n urlParsingNode.pathname :\n '/' + urlParsingNode.pathname\n };\n }\n\n originURL = resolveURL(window.location.href);\n\n /**\n * Determine if a URL shares the same origin as the current location\n *\n * @param {String} requestURL The URL to test\n * @returns {boolean} True if URL shares the same origin, otherwise false\n */\n return function isURLSameOrigin(requestURL) {\n const parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n return (parsed.protocol === originURL.protocol &&\n parsed.host === originURL.host);\n };\n })() :\n\n // Non standard browser envs (web workers, react-native) lack needed support.\n (function nonStandardBrowserEnv() {\n return function isURLSameOrigin() {\n return true;\n };\n })();\n", "'use strict';\n\nexport default function parseProtocol(url) {\n const match = /^([-+\\w]{1,25})(:?\\/\\/|:)/.exec(url);\n return match && match[1] || '';\n}\n", "'use strict';\n\n/**\n * Calculate data maxRate\n * @param {Number} [samplesCount= 10]\n * @param {Number} [min= 1000]\n * @returns {Function}\n */\nfunction speedometer(samplesCount, min) {\n samplesCount = samplesCount || 10;\n const bytes = new Array(samplesCount);\n const timestamps = new Array(samplesCount);\n let head = 0;\n let tail = 0;\n let firstSampleTS;\n\n min = min !== undefined ? min : 1000;\n\n return function push(chunkLength) {\n const now = Date.now();\n\n const startedAt = timestamps[tail];\n\n if (!firstSampleTS) {\n firstSampleTS = now;\n }\n\n bytes[head] = chunkLength;\n timestamps[head] = now;\n\n let i = tail;\n let bytesCount = 0;\n\n while (i !== head) {\n bytesCount += bytes[i++];\n i = i % samplesCount;\n }\n\n head = (head + 1) % samplesCount;\n\n if (head === tail) {\n tail = (tail + 1) % samplesCount;\n }\n\n if (now - firstSampleTS < min) {\n return;\n }\n\n const passed = startedAt && now - startedAt;\n\n return passed ? Math.round(bytesCount * 1000 / passed) : undefined;\n };\n}\n\nexport default speedometer;\n", "'use strict';\n\nimport utils from './../utils.js';\nimport settle from './../core/settle.js';\nimport cookies from './../helpers/cookies.js';\nimport buildURL from './../helpers/buildURL.js';\nimport buildFullPath from '../core/buildFullPath.js';\nimport isURLSameOrigin from './../helpers/isURLSameOrigin.js';\nimport transitionalDefaults from '../defaults/transitional.js';\nimport AxiosError from '../core/AxiosError.js';\nimport CanceledError from '../cancel/CanceledError.js';\nimport parseProtocol from '../helpers/parseProtocol.js';\nimport platform from '../platform/index.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\nimport speedometer from '../helpers/speedometer.js';\n\nfunction progressEventReducer(listener, isDownloadStream) {\n let bytesNotified = 0;\n const _speedometer = speedometer(50, 250);\n\n return e => {\n const loaded = e.loaded;\n const total = e.lengthComputable ? e.total : undefined;\n const progressBytes = loaded - bytesNotified;\n const rate = _speedometer(progressBytes);\n const inRange = loaded <= total;\n\n bytesNotified = loaded;\n\n const data = {\n loaded,\n total,\n progress: total ? (loaded / total) : undefined,\n bytes: progressBytes,\n rate: rate ? rate : undefined,\n estimated: rate && total && inRange ? (total - loaded) / rate : undefined,\n event: e\n };\n\n data[isDownloadStream ? 'download' : 'upload'] = true;\n\n listener(data);\n };\n}\n\nconst isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';\n\nexport default isXHRAdapterSupported && function (config) {\n return new Promise(function dispatchXhrRequest(resolve, reject) {\n let requestData = config.data;\n const requestHeaders = AxiosHeaders.from(config.headers).normalize();\n let {responseType, withXSRFToken} = config;\n let onCanceled;\n function done() {\n if (config.cancelToken) {\n config.cancelToken.unsubscribe(onCanceled);\n }\n\n if (config.signal) {\n config.signal.removeEventListener('abort', onCanceled);\n }\n }\n\n let contentType;\n\n if (utils.isFormData(requestData)) {\n if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {\n requestHeaders.setContentType(false); // Let the browser set it\n } else if ((contentType = requestHeaders.getContentType()) !== false) {\n // fix semicolon duplication issue for ReactNative FormData implementation\n const [type, ...tokens] = contentType ? contentType.split(';').map(token => token.trim()).filter(Boolean) : [];\n requestHeaders.setContentType([type || 'multipart/form-data', ...tokens].join('; '));\n }\n }\n\n let request = new XMLHttpRequest();\n\n // HTTP basic authentication\n if (config.auth) {\n const username = config.auth.username || '';\n const password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';\n requestHeaders.set('Authorization', 'Basic ' + btoa(username + ':' + password));\n }\n\n const fullPath = buildFullPath(config.baseURL, config.url);\n\n request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);\n\n // Set the request timeout in MS\n request.timeout = config.timeout;\n\n function onloadend() {\n if (!request) {\n return;\n }\n // Prepare the response\n const responseHeaders = AxiosHeaders.from(\n 'getAllResponseHeaders' in request && request.getAllResponseHeaders()\n );\n const responseData = !responseType || responseType === 'text' || responseType === 'json' ?\n request.responseText : request.response;\n const response = {\n data: responseData,\n status: request.status,\n statusText: request.statusText,\n headers: responseHeaders,\n config,\n request\n };\n\n settle(function _resolve(value) {\n resolve(value);\n done();\n }, function _reject(err) {\n reject(err);\n done();\n }, response);\n\n // Clean up request\n request = null;\n }\n\n if ('onloadend' in request) {\n // Use onloadend if available\n request.onloadend = onloadend;\n } else {\n // Listen for ready state to emulate onloadend\n request.onreadystatechange = function handleLoad() {\n if (!request || request.readyState !== 4) {\n return;\n }\n\n // The request errored out and we didn't get a response, this will be\n // handled by onerror instead\n // With one exception: request that using file: protocol, most browsers\n // will return status as 0 even though it's a successful request\n if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n return;\n }\n // readystate handler is calling before onerror or ontimeout handlers,\n // so we should call onloadend on the next 'tick'\n setTimeout(onloadend);\n };\n }\n\n // Handle browser request cancellation (as opposed to a manual cancellation)\n request.onabort = function handleAbort() {\n if (!request) {\n return;\n }\n\n reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, config, request));\n\n // Clean up request\n request = null;\n };\n\n // Handle low level network errors\n request.onerror = function handleError() {\n // Real errors are hidden from us by the browser\n // onerror should only fire if it's a network error\n reject(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request));\n\n // Clean up request\n request = null;\n };\n\n // Handle timeout\n request.ontimeout = function handleTimeout() {\n let timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded';\n const transitional = config.transitional || transitionalDefaults;\n if (config.timeoutErrorMessage) {\n timeoutErrorMessage = config.timeoutErrorMessage;\n }\n reject(new AxiosError(\n timeoutErrorMessage,\n transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,\n config,\n request));\n\n // Clean up request\n request = null;\n };\n\n // Add xsrf header\n // This is only done if running in a standard browser environment.\n // Specifically not if we're in a web worker, or react-native.\n if(platform.hasStandardBrowserEnv) {\n withXSRFToken && utils.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(config));\n\n if (withXSRFToken || (withXSRFToken !== false && isURLSameOrigin(fullPath))) {\n // Add xsrf header\n const xsrfValue = config.xsrfHeaderName && config.xsrfCookieName && cookies.read(config.xsrfCookieName);\n\n if (xsrfValue) {\n requestHeaders.set(config.xsrfHeaderName, xsrfValue);\n }\n }\n }\n\n // Remove Content-Type if data is undefined\n requestData === undefined && requestHeaders.setContentType(null);\n\n // Add headers to the request\n if ('setRequestHeader' in request) {\n utils.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {\n request.setRequestHeader(key, val);\n });\n }\n\n // Add withCredentials to request if needed\n if (!utils.isUndefined(config.withCredentials)) {\n request.withCredentials = !!config.withCredentials;\n }\n\n // Add responseType to request if needed\n if (responseType && responseType !== 'json') {\n request.responseType = config.responseType;\n }\n\n // Handle progress if needed\n if (typeof config.onDownloadProgress === 'function') {\n request.addEventListener('progress', progressEventReducer(config.onDownloadProgress, true));\n }\n\n // Not all browsers support upload events\n if (typeof config.onUploadProgress === 'function' && request.upload) {\n request.upload.addEventListener('progress', progressEventReducer(config.onUploadProgress));\n }\n\n if (config.cancelToken || config.signal) {\n // Handle cancellation\n // eslint-disable-next-line func-names\n onCanceled = cancel => {\n if (!request) {\n return;\n }\n reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);\n request.abort();\n request = null;\n };\n\n config.cancelToken && config.cancelToken.subscribe(onCanceled);\n if (config.signal) {\n config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);\n }\n }\n\n const protocol = parseProtocol(fullPath);\n\n if (protocol && platform.protocols.indexOf(protocol) === -1) {\n reject(new AxiosError('Unsupported protocol ' + protocol + ':', AxiosError.ERR_BAD_REQUEST, config));\n return;\n }\n\n\n // Send the request\n request.send(requestData || null);\n });\n}\n", "import utils from '../utils.js';\nimport httpAdapter from './http.js';\nimport xhrAdapter from './xhr.js';\nimport AxiosError from \"../core/AxiosError.js\";\n\nconst knownAdapters = {\n http: httpAdapter,\n xhr: xhrAdapter\n}\n\nutils.forEach(knownAdapters, (fn, value) => {\n if (fn) {\n try {\n Object.defineProperty(fn, 'name', {value});\n } catch (e) {\n // eslint-disable-next-line no-empty\n }\n Object.defineProperty(fn, 'adapterName', {value});\n }\n});\n\nconst renderReason = (reason) => `- ${reason}`;\n\nconst isResolvedHandle = (adapter) => utils.isFunction(adapter) || adapter === null || adapter === false;\n\nexport default {\n getAdapter: (adapters) => {\n adapters = utils.isArray(adapters) ? adapters : [adapters];\n\n const {length} = adapters;\n let nameOrAdapter;\n let adapter;\n\n const rejectedReasons = {};\n\n for (let i = 0; i < length; i++) {\n nameOrAdapter = adapters[i];\n let id;\n\n adapter = nameOrAdapter;\n\n if (!isResolvedHandle(nameOrAdapter)) {\n adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];\n\n if (adapter === undefined) {\n throw new AxiosError(`Unknown adapter '${id}'`);\n }\n }\n\n if (adapter) {\n break;\n }\n\n rejectedReasons[id || '#' + i] = adapter;\n }\n\n if (!adapter) {\n\n const reasons = Object.entries(rejectedReasons)\n .map(([id, state]) => `adapter ${id} ` +\n (state === false ? 'is not supported by the environment' : 'is not available in the build')\n );\n\n let s = length ?\n (reasons.length > 1 ? 'since :\\n' + reasons.map(renderReason).join('\\n') : ' ' + renderReason(reasons[0])) :\n 'as no adapter specified';\n\n throw new AxiosError(\n `There is no suitable adapter to dispatch the request ` + s,\n 'ERR_NOT_SUPPORT'\n );\n }\n\n return adapter;\n },\n adapters: knownAdapters\n}\n", "'use strict';\n\nimport transformData from './transformData.js';\nimport isCancel from '../cancel/isCancel.js';\nimport defaults from '../defaults/index.js';\nimport CanceledError from '../cancel/CanceledError.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\nimport adapters from \"../adapters/adapters.js\";\n\n/**\n * Throws a `CanceledError` if cancellation has been requested.\n *\n * @param {Object} config The config that is to be used for the request\n *\n * @returns {void}\n */\nfunction throwIfCancellationRequested(config) {\n if (config.cancelToken) {\n config.cancelToken.throwIfRequested();\n }\n\n if (config.signal && config.signal.aborted) {\n throw new CanceledError(null, config);\n }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n *\n * @returns {Promise} The Promise to be fulfilled\n */\nexport default function dispatchRequest(config) {\n throwIfCancellationRequested(config);\n\n config.headers = AxiosHeaders.from(config.headers);\n\n // Transform request data\n config.data = transformData.call(\n config,\n config.transformRequest\n );\n\n if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {\n config.headers.setContentType('application/x-www-form-urlencoded', false);\n }\n\n const adapter = adapters.getAdapter(config.adapter || defaults.adapter);\n\n return adapter(config).then(function onAdapterResolution(response) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n response.data = transformData.call(\n config,\n config.transformResponse,\n response\n );\n\n response.headers = AxiosHeaders.from(response.headers);\n\n return response;\n }, function onAdapterRejection(reason) {\n if (!isCancel(reason)) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n if (reason && reason.response) {\n reason.response.data = transformData.call(\n config,\n config.transformResponse,\n reason.response\n );\n reason.response.headers = AxiosHeaders.from(reason.response.headers);\n }\n }\n\n return Promise.reject(reason);\n });\n}\n", "'use strict';\n\nimport utils from '../utils.js';\nimport AxiosHeaders from \"./AxiosHeaders.js\";\n\nconst headersToObject = (thing) => thing instanceof AxiosHeaders ? thing.toJSON() : thing;\n\n/**\n * Config-specific merge-function which creates a new config-object\n * by merging two configuration objects together.\n *\n * @param {Object} config1\n * @param {Object} config2\n *\n * @returns {Object} New object resulting from merging config2 to config1\n */\nexport default function mergeConfig(config1, config2) {\n // eslint-disable-next-line no-param-reassign\n config2 = config2 || {};\n const config = {};\n\n function getMergedValue(target, source, caseless) {\n if (utils.isPlainObject(target) && utils.isPlainObject(source)) {\n return utils.merge.call({caseless}, target, source);\n } else if (utils.isPlainObject(source)) {\n return utils.merge({}, source);\n } else if (utils.isArray(source)) {\n return source.slice();\n }\n return source;\n }\n\n // eslint-disable-next-line consistent-return\n function mergeDeepProperties(a, b, caseless) {\n if (!utils.isUndefined(b)) {\n return getMergedValue(a, b, caseless);\n } else if (!utils.isUndefined(a)) {\n return getMergedValue(undefined, a, caseless);\n }\n }\n\n // eslint-disable-next-line consistent-return\n function valueFromConfig2(a, b) {\n if (!utils.isUndefined(b)) {\n return getMergedValue(undefined, b);\n }\n }\n\n // eslint-disable-next-line consistent-return\n function defaultToConfig2(a, b) {\n if (!utils.isUndefined(b)) {\n return getMergedValue(undefined, b);\n } else if (!utils.isUndefined(a)) {\n return getMergedValue(undefined, a);\n }\n }\n\n // eslint-disable-next-line consistent-return\n function mergeDirectKeys(a, b, prop) {\n if (prop in config2) {\n return getMergedValue(a, b);\n } else if (prop in config1) {\n return getMergedValue(undefined, a);\n }\n }\n\n const mergeMap = {\n url: valueFromConfig2,\n method: valueFromConfig2,\n data: valueFromConfig2,\n baseURL: defaultToConfig2,\n transformRequest: defaultToConfig2,\n transformResponse: defaultToConfig2,\n paramsSerializer: defaultToConfig2,\n timeout: defaultToConfig2,\n timeoutMessage: defaultToConfig2,\n withCredentials: defaultToConfig2,\n withXSRFToken: defaultToConfig2,\n adapter: defaultToConfig2,\n responseType: defaultToConfig2,\n xsrfCookieName: defaultToConfig2,\n xsrfHeaderName: defaultToConfig2,\n onUploadProgress: defaultToConfig2,\n onDownloadProgress: defaultToConfig2,\n decompress: defaultToConfig2,\n maxContentLength: defaultToConfig2,\n maxBodyLength: defaultToConfig2,\n beforeRedirect: defaultToConfig2,\n transport: defaultToConfig2,\n httpAgent: defaultToConfig2,\n httpsAgent: defaultToConfig2,\n cancelToken: defaultToConfig2,\n socketPath: defaultToConfig2,\n responseEncoding: defaultToConfig2,\n validateStatus: mergeDirectKeys,\n headers: (a, b) => mergeDeepProperties(headersToObject(a), headersToObject(b), true)\n };\n\n utils.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {\n const merge = mergeMap[prop] || mergeDeepProperties;\n const configValue = merge(config1[prop], config2[prop], prop);\n (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);\n });\n\n return config;\n}\n", "export const VERSION = \"1.6.7\";", "'use strict';\n\nimport {VERSION} from '../env/data.js';\nimport AxiosError from '../core/AxiosError.js';\n\nconst validators = {};\n\n// eslint-disable-next-line func-names\n['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach((type, i) => {\n validators[type] = function validator(thing) {\n return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;\n };\n});\n\nconst deprecatedWarnings = {};\n\n/**\n * Transitional option validator\n *\n * @param {function|boolean?} validator - set to false if the transitional option has been removed\n * @param {string?} version - deprecated version / removed since version\n * @param {string?} message - some message with additional info\n *\n * @returns {function}\n */\nvalidators.transitional = function transitional(validator, version, message) {\n function formatMessage(opt, desc) {\n return '[Axios v' + VERSION + '] Transitional option \\'' + opt + '\\'' + desc + (message ? '. ' + message : '');\n }\n\n // eslint-disable-next-line func-names\n return (value, opt, opts) => {\n if (validator === false) {\n throw new AxiosError(\n formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),\n AxiosError.ERR_DEPRECATED\n );\n }\n\n if (version && !deprecatedWarnings[opt]) {\n deprecatedWarnings[opt] = true;\n // eslint-disable-next-line no-console\n console.warn(\n formatMessage(\n opt,\n ' has been deprecated since v' + version + ' and will be removed in the near future'\n )\n );\n }\n\n return validator ? validator(value, opt, opts) : true;\n };\n};\n\n/**\n * Assert object's properties type\n *\n * @param {object} options\n * @param {object} schema\n * @param {boolean?} allowUnknown\n *\n * @returns {object}\n */\n\nfunction assertOptions(options, schema, allowUnknown) {\n if (typeof options !== 'object') {\n throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);\n }\n const keys = Object.keys(options);\n let i = keys.length;\n while (i-- > 0) {\n const opt = keys[i];\n const validator = schema[opt];\n if (validator) {\n const value = options[opt];\n const result = value === undefined || validator(value, opt, options);\n if (result !== true) {\n throw new AxiosError('option ' + opt + ' must be ' + result, AxiosError.ERR_BAD_OPTION_VALUE);\n }\n continue;\n }\n if (allowUnknown !== true) {\n throw new AxiosError('Unknown option ' + opt, AxiosError.ERR_BAD_OPTION);\n }\n }\n}\n\nexport default {\n assertOptions,\n validators\n};\n", "'use strict';\n\nimport utils from './../utils.js';\nimport buildURL from '../helpers/buildURL.js';\nimport InterceptorManager from './InterceptorManager.js';\nimport dispatchRequest from './dispatchRequest.js';\nimport mergeConfig from './mergeConfig.js';\nimport buildFullPath from './buildFullPath.js';\nimport validator from '../helpers/validator.js';\nimport AxiosHeaders from './AxiosHeaders.js';\n\nconst validators = validator.validators;\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n *\n * @return {Axios} A new instance of Axios\n */\nclass Axios {\n constructor(instanceConfig) {\n this.defaults = instanceConfig;\n this.interceptors = {\n request: new InterceptorManager(),\n response: new InterceptorManager()\n };\n }\n\n /**\n * Dispatch a request\n *\n * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)\n * @param {?Object} config\n *\n * @returns {Promise} The Promise to be fulfilled\n */\n async request(configOrUrl, config) {\n try {\n return await this._request(configOrUrl, config);\n } catch (err) {\n if (err instanceof Error) {\n let dummy;\n\n Error.captureStackTrace ? Error.captureStackTrace(dummy = {}) : (dummy = new Error());\n\n // slice off the Error: ... line\n const stack = dummy.stack ? dummy.stack.replace(/^.+\\n/, '') : '';\n\n if (!err.stack) {\n err.stack = stack;\n // match without the 2 top stack lines\n } else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\\n.+\\n/, ''))) {\n err.stack += '\\n' + stack\n }\n }\n\n throw err;\n }\n }\n\n _request(configOrUrl, config) {\n /*eslint no-param-reassign:0*/\n // Allow for axios('example/url'[, config]) a la fetch API\n if (typeof configOrUrl === 'string') {\n config = config || {};\n config.url = configOrUrl;\n } else {\n config = configOrUrl || {};\n }\n\n config = mergeConfig(this.defaults, config);\n\n const {transitional, paramsSerializer, headers} = config;\n\n if (transitional !== undefined) {\n validator.assertOptions(transitional, {\n silentJSONParsing: validators.transitional(validators.boolean),\n forcedJSONParsing: validators.transitional(validators.boolean),\n clarifyTimeoutError: validators.transitional(validators.boolean)\n }, false);\n }\n\n if (paramsSerializer != null) {\n if (utils.isFunction(paramsSerializer)) {\n config.paramsSerializer = {\n serialize: paramsSerializer\n }\n } else {\n validator.assertOptions(paramsSerializer, {\n encode: validators.function,\n serialize: validators.function\n }, true);\n }\n }\n\n // Set config.method\n config.method = (config.method || this.defaults.method || 'get').toLowerCase();\n\n // Flatten headers\n let contextHeaders = headers && utils.merge(\n headers.common,\n headers[config.method]\n );\n\n headers && utils.forEach(\n ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n (method) => {\n delete headers[method];\n }\n );\n\n config.headers = AxiosHeaders.concat(contextHeaders, headers);\n\n // filter out skipped interceptors\n const requestInterceptorChain = [];\n let synchronousRequestInterceptors = true;\n this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {\n return;\n }\n\n synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;\n\n requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);\n });\n\n const responseInterceptorChain = [];\n this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);\n });\n\n let promise;\n let i = 0;\n let len;\n\n if (!synchronousRequestInterceptors) {\n const chain = [dispatchRequest.bind(this), undefined];\n chain.unshift.apply(chain, requestInterceptorChain);\n chain.push.apply(chain, responseInterceptorChain);\n len = chain.length;\n\n promise = Promise.resolve(config);\n\n while (i < len) {\n promise = promise.then(chain[i++], chain[i++]);\n }\n\n return promise;\n }\n\n len = requestInterceptorChain.length;\n\n let newConfig = config;\n\n i = 0;\n\n while (i < len) {\n const onFulfilled = requestInterceptorChain[i++];\n const onRejected = requestInterceptorChain[i++];\n try {\n newConfig = onFulfilled(newConfig);\n } catch (error) {\n onRejected.call(this, error);\n break;\n }\n }\n\n try {\n promise = dispatchRequest.call(this, newConfig);\n } catch (error) {\n return Promise.reject(error);\n }\n\n i = 0;\n len = responseInterceptorChain.length;\n\n while (i < len) {\n promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);\n }\n\n return promise;\n }\n\n getUri(config) {\n config = mergeConfig(this.defaults, config);\n const fullPath = buildFullPath(config.baseURL, config.url);\n return buildURL(fullPath, config.params, config.paramsSerializer);\n }\n}\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, config) {\n return this.request(mergeConfig(config || {}, {\n method,\n url,\n data: (config || {}).data\n }));\n };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n /*eslint func-names:0*/\n\n function generateHTTPMethod(isForm) {\n return function httpMethod(url, data, config) {\n return this.request(mergeConfig(config || {}, {\n method,\n headers: isForm ? {\n 'Content-Type': 'multipart/form-data'\n } : {},\n url,\n data\n }));\n };\n }\n\n Axios.prototype[method] = generateHTTPMethod();\n\n Axios.prototype[method + 'Form'] = generateHTTPMethod(true);\n});\n\nexport default Axios;\n", "'use strict';\n\nimport CanceledError from './CanceledError.js';\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @param {Function} executor The executor function.\n *\n * @returns {CancelToken}\n */\nclass CancelToken {\n constructor(executor) {\n if (typeof executor !== 'function') {\n throw new TypeError('executor must be a function.');\n }\n\n let resolvePromise;\n\n this.promise = new Promise(function promiseExecutor(resolve) {\n resolvePromise = resolve;\n });\n\n const token = this;\n\n // eslint-disable-next-line func-names\n this.promise.then(cancel => {\n if (!token._listeners) return;\n\n let i = token._listeners.length;\n\n while (i-- > 0) {\n token._listeners[i](cancel);\n }\n token._listeners = null;\n });\n\n // eslint-disable-next-line func-names\n this.promise.then = onfulfilled => {\n let _resolve;\n // eslint-disable-next-line func-names\n const promise = new Promise(resolve => {\n token.subscribe(resolve);\n _resolve = resolve;\n }).then(onfulfilled);\n\n promise.cancel = function reject() {\n token.unsubscribe(_resolve);\n };\n\n return promise;\n };\n\n executor(function cancel(message, config, request) {\n if (token.reason) {\n // Cancellation has already been requested\n return;\n }\n\n token.reason = new CanceledError(message, config, request);\n resolvePromise(token.reason);\n });\n }\n\n /**\n * Throws a `CanceledError` if cancellation has been requested.\n */\n throwIfRequested() {\n if (this.reason) {\n throw this.reason;\n }\n }\n\n /**\n * Subscribe to the cancel signal\n */\n\n subscribe(listener) {\n if (this.reason) {\n listener(this.reason);\n return;\n }\n\n if (this._listeners) {\n this._listeners.push(listener);\n } else {\n this._listeners = [listener];\n }\n }\n\n /**\n * Unsubscribe from the cancel signal\n */\n\n unsubscribe(listener) {\n if (!this._listeners) {\n return;\n }\n const index = this._listeners.indexOf(listener);\n if (index !== -1) {\n this._listeners.splice(index, 1);\n }\n }\n\n /**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\n static source() {\n let cancel;\n const token = new CancelToken(function executor(c) {\n cancel = c;\n });\n return {\n token,\n cancel\n };\n }\n}\n\nexport default CancelToken;\n", "'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n * ```js\n * function f(x, y, z) {}\n * var args = [1, 2, 3];\n * f.apply(null, args);\n * ```\n *\n * With `spread` this example can be re-written.\n *\n * ```js\n * spread(function(x, y, z) {})([1, 2, 3]);\n * ```\n *\n * @param {Function} callback\n *\n * @returns {Function}\n */\nexport default function spread(callback) {\n return function wrap(arr) {\n return callback.apply(null, arr);\n };\n}\n", "'use strict';\n\nimport utils from './../utils.js';\n\n/**\n * Determines whether the payload is an error thrown by Axios\n *\n * @param {*} payload The value to test\n *\n * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false\n */\nexport default function isAxiosError(payload) {\n return utils.isObject(payload) && (payload.isAxiosError === true);\n}\n", "const HttpStatusCode = {\n Continue: 100,\n SwitchingProtocols: 101,\n Processing: 102,\n EarlyHints: 103,\n Ok: 200,\n Created: 201,\n Accepted: 202,\n NonAuthoritativeInformation: 203,\n NoContent: 204,\n ResetContent: 205,\n PartialContent: 206,\n MultiStatus: 207,\n AlreadyReported: 208,\n ImUsed: 226,\n MultipleChoices: 300,\n MovedPermanently: 301,\n Found: 302,\n SeeOther: 303,\n NotModified: 304,\n UseProxy: 305,\n Unused: 306,\n TemporaryRedirect: 307,\n PermanentRedirect: 308,\n BadRequest: 400,\n Unauthorized: 401,\n PaymentRequired: 402,\n Forbidden: 403,\n NotFound: 404,\n MethodNotAllowed: 405,\n NotAcceptable: 406,\n ProxyAuthenticationRequired: 407,\n RequestTimeout: 408,\n Conflict: 409,\n Gone: 410,\n LengthRequired: 411,\n PreconditionFailed: 412,\n PayloadTooLarge: 413,\n UriTooLong: 414,\n UnsupportedMediaType: 415,\n RangeNotSatisfiable: 416,\n ExpectationFailed: 417,\n ImATeapot: 418,\n MisdirectedRequest: 421,\n UnprocessableEntity: 422,\n Locked: 423,\n FailedDependency: 424,\n TooEarly: 425,\n UpgradeRequired: 426,\n PreconditionRequired: 428,\n TooManyRequests: 429,\n RequestHeaderFieldsTooLarge: 431,\n UnavailableForLegalReasons: 451,\n InternalServerError: 500,\n NotImplemented: 501,\n BadGateway: 502,\n ServiceUnavailable: 503,\n GatewayTimeout: 504,\n HttpVersionNotSupported: 505,\n VariantAlsoNegotiates: 506,\n InsufficientStorage: 507,\n LoopDetected: 508,\n NotExtended: 510,\n NetworkAuthenticationRequired: 511,\n};\n\nObject.entries(HttpStatusCode).forEach(([key, value]) => {\n HttpStatusCode[value] = key;\n});\n\nexport default HttpStatusCode;\n", "'use strict';\n\nimport utils from './utils.js';\nimport bind from './helpers/bind.js';\nimport Axios from './core/Axios.js';\nimport mergeConfig from './core/mergeConfig.js';\nimport defaults from './defaults/index.js';\nimport formDataToJSON from './helpers/formDataToJSON.js';\nimport CanceledError from './cancel/CanceledError.js';\nimport CancelToken from './cancel/CancelToken.js';\nimport isCancel from './cancel/isCancel.js';\nimport {VERSION} from './env/data.js';\nimport toFormData from './helpers/toFormData.js';\nimport AxiosError from './core/AxiosError.js';\nimport spread from './helpers/spread.js';\nimport isAxiosError from './helpers/isAxiosError.js';\nimport AxiosHeaders from \"./core/AxiosHeaders.js\";\nimport adapters from './adapters/adapters.js';\nimport HttpStatusCode from './helpers/HttpStatusCode.js';\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n *\n * @returns {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n const context = new Axios(defaultConfig);\n const instance = bind(Axios.prototype.request, context);\n\n // Copy axios.prototype to instance\n utils.extend(instance, Axios.prototype, context, {allOwnKeys: true});\n\n // Copy context to instance\n utils.extend(instance, context, null, {allOwnKeys: true});\n\n // Factory for creating new instances\n instance.create = function create(instanceConfig) {\n return createInstance(mergeConfig(defaultConfig, instanceConfig));\n };\n\n return instance;\n}\n\n// Create the default instance to be exported\nconst axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Expose Cancel & CancelToken\naxios.CanceledError = CanceledError;\naxios.CancelToken = CancelToken;\naxios.isCancel = isCancel;\naxios.VERSION = VERSION;\naxios.toFormData = toFormData;\n\n// Expose AxiosError class\naxios.AxiosError = AxiosError;\n\n// alias for CanceledError for backward compatibility\naxios.Cancel = axios.CanceledError;\n\n// Expose all/spread\naxios.all = function all(promises) {\n return Promise.all(promises);\n};\n\naxios.spread = spread;\n\n// Expose isAxiosError\naxios.isAxiosError = isAxiosError;\n\n// Expose mergeConfig\naxios.mergeConfig = mergeConfig;\n\naxios.AxiosHeaders = AxiosHeaders;\n\naxios.formToJSON = thing => formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);\n\naxios.getAdapter = adapters.getAdapter;\n\naxios.HttpStatusCode = HttpStatusCode;\n\naxios.default = axios;\n\n// this module should only have a default export\nexport default axios\n", "import axios from './lib/axios.js';\n\n// This module is intended to unwrap Axios default export as named.\n// Keep top-level export same with static properties\n// so that it can keep same with es module or cjs\nconst {\n Axios,\n AxiosError,\n CanceledError,\n isCancel,\n CancelToken,\n VERSION,\n all,\n Cancel,\n isAxiosError,\n spread,\n toFormData,\n AxiosHeaders,\n HttpStatusCode,\n formToJSON,\n getAdapter,\n mergeConfig\n} = axios;\n\nexport {\n axios as default,\n Axios,\n AxiosError,\n CanceledError,\n isCancel,\n CancelToken,\n VERSION,\n all,\n Cancel,\n isAxiosError,\n spread,\n toFormData,\n AxiosHeaders,\n HttpStatusCode,\n formToJSON,\n getAdapter,\n mergeConfig\n}\n", "import d from \"./node_modules/axios/index.js\";export default d;\nexport * from \"./node_modules/axios/index.js\""], + "mappings": "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", + "names": [] +} diff --git a/public/favicon.ico b/public/favicon.ico index df36fcfb..d23f8a07 100644 Binary files a/public/favicon.ico and b/public/favicon.ico differ diff --git a/src/App.vue b/src/App.vue index 9b995fa3..87be8229 100644 --- a/src/App.vue +++ b/src/App.vue @@ -21,16 +21,25 @@ // ... \ No newline at end of file + white-space: nowrap; + + text-overflow: ellipsis; + +} + diff --git a/src/api/index.js b/src/api/index.js index ab3d8c19..d6446440 100644 --- a/src/api/index.js +++ b/src/api/index.js @@ -1,12 +1,21 @@ import http from './request'; -export function getXXX() { - return http('/api/get'); +export function getPolitics(params) { + return http('/api/politics/politics', { + method: 'GET', + params: params, + }); } -export function postXXX(params) { - return http('/api/post', { +export function getNewsbx(params) { + return http('/api/newsbx/group', { method: 'POST', params: params, }); -} \ No newline at end of file +} +export function getNewsbxList(params) { + return http('/api/newsbx/index', { + method: 'POST', + params: params, + }); +} diff --git a/src/api/request.js b/src/api/request.js index 2aa1743d..3f0de40c 100644 --- a/src/api/request.js +++ b/src/api/request.js @@ -3,7 +3,7 @@ import axios from 'axios'; // 创建新的axios实例 const service = axios.create({ // 环境变量，需要在.env文件中配置 - baseURL: 'http://wz.lytv.com.cn/', + baseURL: '/api', // 超时时间暂定5s timeout: 5000, }); @@ -77,4 +77,4 @@ service.interceptors.response.use( return Promise.resolve(error.response); } ); -export default Request; \ No newline at end of file +export default Request; diff --git a/src/assets/img/logo.png b/src/assets/img/logo.png new file mode 100644 index 00000000..d1bf5b28 Binary files /dev/null and b/src/assets/img/logo.png differ diff --git a/src/assets/img/qrcode1.png b/src/assets/img/qrcode1.png new file mode 100644 index 00000000..c0fb943e Binary files /dev/null and b/src/assets/img/qrcode1.png differ diff --git a/src/components/Footer.vue b/src/components/Footer.vue index 679cbebc..838c9278 100644 --- a/src/components/Footer.vue +++ b/src/components/Footer.vue @@ -1,6 +1,24 @@ @@ -8,4 +26,4 @@ \ No newline at end of file + diff --git a/src/components/Head.vue b/src/components/Head.vue index c75c6a18..8066fb49 100644 --- a/src/components/Head.vue +++ b/src/components/Head.vue @@ -1,24 +1,28 @@