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