273 lines
11 KiB
JavaScript
273 lines
11 KiB
JavaScript
!function(t) {
|
|
"use strict";
|
|
var r, e = Object.prototype, n = e.hasOwnProperty, o = "function" == typeof Symbol ? Symbol : {}, i = o.iterator || "@@iterator", a = o.asyncIterator || "@@asyncIterator", c = o.toStringTag || "@@toStringTag", u = "object" == typeof module, h = t.regeneratorRuntime;
|
|
if (h) u && (module.exports = h); else {
|
|
(h = t.regeneratorRuntime = u ? module.exports : {}).wrap = w;
|
|
var f = "suspendedStart", s = "suspendedYield", l = "executing", p = "completed", y = {}, v = {};
|
|
v[i] = function() {
|
|
return this;
|
|
};
|
|
var d = Object.getPrototypeOf, g = d && d(d(P([])));
|
|
g && g !== e && n.call(g, i) && (v = g);
|
|
var m = b.prototype = x.prototype = Object.create(v);
|
|
E.prototype = m.constructor = b, b.constructor = E, b[c] = E.displayName = "GeneratorFunction",
|
|
h.isGeneratorFunction = function(t) {
|
|
var r = "function" == typeof t && t.constructor;
|
|
return !!r && (r === E || "GeneratorFunction" === (r.displayName || r.name));
|
|
}, h.mark = function(t) {
|
|
return Object.setPrototypeOf ? Object.setPrototypeOf(t, b) : (t.__proto__ = b, c in t || (t[c] = "GeneratorFunction")),
|
|
t.prototype = Object.create(m), t;
|
|
}, h.awrap = function(t) {
|
|
return {
|
|
__await: t
|
|
};
|
|
}, _(j.prototype), j.prototype[a] = function() {
|
|
return this;
|
|
}, h.AsyncIterator = j, h.async = function(t, r, e, n) {
|
|
var o = new j(w(t, r, e, n));
|
|
return h.isGeneratorFunction(r) ? o : o.next().then(function(t) {
|
|
return t.done ? t.value : o.next();
|
|
});
|
|
}, _(m), m[c] = "Generator", m[i] = function() {
|
|
return this;
|
|
}, m.toString = function() {
|
|
return "[object Generator]";
|
|
}, h.keys = function(t) {
|
|
var r = [];
|
|
for (var e in t) r.push(e);
|
|
return r.reverse(), function e() {
|
|
for (;r.length; ) {
|
|
var n = r.pop();
|
|
if (n in t) return e.value = n, e.done = !1, e;
|
|
}
|
|
return e.done = !0, e;
|
|
};
|
|
}, h.values = P, N.prototype = {
|
|
constructor: N,
|
|
reset: function(t) {
|
|
if (this.prev = 0, this.next = 0, this.sent = this._sent = r, this.done = !1, this.delegate = null,
|
|
this.method = "next", this.arg = r, this.tryEntries.forEach(G), !t) for (var e in this) "t" === e.charAt(0) && n.call(this, e) && !isNaN(+e.slice(1)) && (this[e] = r);
|
|
},
|
|
stop: function() {
|
|
this.done = !0;
|
|
var t = this.tryEntries[0].completion;
|
|
if ("throw" === t.type) throw t.arg;
|
|
return this.rval;
|
|
},
|
|
dispatchException: function(t) {
|
|
if (this.done) throw t;
|
|
var e = this;
|
|
function o(n, o) {
|
|
return c.type = "throw", c.arg = t, e.next = n, o && (e.method = "next", e.arg = r),
|
|
!!o;
|
|
}
|
|
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
|
|
var a = this.tryEntries[i], c = a.completion;
|
|
if ("root" === a.tryLoc) return o("end");
|
|
if (a.tryLoc <= this.prev) {
|
|
var u = n.call(a, "catchLoc"), h = n.call(a, "finallyLoc");
|
|
if (u && h) {
|
|
if (this.prev < a.catchLoc) return o(a.catchLoc, !0);
|
|
if (this.prev < a.finallyLoc) return o(a.finallyLoc);
|
|
} else if (u) {
|
|
if (this.prev < a.catchLoc) return o(a.catchLoc, !0);
|
|
} else {
|
|
if (!h) throw new Error("try statement without catch or finally");
|
|
if (this.prev < a.finallyLoc) return o(a.finallyLoc);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
abrupt: function(t, r) {
|
|
for (var e = this.tryEntries.length - 1; e >= 0; --e) {
|
|
var o = this.tryEntries[e];
|
|
if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
|
|
var i = o;
|
|
break;
|
|
}
|
|
}
|
|
i && ("break" === t || "continue" === t) && i.tryLoc <= r && r <= i.finallyLoc && (i = null);
|
|
var a = i ? i.completion : {};
|
|
return a.type = t, a.arg = r, i ? (this.method = "next", this.next = i.finallyLoc,
|
|
y) : this.complete(a);
|
|
},
|
|
complete: function(t, r) {
|
|
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 && r && (this.next = r),
|
|
y;
|
|
},
|
|
finish: function(t) {
|
|
for (var r = this.tryEntries.length - 1; r >= 0; --r) {
|
|
var e = this.tryEntries[r];
|
|
if (e.finallyLoc === t) return this.complete(e.completion, e.afterLoc), G(e), y;
|
|
}
|
|
},
|
|
catch: function(t) {
|
|
for (var r = this.tryEntries.length - 1; r >= 0; --r) {
|
|
var e = this.tryEntries[r];
|
|
if (e.tryLoc === t) {
|
|
var n = e.completion;
|
|
if ("throw" === n.type) {
|
|
var o = n.arg;
|
|
G(e);
|
|
}
|
|
return o;
|
|
}
|
|
}
|
|
throw new Error("illegal catch attempt");
|
|
},
|
|
delegateYield: function(t, e, n) {
|
|
return this.delegate = {
|
|
iterator: P(t),
|
|
resultName: e,
|
|
nextLoc: n
|
|
}, "next" === this.method && (this.arg = r), y;
|
|
}
|
|
};
|
|
}
|
|
function w(t, r, e, n) {
|
|
var o = r && r.prototype instanceof x ? r : x, i = Object.create(o.prototype), a = new N(n || []);
|
|
return i._invoke = function(t, r, e) {
|
|
var n = f;
|
|
return function(o, i) {
|
|
if (n === l) throw new Error("Generator is already running");
|
|
if (n === p) {
|
|
if ("throw" === o) throw i;
|
|
return F();
|
|
}
|
|
for (e.method = o, e.arg = i; ;) {
|
|
var a = e.delegate;
|
|
if (a) {
|
|
var c = O(a, e);
|
|
if (c) {
|
|
if (c === y) continue;
|
|
return c;
|
|
}
|
|
}
|
|
if ("next" === e.method) e.sent = e._sent = e.arg; else if ("throw" === e.method) {
|
|
if (n === f) throw n = p, e.arg;
|
|
e.dispatchException(e.arg);
|
|
} else "return" === e.method && e.abrupt("return", e.arg);
|
|
n = l;
|
|
var u = L(t, r, e);
|
|
if ("normal" === u.type) {
|
|
if (n = e.done ? p : s, u.arg === y) continue;
|
|
return {
|
|
value: u.arg,
|
|
done: e.done
|
|
};
|
|
}
|
|
"throw" === u.type && (n = p, e.method = "throw", e.arg = u.arg);
|
|
}
|
|
};
|
|
}(t, e, a), i;
|
|
}
|
|
function L(t, r, e) {
|
|
try {
|
|
return {
|
|
type: "normal",
|
|
arg: t.call(r, e)
|
|
};
|
|
} catch (t) {
|
|
return {
|
|
type: "throw",
|
|
arg: t
|
|
};
|
|
}
|
|
}
|
|
function x() {}
|
|
function E() {}
|
|
function b() {}
|
|
function _(t) {
|
|
[ "next", "throw", "return" ].forEach(function(r) {
|
|
t[r] = function(t) {
|
|
return this._invoke(r, t);
|
|
};
|
|
});
|
|
}
|
|
function j(t) {
|
|
var r;
|
|
this._invoke = function(e, o) {
|
|
function i() {
|
|
return new Promise(function(r, i) {
|
|
!function r(e, o, i, a) {
|
|
var c = L(t[e], t, o);
|
|
if ("throw" !== c.type) {
|
|
var u = c.arg, h = u.value;
|
|
return h && "object" == typeof h && n.call(h, "__await") ? Promise.resolve(h.__await).then(function(t) {
|
|
r("next", t, i, a);
|
|
}, function(t) {
|
|
r("throw", t, i, a);
|
|
}) : Promise.resolve(h).then(function(t) {
|
|
u.value = t, i(u);
|
|
}, function(t) {
|
|
return r("throw", t, i, a);
|
|
});
|
|
}
|
|
a(c.arg);
|
|
}(e, o, r, i);
|
|
});
|
|
}
|
|
return r = r ? r.then(i, i) : i();
|
|
};
|
|
}
|
|
function O(t, e) {
|
|
var n = t.iterator[e.method];
|
|
if (n === r) {
|
|
if (e.delegate = null, "throw" === e.method) {
|
|
if (t.iterator.return && (e.method = "return", e.arg = r, O(t, e), "throw" === e.method)) return y;
|
|
e.method = "throw", e.arg = new TypeError("The iterator does not provide a 'throw' method");
|
|
}
|
|
return y;
|
|
}
|
|
var o = L(n, t.iterator, e.arg);
|
|
if ("throw" === o.type) return e.method = "throw", e.arg = o.arg, e.delegate = null,
|
|
y;
|
|
var i = o.arg;
|
|
return i ? i.done ? (e[t.resultName] = i.value, e.next = t.nextLoc, "return" !== e.method && (e.method = "next",
|
|
e.arg = r), e.delegate = null, y) : i : (e.method = "throw", e.arg = new TypeError("iterator result is not an object"),
|
|
e.delegate = null, y);
|
|
}
|
|
function k(t) {
|
|
var r = {
|
|
tryLoc: t[0]
|
|
};
|
|
1 in t && (r.catchLoc = t[1]), 2 in t && (r.finallyLoc = t[2], r.afterLoc = t[3]),
|
|
this.tryEntries.push(r);
|
|
}
|
|
function G(t) {
|
|
var r = t.completion || {};
|
|
r.type = "normal", delete r.arg, t.completion = r;
|
|
}
|
|
function N(t) {
|
|
this.tryEntries = [ {
|
|
tryLoc: "root"
|
|
} ], t.forEach(k, this), this.reset(!0);
|
|
}
|
|
function P(t) {
|
|
if (t) {
|
|
var e = t[i];
|
|
if (e) return e.call(t);
|
|
if ("function" == typeof t.next) return t;
|
|
if (!isNaN(t.length)) {
|
|
var o = -1, a = function e() {
|
|
for (;++o < t.length; ) if (n.call(t, o)) return e.value = t[o], e.done = !1, e;
|
|
return e.value = r, e.done = !0, e;
|
|
};
|
|
return a.next = a;
|
|
}
|
|
}
|
|
return {
|
|
next: F
|
|
};
|
|
}
|
|
function F() {
|
|
return {
|
|
value: r,
|
|
done: !0
|
|
};
|
|
}
|
|
}(function() {
|
|
return this || "object" == typeof self && self;
|
|
}() || Function("return this")()); |