From 28754c86d5b600e3d3067e51fc532f79d57ed4cc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A6=86=E9=92=B1=E8=90=BD=E5=B0=BD=E6=A7=BF=E8=8A=B1?= =?UTF-8?q?=E7=A8=80?= <2675540038@qq.com> Date: Mon, 29 Jan 2024 17:57:41 +0800 Subject: [PATCH] 1 --- index.html | 4 +- node_modules/.vite/_metadata.json | 7 +- node_modules/.vite/axios.js | 2062 +++++++++++++++++++++++++++++ node_modules/.vite/axios.js.map | 7 + public/favicon.ico | Bin 4286 -> 4158 bytes src/App.vue | 13 +- src/api/index.js | 19 +- src/api/request.js | 4 +- src/assets/img/logo.png | Bin 0 -> 12576 bytes src/assets/img/qrcode1.png | Bin 0 -> 25135 bytes src/components/Footer.vue | 24 +- src/components/Head.vue | 34 +- src/router/routes.js | 4 +- src/view/home/index.vue | 485 ++++--- vite.config.js | 15 +- 15 files changed, 2472 insertions(+), 206 deletions(-) create mode 100644 node_modules/.vite/axios.js create mode 100644 node_modules/.vite/axios.js.map create mode 100644 src/assets/img/logo.png create mode 100644 src/assets/img/qrcode1.png 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 df36fcfb72584e00488330b560ebcf34a41c64c2..d23f8a079b0fc45a7c22a3ee3d5a843a0532b485 100644 GIT binary patch literal 4158 zcmeHJX;4#F6b=MMNCcExm)at><6zYZAV?_|g17;SODxJF0s#U^2#`PsVM|C@!YbJp z3<)73fw+`_BBT_k6s`N-sZJ{uyH{J=Ix6J$J}p0F#v!!*)$wJ%yt(I``<>;TckV-> zY~XLn5)|@}@^C?+UPqx&9uQE3!b2ePXBX7Hx?WXaIu&SXX~85UB)qHDYF8l8Xf!L# zX0yw{z<}N0;NYtM{(escCX>mludi>xbhxdt6%^9f@Y&1?ZeEUn15s4K7Bn?ARf@~` z?m6V7;+!;MX*NV*c2iyaXftiJ+q|#+2 zP*w_Mh>iyl>$T`pjap7^(Y8cb!)=X?Sy_e?1i$fQ!aoCteVj~ZE~5}%^pEI^yfJ_t zvy~^8%Vq8D?eneSpUUQo;hvfD#C2Dn`^SI+FAN}r<9Cw(_K(!0^nGVgg4DKi4*-gc7jowh2#^U>8pVb+uIW^p`ijwv`e$<2kTJ?pF?WsdlIEwvEO7gxlhG!jlLyoj|So9L7xm9<|&Wh{|R@EBS2!vONmxo zy3~z2QJ|I@l%kRpGvko`BUjGao$nEb1{O|-=bzf1yFFmr#-kLK_&EVCeAm)(E)Q5a83eIN zEQfQ~>7VjWXWw@>E~1ZBFr<8cXA1}RBgu2_H@rgj7KK7CY->9-XF6OHwkJ+ctOiK1!e6_l^e6vU-RKc^^ZGv~IJBie8 zLriRZj}XPL#0TirA$U=FN|KCRSX7rL77NRoTbfJsy5{J?!J!46ot-bxjoi9qd#o-e zw{pWb?FqXEFqcwz}(KdLX`+z#XxKU#Xk z_)7@?NQ!tDcjeb%G@rv6R4-s;YFlCV^hB-QCsI;dbHTnHjf+dmM%hf;7e6 zwbzUN=Z(d!T{xV}Anq*|3NyuG>48pD7td%k#;Y2Xp$F8;O-iLIyyeir)Zl<$PR&MJ zfD?>ijo+E(xY!3Td^^bcWGKUN@gjklQbrKIeLsNi^uzXa-&RIJ7CE0)6fc)3c@0Vx zJaXldUUM&}t63a(LMzz$Q9**bhVcF^YLLfu@)o=(hm=I)&C*KXgfI2(c@6J0GV~7yF_Bg1_4*0R`pZHPcUkOX~ zSI057vB|mdnRGUlnLy)jXJ#aak~8Aclenud@21TJQHl0oPxLIyuE-hVk$Yy2rz9=@ zsj`9=Qd$06^c;t$mW8gL-yx;4947mnyzUITc|Iezu~Pi>pKr9L(7bRDtL=T2C?^Vs?tI}lW3`wVy(Qy}z*ueJjl>g++J z%pl)Z^_=d&B-4g`WgpcNi;jF)Eofk9 q>rIqHG<}Fn(3MmqZIp&z9vxVWUqABF{PtIzTW*cNS2q8z3j75Fg7}gE literal 4286 zcmds*O-Phc6o&64GDVCEQHxsW(p4>LW*W<827=Unuo8sGpRux(DN@jWP-e29Wl%wj zY84_aq9}^Am9-cWTD5GGEo#+5Fi2wX_P*bo+xO!)p*7B;iKlbFd(U~_d(U?#hLj56 zPhFkj-|A6~Qk#@g^#D^U0XT1cu=c-vu1+SElX9NR;kzAUV(q0|dl0|%h|dI$%VICy zJnu2^L*Te9JrJMGh%-P79CL0}dq92RGU6gI{v2~|)p}sG5x0U*z<8U;Ij*hB9z?ei z@g6Xq-pDoPl=MANPiR7%172VA%r)kevtV-_5H*QJKFmd;8yA$98zCxBZYXTNZ#QFk2(TX0;Y2dt&WitL#$96|gJY=3xX zpCoi|YNzgO3R`f@IiEeSmKrPSf#h#Qd<$%Ej^RIeeYfsxhPMOG`S`Pz8q``=511zm zAm)MX5AV^5xIWPyEu7u>qYs?pn$I4nL9J!=K=SGlKLXpE<5x+2cDTXq?brj?n6sp= zphe9;_JHf40^9~}9i08r{XM$7HB!`{Ys~TK0kx<}ZQng`UPvH*11|q7&l9?@FQz;8 zx!=3<4seY*%=OlbCbcae?5^V_}*K>Uo6ZWV8mTyE^B=DKy7-sdLYkR5Z?paTgK-zyIkKjIcpyO z{+uIt&YSa_$QnN_@t~L014dyK(fOOo+W*MIxbA6Ndgr=Y!f#Tokqv}n<7-9qfHkc3 z=>a|HWqcX8fzQCT=dqVbogRq!-S>H%yA{1w#2Pn;=e>JiEj7Hl;zdt-2f+j2%DeVD zsW0Ab)ZK@0cIW%W7z}H{&~yGhn~D;aiP4=;m-HCo`BEI+Kd6 z={Xwx{TKxD#iCLfl2vQGDitKtN>z|-AdCN|$jTFDg0m3O`WLD4_s#$S 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 0000000000000000000000000000000000000000..d1bf5b284463db5e8ac9c82075755b23795c56ac GIT binary patch literal 12576 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 i_kvTPm59<#=l(y%eGSw~qK2~o0000 -
- ************** +
+
+
+ +
河南人民政府
+
河南人民政府
+
河南人民政府
+
河南人民政府
+
河南人民政府
+
河南人民政府
+
河南人民政府
+ +
+
+
+
洛阳中网 豫ICP备05020961号 \ 豫公网安备 41031102000159 信息网络传播视听节目许可证（AVSP）编号：1608331
+
网络举报电话：0379-63353039 网络举报邮箱：lytvzhwzh@163.com
+
声明：本网部分内容来源于互联网，如有侵权内容请及时与网站管理员联系及时删除处理！
+
+
@@ -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 @@