You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1272 lines
40 KiB
1272 lines
40 KiB
import {
|
|
require_lottie
|
|
} from "./chunk-AOAGPUU7.js";
|
|
import {
|
|
__commonJS,
|
|
__toESM
|
|
} from "./chunk-LQ2VYIYD.js";
|
|
|
|
// node_modules/axios/lib/helpers/bind.js
|
|
var require_bind = __commonJS({
|
|
"node_modules/axios/lib/helpers/bind.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = function bind(fn, thisArg) {
|
|
return function wrap() {
|
|
var args = new Array(arguments.length);
|
|
for (var i = 0; i < args.length; i++) {
|
|
args[i] = arguments[i];
|
|
}
|
|
return fn.apply(thisArg, args);
|
|
};
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/utils.js
|
|
var require_utils = __commonJS({
|
|
"node_modules/axios/lib/utils.js"(exports, module) {
|
|
"use strict";
|
|
var bind = require_bind();
|
|
var toString = Object.prototype.toString;
|
|
function isArray(val) {
|
|
return toString.call(val) === "[object Array]";
|
|
}
|
|
function isUndefined(val) {
|
|
return typeof val === "undefined";
|
|
}
|
|
function isBuffer(val) {
|
|
return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val);
|
|
}
|
|
function isArrayBuffer(val) {
|
|
return toString.call(val) === "[object ArrayBuffer]";
|
|
}
|
|
function isFormData(val) {
|
|
return typeof FormData !== "undefined" && val instanceof FormData;
|
|
}
|
|
function isArrayBufferView(val) {
|
|
var result;
|
|
if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
|
|
result = ArrayBuffer.isView(val);
|
|
} else {
|
|
result = val && val.buffer && val.buffer instanceof ArrayBuffer;
|
|
}
|
|
return result;
|
|
}
|
|
function isString(val) {
|
|
return typeof val === "string";
|
|
}
|
|
function isNumber(val) {
|
|
return typeof val === "number";
|
|
}
|
|
function isObject(val) {
|
|
return val !== null && typeof val === "object";
|
|
}
|
|
function isDate(val) {
|
|
return toString.call(val) === "[object Date]";
|
|
}
|
|
function isFile(val) {
|
|
return toString.call(val) === "[object File]";
|
|
}
|
|
function isBlob(val) {
|
|
return toString.call(val) === "[object Blob]";
|
|
}
|
|
function isFunction(val) {
|
|
return toString.call(val) === "[object Function]";
|
|
}
|
|
function isStream(val) {
|
|
return isObject(val) && isFunction(val.pipe);
|
|
}
|
|
function isURLSearchParams(val) {
|
|
return typeof URLSearchParams !== "undefined" && val instanceof URLSearchParams;
|
|
}
|
|
function trim(str) {
|
|
return str.replace(/^\s*/, "").replace(/\s*$/, "");
|
|
}
|
|
function isStandardBrowserEnv() {
|
|
if (typeof navigator !== "undefined" && (navigator.product === "ReactNative" || navigator.product === "NativeScript" || navigator.product === "NS")) {
|
|
return false;
|
|
}
|
|
return typeof window !== "undefined" && typeof document !== "undefined";
|
|
}
|
|
function forEach(obj, fn) {
|
|
if (obj === null || typeof obj === "undefined") {
|
|
return;
|
|
}
|
|
if (typeof obj !== "object") {
|
|
obj = [obj];
|
|
}
|
|
if (isArray(obj)) {
|
|
for (var i = 0, l = obj.length; i < l; i++) {
|
|
fn.call(null, obj[i], i, obj);
|
|
}
|
|
} else {
|
|
for (var key in obj) {
|
|
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
|
fn.call(null, obj[key], key, obj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function merge() {
|
|
var result = {};
|
|
function assignValue(val, key) {
|
|
if (typeof result[key] === "object" && typeof val === "object") {
|
|
result[key] = merge(result[key], val);
|
|
} else {
|
|
result[key] = val;
|
|
}
|
|
}
|
|
for (var i = 0, l = arguments.length; i < l; i++) {
|
|
forEach(arguments[i], assignValue);
|
|
}
|
|
return result;
|
|
}
|
|
function deepMerge() {
|
|
var result = {};
|
|
function assignValue(val, key) {
|
|
if (typeof result[key] === "object" && typeof val === "object") {
|
|
result[key] = deepMerge(result[key], val);
|
|
} else if (typeof val === "object") {
|
|
result[key] = deepMerge({}, val);
|
|
} else {
|
|
result[key] = val;
|
|
}
|
|
}
|
|
for (var i = 0, l = arguments.length; i < l; i++) {
|
|
forEach(arguments[i], assignValue);
|
|
}
|
|
return result;
|
|
}
|
|
function extend(a, b, thisArg) {
|
|
forEach(b, function assignValue(val, key) {
|
|
if (thisArg && typeof val === "function") {
|
|
a[key] = bind(val, thisArg);
|
|
} else {
|
|
a[key] = val;
|
|
}
|
|
});
|
|
return a;
|
|
}
|
|
module.exports = {
|
|
isArray,
|
|
isArrayBuffer,
|
|
isBuffer,
|
|
isFormData,
|
|
isArrayBufferView,
|
|
isString,
|
|
isNumber,
|
|
isObject,
|
|
isUndefined,
|
|
isDate,
|
|
isFile,
|
|
isBlob,
|
|
isFunction,
|
|
isStream,
|
|
isURLSearchParams,
|
|
isStandardBrowserEnv,
|
|
forEach,
|
|
merge,
|
|
deepMerge,
|
|
extend,
|
|
trim
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/helpers/buildURL.js
|
|
var require_buildURL = __commonJS({
|
|
"node_modules/axios/lib/helpers/buildURL.js"(exports, module) {
|
|
"use strict";
|
|
var utils = require_utils();
|
|
function encode(val) {
|
|
return encodeURIComponent(val).replace(/%40/gi, "@").replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
|
|
}
|
|
module.exports = function buildURL(url, params, paramsSerializer) {
|
|
if (!params) {
|
|
return url;
|
|
}
|
|
var serializedParams;
|
|
if (paramsSerializer) {
|
|
serializedParams = paramsSerializer(params);
|
|
} else if (utils.isURLSearchParams(params)) {
|
|
serializedParams = params.toString();
|
|
} else {
|
|
var parts = [];
|
|
utils.forEach(params, function serialize(val, key) {
|
|
if (val === null || typeof val === "undefined") {
|
|
return;
|
|
}
|
|
if (utils.isArray(val)) {
|
|
key = key + "[]";
|
|
} else {
|
|
val = [val];
|
|
}
|
|
utils.forEach(val, function parseValue(v) {
|
|
if (utils.isDate(v)) {
|
|
v = v.toISOString();
|
|
} else if (utils.isObject(v)) {
|
|
v = JSON.stringify(v);
|
|
}
|
|
parts.push(encode(key) + "=" + encode(v));
|
|
});
|
|
});
|
|
serializedParams = parts.join("&");
|
|
}
|
|
if (serializedParams) {
|
|
var 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
|
|
var require_InterceptorManager = __commonJS({
|
|
"node_modules/axios/lib/core/InterceptorManager.js"(exports, module) {
|
|
"use strict";
|
|
var utils = require_utils();
|
|
function InterceptorManager() {
|
|
this.handlers = [];
|
|
}
|
|
InterceptorManager.prototype.use = function use(fulfilled, rejected) {
|
|
this.handlers.push({
|
|
fulfilled,
|
|
rejected
|
|
});
|
|
return this.handlers.length - 1;
|
|
};
|
|
InterceptorManager.prototype.eject = function eject(id) {
|
|
if (this.handlers[id]) {
|
|
this.handlers[id] = null;
|
|
}
|
|
};
|
|
InterceptorManager.prototype.forEach = function forEach(fn) {
|
|
utils.forEach(this.handlers, function forEachHandler(h) {
|
|
if (h !== null) {
|
|
fn(h);
|
|
}
|
|
});
|
|
};
|
|
module.exports = InterceptorManager;
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/core/transformData.js
|
|
var require_transformData = __commonJS({
|
|
"node_modules/axios/lib/core/transformData.js"(exports, module) {
|
|
"use strict";
|
|
var utils = require_utils();
|
|
module.exports = function transformData(data, headers, fns) {
|
|
utils.forEach(fns, function transform(fn) {
|
|
data = fn(data, headers);
|
|
});
|
|
return data;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/cancel/isCancel.js
|
|
var require_isCancel = __commonJS({
|
|
"node_modules/axios/lib/cancel/isCancel.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = function isCancel(value) {
|
|
return !!(value && value.__CANCEL__);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/helpers/normalizeHeaderName.js
|
|
var require_normalizeHeaderName = __commonJS({
|
|
"node_modules/axios/lib/helpers/normalizeHeaderName.js"(exports, module) {
|
|
"use strict";
|
|
var utils = require_utils();
|
|
module.exports = function normalizeHeaderName(headers, normalizedName) {
|
|
utils.forEach(headers, function processHeader(value, name) {
|
|
if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
|
|
headers[normalizedName] = value;
|
|
delete headers[name];
|
|
}
|
|
});
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/core/enhanceError.js
|
|
var require_enhanceError = __commonJS({
|
|
"node_modules/axios/lib/core/enhanceError.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = function enhanceError(error, config, code, request, response) {
|
|
error.config = config;
|
|
if (code) {
|
|
error.code = code;
|
|
}
|
|
error.request = request;
|
|
error.response = response;
|
|
error.isAxiosError = true;
|
|
error.toJSON = function() {
|
|
return {
|
|
// Standard
|
|
message: this.message,
|
|
name: this.name,
|
|
// Microsoft
|
|
description: this.description,
|
|
number: this.number,
|
|
// Mozilla
|
|
fileName: this.fileName,
|
|
lineNumber: this.lineNumber,
|
|
columnNumber: this.columnNumber,
|
|
stack: this.stack,
|
|
// Axios
|
|
config: this.config,
|
|
code: this.code
|
|
};
|
|
};
|
|
return error;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/core/createError.js
|
|
var require_createError = __commonJS({
|
|
"node_modules/axios/lib/core/createError.js"(exports, module) {
|
|
"use strict";
|
|
var enhanceError = require_enhanceError();
|
|
module.exports = function createError(message, config, code, request, response) {
|
|
var error = new Error(message);
|
|
return enhanceError(error, config, code, request, response);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/core/settle.js
|
|
var require_settle = __commonJS({
|
|
"node_modules/axios/lib/core/settle.js"(exports, module) {
|
|
"use strict";
|
|
var createError = require_createError();
|
|
module.exports = function settle(resolve, reject, response) {
|
|
var validateStatus = response.config.validateStatus;
|
|
if (!validateStatus || validateStatus(response.status)) {
|
|
resolve(response);
|
|
} else {
|
|
reject(createError(
|
|
"Request failed with status code " + response.status,
|
|
response.config,
|
|
null,
|
|
response.request,
|
|
response
|
|
));
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/helpers/isAbsoluteURL.js
|
|
var require_isAbsoluteURL = __commonJS({
|
|
"node_modules/axios/lib/helpers/isAbsoluteURL.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = function isAbsoluteURL(url) {
|
|
return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/helpers/combineURLs.js
|
|
var require_combineURLs = __commonJS({
|
|
"node_modules/axios/lib/helpers/combineURLs.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = function combineURLs(baseURL, relativeURL) {
|
|
return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/core/buildFullPath.js
|
|
var require_buildFullPath = __commonJS({
|
|
"node_modules/axios/lib/core/buildFullPath.js"(exports, module) {
|
|
"use strict";
|
|
var isAbsoluteURL = require_isAbsoluteURL();
|
|
var combineURLs = require_combineURLs();
|
|
module.exports = function buildFullPath(baseURL, requestedURL) {
|
|
if (baseURL && !isAbsoluteURL(requestedURL)) {
|
|
return combineURLs(baseURL, requestedURL);
|
|
}
|
|
return requestedURL;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/helpers/parseHeaders.js
|
|
var require_parseHeaders = __commonJS({
|
|
"node_modules/axios/lib/helpers/parseHeaders.js"(exports, module) {
|
|
"use strict";
|
|
var utils = require_utils();
|
|
var ignoreDuplicateOf = [
|
|
"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"
|
|
];
|
|
module.exports = function parseHeaders(headers) {
|
|
var parsed = {};
|
|
var key;
|
|
var val;
|
|
var i;
|
|
if (!headers) {
|
|
return parsed;
|
|
}
|
|
utils.forEach(headers.split("\n"), function parser(line) {
|
|
i = line.indexOf(":");
|
|
key = utils.trim(line.substr(0, i)).toLowerCase();
|
|
val = utils.trim(line.substr(i + 1));
|
|
if (key) {
|
|
if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
|
|
return;
|
|
}
|
|
if (key === "set-cookie") {
|
|
parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
|
|
} else {
|
|
parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
|
|
}
|
|
}
|
|
});
|
|
return parsed;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/helpers/isURLSameOrigin.js
|
|
var require_isURLSameOrigin = __commonJS({
|
|
"node_modules/axios/lib/helpers/isURLSameOrigin.js"(exports, module) {
|
|
"use strict";
|
|
var utils = require_utils();
|
|
module.exports = utils.isStandardBrowserEnv() ? (
|
|
// Standard browser envs have full support of the APIs needed to test
|
|
// whether the request URL is of the same origin as current location.
|
|
function standardBrowserEnv() {
|
|
var msie = /(msie|trident)/i.test(navigator.userAgent);
|
|
var urlParsingNode = document.createElement("a");
|
|
var originURL;
|
|
function resolveURL(url) {
|
|
var 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) {
|
|
var parsed = utils.isString(requestURL) ? resolveURL(requestURL) : requestURL;
|
|
return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
|
|
};
|
|
}()
|
|
) : (
|
|
// Non standard browser envs (web workers, react-native) lack needed support.
|
|
/* @__PURE__ */ function nonStandardBrowserEnv() {
|
|
return function isURLSameOrigin() {
|
|
return true;
|
|
};
|
|
}()
|
|
);
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/helpers/cookies.js
|
|
var require_cookies = __commonJS({
|
|
"node_modules/axios/lib/helpers/cookies.js"(exports, module) {
|
|
"use strict";
|
|
var utils = require_utils();
|
|
module.exports = utils.isStandardBrowserEnv() ? (
|
|
// Standard browser envs support document.cookie
|
|
/* @__PURE__ */ function standardBrowserEnv() {
|
|
return {
|
|
write: function write(name, value, expires, path, domain, secure) {
|
|
var cookie = [];
|
|
cookie.push(name + "=" + encodeURIComponent(value));
|
|
if (utils.isNumber(expires)) {
|
|
cookie.push("expires=" + new Date(expires).toGMTString());
|
|
}
|
|
if (utils.isString(path)) {
|
|
cookie.push("path=" + path);
|
|
}
|
|
if (utils.isString(domain)) {
|
|
cookie.push("domain=" + domain);
|
|
}
|
|
if (secure === true) {
|
|
cookie.push("secure");
|
|
}
|
|
document.cookie = cookie.join("; ");
|
|
},
|
|
read: function read(name) {
|
|
var match = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)"));
|
|
return match ? decodeURIComponent(match[3]) : null;
|
|
},
|
|
remove: function remove(name) {
|
|
this.write(name, "", Date.now() - 864e5);
|
|
}
|
|
};
|
|
}()
|
|
) : (
|
|
// Non standard browser env (web workers, react-native) lack needed support.
|
|
/* @__PURE__ */ function nonStandardBrowserEnv() {
|
|
return {
|
|
write: function write() {
|
|
},
|
|
read: function read() {
|
|
return null;
|
|
},
|
|
remove: function remove() {
|
|
}
|
|
};
|
|
}()
|
|
);
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/adapters/xhr.js
|
|
var require_xhr = __commonJS({
|
|
"node_modules/axios/lib/adapters/xhr.js"(exports, module) {
|
|
"use strict";
|
|
var utils = require_utils();
|
|
var settle = require_settle();
|
|
var buildURL = require_buildURL();
|
|
var buildFullPath = require_buildFullPath();
|
|
var parseHeaders = require_parseHeaders();
|
|
var isURLSameOrigin = require_isURLSameOrigin();
|
|
var createError = require_createError();
|
|
module.exports = function xhrAdapter(config) {
|
|
return new Promise(function dispatchXhrRequest(resolve, reject) {
|
|
var requestData = config.data;
|
|
var requestHeaders = config.headers;
|
|
if (utils.isFormData(requestData)) {
|
|
delete requestHeaders["Content-Type"];
|
|
}
|
|
var request = new XMLHttpRequest();
|
|
if (config.auth) {
|
|
var username = config.auth.username || "";
|
|
var password = config.auth.password || "";
|
|
requestHeaders.Authorization = "Basic " + btoa(username + ":" + password);
|
|
}
|
|
var fullPath = buildFullPath(config.baseURL, config.url);
|
|
request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
|
|
request.timeout = config.timeout;
|
|
request.onreadystatechange = function handleLoad() {
|
|
if (!request || request.readyState !== 4) {
|
|
return;
|
|
}
|
|
if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0)) {
|
|
return;
|
|
}
|
|
var responseHeaders = "getAllResponseHeaders" in request ? parseHeaders(request.getAllResponseHeaders()) : null;
|
|
var responseData = !config.responseType || config.responseType === "text" ? request.responseText : request.response;
|
|
var response = {
|
|
data: responseData,
|
|
status: request.status,
|
|
statusText: request.statusText,
|
|
headers: responseHeaders,
|
|
config,
|
|
request
|
|
};
|
|
settle(resolve, reject, response);
|
|
request = null;
|
|
};
|
|
request.onabort = function handleAbort() {
|
|
if (!request) {
|
|
return;
|
|
}
|
|
reject(createError("Request aborted", config, "ECONNABORTED", request));
|
|
request = null;
|
|
};
|
|
request.onerror = function handleError() {
|
|
reject(createError("Network Error", config, null, request));
|
|
request = null;
|
|
};
|
|
request.ontimeout = function handleTimeout() {
|
|
var timeoutErrorMessage = "timeout of " + config.timeout + "ms exceeded";
|
|
if (config.timeoutErrorMessage) {
|
|
timeoutErrorMessage = config.timeoutErrorMessage;
|
|
}
|
|
reject(createError(
|
|
timeoutErrorMessage,
|
|
config,
|
|
"ECONNABORTED",
|
|
request
|
|
));
|
|
request = null;
|
|
};
|
|
if (utils.isStandardBrowserEnv()) {
|
|
var cookies = require_cookies();
|
|
var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ? cookies.read(config.xsrfCookieName) : void 0;
|
|
if (xsrfValue) {
|
|
requestHeaders[config.xsrfHeaderName] = xsrfValue;
|
|
}
|
|
}
|
|
if ("setRequestHeader" in request) {
|
|
utils.forEach(requestHeaders, function setRequestHeader(val, key) {
|
|
if (typeof requestData === "undefined" && key.toLowerCase() === "content-type") {
|
|
delete requestHeaders[key];
|
|
} else {
|
|
request.setRequestHeader(key, val);
|
|
}
|
|
});
|
|
}
|
|
if (!utils.isUndefined(config.withCredentials)) {
|
|
request.withCredentials = !!config.withCredentials;
|
|
}
|
|
if (config.responseType) {
|
|
try {
|
|
request.responseType = config.responseType;
|
|
} catch (e) {
|
|
if (config.responseType !== "json") {
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
if (typeof config.onDownloadProgress === "function") {
|
|
request.addEventListener("progress", config.onDownloadProgress);
|
|
}
|
|
if (typeof config.onUploadProgress === "function" && request.upload) {
|
|
request.upload.addEventListener("progress", config.onUploadProgress);
|
|
}
|
|
if (config.cancelToken) {
|
|
config.cancelToken.promise.then(function onCanceled(cancel) {
|
|
if (!request) {
|
|
return;
|
|
}
|
|
request.abort();
|
|
reject(cancel);
|
|
request = null;
|
|
});
|
|
}
|
|
if (requestData === void 0) {
|
|
requestData = null;
|
|
}
|
|
request.send(requestData);
|
|
});
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/defaults.js
|
|
var require_defaults = __commonJS({
|
|
"node_modules/axios/lib/defaults.js"(exports, module) {
|
|
"use strict";
|
|
var utils = require_utils();
|
|
var normalizeHeaderName = require_normalizeHeaderName();
|
|
var DEFAULT_CONTENT_TYPE = {
|
|
"Content-Type": "application/x-www-form-urlencoded"
|
|
};
|
|
function setContentTypeIfUnset(headers, value) {
|
|
if (!utils.isUndefined(headers) && utils.isUndefined(headers["Content-Type"])) {
|
|
headers["Content-Type"] = value;
|
|
}
|
|
}
|
|
function getDefaultAdapter() {
|
|
var adapter;
|
|
if (typeof XMLHttpRequest !== "undefined") {
|
|
adapter = require_xhr();
|
|
} else if (typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]") {
|
|
adapter = require_xhr();
|
|
}
|
|
return adapter;
|
|
}
|
|
var defaults = {
|
|
adapter: getDefaultAdapter(),
|
|
transformRequest: [function transformRequest(data, headers) {
|
|
normalizeHeaderName(headers, "Accept");
|
|
normalizeHeaderName(headers, "Content-Type");
|
|
if (utils.isFormData(data) || utils.isArrayBuffer(data) || utils.isBuffer(data) || utils.isStream(data) || utils.isFile(data) || utils.isBlob(data)) {
|
|
return data;
|
|
}
|
|
if (utils.isArrayBufferView(data)) {
|
|
return data.buffer;
|
|
}
|
|
if (utils.isURLSearchParams(data)) {
|
|
setContentTypeIfUnset(headers, "application/x-www-form-urlencoded;charset=utf-8");
|
|
return data.toString();
|
|
}
|
|
if (utils.isObject(data)) {
|
|
setContentTypeIfUnset(headers, "application/json;charset=utf-8");
|
|
return JSON.stringify(data);
|
|
}
|
|
return data;
|
|
}],
|
|
transformResponse: [function transformResponse(data) {
|
|
if (typeof data === "string") {
|
|
try {
|
|
data = JSON.parse(data);
|
|
} catch (e) {
|
|
}
|
|
}
|
|
return data;
|
|
}],
|
|
/**
|
|
* A timeout in milliseconds to abort a request. If set to 0 (default) a
|
|
* timeout is not created.
|
|
*/
|
|
timeout: 0,
|
|
xsrfCookieName: "XSRF-TOKEN",
|
|
xsrfHeaderName: "X-XSRF-TOKEN",
|
|
maxContentLength: -1,
|
|
validateStatus: function validateStatus(status) {
|
|
return status >= 200 && status < 300;
|
|
}
|
|
};
|
|
defaults.headers = {
|
|
common: {
|
|
"Accept": "application/json, text/plain, */*"
|
|
}
|
|
};
|
|
utils.forEach(["delete", "get", "head"], function forEachMethodNoData(method) {
|
|
defaults.headers[method] = {};
|
|
});
|
|
utils.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
|
|
defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
|
|
});
|
|
module.exports = defaults;
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/core/dispatchRequest.js
|
|
var require_dispatchRequest = __commonJS({
|
|
"node_modules/axios/lib/core/dispatchRequest.js"(exports, module) {
|
|
"use strict";
|
|
var utils = require_utils();
|
|
var transformData = require_transformData();
|
|
var isCancel = require_isCancel();
|
|
var defaults = require_defaults();
|
|
function throwIfCancellationRequested(config) {
|
|
if (config.cancelToken) {
|
|
config.cancelToken.throwIfRequested();
|
|
}
|
|
}
|
|
module.exports = function dispatchRequest(config) {
|
|
throwIfCancellationRequested(config);
|
|
config.headers = config.headers || {};
|
|
config.data = transformData(
|
|
config.data,
|
|
config.headers,
|
|
config.transformRequest
|
|
);
|
|
config.headers = utils.merge(
|
|
config.headers.common || {},
|
|
config.headers[config.method] || {},
|
|
config.headers
|
|
);
|
|
utils.forEach(
|
|
["delete", "get", "head", "post", "put", "patch", "common"],
|
|
function cleanHeaderConfig(method) {
|
|
delete config.headers[method];
|
|
}
|
|
);
|
|
var adapter = config.adapter || defaults.adapter;
|
|
return adapter(config).then(function onAdapterResolution(response) {
|
|
throwIfCancellationRequested(config);
|
|
response.data = transformData(
|
|
response.data,
|
|
response.headers,
|
|
config.transformResponse
|
|
);
|
|
return response;
|
|
}, function onAdapterRejection(reason) {
|
|
if (!isCancel(reason)) {
|
|
throwIfCancellationRequested(config);
|
|
if (reason && reason.response) {
|
|
reason.response.data = transformData(
|
|
reason.response.data,
|
|
reason.response.headers,
|
|
config.transformResponse
|
|
);
|
|
}
|
|
}
|
|
return Promise.reject(reason);
|
|
});
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/core/mergeConfig.js
|
|
var require_mergeConfig = __commonJS({
|
|
"node_modules/axios/lib/core/mergeConfig.js"(exports, module) {
|
|
"use strict";
|
|
var utils = require_utils();
|
|
module.exports = function mergeConfig(config1, config2) {
|
|
config2 = config2 || {};
|
|
var config = {};
|
|
var valueFromConfig2Keys = ["url", "method", "params", "data"];
|
|
var mergeDeepPropertiesKeys = ["headers", "auth", "proxy"];
|
|
var defaultToConfig2Keys = [
|
|
"baseURL",
|
|
"url",
|
|
"transformRequest",
|
|
"transformResponse",
|
|
"paramsSerializer",
|
|
"timeout",
|
|
"withCredentials",
|
|
"adapter",
|
|
"responseType",
|
|
"xsrfCookieName",
|
|
"xsrfHeaderName",
|
|
"onUploadProgress",
|
|
"onDownloadProgress",
|
|
"maxContentLength",
|
|
"validateStatus",
|
|
"maxRedirects",
|
|
"httpAgent",
|
|
"httpsAgent",
|
|
"cancelToken",
|
|
"socketPath"
|
|
];
|
|
utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
|
|
if (typeof config2[prop] !== "undefined") {
|
|
config[prop] = config2[prop];
|
|
}
|
|
});
|
|
utils.forEach(mergeDeepPropertiesKeys, function mergeDeepProperties(prop) {
|
|
if (utils.isObject(config2[prop])) {
|
|
config[prop] = utils.deepMerge(config1[prop], config2[prop]);
|
|
} else if (typeof config2[prop] !== "undefined") {
|
|
config[prop] = config2[prop];
|
|
} else if (utils.isObject(config1[prop])) {
|
|
config[prop] = utils.deepMerge(config1[prop]);
|
|
} else if (typeof config1[prop] !== "undefined") {
|
|
config[prop] = config1[prop];
|
|
}
|
|
});
|
|
utils.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {
|
|
if (typeof config2[prop] !== "undefined") {
|
|
config[prop] = config2[prop];
|
|
} else if (typeof config1[prop] !== "undefined") {
|
|
config[prop] = config1[prop];
|
|
}
|
|
});
|
|
var axiosKeys = valueFromConfig2Keys.concat(mergeDeepPropertiesKeys).concat(defaultToConfig2Keys);
|
|
var otherKeys = Object.keys(config2).filter(function filterAxiosKeys(key) {
|
|
return axiosKeys.indexOf(key) === -1;
|
|
});
|
|
utils.forEach(otherKeys, function otherKeysDefaultToConfig2(prop) {
|
|
if (typeof config2[prop] !== "undefined") {
|
|
config[prop] = config2[prop];
|
|
} else if (typeof config1[prop] !== "undefined") {
|
|
config[prop] = config1[prop];
|
|
}
|
|
});
|
|
return config;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/core/Axios.js
|
|
var require_Axios = __commonJS({
|
|
"node_modules/axios/lib/core/Axios.js"(exports, module) {
|
|
"use strict";
|
|
var utils = require_utils();
|
|
var buildURL = require_buildURL();
|
|
var InterceptorManager = require_InterceptorManager();
|
|
var dispatchRequest = require_dispatchRequest();
|
|
var mergeConfig = require_mergeConfig();
|
|
function Axios(instanceConfig) {
|
|
this.defaults = instanceConfig;
|
|
this.interceptors = {
|
|
request: new InterceptorManager(),
|
|
response: new InterceptorManager()
|
|
};
|
|
}
|
|
Axios.prototype.request = function request(config) {
|
|
if (typeof config === "string") {
|
|
config = arguments[1] || {};
|
|
config.url = arguments[0];
|
|
} else {
|
|
config = config || {};
|
|
}
|
|
config = mergeConfig(this.defaults, config);
|
|
if (config.method) {
|
|
config.method = config.method.toLowerCase();
|
|
} else if (this.defaults.method) {
|
|
config.method = this.defaults.method.toLowerCase();
|
|
} else {
|
|
config.method = "get";
|
|
}
|
|
var chain = [dispatchRequest, void 0];
|
|
var promise = Promise.resolve(config);
|
|
this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
|
|
chain.unshift(interceptor.fulfilled, interceptor.rejected);
|
|
});
|
|
this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
|
|
chain.push(interceptor.fulfilled, interceptor.rejected);
|
|
});
|
|
while (chain.length) {
|
|
promise = promise.then(chain.shift(), chain.shift());
|
|
}
|
|
return promise;
|
|
};
|
|
Axios.prototype.getUri = function getUri(config) {
|
|
config = mergeConfig(this.defaults, config);
|
|
return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, "");
|
|
};
|
|
utils.forEach(["delete", "get", "head", "options"], function forEachMethodNoData(method) {
|
|
Axios.prototype[method] = function(url, config) {
|
|
return this.request(utils.merge(config || {}, {
|
|
method,
|
|
url
|
|
}));
|
|
};
|
|
});
|
|
utils.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
|
|
Axios.prototype[method] = function(url, data, config) {
|
|
return this.request(utils.merge(config || {}, {
|
|
method,
|
|
url,
|
|
data
|
|
}));
|
|
};
|
|
});
|
|
module.exports = Axios;
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/cancel/Cancel.js
|
|
var require_Cancel = __commonJS({
|
|
"node_modules/axios/lib/cancel/Cancel.js"(exports, module) {
|
|
"use strict";
|
|
function Cancel(message) {
|
|
this.message = message;
|
|
}
|
|
Cancel.prototype.toString = function toString() {
|
|
return "Cancel" + (this.message ? ": " + this.message : "");
|
|
};
|
|
Cancel.prototype.__CANCEL__ = true;
|
|
module.exports = Cancel;
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/cancel/CancelToken.js
|
|
var require_CancelToken = __commonJS({
|
|
"node_modules/axios/lib/cancel/CancelToken.js"(exports, module) {
|
|
"use strict";
|
|
var Cancel = require_Cancel();
|
|
function CancelToken(executor) {
|
|
if (typeof executor !== "function") {
|
|
throw new TypeError("executor must be a function.");
|
|
}
|
|
var resolvePromise;
|
|
this.promise = new Promise(function promiseExecutor(resolve) {
|
|
resolvePromise = resolve;
|
|
});
|
|
var token = this;
|
|
executor(function cancel(message) {
|
|
if (token.reason) {
|
|
return;
|
|
}
|
|
token.reason = new Cancel(message);
|
|
resolvePromise(token.reason);
|
|
});
|
|
}
|
|
CancelToken.prototype.throwIfRequested = function throwIfRequested() {
|
|
if (this.reason) {
|
|
throw this.reason;
|
|
}
|
|
};
|
|
CancelToken.source = function source() {
|
|
var cancel;
|
|
var token = new CancelToken(function executor(c) {
|
|
cancel = c;
|
|
});
|
|
return {
|
|
token,
|
|
cancel
|
|
};
|
|
};
|
|
module.exports = CancelToken;
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/helpers/spread.js
|
|
var require_spread = __commonJS({
|
|
"node_modules/axios/lib/helpers/spread.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = function spread(callback) {
|
|
return function wrap(arr) {
|
|
return callback.apply(null, arr);
|
|
};
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/lib/axios.js
|
|
var require_axios = __commonJS({
|
|
"node_modules/axios/lib/axios.js"(exports, module) {
|
|
"use strict";
|
|
var utils = require_utils();
|
|
var bind = require_bind();
|
|
var Axios = require_Axios();
|
|
var mergeConfig = require_mergeConfig();
|
|
var defaults = require_defaults();
|
|
function createInstance(defaultConfig) {
|
|
var context = new Axios(defaultConfig);
|
|
var instance = bind(Axios.prototype.request, context);
|
|
utils.extend(instance, Axios.prototype, context);
|
|
utils.extend(instance, context);
|
|
return instance;
|
|
}
|
|
var axios2 = createInstance(defaults);
|
|
axios2.Axios = Axios;
|
|
axios2.create = function create(instanceConfig) {
|
|
return createInstance(mergeConfig(axios2.defaults, instanceConfig));
|
|
};
|
|
axios2.Cancel = require_Cancel();
|
|
axios2.CancelToken = require_CancelToken();
|
|
axios2.isCancel = require_isCancel();
|
|
axios2.all = function all(promises) {
|
|
return Promise.all(promises);
|
|
};
|
|
axios2.spread = require_spread();
|
|
module.exports = axios2;
|
|
module.exports.default = axios2;
|
|
}
|
|
});
|
|
|
|
// node_modules/axios/index.js
|
|
var require_axios2 = __commonJS({
|
|
"node_modules/axios/index.js"(exports, module) {
|
|
module.exports = require_axios();
|
|
}
|
|
});
|
|
|
|
// node_modules/lottie-vuejs/dist/lottie-animation.esm.js
|
|
var import_lottie_web = __toESM(require_lottie());
|
|
var import_axios = __toESM(require_axios2());
|
|
var script = {
|
|
props: {
|
|
path: {
|
|
required: true
|
|
},
|
|
speed: {
|
|
type: Number,
|
|
required: false,
|
|
default: 1
|
|
},
|
|
width: {
|
|
type: Number,
|
|
required: false,
|
|
default: -1
|
|
},
|
|
height: {
|
|
type: Number,
|
|
required: false,
|
|
default: -1
|
|
},
|
|
loop: {
|
|
type: Boolean,
|
|
required: false,
|
|
default: true
|
|
},
|
|
autoPlay: {
|
|
type: Boolean,
|
|
required: false,
|
|
default: true
|
|
},
|
|
loopDelayMin: {
|
|
type: Number,
|
|
required: false,
|
|
default: 0
|
|
},
|
|
loopDelayMax: {
|
|
type: Number,
|
|
required: false,
|
|
default: 0
|
|
}
|
|
},
|
|
data: function() {
|
|
return {
|
|
name: "lottie-animation",
|
|
rendererSettings: {
|
|
scaleMode: "centerCrop",
|
|
clearCanvas: true,
|
|
progressiveLoad: false,
|
|
hideOnTransparent: true
|
|
},
|
|
anim: null,
|
|
style: null
|
|
};
|
|
},
|
|
mounted: function mounted() {
|
|
this.init();
|
|
},
|
|
methods: {
|
|
loadJsonData: async function loadJsonData(path) {
|
|
return await import_axios.default.get("/" + path).then(function(response) {
|
|
return response.data;
|
|
});
|
|
},
|
|
init: async function init() {
|
|
this.style = {
|
|
width: this.width != -1 ? this.width + "px" : "100%",
|
|
height: this.height != -1 ? this.height + "px" : "100%",
|
|
overflow: "hidden",
|
|
margin: "0 auto"
|
|
};
|
|
var jsonData = await this.loadJsonData(this.path);
|
|
if (this.anim) {
|
|
this.anim.destroy();
|
|
}
|
|
this.anim = import_lottie_web.default.loadAnimation({
|
|
container: this.$refs.lavContainer,
|
|
renderer: "svg",
|
|
loop: this.loop,
|
|
autoplay: this.autoPlay,
|
|
animationData: jsonData,
|
|
rendererSettings: this.rendererSettings
|
|
});
|
|
this.$emit("AnimControl", this.anim);
|
|
this.anim.setSpeed(this.speed);
|
|
if (this.loopDelayMin > 0) {
|
|
this.anim.loop = false;
|
|
this.anim.autoplay = false;
|
|
this.executeLoop();
|
|
}
|
|
},
|
|
getRandomInt: function getRandomInt(min, max) {
|
|
min = Math.ceil(min);
|
|
max = Math.floor(max);
|
|
return Math.floor(Math.random() * (max - min)) + min;
|
|
},
|
|
executeLoop: function executeLoop() {
|
|
var this$1 = this;
|
|
this.anim.play();
|
|
setTimeout(function() {
|
|
this$1.anim.stop();
|
|
this$1.executeLoop();
|
|
}, this.getRandomInt(this.loopDelayMin, this.loopDelayMax == 0 ? this.loopDelayMin : this.loopDelayMax));
|
|
}
|
|
},
|
|
watch: {
|
|
path: function(newVal, oldVal) {
|
|
this.init();
|
|
}
|
|
}
|
|
};
|
|
function normalizeComponent(template, style, script2, scopeId, isFunctionalTemplate, moduleIdentifier, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {
|
|
if (typeof shadowMode !== "boolean") {
|
|
createInjectorSSR = createInjector;
|
|
createInjector = shadowMode;
|
|
shadowMode = false;
|
|
}
|
|
var options = typeof script2 === "function" ? script2.options : script2;
|
|
if (template && template.render) {
|
|
options.render = template.render;
|
|
options.staticRenderFns = template.staticRenderFns;
|
|
options._compiled = true;
|
|
if (isFunctionalTemplate) {
|
|
options.functional = true;
|
|
}
|
|
}
|
|
if (scopeId) {
|
|
options._scopeId = scopeId;
|
|
}
|
|
var hook;
|
|
if (moduleIdentifier) {
|
|
hook = function hook2(context) {
|
|
context = context || // cached call
|
|
this.$vnode && this.$vnode.ssrContext || // stateful
|
|
this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext;
|
|
if (!context && typeof __VUE_SSR_CONTEXT__ !== "undefined") {
|
|
context = __VUE_SSR_CONTEXT__;
|
|
}
|
|
if (style) {
|
|
style.call(this, createInjectorSSR(context));
|
|
}
|
|
if (context && context._registeredComponents) {
|
|
context._registeredComponents.add(moduleIdentifier);
|
|
}
|
|
};
|
|
options._ssrRegister = hook;
|
|
} else if (style) {
|
|
hook = shadowMode ? function() {
|
|
style.call(this, createInjectorShadow(this.$root.$options.shadowRoot));
|
|
} : function(context) {
|
|
style.call(this, createInjector(context));
|
|
};
|
|
}
|
|
if (hook) {
|
|
if (options.functional) {
|
|
var originalRender = options.render;
|
|
options.render = function renderWithStyleInjection(h, context) {
|
|
hook.call(context);
|
|
return originalRender(h, context);
|
|
};
|
|
} else {
|
|
var existing = options.beforeCreate;
|
|
options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
|
|
}
|
|
}
|
|
return script2;
|
|
}
|
|
var normalizeComponent_1 = normalizeComponent;
|
|
var __vue_script__ = script;
|
|
var __vue_render__ = function() {
|
|
var _vm = this;
|
|
var _h = _vm.$createElement;
|
|
var _c = _vm._self._c || _h;
|
|
return _vm.style ? _c("div", { ref: "lavContainer", style: _vm.style }) : _vm._e();
|
|
};
|
|
var __vue_staticRenderFns__ = [];
|
|
__vue_render__._withStripped = true;
|
|
var __vue_inject_styles__ = void 0;
|
|
var __vue_scope_id__ = void 0;
|
|
var __vue_module_identifier__ = void 0;
|
|
var __vue_is_functional_template__ = false;
|
|
var __vue_component__ = normalizeComponent_1(
|
|
{ render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },
|
|
__vue_inject_styles__,
|
|
__vue_script__,
|
|
__vue_scope_id__,
|
|
__vue_is_functional_template__,
|
|
__vue_module_identifier__,
|
|
false,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
);
|
|
var wrapper = {
|
|
install: function install(Vue, options) {
|
|
Vue.component("lottie-animation", __vue_component__);
|
|
Vue.mixin({
|
|
mounted: function mounted2() {
|
|
}
|
|
});
|
|
}
|
|
};
|
|
var lottie_animation_esm_default = wrapper;
|
|
export {
|
|
lottie_animation_esm_default as default
|
|
};
|
|
//# sourceMappingURL=lottie-vuejs.js.map
|