mirror of
https://github.com/smallfawn/decode_action.git
synced 2025-12-22 01:34:58 +08:00
1880 lines
50 KiB
JavaScript
1880 lines
50 KiB
JavaScript
//Wed Mar 26 2025 02:03:57 GMT+0000 (Coordinated Universal Time)
|
||
//Base:<url id="cv1cref6o68qmpt26ol0" type="url" status="parsed" title="GitHub - echo094/decode-js: JS混淆代码的AST分析工具 AST analysis tool for obfuscated JS code" wc="2165">https://github.com/echo094/decode-js</url>
|
||
//Modify:<url id="cv1cref6o68qmpt26olg" type="url" status="parsed" title="GitHub - smallfawn/decode_action: 世界上本来不存在加密，加密的人多了，也便成就了解密" wc="741">https://github.com/smallfawn/decode_action</url>
|
||
(() => {
|
||
var j = {
|
||
NfSCA: function (P, Q) {
|
||
return P == Q;
|
||
},
|
||
JLkGA: "function",
|
||
aoxMZ: function (P, Q) {
|
||
return P(Q);
|
||
},
|
||
RgRoK: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
rajRC: "EAQLX",
|
||
veENK: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
hIYvf: "OqzBj",
|
||
Hsdhf: "RFLnu",
|
||
iOiHF: function (P, Q) {
|
||
return P == Q;
|
||
},
|
||
lGAPZ: function (P, Q) {
|
||
return P == Q;
|
||
},
|
||
yZSxV: "try statement without catch or finally",
|
||
Kalir: function (P, Q) {
|
||
return P < Q;
|
||
},
|
||
HlyLN: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
bHbcU: function (P, Q) {
|
||
return P == Q;
|
||
},
|
||
mXCJq: function (P, Q) {
|
||
return P + Q;
|
||
},
|
||
cXYTR: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
kzYyT: "Xlnap",
|
||
XefLH: "EPLmo",
|
||
jzgiA: "VyRny",
|
||
iZXSP: "string",
|
||
jJAcG: function (P, Q, R) {
|
||
return P(Q, R);
|
||
},
|
||
eYEgo: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
gOzYQ: "Map",
|
||
pJymx: "Set",
|
||
GNCxp: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
jXGtW: "Arguments",
|
||
GqTin: function (P, Q, R) {
|
||
return P(Q, R);
|
||
},
|
||
iWZcZ: function (P) {
|
||
return P();
|
||
},
|
||
osaRj: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
YuHHU: "kTkpe",
|
||
IGBDR: "RmWIv",
|
||
MFdwU: "cgtFk",
|
||
JRyPE: "AougV",
|
||
Guspo: function (P, Q) {
|
||
return P >= Q;
|
||
},
|
||
wbAOy: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
fXSLx: "VXMmZ",
|
||
wnlJO: "hPMBM",
|
||
zdAvd: "throw",
|
||
PxYMd: "next",
|
||
oIAzn: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
LVnYv: " API请求失败，请检查网路重试",
|
||
bKxMI: function (P) {
|
||
return P();
|
||
},
|
||
mVTQW: "end",
|
||
FrJBU: function (P, Q) {
|
||
return P != Q;
|
||
},
|
||
oZPjh: "@@iterator",
|
||
EKoEG: "wQTpd",
|
||
pcsMz: "number",
|
||
eCozK: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
PVwaK: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
BioHb: "qymoI",
|
||
cTPZk: function (P, Q) {
|
||
return P == Q;
|
||
},
|
||
HELGs: function (P, Q) {
|
||
return P > Q;
|
||
},
|
||
QOiVQ: function (P, Q) {
|
||
return P < Q;
|
||
},
|
||
AmBAQ: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
aRlET: "RIuWn",
|
||
NyDAm: "vvwXy",
|
||
xmATh: "oXuUW",
|
||
Dfiad: "oQpEa",
|
||
hwYAK: "YmSkJ",
|
||
CMZOz: "TNVto",
|
||
EHwYr: "pHzsK",
|
||
mwKyY: "TuqIn",
|
||
lOaEi: function (P, Q, R, S) {
|
||
return P(Q, R, S);
|
||
},
|
||
LwpYw: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
chDTN: "nEnQR",
|
||
Umhdk: "kNrpf",
|
||
JztWq: function (P, Q) {
|
||
return P == Q;
|
||
},
|
||
GEGmK: function (P, Q) {
|
||
return P(Q);
|
||
},
|
||
Hkbrn: function (P, Q) {
|
||
return P == Q;
|
||
},
|
||
tYQVb: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
efJGz: "IjCnL",
|
||
HjcUs: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
vgDeK: "QJbMP",
|
||
jQHNJ: "_invoke",
|
||
xtVME: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
oqfUw: function (P, Q) {
|
||
return P in Q;
|
||
},
|
||
tggDq: function (P, Q) {
|
||
return P in Q;
|
||
},
|
||
ZbPrx: "fWZrW",
|
||
fgEYo: "normal",
|
||
CZpQh: function (P, Q, R, S) {
|
||
return P(Q, R, S);
|
||
},
|
||
LqsnK: "GeneratorFunction",
|
||
UXChp: function (P, Q, R, S, T) {
|
||
return P(Q, R, S, T);
|
||
},
|
||
tPGYQ: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
EGZbi: "uhddM",
|
||
RAruk: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
jjCpK: "VTFin",
|
||
DPnIZ: "ShdBR",
|
||
DRGLr: "YPATs",
|
||
ldGqk: "uVFpJ",
|
||
hSzJp: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
fkFgU: "MSLba",
|
||
nldDE: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
aDmVn: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
UKSmp: "GqLdZ",
|
||
qPaBc: "mvgsX",
|
||
axDpg: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
ELBwk: "break",
|
||
gawYH: "continue",
|
||
pmlec: "return",
|
||
HUEgH: "Bxkdy",
|
||
PLAFc: function (P, Q) {
|
||
return P - Q;
|
||
},
|
||
LTHsk: "dFTCX",
|
||
YUICg: "UoNXG",
|
||
VHdzu: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
ipLfG: "TsbBB",
|
||
MtReV: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
ruVyr: "kSpzQ",
|
||
QuGGi: "UVHNH",
|
||
VusTW: "okJGO",
|
||
JTLAE: "tFyeF",
|
||
vkQaP: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
xMBPl: "NzvPJ",
|
||
BCLMS: function (P, Q, R) {
|
||
return P(Q, R);
|
||
},
|
||
XnZyM: "Object",
|
||
dqjsr: "IxjfH",
|
||
fVwHr: "PIXHE",
|
||
jbVWS: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
imvbb: function (P, Q, R) {
|
||
return P(Q, R);
|
||
},
|
||
kJmGN: function (P, Q) {
|
||
return P + Q;
|
||
},
|
||
vYNCz: "' method",
|
||
TxoPZ: "NsHnb",
|
||
HYaTm: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
qsCGg: "wLDRX",
|
||
BTOjF: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
HdWYB: "HGRan",
|
||
VQDnc: "jEtEm",
|
||
tcKdh: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
CZTBt: "JvtEe",
|
||
yUcsk: "DsrdW",
|
||
ILbOw: function (P, Q) {
|
||
return P < Q;
|
||
},
|
||
WragJ: "SWfVS",
|
||
suwSo: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
dZKAJ: "WdMQB",
|
||
couPQ: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
RIJfS: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
bkBkc: "KvDUz",
|
||
Hgfzv: "JDJNp",
|
||
YdaZB: "iYVLX",
|
||
QrmWo: function (P, Q) {
|
||
return P(Q);
|
||
},
|
||
yXQON: " is not iterable",
|
||
PGCYK: "daPqY",
|
||
UKoDa: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
RmMuh: "HxFjV",
|
||
WXtsv: function (P, Q, R, S) {
|
||
return P(Q, R, S);
|
||
},
|
||
DHDSA: function (P, Q, R, S, T) {
|
||
return P(Q, R, S, T);
|
||
},
|
||
PlDrk: "LyEtc",
|
||
fhBjA: "HzSAW",
|
||
CfuKI: "XaPMi",
|
||
FxLCn: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
hIsGL: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
pjqet: "symbol",
|
||
xKSsN: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
Bcqnp: "sVoGc",
|
||
yNiBp: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
UmWQa: "pHaTf",
|
||
zjBNP: "WEnUW",
|
||
mikHt: function (P, Q) {
|
||
return P <= Q;
|
||
},
|
||
jqKJt: "UJPdI",
|
||
zsVsg: "DlgEV",
|
||
vKfxa: function (P, Q, R) {
|
||
return P(Q, R);
|
||
},
|
||
EoIMe: "deknD",
|
||
PIGgC: "ynaPr",
|
||
vaAzG: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
jXbaS: "zGgrs",
|
||
DJZOF: "PODxL",
|
||
OzLCz: function (P, Q) {
|
||
return P - Q;
|
||
},
|
||
BvNMZ: "DRnjY",
|
||
NYzgE: "FNfiq",
|
||
PzNRV: "RcMpF",
|
||
ctUkB: "qvtRF",
|
||
CIYGf: "illegal catch attempt",
|
||
cZMxD: "FEZSz",
|
||
ZYjWP: function (P, Q) {
|
||
return P == Q;
|
||
},
|
||
DzccP: "@@asyncIterator",
|
||
IrisN: "@@toStringTag",
|
||
FYvjp: "JsuTy",
|
||
MmmEC: "qdsJq",
|
||
aUNSe: "shMEt",
|
||
LDKER: "suspendedStart",
|
||
DQoSs: "suspendedYield",
|
||
DYvbs: "executing",
|
||
IXqcJ: function (P, Q) {
|
||
return P(Q);
|
||
},
|
||
MDRjQ: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
WzyII: "constructor",
|
||
AVIyh: function (P, Q, R, S) {
|
||
return P(Q, R, S);
|
||
},
|
||
GfIVL: function (P, Q) {
|
||
return P(Q);
|
||
},
|
||
jAVIl: function (P, Q, R, S) {
|
||
return P(Q, R, S);
|
||
},
|
||
mtSyr: "Generator",
|
||
DWhkT: function (P, Q, R, S) {
|
||
return P(Q, R, S);
|
||
},
|
||
lJtns: "catchLoc",
|
||
sypwv: "finallyLoc",
|
||
GoJwn: function (P, Q) {
|
||
return P && Q;
|
||
},
|
||
abCte: function (P, Q) {
|
||
return P < Q;
|
||
},
|
||
WRgDJ: function (P, Q) {
|
||
return P(Q);
|
||
},
|
||
KciTE: function (P, Q) {
|
||
return P(Q);
|
||
},
|
||
QQqeh: "uUjJk",
|
||
vFsmv: "jcGbh",
|
||
jBeaS: "HANpA",
|
||
FoFVM: "GFbhp",
|
||
uaabp: function (P, Q, R, S, T, U, V, W) {
|
||
return P(Q, R, S, T, U, V, W);
|
||
},
|
||
ErPGf: "用户：",
|
||
Ynesu: "开始任务",
|
||
MNRFD: "/consumer/newYear/turntable/share",
|
||
RhVFS: "weixin",
|
||
sAXDs: "1106289",
|
||
HDzNU: "剩余抽奖次数：",
|
||
clGkG: function (P, Q) {
|
||
return P < Q;
|
||
},
|
||
SvCBS: function (P, Q) {
|
||
return P !== Q;
|
||
},
|
||
PKaql: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
ePlTX: " 抽奖获得微信红包：",
|
||
BjzmN: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
DRiIN: function (P, Q) {
|
||
return P == Q;
|
||
},
|
||
xrLQP: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
fTDbA: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
OvCRy: function (P, Q) {
|
||
return P === Q;
|
||
},
|
||
kydCN: function (P, Q, R) {
|
||
return P(Q, R);
|
||
},
|
||
nNcKR: "请完成实名认证",
|
||
GhYYC: "提现：",
|
||
FGJFA: "元 提现结果：",
|
||
gFSIX: "钱包余额：",
|
||
MPirK: function (P) {
|
||
return P();
|
||
},
|
||
glxFH: "🎉用户",
|
||
qhELe: "成功!",
|
||
nhEcF: "https://erp.5jingcai.com",
|
||
dlRLs: "Bearer ",
|
||
ElPEy: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36 MicroMessenger/6.8.0(0x16080000) NetType/WIFI MiniProgramEnv/Mac MacWechat/WMPF MacWechat/3.8.9(0x13080911) XWEB/1227",
|
||
uDJkh: "cors",
|
||
VElLZ: "empty",
|
||
tlyFz: "https://servicewechat.com/wxd79ec05386a78727/85/page-frame.html",
|
||
yhdaP: function (P, Q) {
|
||
return P(Q);
|
||
},
|
||
qtSmx: "undefined",
|
||
TsZbl: function (P, Q) {
|
||
return P == Q;
|
||
},
|
||
WIYLJ: "JingCai"
|
||
};
|
||
function k(P) {
|
||
{
|
||
k = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (S) {
|
||
{
|
||
return typeof S;
|
||
}
|
||
} : function (S) {
|
||
{
|
||
return S && "function" == typeof Symbol && S.constructor === Symbol && S !== Symbol.prototype ? "symbol" : typeof S;
|
||
}
|
||
};
|
||
return k(P);
|
||
}
|
||
}
|
||
function q(P, Q) {
|
||
var R = {
|
||
EoIbr: function (Y, Z) {
|
||
return Y !== Z;
|
||
},
|
||
ttzXP: "AougV",
|
||
LyhOJ: function (Y, Z) {
|
||
return Y >= Z;
|
||
},
|
||
EkIEf: function (Y, Z) {
|
||
return Y(Z);
|
||
},
|
||
olJED: function (Y, Z) {
|
||
return Y === Z;
|
||
},
|
||
ohNHH: "VXMmZ",
|
||
oWakJ: "hPMBM",
|
||
pdjQd: "throw",
|
||
fxlTd: "next",
|
||
hospv: function (Y, Z) {
|
||
return Y === Z;
|
||
},
|
||
hbAgJ: function (Y, Z) {
|
||
return Y(Z);
|
||
},
|
||
lEWcQ: function (Y, Z) {
|
||
return Y == Z;
|
||
},
|
||
jAqRJ: "SPDrB",
|
||
oLvOF: " API请求失败，请检查网路重试",
|
||
ZGjKw: function (Y) {
|
||
return Y();
|
||
},
|
||
XxpAl: "end",
|
||
ayJfP: function (Y, Z) {
|
||
return Y === Z;
|
||
},
|
||
gdXdM: "VZHRD",
|
||
DhnPx: "JcvAq",
|
||
vIOWl: "qkesK"
|
||
};
|
||
{
|
||
var S = "undefined" != typeof Symbol && P[Symbol.iterator] || P["@@iterator"];
|
||
if (!S) {
|
||
{
|
||
if (Array.isArray(P) || (S = function (Y, Z) {
|
||
{
|
||
if (Y) {
|
||
{
|
||
if ("string" == typeof Y) {
|
||
return w(Y, Z);
|
||
}
|
||
var a1 = {}.toString.call(Y).slice(8, -1);
|
||
"Object" === a1 && Y.constructor && (a1 = Y.constructor.name);
|
||
return "Map" === a1 || "Set" === a1 ? Array.from(Y) : "Arguments" === a1 || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(a1) ? w(Y, Z) : undefined;
|
||
}
|
||
}
|
||
}
|
||
}(P)) || Q && P && "number" == typeof P.length) {
|
||
{
|
||
S && (P = S);
|
||
var T = 0;
|
||
var U = function () {};
|
||
return {
|
||
s: U,
|
||
n: function () {
|
||
{
|
||
var Y = {
|
||
done: true
|
||
};
|
||
return T >= P.length ? Y : {
|
||
done: false,
|
||
value: P[T++]
|
||
};
|
||
}
|
||
},
|
||
e: function (Y) {
|
||
{
|
||
throw Y;
|
||
}
|
||
},
|
||
f: U
|
||
};
|
||
}
|
||
}
|
||
throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
||
}
|
||
}
|
||
var V;
|
||
var W = true;
|
||
var X = false;
|
||
return {
|
||
s: function () {
|
||
S = S.call(P);
|
||
},
|
||
n: function () {
|
||
{
|
||
var a0 = S.next();
|
||
W = a0.done;
|
||
return a0;
|
||
}
|
||
},
|
||
e: function (a0) {
|
||
{
|
||
X = true;
|
||
V = a0;
|
||
}
|
||
},
|
||
f: function () {
|
||
{
|
||
try {
|
||
{
|
||
W || null == S.return || S.return();
|
||
}
|
||
} finally {
|
||
{
|
||
if (X) {
|
||
throw V;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
}
|
||
}
|
||
function w(P, Q) {
|
||
{
|
||
(null == Q || Q > P.length) && (Q = P.length);
|
||
for (var R = 0, S = Array(Q); R < Q; R++) {
|
||
S[R] = P[R];
|
||
}
|
||
return S;
|
||
}
|
||
}
|
||
function x() {
|
||
"use strict";
|
||
|
||
var P = {
|
||
BXZPz: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
hhOqr: "TsbBB",
|
||
YpuPr: " API请求失败，请检查网路重试",
|
||
OBQKB: function (ao, ap) {
|
||
return ao in ap;
|
||
},
|
||
DVPKG: function (ao, ap, aq, ar, as) {
|
||
return ao(ap, aq, ar, as);
|
||
},
|
||
mVMFM: function (ao, ap) {
|
||
return ao !== ap;
|
||
},
|
||
pFwtw: "kSpzQ",
|
||
RIYSN: "sCjjw",
|
||
UcamC: function (ao, ap, aq, ar) {
|
||
return ao(ap, aq, ar);
|
||
},
|
||
vGevc: "_invoke",
|
||
RCSyN: function (ao, ap, aq, ar) {
|
||
return ao(ap, aq, ar);
|
||
},
|
||
HAgOV: "normal",
|
||
WiNmP: function (ao, ap) {
|
||
return ao < ap;
|
||
},
|
||
ggbKV: "CqWbJ",
|
||
TSmRK: "UVHNH",
|
||
KGPzu: "okJGO",
|
||
qhxGr: function (ao, ap) {
|
||
return ao !== ap;
|
||
},
|
||
aFUub: "KjdYv",
|
||
JAbah: "tFyeF",
|
||
cANDP: "throw",
|
||
QmgFe: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
WMPSs: "JGAdI",
|
||
nZwMQ: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
rDdrT: "NzvPJ",
|
||
yrfQh: function (ao, ap, aq, ar) {
|
||
return ao(ap, aq, ar);
|
||
},
|
||
TcsJQ: function (ao, ap, aq) {
|
||
return ao(ap, aq);
|
||
},
|
||
DXotn: "Object",
|
||
KLqiQ: "Map",
|
||
EirxA: "Set",
|
||
shpeM: "Arguments",
|
||
WjMVc: function (ao, ap, aq) {
|
||
return ao(ap, aq);
|
||
},
|
||
mbZWV: "next",
|
||
NdAFt: "return",
|
||
EUezs: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
Sphzt: "IxjfH",
|
||
KULWm: function (ao, ap) {
|
||
return ao !== ap;
|
||
},
|
||
UTLva: "PIXHE",
|
||
AVLYV: function (ao) {
|
||
return ao();
|
||
},
|
||
Xixex: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
dQuGj: function (ao, ap, aq) {
|
||
return ao(ap, aq);
|
||
},
|
||
ZcSxN: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
XYjOC: function (ao, ap) {
|
||
return ao + ap;
|
||
},
|
||
DdHAN: function (ao, ap) {
|
||
return ao + ap;
|
||
},
|
||
jaGRw: "' method",
|
||
UpzMi: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
CFbWa: function (ao, ap) {
|
||
return ao !== ap;
|
||
},
|
||
BAAfv: "NsHnb",
|
||
LUzGB: function (ao, ap) {
|
||
return ao(ap);
|
||
},
|
||
ojdDJ: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
YzmbP: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
aFFbK: "wLDRX",
|
||
jEumF: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
MWvAF: "HGRan",
|
||
aKhSm: "jEtEm",
|
||
rdiLP: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
KBIwQ: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
BaUDD: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
Cesky: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
kRShx: "JvtEe",
|
||
ITwUX: "DsrdW",
|
||
NWKak: function (ao, ap) {
|
||
return ao < ap;
|
||
},
|
||
rwNOI: function (ao, ap) {
|
||
return ao !== ap;
|
||
},
|
||
kgnTi: "SWfVS",
|
||
HRgiH: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
XVhfC: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
jdBKC: function (ao, ap) {
|
||
return ao + ap;
|
||
},
|
||
LHObg: "WdMQB",
|
||
qAqEE: "root",
|
||
Smlos: "jSyfy",
|
||
pkMPG: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
kNgCc: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
xDits: "KvDUz",
|
||
nptdB: function (ao, ap) {
|
||
return ao == ap;
|
||
},
|
||
kjDzO: "function",
|
||
Uqbed: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
eYqyS: "JDJNp",
|
||
aDNMn: "iYVLX",
|
||
bujEd: function (ao, ap) {
|
||
return ao(ap);
|
||
},
|
||
iTfjQ: " is not iterable",
|
||
Gaxdb: function (ao, ap) {
|
||
return ao !== ap;
|
||
},
|
||
zZruo: "daPqY",
|
||
FCHOo: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
PYIna: "GeneratorFunction",
|
||
mQWSG: "HxFjV",
|
||
GLDrU: function (ao, ap, aq, ar) {
|
||
return ao(ap, aq, ar);
|
||
},
|
||
nQNdp: "string",
|
||
nMcIw: "qzUUn",
|
||
vURjj: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
OuAtT: function (ao, ap, aq, ar, as) {
|
||
return ao(ap, aq, ar, as);
|
||
},
|
||
VFlqu: function (ao, ap) {
|
||
return ao == ap;
|
||
},
|
||
LGUqC: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
nUeOL: function (ao, ap, aq, ar, as, at, au, av) {
|
||
return ao(ap, aq, ar, as, at, au, av);
|
||
},
|
||
REmDG: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
yoxll: "LyEtc",
|
||
kbBKW: function (ao, ap, aq) {
|
||
return ao(ap, aq);
|
||
},
|
||
HZoXw: function (ao, ap) {
|
||
return ao < ap;
|
||
},
|
||
lkidy: function (ao, ap) {
|
||
return ao !== ap;
|
||
},
|
||
mEiNc: "HzSAW",
|
||
EYCjL: "XaPMi",
|
||
TJmpK: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
MwTsu: function (ao, ap) {
|
||
return ao !== ap;
|
||
},
|
||
YAfve: "symbol",
|
||
phYFs: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
SIWEt: "sVoGc",
|
||
KCyai: function (ao, ap) {
|
||
return ao >= ap;
|
||
},
|
||
UcGiv: function (ao, ap) {
|
||
return ao !== ap;
|
||
},
|
||
JNNlJ: "pHaTf",
|
||
AEzLi: "WEnUW",
|
||
OAFzF: function (ao, ap) {
|
||
return ao(ap);
|
||
},
|
||
OWGnj: "end",
|
||
EznXq: function (ao, ap) {
|
||
return ao <= ap;
|
||
},
|
||
WKLwl: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
iKELl: "UJPdI",
|
||
XlIbk: "finallyLoc",
|
||
Jglmy: "DlgEV",
|
||
GEasV: function (ao, ap, aq) {
|
||
return ao(ap, aq);
|
||
},
|
||
bZKjN: function (ao, ap) {
|
||
return ao < ap;
|
||
},
|
||
pkuRf: function (ao, ap) {
|
||
return ao(ap);
|
||
},
|
||
WFxpb: "deknD",
|
||
YFREk: function (ao, ap) {
|
||
return ao !== ap;
|
||
},
|
||
ZgZqC: "ynaPr",
|
||
ryJoM: function (ao, ap) {
|
||
return ao in ap;
|
||
},
|
||
QhQMl: function (ao, ap) {
|
||
return ao !== ap;
|
||
},
|
||
qvBXC: "zGgrs",
|
||
QXrnZ: "PODxL",
|
||
TjZnr: function (ao, ap) {
|
||
return ao - ap;
|
||
},
|
||
mgdhj: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
CBgHN: function (ao, ap) {
|
||
return ao < ap;
|
||
},
|
||
sHUub: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
mprYR: "DRnjY",
|
||
ovKdV: "break",
|
||
smjvG: "continue",
|
||
donjw: function (ao, ap) {
|
||
return ao <= ap;
|
||
},
|
||
gzXZP: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
AaduF: "FNfiq",
|
||
dNBNl: "RcMpF",
|
||
YZQey: function (ao, ap) {
|
||
return ao === ap;
|
||
},
|
||
uNVfr: "qvtRF",
|
||
FxgXi: "VIAuS",
|
||
Faled: "illegal catch attempt",
|
||
jWekb: "FEZSz"
|
||
};
|
||
x = function () {
|
||
{
|
||
return R;
|
||
}
|
||
};
|
||
var Q;
|
||
var R = {
|
||
wrap: a2
|
||
};
|
||
var U = Object.prototype;
|
||
var V = U.hasOwnProperty;
|
||
var W = Object.defineProperty || function (ao, ap, aq) {
|
||
ao[ap] = aq.value;
|
||
};
|
||
var X = "function" == typeof Symbol ? Symbol : {};
|
||
var Y = X.iterator || "@@iterator";
|
||
var Z = X.asyncIterator || "@@asyncIterator";
|
||
var a0 = X.toStringTag || "@@toStringTag";
|
||
function a1(ao, ap, aq) {
|
||
{
|
||
var ar = {
|
||
value: aq,
|
||
enumerable: true,
|
||
configurable: true,
|
||
writable: true
|
||
};
|
||
Object.defineProperty(ao, ap, ar);
|
||
return ao[ap];
|
||
}
|
||
}
|
||
try {
|
||
{
|
||
a1({}, "");
|
||
}
|
||
} catch (ap) {
|
||
{
|
||
a1 = function (ar, as, at) {
|
||
{
|
||
return ar[as] = at;
|
||
}
|
||
};
|
||
}
|
||
}
|
||
function a2(ar, as, at, au) {
|
||
{
|
||
var av = as && as.prototype instanceof a9 ? as : a9;
|
||
var aw = Object.create(av.prototype);
|
||
var ax = new am(au || []);
|
||
W(aw, "_invoke", {
|
||
value: ai(ar, at, ax)
|
||
});
|
||
return aw;
|
||
}
|
||
}
|
||
function a3(ar, as, at) {
|
||
{
|
||
try {
|
||
{
|
||
return {
|
||
type: "normal",
|
||
arg: ar.call(as, at)
|
||
};
|
||
}
|
||
} catch (aw) {
|
||
{
|
||
var au = {
|
||
type: "throw",
|
||
arg: aw
|
||
};
|
||
return au;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
var a4 = "suspendedStart";
|
||
var a5 = "suspendedYield";
|
||
var a6 = "executing";
|
||
var a7 = "completed";
|
||
var a8 = {};
|
||
function a9() {}
|
||
function aa() {}
|
||
function ab() {}
|
||
var ac = {};
|
||
a1(ac, Y, function () {
|
||
return this;
|
||
});
|
||
var ad = Object.getPrototypeOf;
|
||
var ae = ad && ad(ad(an([])));
|
||
ae && ae !== U && V.call(ae, Y) && (ac = ae);
|
||
ab.prototype = a9.prototype = Object.create(ac);
|
||
var af = ab.prototype;
|
||
function ag(ar) {
|
||
{
|
||
["next", "throw", "return"].forEach(function (at) {
|
||
{
|
||
a1(ar, at, function (aw) {
|
||
return this._invoke(at, aw);
|
||
});
|
||
}
|
||
});
|
||
}
|
||
}
|
||
function ah(ar, as) {
|
||
{
|
||
function aw(ax, ay, az, aA) {
|
||
{
|
||
var aC = a3(ar[ax], ar, ay);
|
||
if ("throw" !== aC.type) {
|
||
{
|
||
var aD = aC.arg;
|
||
var aE = aD.value;
|
||
return aE && "object" == k(aE) && V.call(aE, "__await") ? as.resolve(aE.__await).then(function (aG) {
|
||
aw("next", aG, az, aA);
|
||
}, function (aG) {
|
||
{
|
||
aw("throw", aG, az, aA);
|
||
}
|
||
}) : as.resolve(aE).then(function (aG) {
|
||
{
|
||
aD.value = aG;
|
||
az(aD);
|
||
}
|
||
}, function (aG) {
|
||
{
|
||
return aw("throw", aG, az, aA);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
aA(aC.arg);
|
||
}
|
||
}
|
||
var au;
|
||
W(this, "_invoke", {
|
||
value: function (ax, ay) {
|
||
{
|
||
function aB() {
|
||
return new as(function (aE, aF) {
|
||
{
|
||
aw(ax, ay, aE, aF);
|
||
}
|
||
});
|
||
}
|
||
return au = au ? au.then(aB, aB) : aB();
|
||
}
|
||
}
|
||
});
|
||
}
|
||
}
|
||
function ai(ar, as, at) {
|
||
{
|
||
var av = a4;
|
||
return function (aw, ax) {
|
||
{
|
||
if (av === a6) {
|
||
throw Error("Generator is already running");
|
||
}
|
||
if (av === a7) {
|
||
{
|
||
if ("throw" === aw) {
|
||
throw ax;
|
||
}
|
||
var aA = {
|
||
value: Q,
|
||
done: true
|
||
};
|
||
return aA;
|
||
}
|
||
}
|
||
for (at.method = aw, at.arg = ax;;) {
|
||
{
|
||
var aB = at.delegate;
|
||
if (aB) {
|
||
{
|
||
var aC = aj(aB, at);
|
||
if (aC) {
|
||
{
|
||
if (aC === a8) {
|
||
continue;
|
||
}
|
||
return aC;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if ("next" === at.method) {
|
||
at.sent = at._sent = at.arg;
|
||
} else {
|
||
if ("throw" === at.method) {
|
||
{
|
||
if (av === a4) {
|
||
throw av = a7, at.arg;
|
||
}
|
||
at.dispatchException(at.arg);
|
||
}
|
||
} else {
|
||
"return" === at.method && at.abrupt("return", at.arg);
|
||
}
|
||
}
|
||
av = a6;
|
||
var aD = a3(ar, as, at);
|
||
if ("normal" === aD.type) {
|
||
{
|
||
if (av = at.done ? a7 : a5, aD.arg === a8) {
|
||
continue;
|
||
}
|
||
var aE = {
|
||
value: aD.arg,
|
||
done: at.done
|
||
};
|
||
return aE;
|
||
}
|
||
}
|
||
"throw" === aD.type && (av = a7, at.method = "throw", at.arg = aD.arg);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
}
|
||
}
|
||
function aj(ar, as) {
|
||
{
|
||
var ax = as.method;
|
||
var ay = ar.iterator[ax];
|
||
if (ay === Q) {
|
||
as.delegate = null;
|
||
"throw" === ax && ar.iterator.return && (as.method = "return", as.arg = Q, aj(ar, as), "throw" === as.method) || "return" !== ax && (as.method = "throw", as.arg = new TypeError("The iterator does not provide a '" + ax + "' method"));
|
||
return a8;
|
||
}
|
||
var az = a3(ay, ar.iterator, as.arg);
|
||
if ("throw" === az.type) {
|
||
as.method = "throw";
|
||
as.arg = az.arg;
|
||
as.delegate = null;
|
||
return a8;
|
||
}
|
||
var aw = az.arg;
|
||
return aw ? aw.done ? (as[ar.resultName] = aw.value, as.next = ar.nextLoc, "return" !== as.method && (as.method = "next", as.arg = Q), as.delegate = null, a8) : aw : (as.method = "throw", as.arg = new TypeError("iterator result is not an object"), as.delegate = null, a8);
|
||
}
|
||
}
|
||
function ak(ar) {
|
||
{
|
||
var at = {
|
||
tryLoc: ar[0]
|
||
};
|
||
1 in ar && (at.catchLoc = ar[1]);
|
||
2 in ar && (at.finallyLoc = ar[2], at.afterLoc = ar[3]);
|
||
this.tryEntries.push(at);
|
||
}
|
||
}
|
||
function al(ar) {
|
||
{
|
||
var as = ar.completion || {};
|
||
as.type = "normal";
|
||
delete as.arg;
|
||
ar.completion = as;
|
||
}
|
||
}
|
||
function am(ar) {
|
||
{
|
||
var at = {
|
||
tryLoc: "root"
|
||
};
|
||
this.tryEntries = [at];
|
||
ar.forEach(ak, this);
|
||
this.reset(true);
|
||
}
|
||
}
|
||
function an(ar) {
|
||
{
|
||
if (ar || "" === ar) {
|
||
{
|
||
var at = ar[Y];
|
||
if (at) {
|
||
return at.call(ar);
|
||
}
|
||
if ("function" == typeof ar.next) {
|
||
return ar;
|
||
}
|
||
if (!isNaN(ar.length)) {
|
||
{
|
||
var au = -1;
|
||
var av = function ay() {
|
||
{
|
||
for (; ++au < ar.length;) {
|
||
if (V.call(ar, au)) {
|
||
ay.value = ar[au];
|
||
ay.done = false;
|
||
return ay;
|
||
}
|
||
}
|
||
ay.value = Q;
|
||
ay.done = true;
|
||
return ay;
|
||
}
|
||
};
|
||
return av.next = av;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
throw new TypeError(k(ar) + " is not iterable");
|
||
}
|
||
}
|
||
aa.prototype = ab;
|
||
W(af, "constructor", {
|
||
value: ab,
|
||
configurable: true
|
||
});
|
||
W(ab, "constructor", {
|
||
value: aa,
|
||
configurable: true
|
||
});
|
||
aa.displayName = a1(ab, a0, "GeneratorFunction");
|
||
R.isGeneratorFunction = function (ar) {
|
||
{
|
||
var as = "function" == typeof ar && ar.constructor;
|
||
return !!as && (as === aa || "GeneratorFunction" === (as.displayName || as.name));
|
||
}
|
||
};
|
||
R.mark = function (ar) {
|
||
{
|
||
Object.setPrototypeOf ? Object.setPrototypeOf(ar, ab) : (ar.__proto__ = ab, a1(ar, a0, "GeneratorFunction"));
|
||
ar.prototype = Object.create(af);
|
||
return ar;
|
||
}
|
||
};
|
||
R.awrap = function (ar) {
|
||
{
|
||
var as = {
|
||
__await: ar
|
||
};
|
||
return as;
|
||
}
|
||
};
|
||
ag(ah.prototype);
|
||
a1(ah.prototype, Z, function () {
|
||
{
|
||
return this;
|
||
}
|
||
});
|
||
R.AsyncIterator = ah;
|
||
R.async = function (ar, as, at, au, av) {
|
||
undefined === av && (av = Promise);
|
||
var aw = new ah(a2(ar, as, at, au), av);
|
||
return R.isGeneratorFunction(as) ? aw : aw.next().then(function (ay) {
|
||
{
|
||
return ay.done ? ay.value : aw.next();
|
||
}
|
||
});
|
||
};
|
||
ag(af);
|
||
a1(af, a0, "Generator");
|
||
a1(af, Y, function () {
|
||
return this;
|
||
});
|
||
a1(af, "toString", function () {
|
||
return "[object Generator]";
|
||
});
|
||
R.keys = function (ar) {
|
||
{
|
||
var at = Object(ar);
|
||
var au = [];
|
||
for (var av in at) au.push(av);
|
||
au.reverse();
|
||
return function ax() {
|
||
{
|
||
for (; au.length;) {
|
||
{
|
||
var az = au.pop();
|
||
if (az in at) {
|
||
ax.value = az;
|
||
ax.done = false;
|
||
return ax;
|
||
}
|
||
}
|
||
}
|
||
ax.done = true;
|
||
return ax;
|
||
}
|
||
};
|
||
}
|
||
};
|
||
R.values = an;
|
||
am.prototype = {
|
||
constructor: am,
|
||
reset: function (ar) {
|
||
{
|
||
if (this.prev = 0, this.next = 0, this.sent = this._sent = Q, this.done = false, this.delegate = null, this.method = "next", this.arg = Q, this.tryEntries.forEach(al), !ar) {
|
||
for (var as in this) "t" === as.charAt(0) && V.call(this, as) && !isNaN(+as.slice(1)) && (this[as] = Q);
|
||
}
|
||
}
|
||
},
|
||
stop: function () {
|
||
{
|
||
this.done = true;
|
||
var at = this.tryEntries[0].completion;
|
||
if ("throw" === at.type) {
|
||
throw at.arg;
|
||
}
|
||
return this.rval;
|
||
}
|
||
},
|
||
dispatchException: function (ar) {
|
||
{
|
||
if (this.done) {
|
||
throw ar;
|
||
}
|
||
var at = this;
|
||
function aA(aB, aC) {
|
||
{
|
||
aw.type = "throw";
|
||
aw.arg = ar;
|
||
at.next = aB;
|
||
aC && (at.method = "next", at.arg = Q);
|
||
return !!aC;
|
||
}
|
||
}
|
||
for (var au = this.tryEntries.length - 1; au >= 0; --au) {
|
||
{
|
||
var av = this.tryEntries[au];
|
||
var aw = av.completion;
|
||
if ("root" === av.tryLoc) {
|
||
return aA("end");
|
||
}
|
||
if (av.tryLoc <= this.prev) {
|
||
{
|
||
var ax = V.call(av, "catchLoc");
|
||
var ay = V.call(av, "finallyLoc");
|
||
if (ax && ay) {
|
||
{
|
||
if (this.prev < av.catchLoc) {
|
||
return aA(av.catchLoc, true);
|
||
}
|
||
if (this.prev < av.finallyLoc) {
|
||
return aA(av.finallyLoc);
|
||
}
|
||
}
|
||
} else {
|
||
if (ax) {
|
||
{
|
||
if (this.prev < av.catchLoc) {
|
||
return aA(av.catchLoc, true);
|
||
}
|
||
}
|
||
} else {
|
||
{
|
||
if (!ay) {
|
||
throw Error("try statement without catch or finally");
|
||
}
|
||
if (this.prev < av.finallyLoc) {
|
||
return aA(av.finallyLoc);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
},
|
||
abrupt: function (ar, as) {
|
||
{
|
||
for (var au = this.tryEntries.length - 1; au >= 0; --au) {
|
||
{
|
||
var av = this.tryEntries[au];
|
||
if (av.tryLoc <= this.prev && V.call(av, "finallyLoc") && this.prev < av.finallyLoc) {
|
||
{
|
||
var aw = av;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
aw && ("break" === ar || "continue" === ar) && aw.tryLoc <= as && as <= aw.finallyLoc && (aw = null);
|
||
var ax = aw ? aw.completion : {};
|
||
ax.type = ar;
|
||
ax.arg = as;
|
||
return aw ? (this.method = "next", this.next = aw.finallyLoc, a8) : this.complete(ax);
|
||
}
|
||
},
|
||
complete: function (ar, as) {
|
||
{
|
||
if ("throw" === ar.type) {
|
||
throw ar.arg;
|
||
}
|
||
"break" === ar.type || "continue" === ar.type ? this.next = ar.arg : "return" === ar.type ? (this.rval = this.arg = ar.arg, this.method = "return", this.next = "end") : "normal" === ar.type && as && (this.next = as);
|
||
return a8;
|
||
}
|
||
},
|
||
finish: function (ar) {
|
||
{
|
||
for (var at = this.tryEntries.length - 1; at >= 0; --at) {
|
||
{
|
||
var au = this.tryEntries[at];
|
||
if (au.finallyLoc === ar) {
|
||
this.complete(au.completion, au.afterLoc);
|
||
al(au);
|
||
return a8;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
},
|
||
catch: function (ar) {
|
||
{
|
||
for (var as = this.tryEntries.length - 1; as >= 0; --as) {
|
||
{
|
||
var at = this.tryEntries[as];
|
||
if (at.tryLoc === ar) {
|
||
{
|
||
var au = at.completion;
|
||
if ("throw" === au.type) {
|
||
{
|
||
var av = au.arg;
|
||
al(at);
|
||
}
|
||
}
|
||
return av;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
throw Error("illegal catch attempt");
|
||
}
|
||
},
|
||
delegateYield: function (ar, as, at) {
|
||
{
|
||
this.delegate = {
|
||
iterator: an(ar),
|
||
resultName: as,
|
||
nextLoc: at
|
||
};
|
||
"next" === this.method && (this.arg = Q);
|
||
return a8;
|
||
}
|
||
}
|
||
};
|
||
return R;
|
||
}
|
||
function z(P, Q, R, S, T, U, V) {
|
||
{
|
||
try {
|
||
{
|
||
var W = P[U](V);
|
||
var X = W.value;
|
||
}
|
||
} catch (a0) {
|
||
return void R(a0);
|
||
}
|
||
W.done ? Q(X) : Promise.resolve(X).then(S, T);
|
||
}
|
||
}
|
||
function A(P) {
|
||
return function () {
|
||
var T = this;
|
||
var U = arguments;
|
||
return new Promise(function (V, W) {
|
||
var Y = P.apply(T, U);
|
||
function Z(a1) {
|
||
z(Y, V, W, Z, a0, "next", a1);
|
||
}
|
||
function a0(a1) {
|
||
z(Y, V, W, Z, a0, "throw", a1);
|
||
}
|
||
Z(undefined);
|
||
});
|
||
};
|
||
}
|
||
var B = ($.isNode() ? JSON.parse(process.env.JingCai) : $.getjson("JingCai")) || [];
|
||
var C = "";
|
||
var D = "";
|
||
var E = "";
|
||
function F() {
|
||
return G.apply(this, arguments);
|
||
}
|
||
function G() {
|
||
G = A(x().mark(function P() {
|
||
var R;
|
||
var U;
|
||
var V;
|
||
var W;
|
||
var X;
|
||
var Y;
|
||
var Z;
|
||
var a0;
|
||
var a1;
|
||
var a2;
|
||
var a3;
|
||
var a4;
|
||
var a5;
|
||
var a6;
|
||
var a7;
|
||
var a8;
|
||
var a9;
|
||
var aa;
|
||
var ab;
|
||
var ac;
|
||
var ad;
|
||
var ae;
|
||
var af;
|
||
var ag;
|
||
var ah;
|
||
var ai;
|
||
var aj;
|
||
var ak;
|
||
var al;
|
||
var am;
|
||
var an;
|
||
return x().wrap(function (ao) {
|
||
for (;;) {
|
||
switch (ao.prev = ao.next) {
|
||
case 0:
|
||
R = q(B);
|
||
ao.prev = 1;
|
||
R.s();
|
||
case 3:
|
||
if ((U = R.n()).done) {
|
||
ao.next = 58;
|
||
break;
|
||
}
|
||
if (V = U.value, ao.prev = 5, C = V.memberId, D = V.token, console.log("用户：".concat(C, "开始任务")), C != B[0].memberId) {
|
||
ao.next = 16;
|
||
break;
|
||
}
|
||
ao.next = 12;
|
||
return J("/consumer/newYear/turntable/share", {
|
||
loginFrom: "wx",
|
||
memberId: "".concat(C),
|
||
token: D,
|
||
loginType: "wx",
|
||
fromType: "",
|
||
flag: "weixin",
|
||
shareByUserId: C,
|
||
shareUserId: "1106289",
|
||
type: 3
|
||
});
|
||
case 12:
|
||
a1 = ao.sent;
|
||
console.log("助力结果：".concat(null == a1 || null === (a0 = a1.data) || undefined === a0 ? undefined : a0.help));
|
||
ao.next = 20;
|
||
break;
|
||
case 16:
|
||
ao.next = 18;
|
||
return J("/consumer/newYear/turntable/share", {
|
||
loginFrom: "wx",
|
||
memberId: "".concat(C),
|
||
token: D,
|
||
loginType: "wx",
|
||
fromType: "",
|
||
flag: "weixin",
|
||
shareByUserId: C,
|
||
shareUserId: "".concat(B[0].memberId),
|
||
type: 3
|
||
});
|
||
case 18:
|
||
a3 = ao.sent;
|
||
console.log("助力结果：".concat(null == a3 || null === (a2 = a3.data) || undefined === a2 ? undefined : a2.help));
|
||
case 20:
|
||
ao.next = 22;
|
||
return J("/consumer/newYear/prize/getLotteryPrizeInfo");
|
||
case 22:
|
||
a4 = ao.sent;
|
||
console.log("剩余抽奖次数：".concat(null === (W = a4) || undefined === W || null === (W = W.data) || undefined === W ? undefined : W.surplusNum));
|
||
a5 = 0;
|
||
case 25:
|
||
if (!(a5 < (null === (a6 = a4) || undefined === a6 || null === (a6 = a6.data) || undefined === a6 ? undefined : a6.surplusNum))) {
|
||
ao.next = 33;
|
||
break;
|
||
}
|
||
ao.next = 28;
|
||
return J("/consumer/newYear/prize/lotteryEntrance");
|
||
case 28:
|
||
a8 = ao.sent;
|
||
null != a8 && null !== (a7 = a8.data) && undefined !== a7 && a7.prizeAmount ? 1 == (null == a8 || null === (a9 = a8.data) || undefined === a9 ? undefined : a9.amountType) ? (console.log("抽奖获得微信红包：".concat(null == a8 || null === (ab = a8.data) || undefined === ab ? undefined : ab.prizeName, " ").concat(null == a8 || null === (ac = a8.data) || undefined === ac ? undefined : ac.prizeAmount, "元")), E += "用户".concat(C, " 抽奖获得微信红包：").concat(null == a8 || null === (ad = a8.data) || undefined === ad ? undefined : ad.prizeName, " ").concat(null == a8 || null === (ae = a8.data) || undefined === ae ? undefined : ae.prizeAmount, "元\n")) : 2 == (null == a8 || null === (aa = a8.data) || undefined === aa ? undefined : aa.amountType) ? (console.log("抽奖获得余额：".concat(null == a8 || null === (af = a8.data) || undefined === af ? undefined : af.prizeName, " ").concat(null == a8 || null === (ag = a8.data) || undefined === ag ? undefined : ag.prizeAmount, "元")), E += "用户".concat(C, " 抽奖获得余额：").concat(null == a8 || null === (ah = a8.data) || undefined === ah ? undefined : ah.prizeName, " ").concat(null == a8 || null === (ai = a8.data) || undefined === ai ? undefined : ai.prizeAmount, "元\n")) : console.log(null == a8 || null === (aj = a8.data) || undefined === aj ? undefined : aj.prizeName) : console.log(JSON.stringify(a8));
|
||
case 30:
|
||
a5++;
|
||
ao.next = 25;
|
||
break;
|
||
case 33:
|
||
ao.next = 35;
|
||
return J("/consumer/newYear/prize/getLotteryPrizeInfo");
|
||
case 35:
|
||
if (a4 = ao.sent, !((null === (X = a4) || undefined === X || null === (X = X.data) || undefined === X ? undefined : X.amount) >= 0.5)) {
|
||
ao.next = 49;
|
||
break;
|
||
}
|
||
ao.next = 39;
|
||
return J("/consumer/newYear/turntable/accountWithdraw", {
|
||
loginFrom: "wx",
|
||
flag: "weixin",
|
||
fromType: "",
|
||
memberId: "".concat(C),
|
||
token: D,
|
||
cashOutMoney: Math.round(100 * (null === (ak = a4) || undefined === ak || null === (ak = ak.data) || undefined === ak ? undefined : ak.amount)),
|
||
loginType: "wx"
|
||
});
|
||
case 39:
|
||
if (al = ao.sent, null != al && al.msg) {
|
||
ao.next = 44;
|
||
break;
|
||
}
|
||
console.log("请完成实名认证");
|
||
ao.next = 49;
|
||
break;
|
||
case 44:
|
||
console.log("提现：".concat(null === (am = a4) || undefined === am || null === (am = am.data) || undefined === am ? undefined : am.amount, "元 提现结果：").concat(null == al ? undefined : al.msg));
|
||
E += "用户".concat(C, " 提现：").concat(null === (an = a4) || undefined === an || null === (an = an.data) || undefined === an ? undefined : an.amount, "元 提现结果：").concat(null == al ? undefined : al.msg, "\n");
|
||
ao.next = 48;
|
||
return J("/consumer/newYear/prize/getLotteryPrizeInfo");
|
||
case 48:
|
||
a4 = ao.sent;
|
||
case 49:
|
||
console.log("钱包余额：".concat(null === (Y = a4) || undefined === Y || null === (Y = Y.data) || undefined === Y ? undefined : Y.amount));
|
||
E += "用户".concat(C, " 钱包余额：").concat(null === (Z = a4) || undefined === Z || null === (Z = Z.data) || undefined === Z ? undefined : Z.amount, "元\n");
|
||
ao.next = 56;
|
||
break;
|
||
case 53:
|
||
ao.prev = 53;
|
||
ao.t0 = ao.catch(5);
|
||
console.log(ao.t0);
|
||
case 56:
|
||
ao.next = 3;
|
||
break;
|
||
case 58:
|
||
ao.next = 63;
|
||
break;
|
||
case 60:
|
||
ao.prev = 60;
|
||
ao.t1 = ao.catch(1);
|
||
R.e(ao.t1);
|
||
case 63:
|
||
ao.prev = 63;
|
||
R.f();
|
||
return ao.finish(63);
|
||
case 66:
|
||
if (!E) {
|
||
ao.next = 69;
|
||
break;
|
||
}
|
||
ao.next = 69;
|
||
return N(E);
|
||
case 69:
|
||
case "end":
|
||
return ao.stop();
|
||
}
|
||
}
|
||
}, P, null, [[1, 60, 63, 66], [5, 53]]);
|
||
}));
|
||
return G.apply(this, arguments);
|
||
}
|
||
function H() {
|
||
return I.apply(this, arguments);
|
||
}
|
||
function I() {
|
||
I = A(x().mark(function P() {
|
||
var S;
|
||
var T;
|
||
var U;
|
||
var V;
|
||
var W;
|
||
var X;
|
||
return x().wrap(function (Y) {
|
||
for (;;) {
|
||
switch (Y.prev = Y.next) {
|
||
case 0:
|
||
if (S = $request.headers.Authorization || $request.headers.authorization, T = S.split(" ")[1], U = $.toObj($request.body), T && U) {
|
||
Y.next = 5;
|
||
break;
|
||
}
|
||
return Y.abrupt("return");
|
||
case 5:
|
||
if (V = U.memberId, W = {
|
||
memberId: V,
|
||
token: T
|
||
}, X = B.findIndex(function (a1) {
|
||
return a1.memberId == W.memberId;
|
||
}), -1 === X) {
|
||
Y.next = 18;
|
||
break;
|
||
}
|
||
if (B[X].token != W.token) {
|
||
Y.next = 13;
|
||
break;
|
||
}
|
||
return Y.abrupt("return");
|
||
case 13:
|
||
B[X].token = T;
|
||
console.log(W.token);
|
||
$.msg($.name, "🎉用户".concat(W.memberId, "更新token成功!"), "");
|
||
case 16:
|
||
Y.next = 21;
|
||
break;
|
||
case 18:
|
||
B.push(W);
|
||
console.log(W.token);
|
||
$.msg($.name, "🎉新增用户".concat(W.memberId, "成功!"), "");
|
||
case 21:
|
||
$.setjson(B, "JingCai");
|
||
case 22:
|
||
case "end":
|
||
return Y.stop();
|
||
}
|
||
}
|
||
}, P);
|
||
}));
|
||
return I.apply(this, arguments);
|
||
}
|
||
function J(P) {
|
||
return K.apply(this, arguments);
|
||
}
|
||
function K() {
|
||
K = A(x().mark(function Q(R) {
|
||
var T;
|
||
var U = arguments;
|
||
return x().wrap(function (V) {
|
||
for (;;) {
|
||
switch (V.prev = V.next) {
|
||
case 0:
|
||
T = U.length > 1 && undefined !== U[1] ? U[1] : {
|
||
memberId: "".concat(C),
|
||
flag: "weixin",
|
||
loginFrom: "wx",
|
||
loginType: "wx",
|
||
token: D,
|
||
fromType: ""
|
||
};
|
||
return V.abrupt("return", new Promise(function (W) {
|
||
var Y = {
|
||
url: "https://erp.5jingcai.com".concat(R),
|
||
headers: {
|
||
"content-type": "application/json",
|
||
Authorization: "Bearer " + D,
|
||
"user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36 MicroMessenger/6.8.0(0x16080000) NetType/WIFI MiniProgramEnv/Mac MacWechat/WMPF MacWechat/3.8.9(0x13080911) XWEB/1227",
|
||
accept: "*/*",
|
||
"Sec-Fetch-Site": "cross-site",
|
||
"Sec-Fetch-Mode": "cors",
|
||
"Sec-Fetch-Dest": "empty",
|
||
Referer: "https://servicewechat.com/wxd79ec05386a78727/85/page-frame.html",
|
||
"Accept-Encoding": "gzip, deflate, br",
|
||
"Accept-Language": "zh-CN,zh;q=0.9"
|
||
},
|
||
body: JSON.stringify(T)
|
||
};
|
||
$.post(Y, function () {
|
||
var a0 = A(x().mark(function a1(a2, a3, a4) {
|
||
return x().wrap(function (a5) {
|
||
for (;;) {
|
||
switch (a5.prev = a5.next) {
|
||
case 0:
|
||
if (a5.prev = 0, !a2) {
|
||
a5.next = 6;
|
||
break;
|
||
}
|
||
console.log("".concat(JSON.stringify(a2)));
|
||
console.log("".concat($.name, " API请求失败，请检查网路重试"));
|
||
a5.next = 9;
|
||
break;
|
||
case 6:
|
||
a5.next = 8;
|
||
return $.wait(2000);
|
||
case 8:
|
||
W(JSON.parse(a4));
|
||
case 9:
|
||
a5.next = 14;
|
||
break;
|
||
case 11:
|
||
a5.prev = 11;
|
||
a5.t0 = a5.catch(0);
|
||
$.logErr(a5.t0, a3);
|
||
case 14:
|
||
a5.prev = 14;
|
||
W();
|
||
return a5.finish(14);
|
||
case 17:
|
||
case "end":
|
||
return a5.stop();
|
||
}
|
||
}
|
||
}, a1, null, [[0, 11, 14, 17]]);
|
||
}));
|
||
return function (a2, a3, a4) {
|
||
return a0.apply(this, arguments);
|
||
};
|
||
}());
|
||
}));
|
||
case 2:
|
||
case "end":
|
||
return V.stop();
|
||
}
|
||
}
|
||
}, Q);
|
||
}));
|
||
return K.apply(this, arguments);
|
||
}
|
||
function L() {
|
||
return M.apply(this, arguments);
|
||
}
|
||
function M() {
|
||
M = A(x().mark(function P() {
|
||
return x().wrap(function (S) {
|
||
for (;;) {
|
||
switch (S.prev = S.next) {
|
||
case 0:
|
||
return S.abrupt("return", new Promise(function (U) {
|
||
var W = {
|
||
url: "https://fastly.jsdelivr.net/gh/xzxxn777/Surge@main/Utils/Notice.json"
|
||
};
|
||
$.get(W, function () {
|
||
var Y = A(x().mark(function Z(a0, a1, a2) {
|
||
return x().wrap(function (a4) {
|
||
for (;;) {
|
||
switch (a4.prev = a4.next) {
|
||
case 0:
|
||
try {
|
||
a0 ? (console.log("".concat(JSON.stringify(a0))), console.log("".concat($.name, " API请求失败，请检查网路重试"))) : console.log(JSON.parse(a2).notice);
|
||
} catch (a5) {
|
||
$.logErr(a5, a1);
|
||
} finally {
|
||
U();
|
||
}
|
||
case 1:
|
||
case "end":
|
||
return a4.stop();
|
||
}
|
||
}
|
||
}, Z);
|
||
}));
|
||
return function (a0, a1, a2) {
|
||
return Y.apply(this, arguments);
|
||
};
|
||
}());
|
||
}));
|
||
case 1:
|
||
case "end":
|
||
return S.stop();
|
||
}
|
||
}
|
||
}, P);
|
||
}));
|
||
return M.apply(this, arguments);
|
||
}
|
||
function N(P) {
|
||
return O.apply(this, arguments);
|
||
}
|
||
function O() {
|
||
O = A(x().mark(function P(Q) {
|
||
return x().wrap(function (T) {
|
||
for (;;) {
|
||
switch (T.prev = T.next) {
|
||
case 0:
|
||
if (!$.isNode()) {
|
||
T.next = 5;
|
||
break;
|
||
}
|
||
T.next = 3;
|
||
return notify.sendNotify($.name, Q);
|
||
case 3:
|
||
T.next = 6;
|
||
break;
|
||
case 5:
|
||
$.msg($.name, "", Q);
|
||
case 6:
|
||
case "end":
|
||
return T.stop();
|
||
}
|
||
}
|
||
}, P);
|
||
}));
|
||
return O.apply(this, arguments);
|
||
}
|
||
A(x().mark(function P() {
|
||
return x().wrap(function (R) {
|
||
for (;;) {
|
||
switch (R.prev = R.next) {
|
||
case 0:
|
||
if ("undefined" == typeof $request || "OPTIONS" == $request.method) {
|
||
R.next = 5;
|
||
break;
|
||
}
|
||
R.next = 3;
|
||
return H();
|
||
case 3:
|
||
R.next = 9;
|
||
break;
|
||
case 5:
|
||
R.next = 7;
|
||
return L();
|
||
case 7:
|
||
R.next = 9;
|
||
return F();
|
||
case 9:
|
||
case "end":
|
||
return R.stop();
|
||
}
|
||
}
|
||
}, P);
|
||
}))().catch(function (Q) {
|
||
$.log(Q);
|
||
}).finally(function () {
|
||
$.done({});
|
||
});
|
||
})(); |