;
if (o === t)
return (
(r.delegate = null),
("throw" === n &&
e.iterator.return &&
((r.method = "return"),
(r.arg = t),
T(e, r),
"throw" === r.method)) ||
("return" !== n &&
((r.method = "throw"),
(r.arg = new TypeError(
"The iterator does not provide a '" + n + "' method"
)))),
m
);
var i = f(o, e.iterator, r.arg);
if ("throw" === i.type)
return (
(r.method = "throw"), (r.arg = i.arg), (r.delegate = null), m
);
var a = i.arg;
return a
? a.done
? ((r[e.resultName] = a.value),
(r.next = e.nextLoc),
"return" !== r.method && ((r.method = "next"), (r.arg = t)),
(r.delegate = null),
m)
: a
: ((r.method = "throw"),
(r.arg = new TypeError("iterator result is not an object")),
(r.delegate = null),
m);
}
function k(t) {
var e = { tryLoc: t[0] };
1 in t && (e.catchLoc = t[1]),
2 in t && ((e.finallyLoc = t[2]), (e.afterLoc = t[3])),
this.tryEntries.push(e);
}
function D(t) {
var e = t.completion || {};
(e.type = "normal"), delete e.arg, (t.completion = e);
}
function I(t) {
(this.tryEntries = [{ tryLoc: "root" }]),
t.forEach(k, this),
this.reset(!0);
}
function R(e) {
if (e || "" === e) {
var r = e[a];
if (r) return r.call(e);
if ("function" == typeof e.next) return e;
if (!isNaN(e.length)) {
var o = -1,
i = function r() {
for (; ++o < e.length; )
if (n.call(e, o)) return (r.value = e[o]), (r.done = !1), r;
return (r.value = t), (r.done = !0), r;
};
return (i.next = i);
}
}
throw new TypeError(Ic(e) + " is not iterable");
}
return (
(_.prototype = g),
o(P, "constructor", { value: g, configurable: !0 }),
o(g, "constructor", { value: _, configurable: !0 }),
(_.displayName = u(g, c, "GeneratorFunction")),
(e.isGeneratorFunction = function (t) {
var e = "function" == typeof t && t.constructor;
return (
!!e &&
(e === _ || "GeneratorFunction" === (e.displayName || e.name))
);
}),
(e.mark = function (t) {
return (
Object.setPrototypeOf
? Object.setPrototypeOf(t, g)
: ((t.__proto__ = g), u(t, c, "GeneratorFunction")),
(t.prototype = Object.create(P)),
t
);
}),
(e.awrap = function (t) {
return { __await: t };
}),
w(A.prototype),
u(A.prototype, s, function () {
return this;
}),
(e.AsyncIterator = A),
(e.async = function (t, r, n, o, i) {
void 0 === i && (i = Promise);
var a = new A(l(t, r, n, o), i);
return e.isGeneratorFunction(r)
? a
: a.next().then(function (t) {
return t.done ? t.value : a.next();
});
}),
w(P),
u(P, c, "Generator"),
u(P, a, function () {
return this;
}),
u(P, "toString", function () {
return "[object Generator]";
}),
(e.keys = function (t) {
var e = Object(t),
r = [];
for (var n in e) r.push(n);
return (
r.reverse(),
function t() {
for (; r.length; ) {
var n = r.pop();
if (n in e) return (t.value = n), (t.done = !1), t;
}
return (t.done = !0), t;
}
);
}),
(e.values = R),
(I.prototype = {
constructor: I,
reset: function (e) {
if (
((this.prev = 0),
(this.next = 0),
(this.sent = this._sent = t),
(this.done = !1),
(this.delegate = null),
(this.method = "next"),
(this.arg = t),
this.tryEntries.forEach(D),
!e)
)
for (var r in this)
"t" === r.charAt(0) &&
n.call(this, r) &&
!isNaN(+r.slice(1)) &&
(this[r] = t);
},
stop: function () {
this.done = !0;
var t = this.tryEntries[0].completion;
if ("throw" === t.type) throw t.arg;
return this.rval;
},
dispatchException: function (e) {
if (this.done) throw e;
var r = this;
function o(n, o) {
return (
(s.type = "throw"),
(s.arg = e),
(r.next = n),
o && ((r.method = "next"), (r.arg = t)),
!!o
);
}
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var a = this.tryEntries[i],
s = a.completion;
if ("root" === a.tryLoc) return o("end");
if (a.tryLoc <= this.prev) {
var c = n.call(a, "catchLoc"),
u = n.call(a, "finallyLoc");
if (c && u) {
if (this.prev < a.catchLoc) return o(a.catchLoc, !0);
if (this.prev < a.finallyLoc) return o(a.finallyLoc);
} else if (c) {
if (this.prev < a.catchLoc) return o(a.catchLoc, !0);
} else {
if (!u)
throw new Error("try statement without catch or finally");
if (this.prev < a.finallyLoc) return o(a.finallyLoc);
}
}
}
},
abrupt: function (t, e) {
for (var r = this.tryEntries.length - 1; r >= 0; --r) {
var o = this.tryEntries[r];
if (
o.tryLoc <= this.prev &&
n.call(o, "finallyLoc") &&
this.prev < o.finallyLoc
) {
var i = o;
break;
}
}
i &&
("break" === t || "continue" === t) &&
i.tryLoc <= e &&
e <= i.finallyLoc &&
(i = null);
var a = i ? i.completion : {};
return (
(a.type = t),
(a.arg = e),
i
? ((this.method = "next"), (this.next = i.finallyLoc), m)
: this.complete(a)
);
},
complete: function (t, e) {
if ("throw" === t.type) throw t.arg;
return (
"break" === t.type || "continue" === t.type
? (this.next = t.arg)
: "return" === t.type
? ((this.rval = this.arg = t.arg),
(this.method = "return"),
(this.next = "end"))
: "normal" === t.type && e && (this.next = e),
m
);
},
finish: function (t) {
for (var e = this.tryEntries.length - 1; e >= 0; --e) {
var r = this.tryEntries[e];
if (r.finallyLoc === t)
return this.complete(r.completion, r.afterLoc), D(r), m;
}
},
catch: function (t) {
for (var e = this.tryEntries.length - 1; e >= 0; --e) {
var r = this.tryEntries[e];
if (r.tryLoc === t) {
var n = r.completion;
if ("throw" === n.type) {
var o = n.arg;
D(r);
}
return o;
}
}
throw new Error("illegal catch attempt");
},
delegateYield: function (e, r, n) {
return (
(this.delegate = { iterator: R(e), resultName: r, nextLoc: n }),
"next" === this.method && (this.arg = t),
m
);
},
}),
e
);
}
function Tc(t, e, r, n, o, i, a) {
try {
var s = t[i](a),
c = s.value;
} catch (t) {
return void r(t);
}
s.done ? e(c) : Promise.resolve(c).then(n, o);
}
function kc(t, e) {
var r = Object.keys(t);
if (Object.getOwnPropertySymbols) {
var n = Object.getOwnPropertySymbols(t);
e &&
(n = n.filter(function (e) {
return Object.getOwnPropertyDescriptor(t, e).enumerable;
})),
r.push.apply(r, n);
}
return r;
}
function Dc(t) {
for (var e = 1; e < arguments.length; e++) {
var r = null != arguments[e] ? arguments[e] : {};
e % 2
? kc(Object(r), !0).forEach(function (e) {
xc(t, e, r[e]);
})
: Object.getOwnPropertyDescriptors
? Object.defineProperties(t, Object.getOwnPropertyDescriptors(r))
: kc(Object(r)).forEach(function (e) {
Object.defineProperty(
t,
e,
Object.getOwnPropertyDescriptor(r, e)
);
});
}
return t;
}
function Ic(t) {
return (
(Ic =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
}),
Ic(t)
);
}
function Rc(t, e) {
(null == e || e > t.length) && (e = t.length);
for (var r = 0, n |
