2125 lines
62 KiB
JavaScript
2125 lines
62 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: 2eebcf3bb0503188.1045ee8eb6.js
|
|
* Module id: 640958
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (e) => {
|
|
"use strict";
|
|
let t,
|
|
r,
|
|
n,
|
|
o = ["info", "warn", "error", "arms"];
|
|
function i(e) {
|
|
let t = {};
|
|
return (
|
|
(t.namespace = e),
|
|
o.forEach(function (e) {
|
|
t[e] = function (e, ...t) {
|
|
!(function (e, t, r) {
|
|
t
|
|
? r || console.log("util-logger / need methodName")
|
|
: console.log("util-logger / need namespace");
|
|
})(0, this.namespace, e, ...t);
|
|
};
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
let a = null,
|
|
s = "indexeddb";
|
|
async function l(t = "indexeddb") {
|
|
try {
|
|
if ("indexeddb" === t) {
|
|
let { indexedDBLogger: t } = await e.A(585980);
|
|
if ((await t.initPromise, t.initialized)) {
|
|
(a = t),
|
|
(s = "indexeddb"),
|
|
console.log("ShakkerLogger: Using IndexedDB");
|
|
return;
|
|
}
|
|
}
|
|
let { localStorageLogger: r } = await e.A(6597);
|
|
(a = r),
|
|
(s = "localStorage"),
|
|
console.log("ShakkerLogger: Using localStorage");
|
|
} catch (r) {
|
|
console.warn("ShakkerLogger: Failed to initialize logger", r);
|
|
let { localStorageLogger: t } = await e.A(6597);
|
|
(a = t), (s = "localStorage");
|
|
}
|
|
}
|
|
async function c(e, t = "unknown") {
|
|
if (
|
|
(function () {
|
|
try {
|
|
if (!window.localStorage) return !1;
|
|
let e = localStorage.getItem("shakker_logger_enabled");
|
|
return "true" === e;
|
|
} catch (e) {
|
|
return (
|
|
console.warn("ShakkerLogger: Failed to check logger switch", e),
|
|
!1
|
|
);
|
|
}
|
|
})()
|
|
) {
|
|
if ((a || (await l()), !a))
|
|
return void console.warn("ShakkerLogger: No logger available");
|
|
try {
|
|
"indexeddb" === s
|
|
? await a.log({
|
|
url: "/log/acceptor/f",
|
|
method: "POST",
|
|
params: e,
|
|
source: t,
|
|
timestamp: Date.now(),
|
|
})
|
|
: a.log({
|
|
url: "/log/acceptor/f",
|
|
method: "POST",
|
|
params: e,
|
|
source: t,
|
|
timestamp: Date.now(),
|
|
});
|
|
} catch (e) {
|
|
console.warn("ShakkerLogger: Failed to log", e);
|
|
}
|
|
}
|
|
}
|
|
e.s(["Logger", () => i, "logAcceptorCall", () => c], 552119);
|
|
var u = e.i(450203);
|
|
let f = (e, t, r) => {
|
|
var n, o, i, a;
|
|
let { sPath: s, sDomain: l } = (r = r || {});
|
|
return null === t
|
|
? ((n = e),
|
|
(o = s),
|
|
(i = l),
|
|
!!n &&
|
|
!!RegExp(
|
|
"(?:^|;\\s*)" +
|
|
encodeURIComponent(n).replace(/[-.+*]/g, "\\$&") +
|
|
"\\s*\\=",
|
|
).test(document.cookie) &&
|
|
((document.cookie =
|
|
encodeURIComponent(n) +
|
|
"=; expires=Thu, 01 Jan 1970 00:00:00 GMT" +
|
|
(i ? "; domain=" + i : "") +
|
|
(o ? "; path=" + o : "")),
|
|
!0))
|
|
: void 0 === t
|
|
? ((a = e),
|
|
decodeURIComponent(
|
|
document.cookie.replace(
|
|
RegExp(
|
|
"(?:(?:^|.*;)\\s*" +
|
|
encodeURIComponent(a).replace(/[-.+*]/g, "\\$&") +
|
|
"\\s*\\=\\s*([^;]*).*$)|^.*$",
|
|
),
|
|
"$1",
|
|
),
|
|
) || null)
|
|
: (function (e, t, r) {
|
|
if (!e || /^(?:expires|max\-age|path|domain|secure)$/i.test(e))
|
|
return;
|
|
let {
|
|
vEnd: n,
|
|
sPath: o,
|
|
sDomain: i,
|
|
bSecure: a,
|
|
} = (r = r || {}),
|
|
s = "";
|
|
if (n)
|
|
switch (n.constructor) {
|
|
case Number:
|
|
s =
|
|
n === 1 / 0
|
|
? "; expires=Fri, 31 Dec 9999 23:59:59 GMT"
|
|
: "; max-age=" + n;
|
|
break;
|
|
case String:
|
|
s = "; expires=" + n;
|
|
break;
|
|
case Date:
|
|
s = "; expires=" + n.toUTCString();
|
|
}
|
|
return (
|
|
(document.cookie =
|
|
encodeURIComponent(e) +
|
|
"=" +
|
|
encodeURIComponent(t) +
|
|
s +
|
|
(i ? "; domain=" + i : "") +
|
|
(o ? "; path=" + o : "") +
|
|
(a ? "; secure" : "")),
|
|
!0
|
|
);
|
|
})(e, t, r);
|
|
},
|
|
d = "liblibai_usertoken",
|
|
p = "usertoken",
|
|
h = i("@shakkerai/util-cookie"),
|
|
{ config: m } = e.r(325528),
|
|
g = "webid",
|
|
y = (e, t, r = {}) => {
|
|
h.info("setCookieLongTerm", e),
|
|
(0, u.setCookie)(e, t, { ...r, maxAge: 31536e4 });
|
|
},
|
|
b = () => {
|
|
let e = f(d) || f(p) || f(m.platformTokenCookieKey);
|
|
return h.info("getUsertokenFromCookie", e), e;
|
|
},
|
|
w = (e) => {
|
|
"u" > typeof document &&
|
|
((document.cookie =
|
|
encodeURIComponent(e) +
|
|
"=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/"),
|
|
(document.cookie =
|
|
encodeURIComponent(e) +
|
|
"=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/; domain=." +
|
|
window.location.hostname),
|
|
(document.cookie =
|
|
encodeURIComponent(e) +
|
|
"=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/; domain=" +
|
|
window.location.hostname));
|
|
};
|
|
function E(e, t) {
|
|
return function () {
|
|
return e.apply(t, arguments);
|
|
};
|
|
}
|
|
e.s(
|
|
[
|
|
"calculateABTest",
|
|
0,
|
|
(e) => {
|
|
if (!e) return "A";
|
|
let t = e[e.length - 1];
|
|
return (t ? t.charCodeAt(0) : 0) % 2 == 0 ? "A" : "B";
|
|
},
|
|
"clearUsertokenToCookie",
|
|
0,
|
|
() => {
|
|
h.info("clearUsertokenToCookie"),
|
|
f(d, null),
|
|
f(p, null),
|
|
w(d),
|
|
w(p),
|
|
window.localStorage.setItem("__userinfo_token__", null);
|
|
},
|
|
"getCookieWebid",
|
|
0,
|
|
(e) => {
|
|
let t = (0, u.getCookie)(g, e);
|
|
if (!t || "string" != typeof t) {
|
|
let t = (() => {
|
|
let [e, t] = [
|
|
Math.floor(4 * Math.random() + 1),
|
|
Math.floor(8 * Math.random() + 17),
|
|
],
|
|
r = [
|
|
"a",
|
|
"b",
|
|
"c",
|
|
"d",
|
|
"e",
|
|
"f",
|
|
"g",
|
|
"h",
|
|
"i",
|
|
"g",
|
|
"k",
|
|
"l",
|
|
"m",
|
|
"n",
|
|
"o",
|
|
"p",
|
|
"q",
|
|
"r",
|
|
"s",
|
|
"t",
|
|
"u",
|
|
"v",
|
|
"w",
|
|
"x",
|
|
"y",
|
|
"z",
|
|
]
|
|
.sort(() => 0.4 - Math.random())
|
|
.slice(e, t)
|
|
.slice(0, 8)
|
|
.join("");
|
|
return new Date().getTime() + r;
|
|
})();
|
|
return y(g, t, { ...e, secure: !0, sameSite: "none" }), t;
|
|
}
|
|
return t;
|
|
},
|
|
"getUsertokenFromCookie",
|
|
0,
|
|
b,
|
|
"setCookieLongTerm",
|
|
0,
|
|
y,
|
|
],
|
|
640958,
|
|
);
|
|
let { toString: O } = Object.prototype,
|
|
{ getPrototypeOf: S } = Object,
|
|
k =
|
|
((t = Object.create(null)),
|
|
(e) => {
|
|
let r = O.call(e);
|
|
return t[r] || (t[r] = r.slice(8, -1).toLowerCase());
|
|
}),
|
|
v = (e) => ((e = e.toLowerCase()), (t) => k(t) === e),
|
|
R = (e) => (t) => typeof t === e,
|
|
{ isArray: T } = Array,
|
|
C = R("undefined"),
|
|
A = v("ArrayBuffer"),
|
|
x = R("string"),
|
|
j = R("function"),
|
|
N = R("number"),
|
|
P = (e) => null !== e && "object" == typeof e,
|
|
U = (e) => {
|
|
if ("object" !== k(e)) return !1;
|
|
let t = S(e);
|
|
return (
|
|
(null === t ||
|
|
t === Object.prototype ||
|
|
null === Object.getPrototypeOf(t)) &&
|
|
!(Symbol.toStringTag in e) &&
|
|
!(Symbol.iterator in e)
|
|
);
|
|
},
|
|
_ = v("Date"),
|
|
D = v("File"),
|
|
L = v("Blob"),
|
|
F = v("FileList"),
|
|
B = v("URLSearchParams");
|
|
function q(e, t, { allOwnKeys: r = !1 } = {}) {
|
|
let n, o;
|
|
if (null != e)
|
|
if (("object" != typeof e && (e = [e]), T(e)))
|
|
for (n = 0, o = e.length; n < o; n++) t.call(null, e[n], n, e);
|
|
else {
|
|
let o,
|
|
i = r ? Object.getOwnPropertyNames(e) : Object.keys(e),
|
|
a = i.length;
|
|
for (n = 0; n < a; n++) (o = i[n]), t.call(null, e[o], o, e);
|
|
}
|
|
}
|
|
function I(e, t) {
|
|
let r;
|
|
t = t.toLowerCase();
|
|
let n = Object.keys(e),
|
|
o = n.length;
|
|
for (; o-- > 0; ) if (t === (r = n[o]).toLowerCase()) return r;
|
|
return null;
|
|
}
|
|
let M =
|
|
"u" > typeof globalThis
|
|
? globalThis
|
|
: "u" > typeof self
|
|
? self
|
|
: "u" > typeof window
|
|
? window
|
|
: e.g,
|
|
z = (e) => !C(e) && e !== M,
|
|
J =
|
|
((r = "u" > typeof Uint8Array && S(Uint8Array)),
|
|
(e) => r && e instanceof r),
|
|
H = v("HTMLFormElement"),
|
|
$ = (
|
|
({ hasOwnProperty: e }) =>
|
|
(t, r) =>
|
|
e.call(t, r)
|
|
)(Object.prototype),
|
|
W = v("RegExp"),
|
|
K = (e, t) => {
|
|
let r = Object.getOwnPropertyDescriptors(e),
|
|
n = {};
|
|
q(r, (r, o) => {
|
|
let i;
|
|
!1 !== (i = t(r, o, e)) && (n[o] = i || r);
|
|
}),
|
|
Object.defineProperties(e, n);
|
|
},
|
|
G = "abcdefghijklmnopqrstuvwxyz",
|
|
V = "0123456789",
|
|
X = { DIGIT: V, ALPHA: G, ALPHA_DIGIT: G + G.toUpperCase() + V },
|
|
Z = v("AsyncFunction"),
|
|
Q = {
|
|
isArray: T,
|
|
isArrayBuffer: A,
|
|
isBuffer: function (e) {
|
|
return (
|
|
null !== e &&
|
|
!C(e) &&
|
|
null !== e.constructor &&
|
|
!C(e.constructor) &&
|
|
j(e.constructor.isBuffer) &&
|
|
e.constructor.isBuffer(e)
|
|
);
|
|
},
|
|
isFormData: (e) => {
|
|
let t;
|
|
return (
|
|
e &&
|
|
(("function" == typeof FormData && e instanceof FormData) ||
|
|
(j(e.append) &&
|
|
("formdata" === (t = k(e)) ||
|
|
("object" === t &&
|
|
j(e.toString) &&
|
|
"[object FormData]" === e.toString()))))
|
|
);
|
|
},
|
|
isArrayBufferView: function (e) {
|
|
return "u" > typeof ArrayBuffer && ArrayBuffer.isView
|
|
? ArrayBuffer.isView(e)
|
|
: e && e.buffer && A(e.buffer);
|
|
},
|
|
isString: x,
|
|
isNumber: N,
|
|
isBoolean: (e) => !0 === e || !1 === e,
|
|
isObject: P,
|
|
isPlainObject: U,
|
|
isUndefined: C,
|
|
isDate: _,
|
|
isFile: D,
|
|
isBlob: L,
|
|
isRegExp: W,
|
|
isFunction: j,
|
|
isStream: (e) => P(e) && j(e.pipe),
|
|
isURLSearchParams: B,
|
|
isTypedArray: J,
|
|
isFileList: F,
|
|
forEach: q,
|
|
merge: function e() {
|
|
let { caseless: t } = (z(this) && this) || {},
|
|
r = {},
|
|
n = (n, o) => {
|
|
let i = (t && I(r, o)) || o;
|
|
U(r[i]) && U(n)
|
|
? (r[i] = e(r[i], n))
|
|
: U(n)
|
|
? (r[i] = e({}, n))
|
|
: T(n)
|
|
? (r[i] = n.slice())
|
|
: (r[i] = n);
|
|
};
|
|
for (let e = 0, t = arguments.length; e < t; e++)
|
|
arguments[e] && q(arguments[e], n);
|
|
return r;
|
|
},
|
|
extend: (e, t, r, { allOwnKeys: n } = {}) => (
|
|
q(
|
|
t,
|
|
(t, n) => {
|
|
r && j(t) ? (e[n] = E(t, r)) : (e[n] = t);
|
|
},
|
|
{ allOwnKeys: n },
|
|
),
|
|
e
|
|
),
|
|
trim: (e) =>
|
|
e.trim
|
|
? e.trim()
|
|
: e.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ""),
|
|
stripBOM: (e) => (65279 === e.charCodeAt(0) && (e = e.slice(1)), e),
|
|
inherits: (e, t, r, n) => {
|
|
(e.prototype = Object.create(t.prototype, n)),
|
|
(e.prototype.constructor = e),
|
|
Object.defineProperty(e, "super", { value: t.prototype }),
|
|
r && Object.assign(e.prototype, r);
|
|
},
|
|
toFlatObject: (e, t, r, n) => {
|
|
let o,
|
|
i,
|
|
a,
|
|
s = {};
|
|
if (((t = t || {}), null == e)) return t;
|
|
do {
|
|
for (i = (o = Object.getOwnPropertyNames(e)).length; i-- > 0; )
|
|
(a = o[i]),
|
|
(!n || n(a, e, t)) && !s[a] && ((t[a] = e[a]), (s[a] = !0));
|
|
e = !1 !== r && S(e);
|
|
} while (e && (!r || r(e, t)) && e !== Object.prototype);
|
|
return t;
|
|
},
|
|
kindOf: k,
|
|
kindOfTest: v,
|
|
endsWith: (e, t, r) => {
|
|
(e = String(e)),
|
|
(void 0 === r || r > e.length) && (r = e.length),
|
|
(r -= t.length);
|
|
let n = e.indexOf(t, r);
|
|
return -1 !== n && n === r;
|
|
},
|
|
toArray: (e) => {
|
|
if (!e) return null;
|
|
if (T(e)) return e;
|
|
let t = e.length;
|
|
if (!N(t)) return null;
|
|
let r = Array(t);
|
|
for (; t-- > 0; ) r[t] = e[t];
|
|
return r;
|
|
},
|
|
forEachEntry: (e, t) => {
|
|
let r,
|
|
n = (e && e[Symbol.iterator]).call(e);
|
|
for (; (r = n.next()) && !r.done; ) {
|
|
let n = r.value;
|
|
t.call(e, n[0], n[1]);
|
|
}
|
|
},
|
|
matchAll: (e, t) => {
|
|
let r,
|
|
n = [];
|
|
for (; null !== (r = e.exec(t)); ) n.push(r);
|
|
return n;
|
|
},
|
|
isHTMLForm: H,
|
|
hasOwnProperty: $,
|
|
hasOwnProp: $,
|
|
reduceDescriptors: K,
|
|
freezeMethods: (e) => {
|
|
K(e, (t, r) => {
|
|
if (j(e) && -1 !== ["arguments", "caller", "callee"].indexOf(r))
|
|
return !1;
|
|
if (j(e[r])) {
|
|
if (((t.enumerable = !1), "writable" in t)) {
|
|
t.writable = !1;
|
|
return;
|
|
}
|
|
t.set ||
|
|
(t.set = () => {
|
|
throw Error("Can not rewrite read-only method '" + r + "'");
|
|
});
|
|
}
|
|
});
|
|
},
|
|
toObjectSet: (e, t) => {
|
|
let r = {};
|
|
return (
|
|
(T(e) ? e : String(e).split(t)).forEach((e) => {
|
|
r[e] = !0;
|
|
}),
|
|
r
|
|
);
|
|
},
|
|
toCamelCase: (e) =>
|
|
e.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function (e, t, r) {
|
|
return t.toUpperCase() + r;
|
|
}),
|
|
noop: () => {},
|
|
toFiniteNumber: (e, t) => (Number.isFinite((e *= 1)) ? e : t),
|
|
findKey: I,
|
|
global: M,
|
|
isContextDefined: z,
|
|
ALPHABET: X,
|
|
generateString: (e = 16, t = X.ALPHA_DIGIT) => {
|
|
let r = "",
|
|
{ length: n } = t;
|
|
for (; e--; ) r += t[(Math.random() * n) | 0];
|
|
return r;
|
|
},
|
|
isSpecCompliantForm: function (e) {
|
|
return !!(
|
|
e &&
|
|
j(e.append) &&
|
|
"FormData" === e[Symbol.toStringTag] &&
|
|
e[Symbol.iterator]
|
|
);
|
|
},
|
|
toJSONObject: (e) => {
|
|
let t = Array(10),
|
|
r = (e, n) => {
|
|
if (P(e)) {
|
|
if (t.indexOf(e) >= 0) return;
|
|
if (!("toJSON" in e)) {
|
|
t[n] = e;
|
|
let o = T(e) ? [] : {};
|
|
return (
|
|
q(e, (e, t) => {
|
|
let i = r(e, n + 1);
|
|
C(i) || (o[t] = i);
|
|
}),
|
|
(t[n] = void 0),
|
|
o
|
|
);
|
|
}
|
|
}
|
|
return e;
|
|
};
|
|
return r(e, 0);
|
|
},
|
|
isAsyncFn: Z,
|
|
isThenable: (e) => e && (P(e) || j(e)) && j(e.then) && j(e.catch),
|
|
};
|
|
var Y = e.i(42671);
|
|
function ee(e, t, r, n, o) {
|
|
Error.call(this),
|
|
Error.captureStackTrace
|
|
? Error.captureStackTrace(this, this.constructor)
|
|
: (this.stack = Error().stack),
|
|
(this.message = e),
|
|
(this.name = "AxiosError"),
|
|
t && (this.code = t),
|
|
r && (this.config = r),
|
|
n && (this.request = n),
|
|
o && (this.response = o);
|
|
}
|
|
Q.inherits(ee, Error, {
|
|
toJSON: function () {
|
|
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: Q.toJSONObject(this.config),
|
|
code: this.code,
|
|
status:
|
|
this.response && this.response.status ? this.response.status : null,
|
|
};
|
|
},
|
|
});
|
|
let et = ee.prototype,
|
|
er = {};
|
|
function en(e) {
|
|
return Q.isPlainObject(e) || Q.isArray(e);
|
|
}
|
|
function eo(e) {
|
|
return Q.endsWith(e, "[]") ? e.slice(0, -2) : e;
|
|
}
|
|
function ei(e, t, r) {
|
|
return e
|
|
? e
|
|
.concat(t)
|
|
.map(function (e, t) {
|
|
return (e = eo(e)), !r && t ? "[" + e + "]" : e;
|
|
})
|
|
.join(r ? "." : "")
|
|
: t;
|
|
}
|
|
[
|
|
"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((e) => {
|
|
er[e] = { value: e };
|
|
}),
|
|
Object.defineProperties(ee, er),
|
|
Object.defineProperty(et, "isAxiosError", { value: !0 }),
|
|
(ee.from = (e, t, r, n, o, i) => {
|
|
let a = Object.create(et);
|
|
return (
|
|
Q.toFlatObject(
|
|
e,
|
|
a,
|
|
function (e) {
|
|
return e !== Error.prototype;
|
|
},
|
|
(e) => "isAxiosError" !== e,
|
|
),
|
|
ee.call(a, e.message, t, r, n, o),
|
|
(a.cause = e),
|
|
(a.name = e.name),
|
|
i && Object.assign(a, i),
|
|
a
|
|
);
|
|
});
|
|
let ea = Q.toFlatObject(Q, {}, null, function (e) {
|
|
return /^is[A-Z]/.test(e);
|
|
}),
|
|
es = function (e, t, r) {
|
|
if (!Q.isObject(e)) throw TypeError("target must be an object");
|
|
t = t || new FormData();
|
|
let n = (r = Q.toFlatObject(
|
|
r,
|
|
{ metaTokens: !0, dots: !1, indexes: !1 },
|
|
!1,
|
|
function (e, t) {
|
|
return !Q.isUndefined(t[e]);
|
|
},
|
|
)).metaTokens,
|
|
o = r.visitor || c,
|
|
i = r.dots,
|
|
a = r.indexes,
|
|
s =
|
|
(r.Blob || ("u" > typeof Blob && Blob)) && Q.isSpecCompliantForm(t);
|
|
if (!Q.isFunction(o)) throw TypeError("visitor must be a function");
|
|
function l(e) {
|
|
if (null === e) return "";
|
|
if (Q.isDate(e)) return e.toISOString();
|
|
if (!s && Q.isBlob(e))
|
|
throw new ee("Blob is not supported. Use a Buffer instead.");
|
|
return Q.isArrayBuffer(e) || Q.isTypedArray(e)
|
|
? s && "function" == typeof Blob
|
|
? new Blob([e])
|
|
: Y.Buffer.from(e)
|
|
: e;
|
|
}
|
|
function c(e, r, o) {
|
|
let s = e;
|
|
if (e && !o && "object" == typeof e)
|
|
if (Q.endsWith(r, "{}"))
|
|
(r = n ? r : r.slice(0, -2)), (e = JSON.stringify(e));
|
|
else {
|
|
var c;
|
|
if (
|
|
(Q.isArray(e) && ((c = e), Q.isArray(c) && !c.some(en))) ||
|
|
((Q.isFileList(e) || Q.endsWith(r, "[]")) && (s = Q.toArray(e)))
|
|
)
|
|
return (
|
|
(r = eo(r)),
|
|
s.forEach(function (e, n) {
|
|
Q.isUndefined(e) ||
|
|
null === e ||
|
|
t.append(
|
|
!0 === a ? ei([r], n, i) : null === a ? r : r + "[]",
|
|
l(e),
|
|
);
|
|
}),
|
|
!1
|
|
);
|
|
}
|
|
return !!en(e) || (t.append(ei(o, r, i), l(e)), !1);
|
|
}
|
|
let u = [],
|
|
f = Object.assign(ea, {
|
|
defaultVisitor: c,
|
|
convertValue: l,
|
|
isVisitable: en,
|
|
});
|
|
if (!Q.isObject(e)) throw TypeError("data must be an object");
|
|
return (
|
|
!(function e(r, n) {
|
|
if (!Q.isUndefined(r)) {
|
|
if (-1 !== u.indexOf(r))
|
|
throw Error("Circular reference detected in " + n.join("."));
|
|
u.push(r),
|
|
Q.forEach(r, function (r, i) {
|
|
!0 ===
|
|
(!(Q.isUndefined(r) || null === r) &&
|
|
o.call(t, r, Q.isString(i) ? i.trim() : i, n, f)) &&
|
|
e(r, n ? n.concat(i) : [i]);
|
|
}),
|
|
u.pop();
|
|
}
|
|
})(e),
|
|
t
|
|
);
|
|
};
|
|
function el(e) {
|
|
let t = {
|
|
"!": "%21",
|
|
"'": "%27",
|
|
"(": "%28",
|
|
")": "%29",
|
|
"~": "%7E",
|
|
"%20": "+",
|
|
"%00": "\0",
|
|
};
|
|
return encodeURIComponent(e).replace(/[!'()~]|%20|%00/g, function (e) {
|
|
return t[e];
|
|
});
|
|
}
|
|
function ec(e, t) {
|
|
(this._pairs = []), e && es(e, this, t);
|
|
}
|
|
let eu = ec.prototype;
|
|
function ef(e) {
|
|
return encodeURIComponent(e)
|
|
.replace(/%3A/gi, ":")
|
|
.replace(/%24/g, "$")
|
|
.replace(/%2C/gi, ",")
|
|
.replace(/%20/g, "+")
|
|
.replace(/%5B/gi, "[")
|
|
.replace(/%5D/gi, "]");
|
|
}
|
|
function ed(e, t, r) {
|
|
let n;
|
|
if (!t) return e;
|
|
let o = (r && r.encode) || ef,
|
|
i = r && r.serialize;
|
|
if (
|
|
(n = i
|
|
? i(t, r)
|
|
: Q.isURLSearchParams(t)
|
|
? t.toString()
|
|
: new ec(t, r).toString(o))
|
|
) {
|
|
let t = e.indexOf("#");
|
|
-1 !== t && (e = e.slice(0, t)),
|
|
(e += (-1 === e.indexOf("?") ? "?" : "&") + n);
|
|
}
|
|
return e;
|
|
}
|
|
(eu.append = function (e, t) {
|
|
this._pairs.push([e, t]);
|
|
}),
|
|
(eu.toString = function (e) {
|
|
let t = e
|
|
? function (t) {
|
|
return e.call(this, t, el);
|
|
}
|
|
: el;
|
|
return this._pairs
|
|
.map(function (e) {
|
|
return t(e[0]) + "=" + t(e[1]);
|
|
}, "")
|
|
.join("&");
|
|
});
|
|
let ep = class {
|
|
constructor() {
|
|
this.handlers = [];
|
|
}
|
|
use(e, t, r) {
|
|
return (
|
|
this.handlers.push({
|
|
fulfilled: e,
|
|
rejected: t,
|
|
synchronous: !!r && r.synchronous,
|
|
runWhen: r ? r.runWhen : null,
|
|
}),
|
|
this.handlers.length - 1
|
|
);
|
|
}
|
|
eject(e) {
|
|
this.handlers[e] && (this.handlers[e] = null);
|
|
}
|
|
clear() {
|
|
this.handlers && (this.handlers = []);
|
|
}
|
|
forEach(e) {
|
|
Q.forEach(this.handlers, function (t) {
|
|
null !== t && e(t);
|
|
});
|
|
}
|
|
},
|
|
eh = {
|
|
silentJSONParsing: !0,
|
|
forcedJSONParsing: !0,
|
|
clarifyTimeoutError: !1,
|
|
},
|
|
em = "u" > typeof URLSearchParams ? URLSearchParams : ec,
|
|
eg = "u" > typeof FormData ? FormData : null,
|
|
ey = "u" > typeof Blob ? Blob : null,
|
|
eb = "u" > typeof window && "u" > typeof document,
|
|
ew =
|
|
((n = "u" > typeof navigator && navigator.product),
|
|
eb && 0 > ["ReactNative", "NativeScript", "NS"].indexOf(n)),
|
|
eE =
|
|
"u" > typeof WorkerGlobalScope &&
|
|
self instanceof WorkerGlobalScope &&
|
|
"function" == typeof self.importScripts;
|
|
e.s(
|
|
[
|
|
"hasBrowserEnv",
|
|
() => eb,
|
|
"hasStandardBrowserEnv",
|
|
() => ew,
|
|
"hasStandardBrowserWebWorkerEnv",
|
|
() => eE,
|
|
],
|
|
108898,
|
|
);
|
|
let eO = {
|
|
...e.i(108898),
|
|
isBrowser: !0,
|
|
classes: { URLSearchParams: em, FormData: eg, Blob: ey },
|
|
protocols: ["http", "https", "file", "blob", "url", "data"],
|
|
},
|
|
eS = function (e) {
|
|
if (Q.isFormData(e) && Q.isFunction(e.entries)) {
|
|
let t = {};
|
|
return (
|
|
Q.forEachEntry(e, (e, r) => {
|
|
!(function e(t, r, n, o) {
|
|
let i = t[o++];
|
|
if ("__proto__" === i) return !0;
|
|
let a = Number.isFinite(+i),
|
|
s = o >= t.length;
|
|
return (
|
|
((i = !i && Q.isArray(n) ? n.length : i), s)
|
|
? Q.hasOwnProp(n, i)
|
|
? (n[i] = [n[i], r])
|
|
: (n[i] = r)
|
|
: ((n[i] && Q.isObject(n[i])) || (n[i] = []),
|
|
e(t, r, n[i], o) &&
|
|
Q.isArray(n[i]) &&
|
|
(n[i] = (function (e) {
|
|
let t,
|
|
r,
|
|
n = {},
|
|
o = Object.keys(e),
|
|
i = o.length;
|
|
for (t = 0; t < i; t++) n[(r = o[t])] = e[r];
|
|
return n;
|
|
})(n[i]))),
|
|
!a
|
|
);
|
|
})(
|
|
Q.matchAll(/\w+|\[(\w*)]/g, e).map((e) =>
|
|
"[]" === e[0] ? "" : e[1] || e[0],
|
|
),
|
|
r,
|
|
t,
|
|
0,
|
|
);
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
return null;
|
|
},
|
|
ek = {
|
|
transitional: eh,
|
|
adapter: ["xhr", "http"],
|
|
transformRequest: [
|
|
function (e, t) {
|
|
let r,
|
|
n = t.getContentType() || "",
|
|
o = n.indexOf("application/json") > -1,
|
|
i = Q.isObject(e);
|
|
if (
|
|
(i && Q.isHTMLForm(e) && (e = new FormData(e)), Q.isFormData(e))
|
|
)
|
|
return o ? JSON.stringify(eS(e)) : e;
|
|
if (
|
|
Q.isArrayBuffer(e) ||
|
|
Q.isBuffer(e) ||
|
|
Q.isStream(e) ||
|
|
Q.isFile(e) ||
|
|
Q.isBlob(e)
|
|
)
|
|
return e;
|
|
if (Q.isArrayBufferView(e)) return e.buffer;
|
|
if (Q.isURLSearchParams(e))
|
|
return (
|
|
t.setContentType(
|
|
"application/x-www-form-urlencoded;charset=utf-8",
|
|
!1,
|
|
),
|
|
e.toString()
|
|
);
|
|
if (i) {
|
|
if (n.indexOf("application/x-www-form-urlencoded") > -1) {
|
|
var a, s;
|
|
return ((a = e),
|
|
(s = this.formSerializer),
|
|
es(
|
|
a,
|
|
new eO.classes.URLSearchParams(),
|
|
Object.assign(
|
|
{
|
|
visitor: function (e, t, r, n) {
|
|
return eO.isNode && Q.isBuffer(e)
|
|
? (this.append(t, e.toString("base64")), !1)
|
|
: n.defaultVisitor.apply(this, arguments);
|
|
},
|
|
},
|
|
s,
|
|
),
|
|
)).toString();
|
|
}
|
|
if (
|
|
(r = Q.isFileList(e)) ||
|
|
n.indexOf("multipart/form-data") > -1
|
|
) {
|
|
let t = this.env && this.env.FormData;
|
|
return es(
|
|
r ? { "files[]": e } : e,
|
|
t && new t(),
|
|
this.formSerializer,
|
|
);
|
|
}
|
|
}
|
|
if (i || o) {
|
|
t.setContentType("application/json", !1);
|
|
var l = e;
|
|
if (Q.isString(l))
|
|
try {
|
|
return (0, JSON.parse)(l), Q.trim(l);
|
|
} catch (e) {
|
|
if ("SyntaxError" !== e.name) throw e;
|
|
}
|
|
return (0, JSON.stringify)(l);
|
|
}
|
|
return e;
|
|
},
|
|
],
|
|
transformResponse: [
|
|
function (e) {
|
|
let t = this.transitional || ek.transitional,
|
|
r = t && t.forcedJSONParsing,
|
|
n = "json" === this.responseType;
|
|
if (e && Q.isString(e) && ((r && !this.responseType) || n)) {
|
|
let r = t && t.silentJSONParsing;
|
|
try {
|
|
return JSON.parse(e);
|
|
} catch (e) {
|
|
if (!r && n) {
|
|
if ("SyntaxError" === e.name)
|
|
throw ee.from(
|
|
e,
|
|
ee.ERR_BAD_RESPONSE,
|
|
this,
|
|
null,
|
|
this.response,
|
|
);
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
return e;
|
|
},
|
|
],
|
|
timeout: 0,
|
|
xsrfCookieName: "XSRF-TOKEN",
|
|
xsrfHeaderName: "X-XSRF-TOKEN",
|
|
maxContentLength: -1,
|
|
maxBodyLength: -1,
|
|
env: { FormData: eO.classes.FormData, Blob: eO.classes.Blob },
|
|
validateStatus: function (e) {
|
|
return e >= 200 && e < 300;
|
|
},
|
|
headers: {
|
|
common: {
|
|
Accept: "application/json, text/plain, */*",
|
|
"Content-Type": void 0,
|
|
},
|
|
},
|
|
};
|
|
Q.forEach(["delete", "get", "head", "post", "put", "patch"], (e) => {
|
|
ek.headers[e] = {};
|
|
});
|
|
let ev = Q.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",
|
|
]),
|
|
eR = Symbol("internals");
|
|
function eT(e) {
|
|
return e && String(e).trim().toLowerCase();
|
|
}
|
|
function eC(e) {
|
|
return !1 === e || null == e ? e : Q.isArray(e) ? e.map(eC) : String(e);
|
|
}
|
|
function eA(e, t, r, n, o) {
|
|
if (Q.isFunction(n)) return n.call(this, t, r);
|
|
if ((o && (t = r), Q.isString(t))) {
|
|
if (Q.isString(n)) return -1 !== t.indexOf(n);
|
|
if (Q.isRegExp(n)) return n.test(t);
|
|
}
|
|
}
|
|
class ex {
|
|
constructor(e) {
|
|
e && this.set(e);
|
|
}
|
|
set(e, t, r) {
|
|
let n = this;
|
|
function o(e, t, r) {
|
|
let o = eT(t);
|
|
if (!o) throw Error("header name must be a non-empty string");
|
|
let i = Q.findKey(n, o);
|
|
(i && void 0 !== n[i] && !0 !== r && (void 0 !== r || !1 === n[i])) ||
|
|
(n[i || t] = eC(e));
|
|
}
|
|
let i = (e, t) => Q.forEach(e, (e, r) => o(e, r, t));
|
|
if (Q.isPlainObject(e) || e instanceof this.constructor) i(e, t);
|
|
else {
|
|
let n;
|
|
if (
|
|
Q.isString(e) &&
|
|
(e = e.trim()) &&
|
|
((n = e), !/^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(n.trim()))
|
|
) {
|
|
var a;
|
|
let r, n, o, s;
|
|
i(
|
|
((s = {}),
|
|
(a = e) &&
|
|
a.split("\n").forEach(function (e) {
|
|
(o = e.indexOf(":")),
|
|
(r = e.substring(0, o).trim().toLowerCase()),
|
|
(n = e.substring(o + 1).trim()),
|
|
!r ||
|
|
(s[r] && ev[r]) ||
|
|
("set-cookie" === r
|
|
? s[r]
|
|
? s[r].push(n)
|
|
: (s[r] = [n])
|
|
: (s[r] = s[r] ? s[r] + ", " + n : n));
|
|
}),
|
|
s),
|
|
t,
|
|
);
|
|
} else null != e && o(t, e, r);
|
|
}
|
|
return this;
|
|
}
|
|
get(e, t) {
|
|
if ((e = eT(e))) {
|
|
let r = Q.findKey(this, e);
|
|
if (r) {
|
|
let e = this[r];
|
|
if (!t) return e;
|
|
if (!0 === t) {
|
|
let t,
|
|
r = Object.create(null),
|
|
n = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
|
|
for (; (t = n.exec(e)); ) r[t[1]] = t[2];
|
|
return r;
|
|
}
|
|
if (Q.isFunction(t)) return t.call(this, e, r);
|
|
if (Q.isRegExp(t)) return t.exec(e);
|
|
throw TypeError("parser must be boolean|regexp|function");
|
|
}
|
|
}
|
|
}
|
|
has(e, t) {
|
|
if ((e = eT(e))) {
|
|
let r = Q.findKey(this, e);
|
|
return !!(r && void 0 !== this[r] && (!t || eA(this, this[r], r, t)));
|
|
}
|
|
return !1;
|
|
}
|
|
delete(e, t) {
|
|
let r = this,
|
|
n = !1;
|
|
function o(e) {
|
|
if ((e = eT(e))) {
|
|
let o = Q.findKey(r, e);
|
|
o && (!t || eA(r, r[o], o, t)) && (delete r[o], (n = !0));
|
|
}
|
|
}
|
|
return Q.isArray(e) ? e.forEach(o) : o(e), n;
|
|
}
|
|
clear(e) {
|
|
let t = Object.keys(this),
|
|
r = t.length,
|
|
n = !1;
|
|
for (; r--; ) {
|
|
let o = t[r];
|
|
(!e || eA(this, this[o], o, e, !0)) && (delete this[o], (n = !0));
|
|
}
|
|
return n;
|
|
}
|
|
normalize(e) {
|
|
let t = this,
|
|
r = {};
|
|
return (
|
|
Q.forEach(this, (n, o) => {
|
|
let i = Q.findKey(r, o);
|
|
if (i) {
|
|
(t[i] = eC(n)), delete t[o];
|
|
return;
|
|
}
|
|
let a = e
|
|
? o
|
|
.trim()
|
|
.toLowerCase()
|
|
.replace(/([a-z\d])(\w*)/g, (e, t, r) => t.toUpperCase() + r)
|
|
: String(o).trim();
|
|
a !== o && delete t[o], (t[a] = eC(n)), (r[a] = !0);
|
|
}),
|
|
this
|
|
);
|
|
}
|
|
concat(...e) {
|
|
return this.constructor.concat(this, ...e);
|
|
}
|
|
toJSON(e) {
|
|
let t = Object.create(null);
|
|
return (
|
|
Q.forEach(this, (r, n) => {
|
|
null != r &&
|
|
!1 !== r &&
|
|
(t[n] = e && Q.isArray(r) ? r.join(", ") : r);
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
[Symbol.iterator]() {
|
|
return Object.entries(this.toJSON())[Symbol.iterator]();
|
|
}
|
|
toString() {
|
|
return Object.entries(this.toJSON())
|
|
.map(([e, t]) => e + ": " + t)
|
|
.join("\n");
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return "AxiosHeaders";
|
|
}
|
|
static from(e) {
|
|
return e instanceof this ? e : new this(e);
|
|
}
|
|
static concat(e, ...t) {
|
|
let r = new this(e);
|
|
return t.forEach((e) => r.set(e)), r;
|
|
}
|
|
static accessor(e) {
|
|
let t = (this[eR] = this[eR] = { accessors: {} }).accessors,
|
|
r = this.prototype;
|
|
function n(e) {
|
|
let n = eT(e);
|
|
if (!t[n]) {
|
|
let o;
|
|
(o = Q.toCamelCase(" " + e)),
|
|
["get", "set", "has"].forEach((t) => {
|
|
Object.defineProperty(r, t + o, {
|
|
value: function (r, n, o) {
|
|
return this[t].call(this, e, r, n, o);
|
|
},
|
|
configurable: !0,
|
|
});
|
|
}),
|
|
(t[n] = !0);
|
|
}
|
|
}
|
|
return Q.isArray(e) ? e.forEach(n) : n(e), this;
|
|
}
|
|
}
|
|
function ej(e, t) {
|
|
let r = this || ek,
|
|
n = t || r,
|
|
o = ex.from(n.headers),
|
|
i = n.data;
|
|
return (
|
|
Q.forEach(e, function (e) {
|
|
i = e.call(r, i, o.normalize(), t ? t.status : void 0);
|
|
}),
|
|
o.normalize(),
|
|
i
|
|
);
|
|
}
|
|
function eN(e) {
|
|
return !!(e && e.__CANCEL__);
|
|
}
|
|
function eP(e, t, r) {
|
|
ee.call(this, null == e ? "canceled" : e, ee.ERR_CANCELED, t, r),
|
|
(this.name = "CanceledError");
|
|
}
|
|
ex.accessor([
|
|
"Content-Type",
|
|
"Content-Length",
|
|
"Accept",
|
|
"Accept-Encoding",
|
|
"User-Agent",
|
|
"Authorization",
|
|
]),
|
|
Q.reduceDescriptors(ex.prototype, ({ value: e }, t) => {
|
|
let r = t[0].toUpperCase() + t.slice(1);
|
|
return {
|
|
get: () => e,
|
|
set(e) {
|
|
this[r] = e;
|
|
},
|
|
};
|
|
}),
|
|
Q.freezeMethods(ex),
|
|
Q.inherits(eP, ee, { __CANCEL__: !0 });
|
|
let eU = eO.hasStandardBrowserEnv
|
|
? {
|
|
write(e, t, r, n, o, i) {
|
|
let a = [e + "=" + encodeURIComponent(t)];
|
|
Q.isNumber(r) && a.push("expires=" + new Date(r).toGMTString()),
|
|
Q.isString(n) && a.push("path=" + n),
|
|
Q.isString(o) && a.push("domain=" + o),
|
|
!0 === i && a.push("secure"),
|
|
(document.cookie = a.join("; "));
|
|
},
|
|
read(e) {
|
|
let t = document.cookie.match(
|
|
RegExp("(^|;\\s*)(" + e + ")=([^;]*)"),
|
|
);
|
|
return t ? decodeURIComponent(t[3]) : null;
|
|
},
|
|
remove(e) {
|
|
this.write(e, "", Date.now() - 864e5);
|
|
},
|
|
}
|
|
: { write() {}, read: () => null, remove() {} };
|
|
function e_(e, t) {
|
|
return e && !/^([a-z][a-z\d+\-.]*:)?\/\//i.test(t)
|
|
? t
|
|
? e.replace(/\/?\/$/, "") + "/" + t.replace(/^\/+/, "")
|
|
: e
|
|
: t;
|
|
}
|
|
let eD = eO.hasStandardBrowserEnv
|
|
? (function () {
|
|
let e,
|
|
t = /(msie|trident)/i.test(navigator.userAgent),
|
|
r = document.createElement("a");
|
|
function n(e) {
|
|
let n = e;
|
|
return (
|
|
t && (r.setAttribute("href", n), (n = r.href)),
|
|
r.setAttribute("href", n),
|
|
{
|
|
href: r.href,
|
|
protocol: r.protocol ? r.protocol.replace(/:$/, "") : "",
|
|
host: r.host,
|
|
search: r.search ? r.search.replace(/^\?/, "") : "",
|
|
hash: r.hash ? r.hash.replace(/^#/, "") : "",
|
|
hostname: r.hostname,
|
|
port: r.port,
|
|
pathname:
|
|
"/" === r.pathname.charAt(0)
|
|
? r.pathname
|
|
: "/" + r.pathname,
|
|
}
|
|
);
|
|
}
|
|
return (
|
|
(e = n(window.location.href)),
|
|
function (t) {
|
|
let r = Q.isString(t) ? n(t) : t;
|
|
return r.protocol === e.protocol && r.host === e.host;
|
|
}
|
|
);
|
|
})()
|
|
: function () {
|
|
return !0;
|
|
},
|
|
eL = function (e, t) {
|
|
let r,
|
|
n = Array((e = e || 10)),
|
|
o = Array(e),
|
|
i = 0,
|
|
a = 0;
|
|
return (
|
|
(t = void 0 !== t ? t : 1e3),
|
|
function (s) {
|
|
let l = Date.now(),
|
|
c = o[a];
|
|
r || (r = l), (n[i] = s), (o[i] = l);
|
|
let u = a,
|
|
f = 0;
|
|
for (; u !== i; ) (f += n[u++]), (u %= e);
|
|
if (((i = (i + 1) % e) === a && (a = (a + 1) % e), l - r < t))
|
|
return;
|
|
let d = c && l - c;
|
|
return d ? Math.round((1e3 * f) / d) : void 0;
|
|
}
|
|
);
|
|
};
|
|
function eF(e, t) {
|
|
let r = 0,
|
|
n = eL(50, 250);
|
|
return (o) => {
|
|
let i = o.loaded,
|
|
a = o.lengthComputable ? o.total : void 0,
|
|
s = i - r,
|
|
l = n(s);
|
|
r = i;
|
|
let c = {
|
|
loaded: i,
|
|
total: a,
|
|
progress: a ? i / a : void 0,
|
|
bytes: s,
|
|
rate: l || void 0,
|
|
estimated: l && a && i <= a ? (a - i) / l : void 0,
|
|
event: o,
|
|
};
|
|
(c[t ? "download" : "upload"] = !0), e(c);
|
|
};
|
|
}
|
|
let eB = {
|
|
http: null,
|
|
xhr:
|
|
"u" > typeof XMLHttpRequest &&
|
|
function (e) {
|
|
return new Promise(function (t, r) {
|
|
let n,
|
|
o,
|
|
i,
|
|
a = e.data,
|
|
s = ex.from(e.headers).normalize(),
|
|
{ responseType: l, withXSRFToken: c } = e;
|
|
function u() {
|
|
e.cancelToken && e.cancelToken.unsubscribe(o),
|
|
e.signal && e.signal.removeEventListener("abort", o);
|
|
}
|
|
if (Q.isFormData(a)) {
|
|
if (eO.hasStandardBrowserEnv || eO.hasStandardBrowserWebWorkerEnv)
|
|
s.setContentType(!1);
|
|
else if (!1 !== (i = s.getContentType())) {
|
|
let [e, ...t] = i
|
|
? i
|
|
.split(";")
|
|
.map((e) => e.trim())
|
|
.filter(Boolean)
|
|
: [];
|
|
s.setContentType([e || "multipart/form-data", ...t].join("; "));
|
|
}
|
|
}
|
|
let f = new XMLHttpRequest();
|
|
if (e.auth) {
|
|
let t = e.auth.username || "",
|
|
r = e.auth.password
|
|
? unescape(encodeURIComponent(e.auth.password))
|
|
: "";
|
|
s.set("Authorization", "Basic " + btoa(t + ":" + r));
|
|
}
|
|
let d = e_(e.baseURL, e.url);
|
|
function p() {
|
|
let n;
|
|
if (!f) return;
|
|
let o = ex.from(
|
|
"getAllResponseHeaders" in f && f.getAllResponseHeaders(),
|
|
),
|
|
i = {
|
|
data:
|
|
l && "text" !== l && "json" !== l
|
|
? f.response
|
|
: f.responseText,
|
|
status: f.status,
|
|
statusText: f.statusText,
|
|
headers: o,
|
|
config: e,
|
|
request: f,
|
|
};
|
|
(n = i.config.validateStatus),
|
|
!i.status || !n || n(i.status)
|
|
? (function (e) {
|
|
t(e), u();
|
|
})(i)
|
|
: (function (e) {
|
|
r(e), u();
|
|
})(
|
|
new ee(
|
|
"Request failed with status code " + i.status,
|
|
[ee.ERR_BAD_REQUEST, ee.ERR_BAD_RESPONSE][
|
|
Math.floor(i.status / 100) - 4
|
|
],
|
|
i.config,
|
|
i.request,
|
|
i,
|
|
),
|
|
),
|
|
(f = null);
|
|
}
|
|
if (
|
|
(f.open(
|
|
e.method.toUpperCase(),
|
|
ed(d, e.params, e.paramsSerializer),
|
|
!0,
|
|
),
|
|
(f.timeout = e.timeout),
|
|
"onloadend" in f
|
|
? (f.onloadend = p)
|
|
: (f.onreadystatechange = function () {
|
|
!f ||
|
|
4 !== f.readyState ||
|
|
((0 !== f.status ||
|
|
(f.responseURL &&
|
|
0 === f.responseURL.indexOf("file:"))) &&
|
|
setTimeout(p));
|
|
}),
|
|
(f.onabort = function () {
|
|
f &&
|
|
(r(new ee("Request aborted", ee.ECONNABORTED, e, f)),
|
|
(f = null));
|
|
}),
|
|
(f.onerror = function () {
|
|
r(new ee("Network Error", ee.ERR_NETWORK, e, f)), (f = null);
|
|
}),
|
|
(f.ontimeout = function () {
|
|
let t = e.timeout
|
|
? "timeout of " + e.timeout + "ms exceeded"
|
|
: "timeout exceeded",
|
|
n = e.transitional || eh;
|
|
e.timeoutErrorMessage && (t = e.timeoutErrorMessage),
|
|
r(
|
|
new ee(
|
|
t,
|
|
n.clarifyTimeoutError ? ee.ETIMEDOUT : ee.ECONNABORTED,
|
|
e,
|
|
f,
|
|
),
|
|
),
|
|
(f = null);
|
|
}),
|
|
eO.hasStandardBrowserEnv &&
|
|
(c && Q.isFunction(c) && (c = c(e)), c || (!1 !== c && eD(d))))
|
|
) {
|
|
let t =
|
|
e.xsrfHeaderName &&
|
|
e.xsrfCookieName &&
|
|
eU.read(e.xsrfCookieName);
|
|
t && s.set(e.xsrfHeaderName, t);
|
|
}
|
|
void 0 === a && s.setContentType(null),
|
|
"setRequestHeader" in f &&
|
|
Q.forEach(s.toJSON(), function (e, t) {
|
|
f.setRequestHeader(t, e);
|
|
}),
|
|
Q.isUndefined(e.withCredentials) ||
|
|
(f.withCredentials = !!e.withCredentials),
|
|
l && "json" !== l && (f.responseType = e.responseType),
|
|
"function" == typeof e.onDownloadProgress &&
|
|
f.addEventListener("progress", eF(e.onDownloadProgress, !0)),
|
|
"function" == typeof e.onUploadProgress &&
|
|
f.upload &&
|
|
f.upload.addEventListener("progress", eF(e.onUploadProgress)),
|
|
(e.cancelToken || e.signal) &&
|
|
((o = (t) => {
|
|
f &&
|
|
(r(!t || t.type ? new eP(null, e, f) : t),
|
|
f.abort(),
|
|
(f = null));
|
|
}),
|
|
e.cancelToken && e.cancelToken.subscribe(o),
|
|
e.signal &&
|
|
(e.signal.aborted
|
|
? o()
|
|
: e.signal.addEventListener("abort", o)));
|
|
let h = ((n = /^([-+\w]{1,25})(:?\/\/|:)/.exec(d)) && n[1]) || "";
|
|
h && -1 === eO.protocols.indexOf(h)
|
|
? r(
|
|
new ee(
|
|
"Unsupported protocol " + h + ":",
|
|
ee.ERR_BAD_REQUEST,
|
|
e,
|
|
),
|
|
)
|
|
: f.send(a || null);
|
|
});
|
|
},
|
|
};
|
|
Q.forEach(eB, (e, t) => {
|
|
if (e) {
|
|
try {
|
|
Object.defineProperty(e, "name", { value: t });
|
|
} catch (e) {}
|
|
Object.defineProperty(e, "adapterName", { value: t });
|
|
}
|
|
});
|
|
let eq = (e) => `- ${e}`,
|
|
eI = (e) => Q.isFunction(e) || null === e || !1 === e,
|
|
eM = (e) => {
|
|
let t,
|
|
r,
|
|
{ length: n } = (e = Q.isArray(e) ? e : [e]),
|
|
o = {};
|
|
for (let i = 0; i < n; i++) {
|
|
let n;
|
|
if (
|
|
((r = t = e[i]),
|
|
!eI(t) && void 0 === (r = eB[(n = String(t)).toLowerCase()]))
|
|
)
|
|
throw new ee(`Unknown adapter '${n}'`);
|
|
if (r) break;
|
|
o[n || "#" + i] = r;
|
|
}
|
|
if (!r) {
|
|
let e = Object.entries(o).map(
|
|
([e, t]) =>
|
|
`adapter ${e} ` +
|
|
(!1 === t
|
|
? "is not supported by the environment"
|
|
: "is not available in the build"),
|
|
);
|
|
throw new ee(
|
|
"There is no suitable adapter to dispatch the request " +
|
|
(n
|
|
? e.length > 1
|
|
? "since :\n" + e.map(eq).join("\n")
|
|
: " " + eq(e[0])
|
|
: "as no adapter specified"),
|
|
"ERR_NOT_SUPPORT",
|
|
);
|
|
}
|
|
return r;
|
|
};
|
|
function ez(e) {
|
|
if (
|
|
(e.cancelToken && e.cancelToken.throwIfRequested(),
|
|
e.signal && e.signal.aborted)
|
|
)
|
|
throw new eP(null, e);
|
|
}
|
|
function eJ(e) {
|
|
return (
|
|
ez(e),
|
|
(e.headers = ex.from(e.headers)),
|
|
(e.data = ej.call(e, e.transformRequest)),
|
|
-1 !== ["post", "put", "patch"].indexOf(e.method) &&
|
|
e.headers.setContentType("application/x-www-form-urlencoded", !1),
|
|
eM(e.adapter || ek.adapter)(e).then(
|
|
function (t) {
|
|
return (
|
|
ez(e),
|
|
(t.data = ej.call(e, e.transformResponse, t)),
|
|
(t.headers = ex.from(t.headers)),
|
|
t
|
|
);
|
|
},
|
|
function (t) {
|
|
return (
|
|
!eN(t) &&
|
|
(ez(e),
|
|
t &&
|
|
t.response &&
|
|
((t.response.data = ej.call(
|
|
e,
|
|
e.transformResponse,
|
|
t.response,
|
|
)),
|
|
(t.response.headers = ex.from(t.response.headers)))),
|
|
Promise.reject(t)
|
|
);
|
|
},
|
|
)
|
|
);
|
|
}
|
|
let eH = (e) => (e instanceof ex ? e.toJSON() : e);
|
|
function e$(e, t) {
|
|
t = t || {};
|
|
let r = {};
|
|
function n(e, t, r) {
|
|
return Q.isPlainObject(e) && Q.isPlainObject(t)
|
|
? Q.merge.call({ caseless: r }, e, t)
|
|
: Q.isPlainObject(t)
|
|
? Q.merge({}, t)
|
|
: Q.isArray(t)
|
|
? t.slice()
|
|
: t;
|
|
}
|
|
function o(e, t, r) {
|
|
return Q.isUndefined(t)
|
|
? Q.isUndefined(e)
|
|
? void 0
|
|
: n(void 0, e, r)
|
|
: n(e, t, r);
|
|
}
|
|
function i(e, t) {
|
|
if (!Q.isUndefined(t)) return n(void 0, t);
|
|
}
|
|
function a(e, t) {
|
|
return Q.isUndefined(t)
|
|
? Q.isUndefined(e)
|
|
? void 0
|
|
: n(void 0, e)
|
|
: n(void 0, t);
|
|
}
|
|
function s(r, o, i) {
|
|
return i in t ? n(r, o) : i in e ? n(void 0, r) : void 0;
|
|
}
|
|
let l = {
|
|
url: i,
|
|
method: i,
|
|
data: i,
|
|
baseURL: a,
|
|
transformRequest: a,
|
|
transformResponse: a,
|
|
paramsSerializer: a,
|
|
timeout: a,
|
|
timeoutMessage: a,
|
|
withCredentials: a,
|
|
withXSRFToken: a,
|
|
adapter: a,
|
|
responseType: a,
|
|
xsrfCookieName: a,
|
|
xsrfHeaderName: a,
|
|
onUploadProgress: a,
|
|
onDownloadProgress: a,
|
|
decompress: a,
|
|
maxContentLength: a,
|
|
maxBodyLength: a,
|
|
beforeRedirect: a,
|
|
transport: a,
|
|
httpAgent: a,
|
|
httpsAgent: a,
|
|
cancelToken: a,
|
|
socketPath: a,
|
|
responseEncoding: a,
|
|
validateStatus: s,
|
|
headers: (e, t) => o(eH(e), eH(t), !0),
|
|
};
|
|
return (
|
|
Q.forEach(Object.keys(Object.assign({}, e, t)), function (n) {
|
|
let i = l[n] || o,
|
|
a = i(e[n], t[n], n);
|
|
(Q.isUndefined(a) && i !== s) || (r[n] = a);
|
|
}),
|
|
r
|
|
);
|
|
}
|
|
let eW = "1.6.7",
|
|
eK = {};
|
|
["object", "boolean", "number", "function", "string", "symbol"].forEach(
|
|
(e, t) => {
|
|
eK[e] = function (r) {
|
|
return typeof r === e || "a" + (t < 1 ? "n " : " ") + e;
|
|
};
|
|
},
|
|
);
|
|
let eG = {};
|
|
eK.transitional = function (e, t, r) {
|
|
function n(e, t) {
|
|
return (
|
|
"[Axios v" +
|
|
eW +
|
|
"] Transitional option '" +
|
|
e +
|
|
"'" +
|
|
t +
|
|
(r ? ". " + r : "")
|
|
);
|
|
}
|
|
return (r, o, i) => {
|
|
if (!1 === e)
|
|
throw new ee(
|
|
n(o, " has been removed" + (t ? " in " + t : "")),
|
|
ee.ERR_DEPRECATED,
|
|
);
|
|
return (
|
|
t &&
|
|
!eG[o] &&
|
|
((eG[o] = !0),
|
|
console.warn(
|
|
n(
|
|
o,
|
|
" has been deprecated since v" +
|
|
t +
|
|
" and will be removed in the near future",
|
|
),
|
|
)),
|
|
!e || e(r, o, i)
|
|
);
|
|
};
|
|
};
|
|
let eV = function (e, t, r) {
|
|
if ("object" != typeof e)
|
|
throw new ee("options must be an object", ee.ERR_BAD_OPTION_VALUE);
|
|
let n = Object.keys(e),
|
|
o = n.length;
|
|
for (; o-- > 0; ) {
|
|
let i = n[o],
|
|
a = t[i];
|
|
if (a) {
|
|
let t = e[i],
|
|
r = void 0 === t || a(t, i, e);
|
|
if (!0 !== r)
|
|
throw new ee(
|
|
"option " + i + " must be " + r,
|
|
ee.ERR_BAD_OPTION_VALUE,
|
|
);
|
|
continue;
|
|
}
|
|
if (!0 !== r) throw new ee("Unknown option " + i, ee.ERR_BAD_OPTION);
|
|
}
|
|
};
|
|
class eX {
|
|
constructor(e) {
|
|
(this.defaults = e),
|
|
(this.interceptors = { request: new ep(), response: new ep() });
|
|
}
|
|
async request(e, t) {
|
|
try {
|
|
return await this._request(e, t);
|
|
} catch (e) {
|
|
if (e instanceof Error) {
|
|
let t;
|
|
Error.captureStackTrace
|
|
? Error.captureStackTrace((t = {}))
|
|
: (t = Error());
|
|
let r = t.stack ? t.stack.replace(/^.+\n/, "") : "";
|
|
e.stack
|
|
? r &&
|
|
!String(e.stack).endsWith(r.replace(/^.+\n.+\n/, "")) &&
|
|
(e.stack += "\n" + r)
|
|
: (e.stack = r);
|
|
}
|
|
throw e;
|
|
}
|
|
}
|
|
_request(e, t) {
|
|
let r, n;
|
|
"string" == typeof e ? ((t = t || {}).url = e) : (t = e || {});
|
|
let {
|
|
transitional: o,
|
|
paramsSerializer: i,
|
|
headers: a,
|
|
} = (t = e$(this.defaults, t));
|
|
void 0 !== o &&
|
|
eV(
|
|
o,
|
|
{
|
|
silentJSONParsing: eK.transitional(eK.boolean),
|
|
forcedJSONParsing: eK.transitional(eK.boolean),
|
|
clarifyTimeoutError: eK.transitional(eK.boolean),
|
|
},
|
|
!1,
|
|
),
|
|
null != i &&
|
|
(Q.isFunction(i)
|
|
? (t.paramsSerializer = { serialize: i })
|
|
: eV(i, { encode: eK.function, serialize: eK.function }, !0)),
|
|
(t.method = (
|
|
t.method ||
|
|
this.defaults.method ||
|
|
"get"
|
|
).toLowerCase());
|
|
let s = a && Q.merge(a.common, a[t.method]);
|
|
a &&
|
|
Q.forEach(
|
|
["delete", "get", "head", "post", "put", "patch", "common"],
|
|
(e) => {
|
|
delete a[e];
|
|
},
|
|
),
|
|
(t.headers = ex.concat(s, a));
|
|
let l = [],
|
|
c = !0;
|
|
this.interceptors.request.forEach(function (e) {
|
|
("function" != typeof e.runWhen || !1 !== e.runWhen(t)) &&
|
|
((c = c && e.synchronous), l.unshift(e.fulfilled, e.rejected));
|
|
});
|
|
let u = [];
|
|
this.interceptors.response.forEach(function (e) {
|
|
u.push(e.fulfilled, e.rejected);
|
|
});
|
|
let f = 0;
|
|
if (!c) {
|
|
let e = [eJ.bind(this), void 0];
|
|
for (
|
|
e.unshift.apply(e, l),
|
|
e.push.apply(e, u),
|
|
n = e.length,
|
|
r = Promise.resolve(t);
|
|
f < n;
|
|
|
|
)
|
|
r = r.then(e[f++], e[f++]);
|
|
return r;
|
|
}
|
|
n = l.length;
|
|
let d = t;
|
|
for (f = 0; f < n; ) {
|
|
let e = l[f++],
|
|
t = l[f++];
|
|
try {
|
|
d = e(d);
|
|
} catch (e) {
|
|
t.call(this, e);
|
|
break;
|
|
}
|
|
}
|
|
try {
|
|
r = eJ.call(this, d);
|
|
} catch (e) {
|
|
return Promise.reject(e);
|
|
}
|
|
for (f = 0, n = u.length; f < n; ) r = r.then(u[f++], u[f++]);
|
|
return r;
|
|
}
|
|
getUri(e) {
|
|
return ed(
|
|
e_((e = e$(this.defaults, e)).baseURL, e.url),
|
|
e.params,
|
|
e.paramsSerializer,
|
|
);
|
|
}
|
|
}
|
|
Q.forEach(["delete", "get", "head", "options"], function (e) {
|
|
eX.prototype[e] = function (t, r) {
|
|
return this.request(
|
|
e$(r || {}, { method: e, url: t, data: (r || {}).data }),
|
|
);
|
|
};
|
|
}),
|
|
Q.forEach(["post", "put", "patch"], function (e) {
|
|
function t(t) {
|
|
return function (r, n, o) {
|
|
return this.request(
|
|
e$(o || {}, {
|
|
method: e,
|
|
headers: t ? { "Content-Type": "multipart/form-data" } : {},
|
|
url: r,
|
|
data: n,
|
|
}),
|
|
);
|
|
};
|
|
}
|
|
(eX.prototype[e] = t()), (eX.prototype[e + "Form"] = t(!0));
|
|
});
|
|
class eZ {
|
|
constructor(e) {
|
|
let t;
|
|
if ("function" != typeof e)
|
|
throw TypeError("executor must be a function.");
|
|
this.promise = new Promise(function (e) {
|
|
t = e;
|
|
});
|
|
const r = this;
|
|
this.promise.then((e) => {
|
|
if (!r._listeners) return;
|
|
let t = r._listeners.length;
|
|
for (; t-- > 0; ) r._listeners[t](e);
|
|
r._listeners = null;
|
|
}),
|
|
(this.promise.then = (e) => {
|
|
let t,
|
|
n = new Promise((e) => {
|
|
r.subscribe(e), (t = e);
|
|
}).then(e);
|
|
return (
|
|
(n.cancel = function () {
|
|
r.unsubscribe(t);
|
|
}),
|
|
n
|
|
);
|
|
}),
|
|
e(function (e, n, o) {
|
|
r.reason || ((r.reason = new eP(e, n, o)), t(r.reason));
|
|
});
|
|
}
|
|
throwIfRequested() {
|
|
if (this.reason) throw this.reason;
|
|
}
|
|
subscribe(e) {
|
|
this.reason
|
|
? e(this.reason)
|
|
: this._listeners
|
|
? this._listeners.push(e)
|
|
: (this._listeners = [e]);
|
|
}
|
|
unsubscribe(e) {
|
|
if (!this._listeners) return;
|
|
let t = this._listeners.indexOf(e);
|
|
-1 !== t && this._listeners.splice(t, 1);
|
|
}
|
|
static source() {
|
|
let e;
|
|
return {
|
|
token: new eZ(function (t) {
|
|
e = t;
|
|
}),
|
|
cancel: e,
|
|
};
|
|
}
|
|
}
|
|
let eQ = {
|
|
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(eQ).forEach(([e, t]) => {
|
|
eQ[t] = e;
|
|
});
|
|
let eY = (function e(t) {
|
|
let r = new eX(t),
|
|
n = E(eX.prototype.request, r);
|
|
return (
|
|
Q.extend(n, eX.prototype, r, { allOwnKeys: !0 }),
|
|
Q.extend(n, r, null, { allOwnKeys: !0 }),
|
|
(n.create = function (r) {
|
|
return e(e$(t, r));
|
|
}),
|
|
n
|
|
);
|
|
})(ek);
|
|
(eY.Axios = eX),
|
|
(eY.CanceledError = eP),
|
|
(eY.CancelToken = eZ),
|
|
(eY.isCancel = eN),
|
|
(eY.VERSION = eW),
|
|
(eY.toFormData = es),
|
|
(eY.AxiosError = ee),
|
|
(eY.Cancel = eY.CanceledError),
|
|
(eY.all = function (e) {
|
|
return Promise.all(e);
|
|
}),
|
|
(eY.spread = function (e) {
|
|
return function (t) {
|
|
return e.apply(null, t);
|
|
};
|
|
}),
|
|
(eY.isAxiosError = function (e) {
|
|
return Q.isObject(e) && !0 === e.isAxiosError;
|
|
}),
|
|
(eY.mergeConfig = e$),
|
|
(eY.AxiosHeaders = ex),
|
|
(eY.formToJSON = (e) => eS(Q.isHTMLForm(e) ? new FormData(e) : e)),
|
|
(eY.getAdapter = eM),
|
|
(eY.HttpStatusCode = eQ),
|
|
(eY.default = eY);
|
|
let e0 = (e, t) => e2(e, "get", t),
|
|
e1 = (e, t) => e2(e, "post", t),
|
|
e2 = (e, t, r) => {
|
|
let n = {};
|
|
return (
|
|
(n.url = e),
|
|
(n.method = t),
|
|
r && (n = Object.assign(n, r)),
|
|
eY.request(n)
|
|
);
|
|
},
|
|
e4 = i("@shakkerai/util-ajax"),
|
|
e5 = async (e, t, r) => (e4.info("get"), await e6(e0, e, t, r)),
|
|
e3 = async (e, t, r) => {
|
|
e4.info("getWithToken");
|
|
let n = Object.assign(r || {}, {});
|
|
return (n.token = b()), await e6(e0, e, t, n);
|
|
},
|
|
e9 = async (e, t, r) => (e4.info("post"), await e6(e1, e, t, r)),
|
|
e8 = async (e, t, r, n) => {
|
|
e4.info("postWithToken");
|
|
let o = Object.assign(r || {}, {});
|
|
return (o.token = b()), await e6(e1, e, t, o, n);
|
|
},
|
|
e6 = async function (e, t, r, n, o) {
|
|
let i,
|
|
a,
|
|
s = "ajax";
|
|
e4.info(s, "url", t), e4.info(s, "data", r), e4.info(s, "headers", n);
|
|
let l = { [e === e0 ? "params" : "data"]: r };
|
|
n && (l.headers = n), o && (l = { ...l, ...o });
|
|
let c = Date.now();
|
|
try {
|
|
i = await e(t, l);
|
|
} catch (e) {
|
|
(a = e), e4.error(s, "request error", e);
|
|
}
|
|
let u = Date.now() - c,
|
|
f = { time: `${u}ms` };
|
|
if (!i) {
|
|
let e = a ? `: ${a.message || a}` : "",
|
|
t = `request fail${e}`;
|
|
return e4.error(s, t), e7(f, t, a);
|
|
}
|
|
if (200 != i.status) {
|
|
let e = `request fail: ${i.status}`;
|
|
return e4.error(s, e), e7(f, e);
|
|
}
|
|
let d = i.data;
|
|
if (!d) {
|
|
let e = "request fail: no data";
|
|
return e4.error(s, e), e7(f, e);
|
|
}
|
|
return (
|
|
(d.time = f.time),
|
|
(d.traceId = i.headers?.tlogtraceid),
|
|
e4.info(s, "status", i.status),
|
|
e4.info(s, "json", d),
|
|
d
|
|
);
|
|
};
|
|
function e7(e, t, r) {
|
|
return (e.msg = t), (e.code = -1), r && (e.cause = r), e;
|
|
}
|
|
e.s(
|
|
[
|
|
"get",
|
|
0,
|
|
e5,
|
|
"getWithToken",
|
|
0,
|
|
e3,
|
|
"post",
|
|
0,
|
|
e9,
|
|
"postWithToken",
|
|
0,
|
|
e8,
|
|
],
|
|
243531,
|
|
);
|
|
};
|
|
|
|
export default moduleFactory;
|