859 lines
18 KiB
JavaScript
859 lines
18 KiB
JavaScript
var t =
|
|
"undefined" != typeof globalThis
|
|
? globalThis
|
|
: "undefined" != typeof window
|
|
? window
|
|
: "undefined" != typeof global
|
|
? global
|
|
: "undefined" != typeof self
|
|
? self
|
|
: {},
|
|
n = function (t) {
|
|
return t && t.Math === Math && t;
|
|
},
|
|
r =
|
|
n("object" == typeof globalThis && globalThis) ||
|
|
n("object" == typeof window && window) ||
|
|
n("object" == typeof self && self) ||
|
|
n("object" == typeof t && t) ||
|
|
(function () {
|
|
return this;
|
|
})() ||
|
|
t ||
|
|
Function("return this")(),
|
|
e = {},
|
|
o = function (t) {
|
|
try {
|
|
return !!t();
|
|
} catch (n) {
|
|
return !0;
|
|
}
|
|
},
|
|
i = !o(function () {
|
|
return (
|
|
7 !==
|
|
Object.defineProperty({}, 1, {
|
|
get: function () {
|
|
return 7;
|
|
},
|
|
})[1]
|
|
);
|
|
}),
|
|
u = !o(function () {
|
|
var t = function () {}.bind();
|
|
return "function" != typeof t || t.hasOwnProperty("prototype");
|
|
}),
|
|
c = u,
|
|
f = Function.prototype.call,
|
|
a = c
|
|
? f.bind(f)
|
|
: function () {
|
|
return f.apply(f, arguments);
|
|
},
|
|
l = {},
|
|
s = {}.propertyIsEnumerable,
|
|
p = Object.getOwnPropertyDescriptor,
|
|
y = p && !s.call({ 1: 2 }, 1);
|
|
l.f = y
|
|
? function (t) {
|
|
var n = p(this, t);
|
|
return !!n && n.enumerable;
|
|
}
|
|
: s;
|
|
var v,
|
|
b,
|
|
h = function (t, n) {
|
|
return {
|
|
enumerable: !(1 & t),
|
|
configurable: !(2 & t),
|
|
writable: !(4 & t),
|
|
value: n,
|
|
};
|
|
},
|
|
g = u,
|
|
m = Function.prototype,
|
|
d = m.call,
|
|
S = g && m.bind.bind(d, d),
|
|
w = g
|
|
? S
|
|
: function (t) {
|
|
return function () {
|
|
return d.apply(t, arguments);
|
|
};
|
|
},
|
|
O = w,
|
|
j = O({}.toString),
|
|
P = O("".slice),
|
|
E = function (t) {
|
|
return P(j(t), 8, -1);
|
|
},
|
|
T = o,
|
|
M = E,
|
|
F = Object,
|
|
I = w("".split),
|
|
A = T(function () {
|
|
return !F("z").propertyIsEnumerable(0);
|
|
})
|
|
? function (t) {
|
|
return "String" === M(t) ? I(t, "") : F(t);
|
|
}
|
|
: F,
|
|
D = function (t) {
|
|
return null == t;
|
|
},
|
|
x = D,
|
|
L = TypeError,
|
|
C = function (t) {
|
|
if (x(t)) throw L("Can't call method on " + t);
|
|
return t;
|
|
},
|
|
_ = A,
|
|
k = C,
|
|
z = function (t) {
|
|
return _(k(t));
|
|
},
|
|
N = "object" == typeof document && document.all,
|
|
R = { all: N, IS_HTMLDDA: void 0 === N && void 0 !== N },
|
|
G = R.all,
|
|
B = R.IS_HTMLDDA
|
|
? function (t) {
|
|
return "function" == typeof t || t === G;
|
|
}
|
|
: function (t) {
|
|
return "function" == typeof t;
|
|
},
|
|
H = B,
|
|
U = R.all,
|
|
W = R.IS_HTMLDDA
|
|
? function (t) {
|
|
return "object" == typeof t ? null !== t : H(t) || t === U;
|
|
}
|
|
: function (t) {
|
|
return "object" == typeof t ? null !== t : H(t);
|
|
},
|
|
q = r,
|
|
K = B,
|
|
V = function (t, n) {
|
|
return arguments.length < 2
|
|
? ((r = q[t]), K(r) ? r : void 0)
|
|
: q[t] && q[t][n];
|
|
var r;
|
|
},
|
|
X = w({}.isPrototypeOf),
|
|
Y = r,
|
|
$ = ("undefined" != typeof navigator && String(navigator.userAgent)) || "",
|
|
J = Y.process,
|
|
Q = Y.Deno,
|
|
Z = (J && J.versions) || (Q && Q.version),
|
|
tt = Z && Z.v8;
|
|
tt && (b = (v = tt.split("."))[0] > 0 && v[0] < 4 ? 1 : +(v[0] + v[1])),
|
|
!b &&
|
|
$ &&
|
|
(!(v = $.match(/Edge\/(\d+)/)) || v[1] >= 74) &&
|
|
(v = $.match(/Chrome\/(\d+)/)) &&
|
|
(b = +v[1]);
|
|
var nt = b,
|
|
rt = o,
|
|
et = r.String,
|
|
ot =
|
|
!!Object.getOwnPropertySymbols &&
|
|
!rt(function () {
|
|
var t = Symbol("symbol detection");
|
|
return (
|
|
!et(t) ||
|
|
!(Object(t) instanceof Symbol) ||
|
|
(!Symbol.sham && nt && nt < 41)
|
|
);
|
|
}),
|
|
it = ot && !Symbol.sham && "symbol" == typeof Symbol.iterator,
|
|
ut = V,
|
|
ct = B,
|
|
ft = X,
|
|
at = Object,
|
|
lt = it
|
|
? function (t) {
|
|
return "symbol" == typeof t;
|
|
}
|
|
: function (t) {
|
|
var n = ut("Symbol");
|
|
return ct(n) && ft(n.prototype, at(t));
|
|
},
|
|
st = String,
|
|
pt = function (t) {
|
|
try {
|
|
return st(t);
|
|
} catch (n) {
|
|
return "Object";
|
|
}
|
|
},
|
|
yt = B,
|
|
vt = pt,
|
|
bt = TypeError,
|
|
ht = function (t) {
|
|
if (yt(t)) return t;
|
|
throw bt(vt(t) + " is not a function");
|
|
},
|
|
gt = ht,
|
|
mt = D,
|
|
dt = a,
|
|
St = B,
|
|
wt = W,
|
|
Ot = TypeError,
|
|
jt = { exports: {} },
|
|
Pt = r,
|
|
Et = Object.defineProperty,
|
|
Tt = function (t, n) {
|
|
try {
|
|
Et(Pt, t, { value: n, configurable: !0, writable: !0 });
|
|
} catch (r) {
|
|
Pt[t] = n;
|
|
}
|
|
return n;
|
|
},
|
|
Mt = Tt,
|
|
Ft = "__core-js_shared__",
|
|
It = r[Ft] || Mt(Ft, {}),
|
|
At = It;
|
|
(jt.exports = function (t, n) {
|
|
return At[t] || (At[t] = void 0 !== n ? n : {});
|
|
})("versions", []).push({
|
|
version: "3.32.2",
|
|
mode: "global",
|
|
copyright: "© 2014-2023 Denis Pushkarev (zloirock.ru)",
|
|
license: "https://github.com/zloirock/core-js/blob/v3.32.2/LICENSE",
|
|
source: "https://github.com/zloirock/core-js",
|
|
});
|
|
var Dt = jt.exports,
|
|
xt = C,
|
|
Lt = Object,
|
|
Ct = function (t) {
|
|
return Lt(xt(t));
|
|
},
|
|
_t = w({}.hasOwnProperty),
|
|
kt =
|
|
Object.hasOwn ||
|
|
function (t, n) {
|
|
return _t(Ct(t), n);
|
|
},
|
|
zt = w,
|
|
Nt = 0,
|
|
Rt = Math.random(),
|
|
Gt = zt((1).toString),
|
|
Bt = function (t) {
|
|
return "Symbol(" + (void 0 === t ? "" : t) + ")_" + Gt(++Nt + Rt, 36);
|
|
},
|
|
Ht = Dt,
|
|
Ut = kt,
|
|
Wt = Bt,
|
|
qt = ot,
|
|
Kt = it,
|
|
Vt = r.Symbol,
|
|
Xt = Ht("wks"),
|
|
Yt = Kt ? Vt.for || Vt : (Vt && Vt.withoutSetter) || Wt,
|
|
$t = function (t) {
|
|
return (
|
|
Ut(Xt, t) || (Xt[t] = qt && Ut(Vt, t) ? Vt[t] : Yt("Symbol." + t)), Xt[t]
|
|
);
|
|
},
|
|
Jt = a,
|
|
Qt = W,
|
|
Zt = lt,
|
|
tn = function (t, n) {
|
|
var r = t[n];
|
|
return mt(r) ? void 0 : gt(r);
|
|
},
|
|
nn = function (t, n) {
|
|
var r, e;
|
|
if ("string" === n && St((r = t.toString)) && !wt((e = dt(r, t)))) return e;
|
|
if (St((r = t.valueOf)) && !wt((e = dt(r, t)))) return e;
|
|
if ("string" !== n && St((r = t.toString)) && !wt((e = dt(r, t)))) return e;
|
|
throw Ot("Can't convert object to primitive value");
|
|
},
|
|
rn = TypeError,
|
|
en = $t("toPrimitive"),
|
|
on = function (t, n) {
|
|
if (!Qt(t) || Zt(t)) return t;
|
|
var r,
|
|
e = tn(t, en);
|
|
if (e) {
|
|
if ((void 0 === n && (n = "default"), (r = Jt(e, t, n)), !Qt(r) || Zt(r)))
|
|
return r;
|
|
throw rn("Can't convert object to primitive value");
|
|
}
|
|
return void 0 === n && (n = "number"), nn(t, n);
|
|
},
|
|
un = lt,
|
|
cn = function (t) {
|
|
var n = on(t, "string");
|
|
return un(n) ? n : n + "";
|
|
},
|
|
fn = W,
|
|
an = r.document,
|
|
ln = fn(an) && fn(an.createElement),
|
|
sn = function (t) {
|
|
return ln ? an.createElement(t) : {};
|
|
},
|
|
pn =
|
|
!i &&
|
|
!o(function () {
|
|
return (
|
|
7 !==
|
|
Object.defineProperty(sn("div"), "a", {
|
|
get: function () {
|
|
return 7;
|
|
},
|
|
}).a
|
|
);
|
|
}),
|
|
yn = i,
|
|
vn = a,
|
|
bn = l,
|
|
hn = h,
|
|
gn = z,
|
|
mn = cn,
|
|
dn = kt,
|
|
Sn = pn,
|
|
wn = Object.getOwnPropertyDescriptor;
|
|
e.f = yn
|
|
? wn
|
|
: function (t, n) {
|
|
if (((t = gn(t)), (n = mn(n)), Sn))
|
|
try {
|
|
return wn(t, n);
|
|
} catch (r) {}
|
|
if (dn(t, n)) return hn(!vn(bn.f, t, n), t[n]);
|
|
};
|
|
var On = {},
|
|
jn =
|
|
i &&
|
|
o(function () {
|
|
return (
|
|
42 !==
|
|
Object.defineProperty(function () {}, "prototype", {
|
|
value: 42,
|
|
writable: !1,
|
|
}).prototype
|
|
);
|
|
}),
|
|
Pn = W,
|
|
En = String,
|
|
Tn = TypeError,
|
|
Mn = function (t) {
|
|
if (Pn(t)) return t;
|
|
throw Tn(En(t) + " is not an object");
|
|
},
|
|
Fn = i,
|
|
In = pn,
|
|
An = jn,
|
|
Dn = Mn,
|
|
xn = cn,
|
|
Ln = TypeError,
|
|
Cn = Object.defineProperty,
|
|
_n = Object.getOwnPropertyDescriptor,
|
|
kn = "enumerable",
|
|
zn = "configurable",
|
|
Nn = "writable";
|
|
On.f = Fn
|
|
? An
|
|
? function (t, n, r) {
|
|
if (
|
|
(Dn(t),
|
|
(n = xn(n)),
|
|
Dn(r),
|
|
"function" == typeof t &&
|
|
"prototype" === n &&
|
|
"value" in r &&
|
|
Nn in r &&
|
|
!r[Nn])
|
|
) {
|
|
var e = _n(t, n);
|
|
e &&
|
|
e[Nn] &&
|
|
((t[n] = r.value),
|
|
(r = {
|
|
configurable: zn in r ? r[zn] : e[zn],
|
|
enumerable: kn in r ? r[kn] : e[kn],
|
|
writable: !1,
|
|
}));
|
|
}
|
|
return Cn(t, n, r);
|
|
}
|
|
: Cn
|
|
: function (t, n, r) {
|
|
if ((Dn(t), (n = xn(n)), Dn(r), In))
|
|
try {
|
|
return Cn(t, n, r);
|
|
} catch (e) {}
|
|
if ("get" in r || "set" in r) throw Ln("Accessors not supported");
|
|
return "value" in r && (t[n] = r.value), t;
|
|
};
|
|
var Rn = On,
|
|
Gn = h,
|
|
Bn = i
|
|
? function (t, n, r) {
|
|
return Rn.f(t, n, Gn(1, r));
|
|
}
|
|
: function (t, n, r) {
|
|
return (t[n] = r), t;
|
|
},
|
|
Hn = { exports: {} },
|
|
Un = i,
|
|
Wn = kt,
|
|
qn = Function.prototype,
|
|
Kn = Un && Object.getOwnPropertyDescriptor,
|
|
Vn = Wn(qn, "name"),
|
|
Xn = {
|
|
EXISTS: Vn,
|
|
PROPER: Vn && "something" === function () {}.name,
|
|
CONFIGURABLE: Vn && (!Un || (Un && Kn(qn, "name").configurable)),
|
|
},
|
|
Yn = B,
|
|
$n = It,
|
|
Jn = w(Function.toString);
|
|
Yn($n.inspectSource) ||
|
|
($n.inspectSource = function (t) {
|
|
return Jn(t);
|
|
});
|
|
var Qn,
|
|
Zn,
|
|
tr,
|
|
nr = $n.inspectSource,
|
|
rr = B,
|
|
er = r.WeakMap,
|
|
or = rr(er) && /native code/.test(String(er)),
|
|
ir = Bt,
|
|
ur = Dt("keys"),
|
|
cr = {},
|
|
fr = or,
|
|
ar = r,
|
|
lr = W,
|
|
sr = Bn,
|
|
pr = kt,
|
|
yr = It,
|
|
vr = function (t) {
|
|
return ur[t] || (ur[t] = ir(t));
|
|
},
|
|
br = cr,
|
|
hr = "Object already initialized",
|
|
gr = ar.TypeError,
|
|
mr = ar.WeakMap;
|
|
if (fr || yr.state) {
|
|
var dr = yr.state || (yr.state = new mr());
|
|
(dr.get = dr.get),
|
|
(dr.has = dr.has),
|
|
(dr.set = dr.set),
|
|
(Qn = function (t, n) {
|
|
if (dr.has(t)) throw gr(hr);
|
|
return (n.facade = t), dr.set(t, n), n;
|
|
}),
|
|
(Zn = function (t) {
|
|
return dr.get(t) || {};
|
|
}),
|
|
(tr = function (t) {
|
|
return dr.has(t);
|
|
});
|
|
} else {
|
|
var Sr = vr("state");
|
|
(br[Sr] = !0),
|
|
(Qn = function (t, n) {
|
|
if (pr(t, Sr)) throw gr(hr);
|
|
return (n.facade = t), sr(t, Sr, n), n;
|
|
}),
|
|
(Zn = function (t) {
|
|
return pr(t, Sr) ? t[Sr] : {};
|
|
}),
|
|
(tr = function (t) {
|
|
return pr(t, Sr);
|
|
});
|
|
}
|
|
var wr = {
|
|
set: Qn,
|
|
get: Zn,
|
|
has: tr,
|
|
enforce: function (t) {
|
|
return tr(t) ? Zn(t) : Qn(t, {});
|
|
},
|
|
getterFor: function (t) {
|
|
return function (n) {
|
|
var r;
|
|
if (!lr(n) || (r = Zn(n)).type !== t)
|
|
throw gr("Incompatible receiver, " + t + " required");
|
|
return r;
|
|
};
|
|
},
|
|
},
|
|
Or = w,
|
|
jr = o,
|
|
Pr = B,
|
|
Er = kt,
|
|
Tr = i,
|
|
Mr = Xn.CONFIGURABLE,
|
|
Fr = nr,
|
|
Ir = wr.enforce,
|
|
Ar = wr.get,
|
|
Dr = String,
|
|
xr = Object.defineProperty,
|
|
Lr = Or("".slice),
|
|
Cr = Or("".replace),
|
|
_r = Or([].join),
|
|
kr =
|
|
Tr &&
|
|
!jr(function () {
|
|
return 8 !== xr(function () {}, "length", { value: 8 }).length;
|
|
}),
|
|
zr = String(String).split("String"),
|
|
Nr = (Hn.exports = function (t, n, r) {
|
|
"Symbol(" === Lr(Dr(n), 0, 7) &&
|
|
(n = "[" + Cr(Dr(n), /^Symbol\(([^)]*)\)/, "$1") + "]"),
|
|
r && r.getter && (n = "get " + n),
|
|
r && r.setter && (n = "set " + n),
|
|
(!Er(t, "name") || (Mr && t.name !== n)) &&
|
|
(Tr ? xr(t, "name", { value: n, configurable: !0 }) : (t.name = n)),
|
|
kr &&
|
|
r &&
|
|
Er(r, "arity") &&
|
|
t.length !== r.arity &&
|
|
xr(t, "length", { value: r.arity });
|
|
try {
|
|
r && Er(r, "constructor") && r.constructor
|
|
? Tr && xr(t, "prototype", { writable: !1 })
|
|
: t.prototype && (t.prototype = void 0);
|
|
} catch (o) {}
|
|
var e = Ir(t);
|
|
return (
|
|
Er(e, "source") || (e.source = _r(zr, "string" == typeof n ? n : "")), t
|
|
);
|
|
});
|
|
Function.prototype.toString = Nr(function () {
|
|
return (Pr(this) && Ar(this).source) || Fr(this);
|
|
}, "toString");
|
|
var Rr = Hn.exports,
|
|
Gr = B,
|
|
Br = On,
|
|
Hr = Rr,
|
|
Ur = Tt,
|
|
Wr = function (t, n, r, e) {
|
|
e || (e = {});
|
|
var o = e.enumerable,
|
|
i = void 0 !== e.name ? e.name : n;
|
|
if ((Gr(r) && Hr(r, i, e), e.global)) o ? (t[n] = r) : Ur(n, r);
|
|
else {
|
|
try {
|
|
e.unsafe ? t[n] && (o = !0) : delete t[n];
|
|
} catch (u) {}
|
|
o
|
|
? (t[n] = r)
|
|
: Br.f(t, n, {
|
|
value: r,
|
|
enumerable: !1,
|
|
configurable: !e.nonConfigurable,
|
|
writable: !e.nonWritable,
|
|
});
|
|
}
|
|
return t;
|
|
},
|
|
qr = {},
|
|
Kr = Math.ceil,
|
|
Vr = Math.floor,
|
|
Xr =
|
|
Math.trunc ||
|
|
function (t) {
|
|
var n = +t;
|
|
return (n > 0 ? Vr : Kr)(n);
|
|
},
|
|
Yr = function (t) {
|
|
var n = +t;
|
|
return n != n || 0 === n ? 0 : Xr(n);
|
|
},
|
|
$r = Yr,
|
|
Jr = Math.max,
|
|
Qr = Math.min,
|
|
Zr = Yr,
|
|
te = Math.min,
|
|
ne = function (t) {
|
|
return t > 0 ? te(Zr(t), 9007199254740991) : 0;
|
|
},
|
|
re = z,
|
|
ee = function (t, n) {
|
|
var r = $r(t);
|
|
return r < 0 ? Jr(r + n, 0) : Qr(r, n);
|
|
},
|
|
oe = function (t) {
|
|
return ne(t.length);
|
|
},
|
|
ie = function (t) {
|
|
return function (n, r, e) {
|
|
var o,
|
|
i = re(n),
|
|
u = oe(i),
|
|
c = ee(e, u);
|
|
if (t && r != r) {
|
|
for (; u > c; ) if ((o = i[c++]) != o) return !0;
|
|
} else
|
|
for (; u > c; c++) if ((t || c in i) && i[c] === r) return t || c || 0;
|
|
return !t && -1;
|
|
};
|
|
},
|
|
ue = { includes: ie(!0), indexOf: ie(!1) },
|
|
ce = kt,
|
|
fe = z,
|
|
ae = ue.indexOf,
|
|
le = cr,
|
|
se = w([].push),
|
|
pe = function (t, n) {
|
|
var r,
|
|
e = fe(t),
|
|
o = 0,
|
|
i = [];
|
|
for (r in e) !ce(le, r) && ce(e, r) && se(i, r);
|
|
for (; n.length > o; ) ce(e, (r = n[o++])) && (~ae(i, r) || se(i, r));
|
|
return i;
|
|
},
|
|
ye = [
|
|
"constructor",
|
|
"hasOwnProperty",
|
|
"isPrototypeOf",
|
|
"propertyIsEnumerable",
|
|
"toLocaleString",
|
|
"toString",
|
|
"valueOf",
|
|
].concat("length", "prototype");
|
|
qr.f =
|
|
Object.getOwnPropertyNames ||
|
|
function (t) {
|
|
return pe(t, ye);
|
|
};
|
|
var ve = {};
|
|
ve.f = Object.getOwnPropertySymbols;
|
|
var be = V,
|
|
he = qr,
|
|
ge = ve,
|
|
me = Mn,
|
|
de = w([].concat),
|
|
Se =
|
|
be("Reflect", "ownKeys") ||
|
|
function (t) {
|
|
var n = he.f(me(t)),
|
|
r = ge.f;
|
|
return r ? de(n, r(t)) : n;
|
|
},
|
|
we = kt,
|
|
Oe = Se,
|
|
je = e,
|
|
Pe = On,
|
|
Ee = o,
|
|
Te = B,
|
|
Me = /#|\.prototype\./,
|
|
Fe = function (t, n) {
|
|
var r = Ae[Ie(t)];
|
|
return r === xe || (r !== De && (Te(n) ? Ee(n) : !!n));
|
|
},
|
|
Ie = (Fe.normalize = function (t) {
|
|
return String(t).replace(Me, ".").toLowerCase();
|
|
}),
|
|
Ae = (Fe.data = {}),
|
|
De = (Fe.NATIVE = "N"),
|
|
xe = (Fe.POLYFILL = "P"),
|
|
Le = Fe,
|
|
Ce = r,
|
|
_e = e.f,
|
|
ke = Bn,
|
|
ze = Wr,
|
|
Ne = Tt,
|
|
Re = function (t, n, r) {
|
|
for (var e = Oe(n), o = Pe.f, i = je.f, u = 0; u < e.length; u++) {
|
|
var c = e[u];
|
|
we(t, c) || (r && we(r, c)) || o(t, c, i(n, c));
|
|
}
|
|
},
|
|
Ge = Le,
|
|
Be = r.Promise,
|
|
He = {};
|
|
He[$t("toStringTag")] = "z";
|
|
var Ue = "[object z]" === String(He),
|
|
We = B,
|
|
qe = E,
|
|
Ke = $t("toStringTag"),
|
|
Ve = Object,
|
|
Xe =
|
|
"Arguments" ===
|
|
qe(
|
|
(function () {
|
|
return arguments;
|
|
})()
|
|
),
|
|
Ye = w,
|
|
$e = o,
|
|
Je = B,
|
|
Qe = Ue
|
|
? qe
|
|
: function (t) {
|
|
var n, r, e;
|
|
return void 0 === t
|
|
? "Undefined"
|
|
: null === t
|
|
? "Null"
|
|
: "string" ==
|
|
typeof (r = (function (t, n) {
|
|
try {
|
|
return t[n];
|
|
} catch (r) {}
|
|
})((n = Ve(t)), Ke))
|
|
? r
|
|
: Xe
|
|
? qe(n)
|
|
: "Object" === (e = qe(n)) && We(n.callee)
|
|
? "Arguments"
|
|
: e;
|
|
},
|
|
Ze = nr,
|
|
to = function () {},
|
|
no = [],
|
|
ro = V("Reflect", "construct"),
|
|
eo = /^\s*(?:class|function)\b/,
|
|
oo = Ye(eo.exec),
|
|
io = !eo.exec(to),
|
|
uo = function (t) {
|
|
if (!Je(t)) return !1;
|
|
try {
|
|
return ro(to, no, t), !0;
|
|
} catch (n) {
|
|
return !1;
|
|
}
|
|
},
|
|
co = function (t) {
|
|
if (!Je(t)) return !1;
|
|
switch (Qe(t)) {
|
|
case "AsyncFunction":
|
|
case "GeneratorFunction":
|
|
case "AsyncGeneratorFunction":
|
|
return !1;
|
|
}
|
|
try {
|
|
return io || !!oo(eo, Ze(t));
|
|
} catch (n) {
|
|
return !0;
|
|
}
|
|
};
|
|
co.sham = !0;
|
|
var fo =
|
|
!ro ||
|
|
$e(function () {
|
|
var t;
|
|
return (
|
|
uo(uo.call) ||
|
|
!uo(Object) ||
|
|
!uo(function () {
|
|
t = !0;
|
|
}) ||
|
|
t
|
|
);
|
|
})
|
|
? co
|
|
: uo,
|
|
ao = pt,
|
|
lo = TypeError,
|
|
so = Mn,
|
|
po = function (t) {
|
|
if (fo(t)) return t;
|
|
throw lo(ao(t) + " is not a constructor");
|
|
},
|
|
yo = D,
|
|
vo = $t("species"),
|
|
bo = {},
|
|
ho = ht,
|
|
go = TypeError,
|
|
mo = function (t) {
|
|
var n, r;
|
|
(this.promise = new t(function (t, e) {
|
|
if (void 0 !== n || void 0 !== r) throw go("Bad Promise constructor");
|
|
(n = t), (r = e);
|
|
})),
|
|
(this.resolve = ho(n)),
|
|
(this.reject = ho(r));
|
|
};
|
|
bo.f = function (t) {
|
|
return new mo(t);
|
|
};
|
|
var So = Mn,
|
|
wo = W,
|
|
Oo = bo,
|
|
jo = function (t, n) {
|
|
var r,
|
|
e,
|
|
o,
|
|
i,
|
|
u,
|
|
c = t.target,
|
|
f = t.global,
|
|
a = t.stat;
|
|
if ((r = f ? Ce : a ? Ce[c] || Ne(c, {}) : (Ce[c] || {}).prototype))
|
|
for (e in n) {
|
|
if (
|
|
((i = n[e]),
|
|
(o = t.dontCallGetSet ? (u = _e(r, e)) && u.value : r[e]),
|
|
!Ge(f ? e : c + (a ? "." : "#") + e, t.forced) && void 0 !== o)
|
|
) {
|
|
if (typeof i == typeof o) continue;
|
|
Re(i, o);
|
|
}
|
|
(t.sham || (o && o.sham)) && ke(i, "sham", !0), ze(r, e, i, t);
|
|
}
|
|
},
|
|
Po = Be,
|
|
Eo = o,
|
|
To = V,
|
|
Mo = B,
|
|
Fo = function (t, n) {
|
|
var r,
|
|
e = so(t).constructor;
|
|
return void 0 === e || yo((r = so(e)[vo])) ? n : po(r);
|
|
},
|
|
Io = function (t, n) {
|
|
if ((So(t), wo(n) && n.constructor === t)) return n;
|
|
var r = Oo.f(t);
|
|
return (0, r.resolve)(n), r.promise;
|
|
},
|
|
Ao = Wr,
|
|
Do = Po && Po.prototype;
|
|
if (
|
|
(jo(
|
|
{
|
|
target: "Promise",
|
|
proto: !0,
|
|
real: !0,
|
|
forced:
|
|
!!Po &&
|
|
Eo(function () {
|
|
Do.finally.call({ then: function () {} }, function () {});
|
|
}),
|
|
},
|
|
{
|
|
finally: function (t) {
|
|
var n = Fo(this, To("Promise")),
|
|
r = Mo(t);
|
|
return this.then(
|
|
r
|
|
? function (r) {
|
|
return Io(n, t()).then(function () {
|
|
return r;
|
|
});
|
|
}
|
|
: t,
|
|
r
|
|
? function (r) {
|
|
return Io(n, t()).then(function () {
|
|
throw r;
|
|
});
|
|
}
|
|
: t
|
|
);
|
|
},
|
|
}
|
|
),
|
|
Mo(Po))
|
|
) {
|
|
var xo = To("Promise").prototype.finally;
|
|
Do.finally !== xo && Ao(Do, "finally", xo, { unsafe: !0 });
|
|
}
|