5405 lines
202 KiB
JavaScript
5405 lines
202 KiB
JavaScript
define("workers/@babel/runtime/helpers/Arrayincludes.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
Array.prototype.includes || Object.defineProperty(Array.prototype, "includes", {
|
||
value: function (r, e) {
|
||
if (null == this) throw new TypeError('"this" is null or not defined');
|
||
var t = Object(this),
|
||
n = t.length >>> 0;
|
||
if (0 == n) return !1;
|
||
for (var i, o, a = 0 | e, u = Math.max(0 <= a ? a : n - Math.abs(a), 0); u < n;) {
|
||
if ((i = t[u]) === (o = r) || "number" == typeof i && "number" == typeof o && isNaN(i) && isNaN(o)) return !0;
|
||
u++
|
||
}
|
||
return !1
|
||
}
|
||
});
|
||
});
|
||
define("workers/@babel/runtime/helpers/arrayLikeToArray.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
function _arrayLikeToArray(r, a) {
|
||
(null == a || a > r.length) && (a = r.length);
|
||
for (var e = 0, n = new Array(a); e < a; e++) n[e] = r[e];
|
||
return n
|
||
}
|
||
module.exports = _arrayLikeToArray;
|
||
});
|
||
define("workers/@babel/runtime/helpers/arrayWithHoles.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
function _arrayWithHoles(r) {
|
||
if (Array.isArray(r)) return r
|
||
}
|
||
module.exports = _arrayWithHoles;
|
||
});
|
||
define("workers/@babel/runtime/helpers/arrayWithoutHoles.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
var arrayLikeToArray = require("./arrayLikeToArray");
|
||
|
||
function _arrayWithoutHoles(r) {
|
||
if (Array.isArray(r)) return arrayLikeToArray(r)
|
||
}
|
||
module.exports = _arrayWithoutHoles;
|
||
});
|
||
define("workers/@babel/runtime/helpers/asyncToGenerator.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
function asyncGeneratorStep(n, e, r, t, o, a, c) {
|
||
try {
|
||
var i = n[a](c),
|
||
u = i.value
|
||
} catch (n) {
|
||
return void r(n)
|
||
}
|
||
i.done ? e(u) : Promise.resolve(u).then(t, o)
|
||
}
|
||
|
||
function _asyncToGenerator(n) {
|
||
return function () {
|
||
var e = this,
|
||
r = arguments;
|
||
return new Promise((function (t, o) {
|
||
var a = n.apply(e, r);
|
||
|
||
function c(n) {
|
||
asyncGeneratorStep(a, t, o, c, i, "next", n)
|
||
}
|
||
|
||
function i(n) {
|
||
asyncGeneratorStep(a, t, o, c, i, "throw", n)
|
||
}
|
||
c(void 0)
|
||
}))
|
||
}
|
||
}
|
||
module.exports = _asyncToGenerator;
|
||
});
|
||
define("workers/@babel/runtime/helpers/classCallCheck.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
function _classCallCheck(a, l) {
|
||
if (!(a instanceof l)) throw new TypeError("Cannot call a class as a function")
|
||
}
|
||
module.exports = _classCallCheck;
|
||
});
|
||
define("workers/@babel/runtime/helpers/createClass.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
var toPropertyKey = require("./toPropertyKey");
|
||
|
||
function _defineProperties(e, r) {
|
||
for (var t = 0; t < r.length; t++) {
|
||
var o = r[t];
|
||
o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, toPropertyKey(o.key), o)
|
||
}
|
||
}
|
||
|
||
function _createClass(e, r, t) {
|
||
return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
|
||
writable: !1
|
||
}), e
|
||
}
|
||
module.exports = _createClass;
|
||
});
|
||
define("workers/@babel/runtime/helpers/createForOfIteratorHelper.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
var unsupportedIterableToArray = require("./unsupportedIterableToArray");
|
||
|
||
function _createForOfIteratorHelper(r, e) {
|
||
var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
|
||
if (!t) {
|
||
if (Array.isArray(r) || (t = unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
|
||
t && (r = t);
|
||
var n = 0,
|
||
o = function () {};
|
||
return {
|
||
s: o,
|
||
n: function () {
|
||
return n >= r.length ? {
|
||
done: !0
|
||
} : {
|
||
done: !1,
|
||
value: r[n++]
|
||
}
|
||
},
|
||
e: function (r) {
|
||
throw r
|
||
},
|
||
f: o
|
||
}
|
||
}
|
||
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 a, u = !0,
|
||
i = !1;
|
||
return {
|
||
s: function () {
|
||
t = t.call(r)
|
||
},
|
||
n: function () {
|
||
var r = t.next();
|
||
return u = r.done, r
|
||
},
|
||
e: function (r) {
|
||
i = !0, a = r
|
||
},
|
||
f: function () {
|
||
try {
|
||
u || null == t.return || t.return()
|
||
} finally {
|
||
if (i) throw a
|
||
}
|
||
}
|
||
}
|
||
}
|
||
module.exports = _createForOfIteratorHelper;
|
||
});
|
||
define("workers/@babel/runtime/helpers/iterableToArray.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
function _iterableToArray(r) {
|
||
if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r)
|
||
}
|
||
module.exports = _iterableToArray;
|
||
});
|
||
define("workers/@babel/runtime/helpers/iterableToArrayLimit.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
function _iterableToArrayLimit(r, e) {
|
||
var l = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
|
||
if (null != l) {
|
||
var t, n, i, a, u = [],
|
||
o = !0,
|
||
f = !1;
|
||
try {
|
||
if (i = (l = l.call(r)).next, 0 === e) {
|
||
if (Object(l) !== l) return;
|
||
o = !1
|
||
} else
|
||
for (; !(o = (t = i.call(l)).done) && (u.push(t.value), u.length !== e); o = !0);
|
||
} catch (r) {
|
||
f = !0, n = r
|
||
} finally {
|
||
try {
|
||
if (!o && null != l.return && (a = l.return(), Object(a) !== a)) return
|
||
} finally {
|
||
if (f) throw n
|
||
}
|
||
}
|
||
return u
|
||
}
|
||
}
|
||
module.exports = _iterableToArrayLimit;
|
||
});
|
||
define("workers/@babel/runtime/helpers/nonIterableRest.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
function _nonIterableRest() {
|
||
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")
|
||
}
|
||
module.exports = _nonIterableRest;
|
||
});
|
||
define("workers/@babel/runtime/helpers/nonIterableSpread.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
function _nonIterableSpread() {
|
||
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")
|
||
}
|
||
module.exports = _nonIterableSpread;
|
||
});
|
||
define("workers/@babel/runtime/helpers/regeneratorRuntime.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
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) {
|
||
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) {
|
||
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;
|
||
|
||
});
|
||
define("workers/@babel/runtime/helpers/slicedToArray.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
var arrayWithHoles = require("./arrayWithHoles"),
|
||
iterableToArrayLimit = require("./iterableToArrayLimit"),
|
||
unsupportedIterableToArray = require("./unsupportedIterableToArray"),
|
||
nonIterableRest = require("./nonIterableRest");
|
||
|
||
function _slicedToArray(r, e) {
|
||
return arrayWithHoles(r) || iterableToArrayLimit(r, e) || unsupportedIterableToArray(r, e) || nonIterableRest()
|
||
}
|
||
module.exports = _slicedToArray;
|
||
});
|
||
define("workers/@babel/runtime/helpers/toConsumableArray.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
var arrayWithoutHoles = require("./arrayWithoutHoles"),
|
||
iterableToArray = require("./iterableToArray"),
|
||
unsupportedIterableToArray = require("./unsupportedIterableToArray"),
|
||
nonIterableSpread = require("./nonIterableSpread");
|
||
|
||
function _toConsumableArray(r) {
|
||
return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread()
|
||
}
|
||
module.exports = _toConsumableArray;
|
||
});
|
||
define("workers/@babel/runtime/helpers/toPrimitive.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
var _typeof = require("./typeof");
|
||
|
||
function _toPrimitive(r, t) {
|
||
if ("object" !== _typeof(r) || null === r) return r;
|
||
var e = r[Symbol.toPrimitive];
|
||
if (void 0 !== e) {
|
||
var i = e.call(r, t || "default");
|
||
if ("object" !== _typeof(i)) return i;
|
||
throw new TypeError("@@toPrimitive must return a primitive value.")
|
||
}
|
||
return ("string" === t ? String : Number)(r)
|
||
}
|
||
module.exports = _toPrimitive;
|
||
});
|
||
define("workers/@babel/runtime/helpers/toPropertyKey.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
var _typeof = require("./typeof"),
|
||
toPrimitive = require("./toPrimitive");
|
||
|
||
function _toPropertyKey(r) {
|
||
var t = toPrimitive(r, "string");
|
||
return "symbol" === _typeof(t) ? t : String(t)
|
||
}
|
||
module.exports = _toPropertyKey;
|
||
});
|
||
define("workers/@babel/runtime/helpers/typeof.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
function _typeof(o) {
|
||
return module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
|
||
return typeof o
|
||
} : function (o) {
|
||
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o
|
||
}, _typeof(o)
|
||
}
|
||
module.exports = _typeof;
|
||
});
|
||
define("workers/@babel/runtime/helpers/unsupportedIterableToArray.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
var arrayLikeToArray = require("./arrayLikeToArray");
|
||
|
||
function _unsupportedIterableToArray(r, e) {
|
||
if (r) {
|
||
if ("string" == typeof r) return arrayLikeToArray(r, e);
|
||
var t = Object.prototype.toString.call(r).slice(8, -1);
|
||
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, e) : void 0
|
||
}
|
||
}
|
||
module.exports = _unsupportedIterableToArray;
|
||
});
|
||
|
||
define("workers/wasm/wasmWorker.js", function (require, module, exports, window, document, frames, self, location, navigator, localStorage, history, Caches, screen, alert, confirm, prompt, XMLHttpRequest, WebSocket, Reporter, webkit, WeixinJSCore) {
|
||
"use strict";
|
||
var e = require("../../workers/@babel/runtime/helpers/slicedToArray");
|
||
require("../../workers/@babel/runtime/helpers/Arrayincludes");
|
||
var r = require("../../workers/@babel/runtime/helpers/toConsumableArray"),
|
||
t = require("../../workers/@babel/runtime/helpers/createForOfIteratorHelper"),
|
||
n = require("../../workers/@babel/runtime/helpers/createClass"),
|
||
o = require("../../workers/@babel/runtime/helpers/classCallCheck"),
|
||
i = require("../../workers/@babel/runtime/helpers/regeneratorRuntime"),
|
||
a = require("../../workers/@babel/runtime/helpers/asyncToGenerator"),
|
||
c = require("../../workers/@babel/runtime/helpers/typeof");
|
||
|
||
function s() {
|
||
var s = function (s) {
|
||
var u = "undefined" != typeof document ? null === (s = document.currentScript) || void 0 === s ? void 0 : s.src : void 0;
|
||
return function () {
|
||
var s, f, l = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {},
|
||
d = l,
|
||
h = new Promise((function (e, r) {
|
||
s = e, f = r
|
||
})),
|
||
v = !0,
|
||
p = !1;
|
||
|
||
function m(e) {
|
||
for (var r, t, n, o, i, a, c = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=", s = e.replace(/=+$/, ""), u = "", f = 0; f < s.length;) r = c.indexOf(s.charAt(f++)) << 2 | (o = c.indexOf(s.charAt(f++))) >> 4, t = (15 & o) << 4 | (i = c.indexOf(s.charAt(f++))) >> 2, n = (3 & i) << 6 | (a = c.indexOf(s.charAt(f++))), u += String.fromCharCode(r), 64 !== i && (u += String.fromCharCode(t)), 64 !== a && (u += String.fromCharCode(n));
|
||
return u
|
||
}
|
||
|
||
function w(e) {
|
||
for (var r = m(e), t = [], n = 0; n < r.length; n++) t.push(r.charCodeAt(n));
|
||
return t
|
||
}
|
||
var _ = function () {
|
||
d.ccall("init", "number", [], [])
|
||
},
|
||
y = function (e) {
|
||
var r = w(e);
|
||
d.cwrap("loadTA", "number", ["array", "number"])(r, r.length)
|
||
},
|
||
g = function (e) {
|
||
for (var r = e.map((function (e) {
|
||
var r = d._malloc(e.length + 1);
|
||
return d.stringToUTF8(e, r, 1 / 0), r
|
||
})), t = d._malloc(4 * r.length), n = 0; n < r.length; n++) d.setValue(t + 4 * n, r[n], "i32");
|
||
return t
|
||
};
|
||
|
||
function E(e) {
|
||
return ArrayBuffer.isView(e) && !(e instanceof DataView)
|
||
}
|
||
var b = function (e, r) {
|
||
var t = r.map((function (e) {
|
||
return Array.isArray(e) || E(e) ? "array" : c(e).includes("object") ? "object" : c(e)
|
||
})),
|
||
n = r.map((function (e) {
|
||
return c(e).includes("string") ? e : E(e) ? JSON.stringify(Array.from(e)) : JSON.stringify(e)
|
||
})),
|
||
o = r.length,
|
||
i = g(t),
|
||
a = g(n);
|
||
return d.ccall("evaljs", "string", ["string", "number", "number", "number"], [e, i, a, o])
|
||
},
|
||
k = function () {
|
||
d.ccall("dispose", "", [], [])
|
||
},
|
||
j = function (e) {
|
||
return d.ccall("evalcode", "string", ["string"], [e])
|
||
},
|
||
S = function (e, r) {
|
||
var t = "globalThis.".concat(e, " = ").concat(r.toString(), ";");
|
||
return d.ccall("addFunc", "", ["string"], [t])
|
||
},
|
||
C = function (e, r) {
|
||
var t = "globalThis.".concat(e, " = ").concat(r.toString(), ";");
|
||
return d.ccall("addFunc", "", ["string"], [t])
|
||
};
|
||
d.initInstance = _, d.loadTACode = y, d.invokerTAFunc = b, d.evalcode = j, d.destroy = k, d.addSyncFunc = S, d.addAsyncFunc = C, d.UTF8ToString = De;
|
||
var F = WXWebAssembly;
|
||
d.printErr = console.error, d.print = console.log;
|
||
var A = "/utils-packages/wasm/picvmp.wasm.br";
|
||
window = {
|
||
document: {}
|
||
};
|
||
var x, D, I = Object.assign({}, d),
|
||
M = "./this.program",
|
||
P = function (e, r) {
|
||
throw r
|
||
},
|
||
T = "";
|
||
(v || p) && (p ? T = "" : "undefined" != typeof document && document.currentScript && (T = document.currentScript.src), u && (T = u), T = T.startsWith("blob:") ? "" : T.substr(0, T.replace(/[?#].*/, "").lastIndexOf("/") + 1), x = function () {
|
||
var e = a(i().mark((function e(r) {
|
||
var t;
|
||
return i().wrap((function (e) {
|
||
for (;;) switch (e.prev = e.next) {
|
||
case 0:
|
||
return e.next = 2, fetch(r, {
|
||
credentials: "same-origin"
|
||
});
|
||
case 2:
|
||
if (!(t = e.sent).ok) {
|
||
e.next = 5;
|
||
break
|
||
}
|
||
return e.abrupt("return", t.arrayBuffer());
|
||
case 5:
|
||
throw new Error(t.status + " : " + t.url);
|
||
case 6:
|
||
case "end":
|
||
return e.stop()
|
||
}
|
||
}), e)
|
||
})));
|
||
return function (r) {
|
||
return e.apply(this, arguments)
|
||
}
|
||
}());
|
||
var R = d.print || function () {}.bind(),
|
||
N = d.printErr || function () {}.bind();
|
||
Object.assign(d, I), I = null, d.arguments && d.arguments, d.thisProgram && (M = d.thisProgram);
|
||
var U, B, z, O, L, H, q, K, W = d.wasmBinary,
|
||
Z = !1;
|
||
|
||
function V(e, r) {
|
||
e || se(r)
|
||
}
|
||
|
||
function X() {
|
||
var e = U.buffer;
|
||
d.HEAP8 = B = new Int8Array(e), d.HEAP16 = O = new Int16Array(e), d.HEAPU8 = z = new Uint8Array(e), d.HEAPU16 = new Uint16Array(e), d.HEAP32 = L = new Int32Array(e), d.HEAPU32 = H = new Uint32Array(e), d.HEAPF32 = q = new Float32Array(e), d.HEAPF64 = K = new Float64Array(e)
|
||
}
|
||
var G = [],
|
||
J = [],
|
||
Y = [];
|
||
|
||
function $() {
|
||
if (d.preRun)
|
||
for ("function" == typeof d.preRun && (d.preRun = [d.preRun]); d.preRun.length;) re(d.preRun.shift());
|
||
be(G)
|
||
}
|
||
|
||
function Q() {
|
||
d.noFSInit || mr.initialized || mr.init(), mr.ignorePermissions = !1, or.init(), Tr.root = mr.mount(Tr, {}, null), be(J)
|
||
}
|
||
|
||
function ee() {
|
||
if (d.postRun)
|
||
for ("function" == typeof d.postRun && (d.postRun = [d.postRun]); d.postRun.length;) ne(d.postRun.shift());
|
||
be(Y)
|
||
}
|
||
|
||
function re(e) {
|
||
G.unshift(e)
|
||
}
|
||
|
||
function te(e) {
|
||
J.unshift(e)
|
||
}
|
||
|
||
function ne(e) {
|
||
Y.unshift(e)
|
||
}
|
||
var oe = 0,
|
||
ie = null;
|
||
|
||
function ae(e) {
|
||
var r;
|
||
oe++, null === (r = d.monitorRunDependencies) || void 0 === r || r.call(d, oe)
|
||
}
|
||
|
||
function ce(e) {
|
||
var r;
|
||
if (oe--, null !== (r = d.monitorRunDependencies) && void 0 !== r && r.call(d, oe), 0 == oe && ie) {
|
||
var t = ie;
|
||
ie = null, t()
|
||
}
|
||
}
|
||
|
||
function se(e) {
|
||
var r;
|
||
null !== (r = d.onAbort) && void 0 !== r && r.call(d, e), N(e = "Aborted(" + e + ")"), Z = !0, e += ". Build with -sASSERTIONS for more info.";
|
||
var t = new Error(e);
|
||
throw f(t), t
|
||
}
|
||
var ue, fe, le, de = "data:application/octet-stream;base64,",
|
||
he = function (e) {
|
||
return e.startsWith(de)
|
||
};
|
||
|
||
function ve(e, r) {
|
||
return pe.apply(this, arguments)
|
||
}
|
||
|
||
function pe() {
|
||
return (pe = a(i().mark((function e(r, t) {
|
||
var n, o;
|
||
return i().wrap((function (e) {
|
||
for (;;) switch (e.prev = e.next) {
|
||
case 0:
|
||
return e.prev = 0, e.next = 3, jn();
|
||
case 3:
|
||
return n = e.sent, e.next = 6, F.instantiate(n, t);
|
||
case 6:
|
||
return o = e.sent, e.abrupt("return", o);
|
||
case 10:
|
||
e.prev = 10, e.t0 = e.catch(0), N("failed to asynchronously prepare wasm: ".concat(e.t0)), se(e.t0);
|
||
case 13:
|
||
case "end":
|
||
return e.stop()
|
||
}
|
||
}), e, null, [
|
||
[0, 10]
|
||
])
|
||
})))).apply(this, arguments)
|
||
}
|
||
|
||
function me(e, r, t) {
|
||
return we.apply(this, arguments)
|
||
}
|
||
|
||
function we() {
|
||
return (we = a(i().mark((function e(r, t, n) {
|
||
var o, a;
|
||
return i().wrap((function (e) {
|
||
for (;;) switch (e.prev = e.next) {
|
||
case 0:
|
||
if (r || "function" != typeof F.instantiateStreaming || he(t) || "function" != typeof fetch) {
|
||
e.next = 12;
|
||
break
|
||
}
|
||
return e.prev = 1, o = fetch(t, {
|
||
credentials: "same-origin"
|
||
}), e.next = 5, F.instantiateStreaming(o, n);
|
||
case 5:
|
||
return a = e.sent, e.abrupt("return", a);
|
||
case 9:
|
||
e.prev = 9, e.t0 = e.catch(1), N("wasm streaming compile failed: ".concat(e.t0)), N("falling back to ArrayBuffer instantiation");
|
||
case 12:
|
||
return e.abrupt("return", ve(t, n));
|
||
case 13:
|
||
case "end":
|
||
return e.stop()
|
||
}
|
||
}), e, null, [
|
||
[1, 9]
|
||
])
|
||
})))).apply(this, arguments)
|
||
}
|
||
|
||
function _e() {
|
||
return {
|
||
env: zt,
|
||
wasi_snapshot_preview1: zt
|
||
}
|
||
}
|
||
|
||
function ye() {
|
||
return ge.apply(this, arguments)
|
||
}
|
||
|
||
function ge() {
|
||
return (ge = a(i().mark((function e() {
|
||
var r, t, n, o;
|
||
return i().wrap((function (e) {
|
||
for (;;) switch (e.prev = e.next) {
|
||
case 0:
|
||
if (t = function (e) {
|
||
r(e.instance)
|
||
}, r = function (e, r) {
|
||
return Bt = e.exports, U = Bt.memory, X(), Se = Bt.__indirect_function_table, te(Bt.__wasm_call_ctors), ce(), Bt
|
||
}, ae(), n = _e(), !d.instantiateWasm) {
|
||
e.next = 12;
|
||
break
|
||
}
|
||
return e.prev = 5, e.abrupt("return", d.instantiateWasm(n, r));
|
||
case 9:
|
||
e.prev = 9, e.t0 = e.catch(5), N("Module.instantiateWasm callback failed with error: ".concat(e.t0)), f(e.t0);
|
||
case 12:
|
||
return ue = "picvmp.wasm.br", e.prev = 13, e.next = 16, me(W, ue, n);
|
||
case 16:
|
||
return o = e.sent, e.abrupt("return", (t(o), o));
|
||
case 20:
|
||
return e.prev = 20, e.t1 = e.catch(13), e.abrupt("return", void f(e.t1));
|
||
case 23:
|
||
case "end":
|
||
return e.stop()
|
||
}
|
||
}), e, null, [
|
||
[5, 9],
|
||
[13, 20]
|
||
])
|
||
})))).apply(this, arguments)
|
||
}
|
||
var Ee = n((function e(r) {
|
||
o(this, e), this.name = "ExitStatus", this.message = "Program terminated with exit(".concat(r, ")"), this.status = r
|
||
})),
|
||
be = function (e) {
|
||
for (; e.length > 0;) e.shift()(d)
|
||
},
|
||
ke = d.noExitRuntime || !0;
|
||
|
||
function je(e, r) {
|
||
var t = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : "i8";
|
||
switch (t.endsWith("*") && (t = "*"), t) {
|
||
case "i1":
|
||
case "i8":
|
||
B[e] = r;
|
||
break;
|
||
case "i16":
|
||
O[e >> 1] = r;
|
||
break;
|
||
case "i32":
|
||
L[e >> 2] = r;
|
||
break;
|
||
case "i64":
|
||
se("to do setValue(i64) use WASM_BIGINT");
|
||
case "float":
|
||
q[e >> 2] = r;
|
||
break;
|
||
case "double":
|
||
K[e >> 3] = r;
|
||
break;
|
||
case "*":
|
||
H[e >> 2] = r;
|
||
break;
|
||
default:
|
||
se("invalid type for setValue: ".concat(t))
|
||
}
|
||
}
|
||
d.setValue = je;
|
||
var Se, Ce = function (e) {
|
||
return Wt(e)
|
||
},
|
||
Fe = function () {
|
||
return Vt()
|
||
},
|
||
Ae = "undefined" != typeof TextDecoder ? new TextDecoder : void 0,
|
||
xe = function (e) {
|
||
for (var r = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 0, t = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : NaN, n = r + t, o = r; e[o] && !(o >= n);) ++o;
|
||
if (o - r > 16 && e.buffer && Ae) return Ae.decode(e.subarray(r, o));
|
||
for (var i = ""; r < o;) {
|
||
var a = e[r++];
|
||
if (128 & a) {
|
||
var c = 63 & e[r++];
|
||
if (192 != (224 & a)) {
|
||
var s = 63 & e[r++];
|
||
if ((a = 224 == (240 & a) ? (15 & a) << 12 | c << 6 | s : (7 & a) << 18 | c << 12 | s << 6 | 63 & e[r++]) < 65536) i += String.fromCharCode(a);
|
||
else {
|
||
var u = a - 65536;
|
||
i += String.fromCharCode(55296 | u >> 10, 56320 | 1023 & u)
|
||
}
|
||
} else i += String.fromCharCode((31 & a) << 6 | c)
|
||
} else i += String.fromCharCode(a)
|
||
}
|
||
return i
|
||
},
|
||
De = function (e, r) {
|
||
return e ? xe(z, e, r) : ""
|
||
},
|
||
Ie = function (e, r, t, n) {
|
||
return se("Assertion failed: ".concat(De(e), ", at: ") + [r ? De(r) : "unknown filename", t, n ? De(n) : "unknown function"])
|
||
},
|
||
Me = [],
|
||
Pe = function (e) {
|
||
var r = Me[e];
|
||
return r || (e >= Me.length && (Me.length = e + 1), Me[e] = r = Se.get(e)), r
|
||
},
|
||
Te = function (e, r) {
|
||
return Pe(e)(r)
|
||
},
|
||
Re = [],
|
||
Ne = 0,
|
||
Ue = function (e) {
|
||
var r = new Oe(e);
|
||
return r.get_caught() || (r.set_caught(!0), Ne--), r.set_rethrown(!1), Re.push(r), Gt(e), $t(e)
|
||
},
|
||
Be = 0,
|
||
ze = function () {
|
||
qt(0, 0);
|
||
var e = Re.pop();
|
||
Xt(e.excPtr), Be = 0
|
||
},
|
||
Oe = function () {
|
||
return n((function e(r) {
|
||
o(this, e), this.excPtr = r, this.ptr = r - 24
|
||
}), [{
|
||
key: "set_type",
|
||
value: function (e) {
|
||
H[this.ptr + 4 >> 2] = e
|
||
}
|
||
}, {
|
||
key: "get_type",
|
||
value: function () {
|
||
return H[this.ptr + 4 >> 2]
|
||
}
|
||
}, {
|
||
key: "set_destructor",
|
||
value: function (e) {
|
||
H[this.ptr + 8 >> 2] = e
|
||
}
|
||
}, {
|
||
key: "get_destructor",
|
||
value: function () {
|
||
return H[this.ptr + 8 >> 2]
|
||
}
|
||
}, {
|
||
key: "set_caught",
|
||
value: function (e) {
|
||
e = e ? 1 : 0, B[this.ptr + 12] = e
|
||
}
|
||
}, {
|
||
key: "get_caught",
|
||
value: function () {
|
||
return 0 != B[this.ptr + 12]
|
||
}
|
||
}, {
|
||
key: "set_rethrown",
|
||
value: function (e) {
|
||
e = e ? 1 : 0, B[this.ptr + 13] = e
|
||
}
|
||
}, {
|
||
key: "get_rethrown",
|
||
value: function () {
|
||
return 0 != B[this.ptr + 13]
|
||
}
|
||
}, {
|
||
key: "init",
|
||
value: function (e, r) {
|
||
this.set_adjusted_ptr(0), this.set_type(e), this.set_destructor(r)
|
||
}
|
||
}, {
|
||
key: "set_adjusted_ptr",
|
||
value: function (e) {
|
||
H[this.ptr + 16 >> 2] = e
|
||
}
|
||
}, {
|
||
key: "get_adjusted_ptr",
|
||
value: function () {
|
||
return H[this.ptr + 16 >> 2]
|
||
}
|
||
}])
|
||
}(),
|
||
Le = function (e) {
|
||
throw Be || (Be = e), Be
|
||
},
|
||
He = function (e) {
|
||
return Kt(e)
|
||
},
|
||
qe = function (e) {
|
||
var r = Be;
|
||
if (!r) return He(0), 0;
|
||
var n = new Oe(r);
|
||
n.set_adjusted_ptr(r);
|
||
var o = n.get_type();
|
||
if (!o) return He(0), r;
|
||
var i, a = t(e);
|
||
try {
|
||
for (a.s(); !(i = a.n()).done;) {
|
||
var c = i.value;
|
||
if (0 === c || c === o) break;
|
||
var s = n.ptr + 16;
|
||
if (Yt(c, o, s)) return He(c), r
|
||
}
|
||
} catch (e) {
|
||
a.e(e)
|
||
} finally {
|
||
a.f()
|
||
}
|
||
return He(o), r
|
||
},
|
||
Ke = function () {
|
||
return qe([])
|
||
},
|
||
We = function (e) {
|
||
return qe([e])
|
||
},
|
||
Ze = function () {
|
||
var e = Re.pop();
|
||
e || se("no exception to throw");
|
||
var r = e.excPtr;
|
||
throw e.get_rethrown() || (Re.push(e), e.set_rethrown(!0), e.set_caught(!1), Ne++), Be = r
|
||
},
|
||
Ve = function (e, r, t) {
|
||
throw new Oe(e).init(r, t), Ne++, Be = e
|
||
},
|
||
Xe = function () {
|
||
return Ne
|
||
},
|
||
Ge = {
|
||
isAbs: function (e) {
|
||
return "/" === e.charAt(0)
|
||
},
|
||
splitPath: function (e) {
|
||
return /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/.exec(e).slice(1)
|
||
},
|
||
normalizeArray: function (e, r) {
|
||
for (var t = 0, n = e.length - 1; n >= 0; n--) {
|
||
var o = e[n];
|
||
"." === o ? e.splice(n, 1) : ".." === o ? (e.splice(n, 1), t++) : t && (e.splice(n, 1), t--)
|
||
}
|
||
if (r)
|
||
for (; t; t--) e.unshift("..");
|
||
return e
|
||
},
|
||
normalize: function (e) {
|
||
var r = Ge.isAbs(e),
|
||
t = "/" === e.substr(-1);
|
||
return (e = Ge.normalizeArray(e.split("/").filter((function (e) {
|
||
return !!e
|
||
})), !r).join("/")) || r || (e = "."), e && t && (e += "/"), (r ? "/" : "") + e
|
||
},
|
||
dirname: function (e) {
|
||
var r = Ge.splitPath(e),
|
||
t = r[0],
|
||
n = r[1];
|
||
return t || n ? (n && (n = n.substr(0, n.length - 1)), t + n) : "."
|
||
},
|
||
basename: function (e) {
|
||
if ("/" === e) return "/";
|
||
var r = (e = (e = Ge.normalize(e)).replace(/\/$/, "")).lastIndexOf("/");
|
||
return -1 === r ? e : e.substr(r + 1)
|
||
},
|
||
join: function () {
|
||
for (var e = arguments.length, r = new Array(e), t = 0; t < e; t++) r[t] = arguments[t];
|
||
return Ge.normalize(r.join("/"))
|
||
},
|
||
join2: function (e, r) {
|
||
return Ge.normalize(e + "/" + r)
|
||
}
|
||
},
|
||
Je = function () {
|
||
if ("object" == ("undefined" == typeof crypto ? "undefined" : c(crypto)) && "function" == typeof crypto.getRandomValues) return function (e) {
|
||
return crypto.getRandomValues(e)
|
||
};
|
||
se("initRandomDevice")
|
||
},
|
||
Ye = function (e) {
|
||
return (Ye = Je())(e)
|
||
},
|
||
$e = {
|
||
resolve: function () {
|
||
for (var e = "", r = !1, t = arguments.length - 1; t >= -1 && !r; t--) {
|
||
var n = t >= 0 ? t < 0 || arguments.length <= t ? void 0 : arguments[t] : mr.cwd();
|
||
if ("string" != typeof n) throw new TypeError("Arguments to path.resolve must be strings");
|
||
if (!n) return "";
|
||
e = n + "/" + e, r = Ge.isAbs(n)
|
||
}
|
||
return (r ? "/" : "") + (e = Ge.normalizeArray(e.split("/").filter((function (e) {
|
||
return !!e
|
||
})), !r).join("/")) || "."
|
||
},
|
||
relative: function (e, r) {
|
||
function t(e) {
|
||
for (var r = 0; r < e.length && "" === e[r]; r++);
|
||
for (var t = e.length - 1; t >= 0 && "" === e[t]; t--);
|
||
return r > t ? [] : e.slice(r, t - r + 1)
|
||
}
|
||
e = $e.resolve(e).substr(1), r = $e.resolve(r).substr(1);
|
||
for (var n = t(e.split("/")), o = t(r.split("/")), i = Math.min(n.length, o.length), a = i, c = 0; c < i; c++)
|
||
if (n[c] !== o[c]) {
|
||
a = c;
|
||
break
|
||
} var s = [];
|
||
for (c = a; c < n.length; c++) s.push("..");
|
||
return (s = s.concat(o.slice(a))).join("/")
|
||
}
|
||
},
|
||
Qe = [],
|
||
er = function (e) {
|
||
for (var r = 0, t = 0; t < e.length; ++t) {
|
||
var n = e.charCodeAt(t);
|
||
n <= 127 ? r++ : n <= 2047 ? r += 2 : n >= 55296 && n <= 57343 ? (r += 4, ++t) : r += 3
|
||
}
|
||
return r
|
||
},
|
||
rr = function (e, r, t, n) {
|
||
if (!(n > 0)) return 0;
|
||
for (var o = t, i = t + n - 1, a = 0; a < e.length; ++a) {
|
||
var c = e.charCodeAt(a);
|
||
if (c >= 55296 && c <= 57343) c = 65536 + ((1023 & c) << 10) | 1023 & e.charCodeAt(++a);
|
||
if (c <= 127) {
|
||
if (t >= i) break;
|
||
r[t++] = c
|
||
} else if (c <= 2047) {
|
||
if (t + 1 >= i) break;
|
||
r[t++] = 192 | c >> 6, r[t++] = 128 | 63 & c
|
||
} else if (c <= 65535) {
|
||
if (t + 2 >= i) break;
|
||
r[t++] = 224 | c >> 12, r[t++] = 128 | c >> 6 & 63, r[t++] = 128 | 63 & c
|
||
} else {
|
||
if (t + 3 >= i) break;
|
||
r[t++] = 240 | c >> 18, r[t++] = 128 | c >> 12 & 63, r[t++] = 128 | c >> 6 & 63, r[t++] = 128 | 63 & c
|
||
}
|
||
}
|
||
return r[t] = 0, t - o
|
||
};
|
||
|
||
function tr(e, r, t) {
|
||
var n = t > 0 ? t : er(e) + 1,
|
||
o = new Array(n),
|
||
i = rr(e, o, 0, o.length);
|
||
return r && (o.length = i), o
|
||
}
|
||
var nr = function () {
|
||
if (!Qe.length) {
|
||
var e = null;
|
||
if ("undefined" != typeof window && "function" == typeof window.prompt && (null !== (e = window.prompt("Input: ")) && (e += "\n")), !e) return null;
|
||
Qe = tr(e, !0)
|
||
}
|
||
return Qe.shift()
|
||
},
|
||
or = {
|
||
ttys: [],
|
||
init: function () {},
|
||
shutdown: function () {},
|
||
register: function (e, r) {
|
||
or.ttys[e] = {
|
||
input: [],
|
||
output: [],
|
||
ops: r
|
||
}, mr.registerDevice(e, or.stream_ops)
|
||
},
|
||
stream_ops: {
|
||
open: function (e) {
|
||
var r = or.ttys[e.node.rdev];
|
||
if (!r) throw new mr.ErrnoError(43);
|
||
e.tty = r, e.seekable = !1
|
||
},
|
||
close: function (e) {
|
||
e.tty.ops.fsync(e.tty)
|
||
},
|
||
fsync: function (e) {
|
||
e.tty.ops.fsync(e.tty)
|
||
},
|
||
read: function (e, r, t, n, o) {
|
||
if (!e.tty || !e.tty.ops.get_char) throw new mr.ErrnoError(60);
|
||
for (var i = 0, a = 0; a < n; a++) {
|
||
var c;
|
||
try {
|
||
c = e.tty.ops.get_char(e.tty)
|
||
} catch (e) {
|
||
throw new mr.ErrnoError(29)
|
||
}
|
||
if (void 0 === c && 0 === i) throw new mr.ErrnoError(6);
|
||
if (null == c) break;
|
||
i++, r[t + a] = c
|
||
}
|
||
return i && (e.node.atime = Date.now()), i
|
||
},
|
||
write: function (e, r, t, n, o) {
|
||
if (!e.tty || !e.tty.ops.put_char) throw new mr.ErrnoError(60);
|
||
try {
|
||
for (var i = 0; i < n; i++) e.tty.ops.put_char(e.tty, r[t + i])
|
||
} catch (e) {
|
||
throw new mr.ErrnoError(29)
|
||
}
|
||
return n && (e.node.mtime = e.node.ctime = Date.now()), i
|
||
}
|
||
},
|
||
default_tty_ops: {
|
||
get_char: function (e) {
|
||
return nr()
|
||
},
|
||
put_char: function (e, r) {
|
||
null === r || 10 === r ? (R(xe(e.output)), e.output = []) : 0 != r && e.output.push(r)
|
||
},
|
||
fsync: function (e) {
|
||
e.output && e.output.length > 0 && (R(xe(e.output)), e.output = [])
|
||
},
|
||
ioctl_tcgets: function (e) {
|
||
return {
|
||
c_iflag: 25856,
|
||
c_oflag: 5,
|
||
c_cflag: 191,
|
||
c_lflag: 35387,
|
||
c_cc: [3, 28, 127, 21, 4, 0, 1, 0, 17, 19, 26, 0, 18, 15, 23, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
|
||
}
|
||
},
|
||
ioctl_tcsets: function (e, r, t) {
|
||
return 0
|
||
},
|
||
ioctl_tiocgwinsz: function (e) {
|
||
return [24, 80]
|
||
}
|
||
},
|
||
default_tty1_ops: {
|
||
put_char: function (e, r) {
|
||
null === r || 10 === r ? (N(xe(e.output)), e.output = []) : 0 != r && e.output.push(r)
|
||
},
|
||
fsync: function (e) {
|
||
e.output && e.output.length > 0 && (N(xe(e.output)), e.output = [])
|
||
}
|
||
}
|
||
},
|
||
ir = function (e, r) {
|
||
z.fill(0, e, e + r)
|
||
},
|
||
ar = function (e, r) {
|
||
return Math.ceil(e / r) * r
|
||
},
|
||
cr = function (e) {
|
||
e = ar(e, 65536);
|
||
var r = Ht(65536, e);
|
||
return r && ir(r, e), r
|
||
},
|
||
sr = {
|
||
ops_table: null,
|
||
mount: function (e) {
|
||
return sr.createNode(null, "/", 16895, 0)
|
||
},
|
||
createNode: function (e, r, t, n) {
|
||
if (mr.isBlkdev(t) || mr.isFIFO(t)) throw new mr.ErrnoError(63);
|
||
sr.ops_table || (sr.ops_table = {
|
||
dir: {
|
||
node: {
|
||
getattr: sr.node_ops.getattr,
|
||
setattr: sr.node_ops.setattr,
|
||
lookup: sr.node_ops.lookup,
|
||
mknod: sr.node_ops.mknod,
|
||
rename: sr.node_ops.rename,
|
||
unlink: sr.node_ops.unlink,
|
||
rmdir: sr.node_ops.rmdir,
|
||
readdir: sr.node_ops.readdir,
|
||
symlink: sr.node_ops.symlink
|
||
},
|
||
stream: {
|
||
llseek: sr.stream_ops.llseek
|
||
}
|
||
},
|
||
file: {
|
||
node: {
|
||
getattr: sr.node_ops.getattr,
|
||
setattr: sr.node_ops.setattr
|
||
},
|
||
stream: {
|
||
llseek: sr.stream_ops.llseek,
|
||
read: sr.stream_ops.read,
|
||
write: sr.stream_ops.write,
|
||
allocate: sr.stream_ops.allocate,
|
||
mmap: sr.stream_ops.mmap,
|
||
msync: sr.stream_ops.msync
|
||
}
|
||
},
|
||
link: {
|
||
node: {
|
||
getattr: sr.node_ops.getattr,
|
||
setattr: sr.node_ops.setattr,
|
||
readlink: sr.node_ops.readlink
|
||
},
|
||
stream: {}
|
||
},
|
||
chrdev: {
|
||
node: {
|
||
getattr: sr.node_ops.getattr,
|
||
setattr: sr.node_ops.setattr
|
||
},
|
||
stream: mr.chrdev_stream_ops
|
||
}
|
||
});
|
||
var o = mr.createNode(e, r, t, n);
|
||
return mr.isDir(o.mode) ? (o.node_ops = sr.ops_table.dir.node, o.stream_ops = sr.ops_table.dir.stream, o.contents = {}) : mr.isFile(o.mode) ? (o.node_ops = sr.ops_table.file.node, o.stream_ops = sr.ops_table.file.stream, o.usedBytes = 0, o.contents = null) : mr.isLink(o.mode) ? (o.node_ops = sr.ops_table.link.node, o.stream_ops = sr.ops_table.link.stream) : mr.isChrdev(o.mode) && (o.node_ops = sr.ops_table.chrdev.node, o.stream_ops = sr.ops_table.chrdev.stream), o.atime = o.mtime = o.ctime = Date.now(), e && (e.contents[r] = o, e.atime = e.mtime = e.ctime = o.atime), o
|
||
},
|
||
getFileDataAsTypedArray: function (e) {
|
||
return e.contents ? e.contents.subarray ? e.contents.subarray(0, e.usedBytes) : new Uint8Array(e.contents) : new Uint8Array(0)
|
||
},
|
||
expandFileStorage: function (e, r) {
|
||
var t = e.contents ? e.contents.length : 0;
|
||
if (!(t >= r)) {
|
||
r = Math.max(r, t * (t < 1048576 ? 2 : 1.125) >>> 0), 0 != t && (r = Math.max(r, 256));
|
||
var n = e.contents;
|
||
e.contents = new Uint8Array(r), e.usedBytes > 0 && e.contents.set(n.subarray(0, e.usedBytes), 0)
|
||
}
|
||
},
|
||
resizeFileStorage: function (e, r) {
|
||
if (e.usedBytes != r)
|
||
if (0 == r) e.contents = null, e.usedBytes = 0;
|
||
else {
|
||
var t = e.contents;
|
||
e.contents = new Uint8Array(r), t && e.contents.set(t.subarray(0, Math.min(r, e.usedBytes))), e.usedBytes = r
|
||
}
|
||
},
|
||
node_ops: {
|
||
getattr: function (e) {
|
||
var r = {};
|
||
return r.dev = mr.isChrdev(e.mode) ? e.id : 1, r.ino = e.id, r.mode = e.mode, r.nlink = 1, r.uid = 0, r.gid = 0, r.rdev = e.rdev, mr.isDir(e.mode) ? r.size = 4096 : mr.isFile(e.mode) ? r.size = e.usedBytes : mr.isLink(e.mode) ? r.size = e.link.length : r.size = 0, r.atime = new Date(e.atime), r.mtime = new Date(e.mtime), r.ctime = new Date(e.ctime), r.blksize = 4096, r.blocks = Math.ceil(r.size / r.blksize), r
|
||
},
|
||
setattr: function (e, r) {
|
||
for (var t = 0, n = ["mode", "atime", "mtime", "ctime"]; t < n.length; t++) {
|
||
var o = n[t];
|
||
r[o] && (e[o] = r[o])
|
||
}
|
||
void 0 !== r.size && sr.resizeFileStorage(e, r.size)
|
||
},
|
||
lookup: function (e, r) {
|
||
throw sr.doesNotExistError
|
||
},
|
||
mknod: function (e, r, t, n) {
|
||
return sr.createNode(e, r, t, n)
|
||
},
|
||
rename: function (e, r, t) {
|
||
var n;
|
||
try {
|
||
n = mr.lookupNode(r, t)
|
||
} catch (e) {}
|
||
if (n) {
|
||
if (mr.isDir(e.mode))
|
||
for (var o in n.contents) throw new mr.ErrnoError(55);
|
||
mr.hashRemoveNode(n)
|
||
}
|
||
delete e.parent.contents[e.name], r.contents[t] = e, e.name = t, r.ctime = r.mtime = e.parent.ctime = e.parent.mtime = Date.now()
|
||
},
|
||
unlink: function (e, r) {
|
||
delete e.contents[r], e.ctime = e.mtime = Date.now()
|
||
},
|
||
rmdir: function (e, r) {
|
||
var t = mr.lookupNode(e, r);
|
||
for (var n in t.contents) throw new mr.ErrnoError(55);
|
||
delete e.contents[r], e.ctime = e.mtime = Date.now()
|
||
},
|
||
readdir: function (e) {
|
||
return [".", ".."].concat(r(Object.keys(e.contents)))
|
||
},
|
||
symlink: function (e, r, t) {
|
||
var n = sr.createNode(e, r, 41471, 0);
|
||
return n.link = t, n
|
||
},
|
||
readlink: function (e) {
|
||
if (!mr.isLink(e.mode)) throw new mr.ErrnoError(28);
|
||
return e.link
|
||
}
|
||
},
|
||
stream_ops: {
|
||
read: function (e, r, t, n, o) {
|
||
var i = e.node.contents;
|
||
if (o >= e.node.usedBytes) return 0;
|
||
var a = Math.min(e.node.usedBytes - o, n);
|
||
if (a > 8 && i.subarray) r.set(i.subarray(o, o + a), t);
|
||
else
|
||
for (var c = 0; c < a; c++) r[t + c] = i[o + c];
|
||
return a
|
||
},
|
||
write: function (e, r, t, n, o, i) {
|
||
if (r.buffer === B.buffer && (i = !1), !n) return 0;
|
||
var a = e.node;
|
||
if (a.mtime = a.ctime = Date.now(), r.subarray && (!a.contents || a.contents.subarray)) {
|
||
if (i) return a.contents = r.subarray(t, t + n), a.usedBytes = n, n;
|
||
if (0 === a.usedBytes && 0 === o) return a.contents = r.slice(t, t + n), a.usedBytes = n, n;
|
||
if (o + n <= a.usedBytes) return a.contents.set(r.subarray(t, t + n), o), n
|
||
}
|
||
if (sr.expandFileStorage(a, o + n), a.contents.subarray && r.subarray) a.contents.set(r.subarray(t, t + n), o);
|
||
else
|
||
for (var c = 0; c < n; c++) a.contents[o + c] = r[t + c];
|
||
return a.usedBytes = Math.max(a.usedBytes, o + n), n
|
||
},
|
||
llseek: function (e, r, t) {
|
||
var n = r;
|
||
if (1 === t ? n += e.position : 2 === t && mr.isFile(e.node.mode) && (n += e.node.usedBytes), n < 0) throw new mr.ErrnoError(28);
|
||
return n
|
||
},
|
||
allocate: function (e, r, t) {
|
||
sr.expandFileStorage(e.node, r + t), e.node.usedBytes = Math.max(e.node.usedBytes, r + t)
|
||
},
|
||
mmap: function (e, r, t, n, o) {
|
||
if (!mr.isFile(e.node.mode)) throw new mr.ErrnoError(43);
|
||
var i, a, c = e.node.contents;
|
||
if (2 & o || !c || c.buffer !== B.buffer) {
|
||
if (a = !0, !(i = cr(r))) throw new mr.ErrnoError(48);
|
||
c && ((t > 0 || t + r < c.length) && (c = c.subarray ? c.subarray(t, t + r) : Array.prototype.slice.call(c, t, t + r)), B.set(c, i))
|
||
} else a = !1, i = c.byteOffset;
|
||
return {
|
||
ptr: i,
|
||
allocated: a
|
||
}
|
||
},
|
||
msync: function (e, r, t, n, o) {
|
||
return sr.stream_ops.write(e, r, 0, n, t, !1), 0
|
||
}
|
||
}
|
||
},
|
||
ur = function () {
|
||
var e = a(i().mark((function e(r) {
|
||
var t;
|
||
return i().wrap((function (e) {
|
||
for (;;) switch (e.prev = e.next) {
|
||
case 0:
|
||
return e.next = 2, x(r);
|
||
case 2:
|
||
return t = e.sent, e.abrupt("return", new Uint8Array(t));
|
||
case 4:
|
||
case "end":
|
||
return e.stop()
|
||
}
|
||
}), e)
|
||
})));
|
||
return function (r) {
|
||
return e.apply(this, arguments)
|
||
}
|
||
}(),
|
||
fr = function (e, r, t, n, o, i) {
|
||
mr.createDataFile(e, r, t, n, o, i)
|
||
},
|
||
lr = d.preloadPlugins || [],
|
||
dr = function (e, r, t, n) {
|
||
"undefined" != typeof Browser && Browser.init();
|
||
var o = !1;
|
||
return lr.forEach((function (i) {
|
||
o || i.canHandle(r) && (i.handle(e, r, t, n), o = !0)
|
||
})), o
|
||
},
|
||
hr = function (e, r, t, n, o, i, a, c, s, u) {
|
||
var f = r ? $e.resolve(Ge.join2(e, r)) : e;
|
||
"cp ".concat(f);
|
||
|
||
function l(t) {
|
||
function l(t) {
|
||
null != u && u(), c || fr(e, r, t, n, o, s), null != i && i(), ce()
|
||
}
|
||
dr(t, f, l, (function () {
|
||
null != a && a(), ce()
|
||
})) || l(t)
|
||
}
|
||
ae(), "string" == typeof t ? ur(t).then(l, a) : l(t)
|
||
},
|
||
vr = function (e) {
|
||
var r = {
|
||
r: 0,
|
||
"r+": 2,
|
||
w: 577,
|
||
"w+": 578,
|
||
a: 1089,
|
||
"a+": 1090
|
||
} [e];
|
||
if (void 0 === r) throw new Error("Unknown file open mode: ".concat(e));
|
||
return r
|
||
},
|
||
pr = function (e, r) {
|
||
var t = 0;
|
||
return e && (t |= 365), r && (t |= 146), t
|
||
},
|
||
mr = {
|
||
root: null,
|
||
mounts: [],
|
||
devices: {},
|
||
streams: [],
|
||
nextInode: 1,
|
||
nameTable: null,
|
||
currentPath: "/",
|
||
initialized: !1,
|
||
ignorePermissions: !0,
|
||
ErrnoError: n((function e(r) {
|
||
o(this, e), this.name = "ErrnoError", this.errno = r
|
||
})),
|
||
filesystems: null,
|
||
syncFSRequests: 0,
|
||
readFiles: {},
|
||
FSStream: function () {
|
||
return n((function e() {
|
||
o(this, e), this.shared = {}
|
||
}), [{
|
||
key: "object",
|
||
get: function () {
|
||
return this.node
|
||
},
|
||
set: function (e) {
|
||
this.node = e
|
||
}
|
||
}, {
|
||
key: "isRead",
|
||
get: function () {
|
||
return 1 != (2097155 & this.flags)
|
||
}
|
||
}, {
|
||
key: "isWrite",
|
||
get: function () {
|
||
return 0 != (2097155 & this.flags)
|
||
}
|
||
}, {
|
||
key: "isAppend",
|
||
get: function () {
|
||
return 1024 & this.flags
|
||
}
|
||
}, {
|
||
key: "flags",
|
||
get: function () {
|
||
return this.shared.flags
|
||
},
|
||
set: function (e) {
|
||
this.shared.flags = e
|
||
}
|
||
}, {
|
||
key: "position",
|
||
get: function () {
|
||
return this.shared.position
|
||
},
|
||
set: function (e) {
|
||
this.shared.position = e
|
||
}
|
||
}])
|
||
}(),
|
||
FSNode: function () {
|
||
return n((function e(r, t, n, i) {
|
||
o(this, e), this.node_ops = {}, this.stream_ops = {}, this.readMode = 365, this.writeMode = 146, this.mounted = null, r || (r = this), this.parent = r, this.mount = r.mount, this.id = mr.nextInode++, this.name = t, this.mode = n, this.rdev = i, this.atime = this.mtime = this.ctime = Date.now()
|
||
}), [{
|
||
key: "read",
|
||
get: function () {
|
||
return (this.mode & this.readMode) === this.readMode
|
||
},
|
||
set: function (e) {
|
||
e ? this.mode |= this.readMode : this.mode &= ~this.readMode
|
||
}
|
||
}, {
|
||
key: "write",
|
||
get: function () {
|
||
return (this.mode & this.writeMode) === this.writeMode
|
||
},
|
||
set: function (e) {
|
||
e ? this.mode |= this.writeMode : this.mode &= ~this.writeMode
|
||
}
|
||
}, {
|
||
key: "isFolder",
|
||
get: function () {
|
||
return mr.isDir(this.mode)
|
||
}
|
||
}, {
|
||
key: "isDevice",
|
||
get: function () {
|
||
return mr.isChrdev(this.mode)
|
||
}
|
||
}])
|
||
}(),
|
||
lookupPath: function (e) {
|
||
var r, t = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
|
||
if (!e) return {
|
||
path: "",
|
||
node: null
|
||
};
|
||
null !== (r = t.follow_mount) && void 0 !== r || (t.follow_mount = !0), Ge.isAbs(e) || (e = mr.cwd() + "/" + e);
|
||
e: for (var n = 0; n < 40; n++) {
|
||
for (var o = e.split("/").filter((function (e) {
|
||
return !!e && "." !== e
|
||
})), i = mr.root, a = "/", c = 0; c < o.length; c++) {
|
||
var s = c === o.length - 1;
|
||
if (s && t.parent) break;
|
||
if (".." !== o[c]) {
|
||
a = Ge.join2(a, o[c]);
|
||
try {
|
||
i = mr.lookupNode(i, o[c])
|
||
} catch (e) {
|
||
if (44 === (null == e ? void 0 : e.errno) && s && t.noent_okay) return {
|
||
path: a
|
||
};
|
||
throw e
|
||
}
|
||
if (!mr.isMountpoint(i) || s && !t.follow_mount || (i = i.mounted.root), mr.isLink(i.mode) && (!s || t.follow)) {
|
||
if (!i.node_ops.readlink) throw new mr.ErrnoError(52);
|
||
var u = i.node_ops.readlink(i);
|
||
Ge.isAbs(u) || (u = Ge.dirname(a) + "/" + u), e = u + "/" + o.slice(c + 1).join("/");
|
||
continue e
|
||
}
|
||
} else a = Ge.dirname(a), i = i.parent
|
||
}
|
||
return {
|
||
path: a,
|
||
node: i
|
||
}
|
||
}
|
||
throw new mr.ErrnoError(32)
|
||
},
|
||
getPath: function (e) {
|
||
for (var r;;) {
|
||
if (mr.isRoot(e)) {
|
||
var t = e.mount.mountpoint;
|
||
return r ? "/" !== t[t.length - 1] ? "".concat(t, "/").concat(r) : t + r : t
|
||
}
|
||
r = r ? "".concat(e.name, "/").concat(r) : e.name, e = e.parent
|
||
}
|
||
},
|
||
hashName: function (e, r) {
|
||
for (var t = 0, n = 0; n < r.length; n++) t = (t << 5) - t + r.charCodeAt(n) | 0;
|
||
return (e + t >>> 0) % mr.nameTable.length
|
||
},
|
||
hashAddNode: function (e) {
|
||
var r = mr.hashName(e.parent.id, e.name);
|
||
e.name_next = mr.nameTable[r], mr.nameTable[r] = e
|
||
},
|
||
hashRemoveNode: function (e) {
|
||
var r = mr.hashName(e.parent.id, e.name);
|
||
if (mr.nameTable[r] === e) mr.nameTable[r] = e.name_next;
|
||
else
|
||
for (var t = mr.nameTable[r]; t;) {
|
||
if (t.name_next === e) {
|
||
t.name_next = e.name_next;
|
||
break
|
||
}
|
||
t = t.name_next
|
||
}
|
||
},
|
||
lookupNode: function (e, r) {
|
||
var t = mr.mayLookup(e);
|
||
if (t) throw new mr.ErrnoError(t);
|
||
for (var n = mr.hashName(e.id, r), o = mr.nameTable[n]; o; o = o.name_next) {
|
||
var i = o.name;
|
||
if (o.parent.id === e.id && i === r) return o
|
||
}
|
||
return mr.lookup(e, r)
|
||
},
|
||
createNode: function (e, r, t, n) {
|
||
var o = new mr.FSNode(e, r, t, n);
|
||
return mr.hashAddNode(o), o
|
||
},
|
||
destroyNode: function (e) {
|
||
mr.hashRemoveNode(e)
|
||
},
|
||
isRoot: function (e) {
|
||
return e === e.parent
|
||
},
|
||
isMountpoint: function (e) {
|
||
return !!e.mounted
|
||
},
|
||
isFile: function (e) {
|
||
return 32768 == (61440 & e)
|
||
},
|
||
isDir: function (e) {
|
||
return 16384 == (61440 & e)
|
||
},
|
||
isLink: function (e) {
|
||
return 40960 == (61440 & e)
|
||
},
|
||
isChrdev: function (e) {
|
||
return 8192 == (61440 & e)
|
||
},
|
||
isBlkdev: function (e) {
|
||
return 24576 == (61440 & e)
|
||
},
|
||
isFIFO: function (e) {
|
||
return 4096 == (61440 & e)
|
||
},
|
||
isSocket: function (e) {
|
||
return 49152 == (49152 & e)
|
||
},
|
||
flagsToPermissionString: function (e) {
|
||
var r = ["r", "w", "rw"][3 & e];
|
||
return 512 & e && (r += "w"), r
|
||
},
|
||
nodePermissions: function (e, r) {
|
||
return mr.ignorePermissions || (!r.includes("r") || 292 & e.mode) && (!r.includes("w") || 146 & e.mode) && (!r.includes("x") || 73 & e.mode) ? 0 : 2
|
||
},
|
||
mayLookup: function (e) {
|
||
return mr.isDir(e.mode) ? mr.nodePermissions(e, "x") || (e.node_ops.lookup ? 0 : 2) : 54
|
||
},
|
||
mayCreate: function (e, r) {
|
||
if (!mr.isDir(e.mode)) return 54;
|
||
try {
|
||
return mr.lookupNode(e, r), 20
|
||
} catch (e) {}
|
||
return mr.nodePermissions(e, "wx")
|
||
},
|
||
mayDelete: function (e, r, t) {
|
||
var n;
|
||
try {
|
||
n = mr.lookupNode(e, r)
|
||
} catch (e) {
|
||
return e.errno
|
||
}
|
||
var o = mr.nodePermissions(e, "wx");
|
||
if (o) return o;
|
||
if (t) {
|
||
if (!mr.isDir(n.mode)) return 54;
|
||
if (mr.isRoot(n) || mr.getPath(n) === mr.cwd()) return 10
|
||
} else if (mr.isDir(n.mode)) return 31;
|
||
return 0
|
||
},
|
||
mayOpen: function (e, r) {
|
||
return e ? mr.isLink(e.mode) ? 32 : mr.isDir(e.mode) && ("r" !== mr.flagsToPermissionString(r) || 512 & r) ? 31 : mr.nodePermissions(e, mr.flagsToPermissionString(r)) : 44
|
||
},
|
||
MAX_OPEN_FDS: 4096,
|
||
nextfd: function () {
|
||
for (var e = 0; e <= mr.MAX_OPEN_FDS; e++)
|
||
if (!mr.streams[e]) return e;
|
||
throw new mr.ErrnoError(33)
|
||
},
|
||
getStreamChecked: function (e) {
|
||
var r = mr.getStream(e);
|
||
if (!r) throw new mr.ErrnoError(8);
|
||
return r
|
||
},
|
||
getStream: function (e) {
|
||
return mr.streams[e]
|
||
},
|
||
createStream: function (e) {
|
||
var r = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : -1;
|
||
return e = Object.assign(new mr.FSStream, e), -1 == r && (r = mr.nextfd()), e.fd = r, mr.streams[r] = e, e
|
||
},
|
||
closeStream: function (e) {
|
||
mr.streams[e] = null
|
||
},
|
||
dupStream: function (e) {
|
||
var r, t, n = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : -1,
|
||
o = mr.createStream(e, n);
|
||
return null !== (r = o.stream_ops) && void 0 !== r && null !== (t = r.dup) && void 0 !== t && t.call(r, o), o
|
||
},
|
||
chrdev_stream_ops: {
|
||
open: function (e) {
|
||
var r, t, n = mr.getDevice(e.node.rdev);
|
||
e.stream_ops = n.stream_ops, null === (r = (t = e.stream_ops).open) || void 0 === r || r.call(t, e)
|
||
},
|
||
llseek: function () {
|
||
throw new mr.ErrnoError(70)
|
||
}
|
||
},
|
||
major: function (e) {
|
||
return e >> 8
|
||
},
|
||
minor: function (e) {
|
||
return 255 & e
|
||
},
|
||
makedev: function (e, r) {
|
||
return e << 8 | r
|
||
},
|
||
registerDevice: function (e, r) {
|
||
mr.devices[e] = {
|
||
stream_ops: r
|
||
}
|
||
},
|
||
getDevice: function (e) {
|
||
return mr.devices[e]
|
||
},
|
||
getMounts: function (e) {
|
||
for (var t = [], n = [e]; n.length;) {
|
||
var o = n.pop();
|
||
t.push(o), n.push.apply(n, r(o.mounts))
|
||
}
|
||
return t
|
||
},
|
||
syncfs: function (e, r) {
|
||
"function" == typeof e && (r = e, e = !1), mr.syncFSRequests++, mr.syncFSRequests > 1 && N("warning: ".concat(mr.syncFSRequests, " FS.syncfs operations in flight at once, probably just doing extra work"));
|
||
var t = mr.getMounts(mr.root.mount),
|
||
n = 0;
|
||
|
||
function o(e) {
|
||
return mr.syncFSRequests--, r(e)
|
||
}
|
||
|
||
function i(e) {
|
||
if (e) return i.errored ? void 0 : (i.errored = !0, o(e));
|
||
++n >= t.length && o(null)
|
||
}
|
||
t.forEach((function (r) {
|
||
if (!r.type.syncfs) return i(null);
|
||
r.type.syncfs(r, e, i)
|
||
}))
|
||
},
|
||
mount: function (e, r, t) {
|
||
var n, o = "/" === t,
|
||
i = !t;
|
||
if (o && mr.root) throw new mr.ErrnoError(10);
|
||
if (!o && !i) {
|
||
var a = mr.lookupPath(t, {
|
||
follow_mount: !1
|
||
});
|
||
if (t = a.path, n = a.node, mr.isMountpoint(n)) throw new mr.ErrnoError(10);
|
||
if (!mr.isDir(n.mode)) throw new mr.ErrnoError(54)
|
||
}
|
||
var c = {
|
||
type: e,
|
||
opts: r,
|
||
mountpoint: t,
|
||
mounts: []
|
||
},
|
||
s = e.mount(c);
|
||
return s.mount = c, c.root = s, o ? mr.root = s : n && (n.mounted = c, n.mount && n.mount.mounts.push(c)), s
|
||
},
|
||
unmount: function (e) {
|
||
var r = mr.lookupPath(e, {
|
||
follow_mount: !1
|
||
});
|
||
if (!mr.isMountpoint(r.node)) throw new mr.ErrnoError(28);
|
||
var t = r.node,
|
||
n = t.mounted,
|
||
o = mr.getMounts(n);
|
||
Object.keys(mr.nameTable).forEach((function (e) {
|
||
for (var r = mr.nameTable[e]; r;) {
|
||
var t = r.name_next;
|
||
o.includes(r.mount) && mr.destroyNode(r), r = t
|
||
}
|
||
})), t.mounted = null;
|
||
var i = t.mount.mounts.indexOf(n);
|
||
t.mount.mounts.splice(i, 1)
|
||
},
|
||
lookup: function (e, r) {
|
||
return e.node_ops.lookup(e, r)
|
||
},
|
||
mknod: function (e, r, t) {
|
||
var n = mr.lookupPath(e, {
|
||
parent: !0
|
||
}).node,
|
||
o = Ge.basename(e);
|
||
if (!o || "." === o || ".." === o) throw new mr.ErrnoError(28);
|
||
var i = mr.mayCreate(n, o);
|
||
if (i) throw new mr.ErrnoError(i);
|
||
if (!n.node_ops.mknod) throw new mr.ErrnoError(63);
|
||
return n.node_ops.mknod(n, o, r, t)
|
||
},
|
||
statfs: function (e) {
|
||
var r = {
|
||
bsize: 4096,
|
||
frsize: 4096,
|
||
blocks: 1e6,
|
||
bfree: 5e5,
|
||
bavail: 5e5,
|
||
files: mr.nextInode,
|
||
ffree: mr.nextInode - 1,
|
||
fsid: 42,
|
||
flags: 2,
|
||
namelen: 255
|
||
},
|
||
t = mr.lookupPath(e, {
|
||
follow: !0
|
||
}).node;
|
||
return null != t && t.node_ops.statfs && Object.assign(r, t.node_ops.statfs(t.mount.opts.root)), r
|
||
},
|
||
create: function (e) {
|
||
var r = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 438;
|
||
return r &= 4095, r |= 32768, mr.mknod(e, r, 0)
|
||
},
|
||
mkdir: function (e) {
|
||
var r = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 511;
|
||
return r &= 1023, r |= 16384, mr.mknod(e, r, 0)
|
||
},
|
||
mkdirTree: function (e, r) {
|
||
for (var t = e.split("/"), n = "", o = 0; o < t.length; ++o)
|
||
if (t[o]) {
|
||
n += "/" + t[o];
|
||
try {
|
||
mr.mkdir(n, r)
|
||
} catch (e) {
|
||
if (20 != e.errno) throw e
|
||
}
|
||
}
|
||
},
|
||
mkdev: function (e, r, t) {
|
||
return void 0 === t && (t = r, r = 438), r |= 8192, mr.mknod(e, r, t)
|
||
},
|
||
symlink: function (e, r) {
|
||
if (!$e.resolve(e)) throw new mr.ErrnoError(44);
|
||
var t = mr.lookupPath(r, {
|
||
parent: !0
|
||
}).node;
|
||
if (!t) throw new mr.ErrnoError(44);
|
||
var n = Ge.basename(r),
|
||
o = mr.mayCreate(t, n);
|
||
if (o) throw new mr.ErrnoError(o);
|
||
if (!t.node_ops.symlink) throw new mr.ErrnoError(63);
|
||
return t.node_ops.symlink(t, n, e)
|
||
},
|
||
rename: function (e, r) {
|
||
var t, n, o = Ge.dirname(e),
|
||
i = Ge.dirname(r),
|
||
a = Ge.basename(e),
|
||
c = Ge.basename(r);
|
||
if (t = mr.lookupPath(e, {
|
||
parent: !0
|
||
}).node, n = mr.lookupPath(r, {
|
||
parent: !0
|
||
}).node, !t || !n) throw new mr.ErrnoError(44);
|
||
if (t.mount !== n.mount) throw new mr.ErrnoError(75);
|
||
var s, u = mr.lookupNode(t, a),
|
||
f = $e.relative(e, i);
|
||
if ("." !== f.charAt(0)) throw new mr.ErrnoError(28);
|
||
if ("." !== (f = $e.relative(r, o)).charAt(0)) throw new mr.ErrnoError(55);
|
||
try {
|
||
s = mr.lookupNode(n, c)
|
||
} catch (e) {}
|
||
if (u !== s) {
|
||
var l = mr.isDir(u.mode),
|
||
d = mr.mayDelete(t, a, l);
|
||
if (d) throw new mr.ErrnoError(d);
|
||
if (d = s ? mr.mayDelete(n, c, l) : mr.mayCreate(n, c)) throw new mr.ErrnoError(d);
|
||
if (!t.node_ops.rename) throw new mr.ErrnoError(63);
|
||
if (mr.isMountpoint(u) || s && mr.isMountpoint(s)) throw new mr.ErrnoError(10);
|
||
if (n !== t && (d = mr.nodePermissions(t, "w"))) throw new mr.ErrnoError(d);
|
||
mr.hashRemoveNode(u);
|
||
try {
|
||
t.node_ops.rename(u, n, c), u.parent = n
|
||
} catch (e) {
|
||
throw e
|
||
} finally {
|
||
mr.hashAddNode(u)
|
||
}
|
||
}
|
||
},
|
||
rmdir: function (e) {
|
||
var r = mr.lookupPath(e, {
|
||
parent: !0
|
||
}).node,
|
||
t = Ge.basename(e),
|
||
n = mr.lookupNode(r, t),
|
||
o = mr.mayDelete(r, t, !0);
|
||
if (o) throw new mr.ErrnoError(o);
|
||
if (!r.node_ops.rmdir) throw new mr.ErrnoError(63);
|
||
if (mr.isMountpoint(n)) throw new mr.ErrnoError(10);
|
||
r.node_ops.rmdir(r, t), mr.destroyNode(n)
|
||
},
|
||
readdir: function (e) {
|
||
var r = mr.lookupPath(e, {
|
||
follow: !0
|
||
}).node;
|
||
if (!r.node_ops.readdir) throw new mr.ErrnoError(54);
|
||
return r.node_ops.readdir(r)
|
||
},
|
||
unlink: function (e) {
|
||
var r = mr.lookupPath(e, {
|
||
parent: !0
|
||
}).node;
|
||
if (!r) throw new mr.ErrnoError(44);
|
||
var t = Ge.basename(e),
|
||
n = mr.lookupNode(r, t),
|
||
o = mr.mayDelete(r, t, !1);
|
||
if (o) throw new mr.ErrnoError(o);
|
||
if (!r.node_ops.unlink) throw new mr.ErrnoError(63);
|
||
if (mr.isMountpoint(n)) throw new mr.ErrnoError(10);
|
||
r.node_ops.unlink(r, t), mr.destroyNode(n)
|
||
},
|
||
readlink: function (e) {
|
||
var r = mr.lookupPath(e).node;
|
||
if (!r) throw new mr.ErrnoError(44);
|
||
if (!r.node_ops.readlink) throw new mr.ErrnoError(28);
|
||
return r.node_ops.readlink(r)
|
||
},
|
||
stat: function (e, r) {
|
||
var t = mr.lookupPath(e, {
|
||
follow: !r
|
||
}).node;
|
||
if (!t) throw new mr.ErrnoError(44);
|
||
if (!t.node_ops.getattr) throw new mr.ErrnoError(63);
|
||
return t.node_ops.getattr(t)
|
||
},
|
||
lstat: function (e) {
|
||
return mr.stat(e, !0)
|
||
},
|
||
chmod: function (e, r, t) {
|
||
var n;
|
||
"string" == typeof e ? n = mr.lookupPath(e, {
|
||
follow: !t
|
||
}).node : n = e;
|
||
if (!n.node_ops.setattr) throw new mr.ErrnoError(63);
|
||
n.node_ops.setattr(n, {
|
||
mode: 4095 & r | -4096 & n.mode,
|
||
ctime: Date.now()
|
||
})
|
||
},
|
||
lchmod: function (e, r) {
|
||
mr.chmod(e, r, !0)
|
||
},
|
||
fchmod: function (e, r) {
|
||
var t = mr.getStreamChecked(e);
|
||
mr.chmod(t.node, r)
|
||
},
|
||
chown: function (e, r, t, n) {
|
||
var o;
|
||
"string" == typeof e ? o = mr.lookupPath(e, {
|
||
follow: !n
|
||
}).node : o = e;
|
||
if (!o.node_ops.setattr) throw new mr.ErrnoError(63);
|
||
o.node_ops.setattr(o, {
|
||
timestamp: Date.now()
|
||
})
|
||
},
|
||
lchown: function (e, r, t) {
|
||
mr.chown(e, r, t, !0)
|
||
},
|
||
fchown: function (e, r, t) {
|
||
var n = mr.getStreamChecked(e);
|
||
mr.chown(n.node, r, t)
|
||
},
|
||
truncate: function (e, r) {
|
||
if (r < 0) throw new mr.ErrnoError(28);
|
||
var t;
|
||
"string" == typeof e ? t = mr.lookupPath(e, {
|
||
follow: !0
|
||
}).node : t = e;
|
||
if (!t.node_ops.setattr) throw new mr.ErrnoError(63);
|
||
if (mr.isDir(t.mode)) throw new mr.ErrnoError(31);
|
||
if (!mr.isFile(t.mode)) throw new mr.ErrnoError(28);
|
||
var n = mr.nodePermissions(t, "w");
|
||
if (n) throw new mr.ErrnoError(n);
|
||
t.node_ops.setattr(t, {
|
||
size: r,
|
||
timestamp: Date.now()
|
||
})
|
||
},
|
||
ftruncate: function (e, r) {
|
||
var t = mr.getStreamChecked(e);
|
||
if (0 == (2097155 & t.flags)) throw new mr.ErrnoError(28);
|
||
mr.truncate(t.node, r)
|
||
},
|
||
utime: function (e, r, t) {
|
||
var n = mr.lookupPath(e, {
|
||
follow: !0
|
||
}).node;
|
||
n.node_ops.setattr(n, {
|
||
atime: r,
|
||
mtime: t
|
||
})
|
||
},
|
||
open: function (e, r) {
|
||
var t, n = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : 438;
|
||
if ("" === e) throw new mr.ErrnoError(44);
|
||
if (n = 64 & (r = "string" == typeof r ? vr(r) : r) ? 4095 & n | 32768 : 0, "object" == c(e)) t = e;
|
||
else {
|
||
var o = mr.lookupPath(e, {
|
||
follow: !(131072 & r),
|
||
noent_okay: !0
|
||
});
|
||
t = o.node, e = o.path
|
||
}
|
||
var i = !1;
|
||
if (64 & r)
|
||
if (t) {
|
||
if (128 & r) throw new mr.ErrnoError(20)
|
||
} else t = mr.mknod(e, n, 0), i = !0;
|
||
if (!t) throw new mr.ErrnoError(44);
|
||
if (mr.isChrdev(t.mode) && (r &= -513), 65536 & r && !mr.isDir(t.mode)) throw new mr.ErrnoError(54);
|
||
if (!i) {
|
||
var a = mr.mayOpen(t, r);
|
||
if (a) throw new mr.ErrnoError(a)
|
||
}
|
||
512 & r && !i && mr.truncate(t, 0), r &= -131713;
|
||
var s = mr.createStream({
|
||
node: t,
|
||
path: mr.getPath(t),
|
||
flags: r,
|
||
seekable: !0,
|
||
position: 0,
|
||
stream_ops: t.stream_ops,
|
||
ungotten: [],
|
||
error: !1
|
||
});
|
||
return s.stream_ops.open && s.stream_ops.open(s), !d.logReadFiles || 1 & r || e in mr.readFiles || (mr.readFiles[e] = 1), s
|
||
},
|
||
close: function (e) {
|
||
if (mr.isClosed(e)) throw new mr.ErrnoError(8);
|
||
e.getdents && (e.getdents = null);
|
||
try {
|
||
e.stream_ops.close && e.stream_ops.close(e)
|
||
} catch (e) {
|
||
throw e
|
||
} finally {
|
||
mr.closeStream(e.fd)
|
||
}
|
||
e.fd = null
|
||
},
|
||
isClosed: function (e) {
|
||
return null === e.fd
|
||
},
|
||
llseek: function (e, r, t) {
|
||
if (mr.isClosed(e)) throw new mr.ErrnoError(8);
|
||
if (!e.seekable || !e.stream_ops.llseek) throw new mr.ErrnoError(70);
|
||
if (0 != t && 1 != t && 2 != t) throw new mr.ErrnoError(28);
|
||
return e.position = e.stream_ops.llseek(e, r, t), e.ungotten = [], e.position
|
||
},
|
||
read: function (e, r, t, n, o) {
|
||
if (n < 0 || o < 0) throw new mr.ErrnoError(28);
|
||
if (mr.isClosed(e)) throw new mr.ErrnoError(8);
|
||
if (1 == (2097155 & e.flags)) throw new mr.ErrnoError(8);
|
||
if (mr.isDir(e.node.mode)) throw new mr.ErrnoError(31);
|
||
if (!e.stream_ops.read) throw new mr.ErrnoError(28);
|
||
var i = void 0 !== o;
|
||
if (i) {
|
||
if (!e.seekable) throw new mr.ErrnoError(70)
|
||
} else o = e.position;
|
||
var a = e.stream_ops.read(e, r, t, n, o);
|
||
return i || (e.position += a), a
|
||
},
|
||
write: function (e, r, t, n, o, i) {
|
||
if (n < 0 || o < 0) throw new mr.ErrnoError(28);
|
||
if (mr.isClosed(e)) throw new mr.ErrnoError(8);
|
||
if (0 == (2097155 & e.flags)) throw new mr.ErrnoError(8);
|
||
if (mr.isDir(e.node.mode)) throw new mr.ErrnoError(31);
|
||
if (!e.stream_ops.write) throw new mr.ErrnoError(28);
|
||
e.seekable && 1024 & e.flags && mr.llseek(e, 0, 2);
|
||
var a = void 0 !== o;
|
||
if (a) {
|
||
if (!e.seekable) throw new mr.ErrnoError(70)
|
||
} else o = e.position;
|
||
var c = e.stream_ops.write(e, r, t, n, o, i);
|
||
return a || (e.position += c), c
|
||
},
|
||
allocate: function (e, r, t) {
|
||
if (mr.isClosed(e)) throw new mr.ErrnoError(8);
|
||
if (r < 0 || t <= 0) throw new mr.ErrnoError(28);
|
||
if (0 == (2097155 & e.flags)) throw new mr.ErrnoError(8);
|
||
if (!mr.isFile(e.node.mode) && !mr.isDir(e.node.mode)) throw new mr.ErrnoError(43);
|
||
if (!e.stream_ops.allocate) throw new mr.ErrnoError(138);
|
||
e.stream_ops.allocate(e, r, t)
|
||
},
|
||
mmap: function (e, r, t, n, o) {
|
||
if (0 != (2 & n) && 0 == (2 & o) && 2 != (2097155 & e.flags)) throw new mr.ErrnoError(2);
|
||
if (1 == (2097155 & e.flags)) throw new mr.ErrnoError(2);
|
||
if (!e.stream_ops.mmap) throw new mr.ErrnoError(43);
|
||
if (!r) throw new mr.ErrnoError(28);
|
||
return e.stream_ops.mmap(e, r, t, n, o)
|
||
},
|
||
msync: function (e, r, t, n, o) {
|
||
return e.stream_ops.msync ? e.stream_ops.msync(e, r, t, n, o) : 0
|
||
},
|
||
ioctl: function (e, r, t) {
|
||
if (!e.stream_ops.ioctl) throw new mr.ErrnoError(59);
|
||
return e.stream_ops.ioctl(e, r, t)
|
||
},
|
||
readFile: function (e) {
|
||
var r = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
|
||
if (r.flags = r.flags || 0, r.encoding = r.encoding || "binary", "utf8" !== r.encoding && "binary" !== r.encoding) throw new Error('Invalid encoding type "'.concat(r.encoding, '"'));
|
||
var t, n = mr.open(e, r.flags),
|
||
o = mr.stat(e),
|
||
i = o.size,
|
||
a = new Uint8Array(i);
|
||
return mr.read(n, a, 0, i, 0), "utf8" === r.encoding ? t = xe(a) : "binary" === r.encoding && (t = a), mr.close(n), t
|
||
},
|
||
writeFile: function (e, r) {
|
||
var t = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
|
||
t.flags = t.flags || 577;
|
||
var n = mr.open(e, t.flags, t.mode);
|
||
if ("string" == typeof r) {
|
||
var o = new Uint8Array(er(r) + 1),
|
||
i = rr(r, o, 0, o.length);
|
||
mr.write(n, o, 0, i, void 0, t.canOwn)
|
||
} else {
|
||
if (!ArrayBuffer.isView(r)) throw new Error("Unsupported data type");
|
||
mr.write(n, r, 0, r.byteLength, void 0, t.canOwn)
|
||
}
|
||
mr.close(n)
|
||
},
|
||
cwd: function () {
|
||
return mr.currentPath
|
||
},
|
||
chdir: function (e) {
|
||
var r = mr.lookupPath(e, {
|
||
follow: !0
|
||
});
|
||
if (null === r.node) throw new mr.ErrnoError(44);
|
||
if (!mr.isDir(r.node.mode)) throw new mr.ErrnoError(54);
|
||
var t = mr.nodePermissions(r.node, "x");
|
||
if (t) throw new mr.ErrnoError(t);
|
||
mr.currentPath = r.path
|
||
},
|
||
createDefaultDirectories: function () {
|
||
mr.mkdir("/tmp"), mr.mkdir("/home"), mr.mkdir("/home/web_user")
|
||
},
|
||
createDefaultDevices: function () {
|
||
mr.mkdir("/dev"), mr.registerDevice(mr.makedev(1, 3), {
|
||
read: function () {
|
||
return 0
|
||
},
|
||
write: function (e, r, t, n, o) {
|
||
return n
|
||
},
|
||
llseek: function () {
|
||
return 0
|
||
}
|
||
}), mr.mkdev("/dev/null", mr.makedev(1, 3)), or.register(mr.makedev(5, 0), or.default_tty_ops), or.register(mr.makedev(6, 0), or.default_tty1_ops), mr.mkdev("/dev/tty", mr.makedev(5, 0)), mr.mkdev("/dev/tty1", mr.makedev(6, 0));
|
||
var e = new Uint8Array(1024),
|
||
r = 0,
|
||
t = function () {
|
||
return 0 === r && (r = Ye(e).byteLength), e[--r]
|
||
};
|
||
mr.createDevice("/dev", "random", t), mr.createDevice("/dev", "urandom", t), mr.mkdir("/dev/shm"), mr.mkdir("/dev/shm/tmp")
|
||
},
|
||
createSpecialDirectories: function () {
|
||
mr.mkdir("/proc");
|
||
var r = mr.mkdir("/proc/self");
|
||
mr.mkdir("/proc/self/fd"), mr.mount({
|
||
mount: function () {
|
||
var t = mr.createNode(r, "fd", 16895, 73);
|
||
return t.stream_ops = {
|
||
llseek: sr.stream_ops.llseek
|
||
}, t.node_ops = {
|
||
lookup: function (e, r) {
|
||
var t = +r,
|
||
n = mr.getStreamChecked(t),
|
||
o = {
|
||
parent: null,
|
||
mount: {
|
||
mountpoint: "fake"
|
||
},
|
||
node_ops: {
|
||
readlink: function () {
|
||
return n.path
|
||
}
|
||
},
|
||
id: t + 1
|
||
};
|
||
return o.parent = o, o
|
||
},
|
||
readdir: function () {
|
||
return Array.from(mr.streams.entries()).filter((function (r) {
|
||
var t = e(r, 2);
|
||
t[0];
|
||
return t[1]
|
||
})).map((function (r) {
|
||
var t = e(r, 2),
|
||
n = t[0];
|
||
t[1];
|
||
return n.toString()
|
||
}))
|
||
}
|
||
}, t
|
||
}
|
||
}, {}, "/proc/self/fd")
|
||
},
|
||
createStandardStreams: function (e, r, t) {
|
||
e ? mr.createDevice("/dev", "stdin", e) : mr.symlink("/dev/tty", "/dev/stdin"), r ? mr.createDevice("/dev", "stdout", null, r) : mr.symlink("/dev/tty", "/dev/stdout"), t ? mr.createDevice("/dev", "stderr", null, t) : mr.symlink("/dev/tty1", "/dev/stderr"), mr.open("/dev/stdin", 0), mr.open("/dev/stdout", 1), mr.open("/dev/stderr", 1)
|
||
},
|
||
staticInit: function () {
|
||
mr.nameTable = new Array(4096), mr.mount(sr, {}, "/"), mr.createDefaultDirectories(), mr.createDefaultDevices(), mr.createSpecialDirectories(), mr.filesystems = {
|
||
MEMFS: sr
|
||
}
|
||
},
|
||
init: function (e, r, t) {
|
||
var n, o, i;
|
||
mr.initialized = !0, null !== (n = e) && void 0 !== n || (e = d.stdin), null !== (o = r) && void 0 !== o || (r = d.stdout), null !== (i = t) && void 0 !== i || (t = d.stderr), mr.createStandardStreams(e, r, t)
|
||
},
|
||
quit: function () {
|
||
mr.initialized = !1;
|
||
for (var e = 0; e < mr.streams.length; e++) {
|
||
var r = mr.streams[e];
|
||
r && mr.close(r)
|
||
}
|
||
},
|
||
findObject: function (e, r) {
|
||
var t = mr.analyzePath(e, r);
|
||
return t.exists ? t.object : null
|
||
},
|
||
analyzePath: function (e, r) {
|
||
try {
|
||
var t = mr.lookupPath(e, {
|
||
follow: !r
|
||
});
|
||
e = t.path
|
||
} catch (e) {}
|
||
var n = {
|
||
isRoot: !1,
|
||
exists: !1,
|
||
error: 0,
|
||
name: null,
|
||
path: null,
|
||
object: null,
|
||
parentExists: !1,
|
||
parentPath: null,
|
||
parentObject: null
|
||
};
|
||
try {
|
||
t = mr.lookupPath(e, {
|
||
parent: !0
|
||
}), n.parentExists = !0, n.parentPath = t.path, n.parentObject = t.node, n.name = Ge.basename(e), t = mr.lookupPath(e, {
|
||
follow: !r
|
||
}), n.exists = !0, n.path = t.path, n.object = t.node, n.name = t.node.name, n.isRoot = "/" === t.path
|
||
} catch (e) {
|
||
n.error = e.errno
|
||
}
|
||
return n
|
||
},
|
||
createPath: function (e, r, t, n) {
|
||
e = "string" == typeof e ? e : mr.getPath(e);
|
||
for (var o = r.split("/").reverse(); o.length;) {
|
||
var i = o.pop();
|
||
if (i) {
|
||
var a = Ge.join2(e, i);
|
||
try {
|
||
mr.mkdir(a)
|
||
} catch (e) {}
|
||
e = a
|
||
}
|
||
}
|
||
return a
|
||
},
|
||
createFile: function (e, r, t, n, o) {
|
||
var i = Ge.join2("string" == typeof e ? e : mr.getPath(e), r),
|
||
a = pr(n, o);
|
||
return mr.create(i, a)
|
||
},
|
||
createDataFile: function (e, r, t, n, o, i) {
|
||
var a = r;
|
||
e && (e = "string" == typeof e ? e : mr.getPath(e), a = r ? Ge.join2(e, r) : e);
|
||
var c = pr(n, o),
|
||
s = mr.create(a, c);
|
||
if (t) {
|
||
if ("string" == typeof t) {
|
||
for (var u = new Array(t.length), f = 0, l = t.length; f < l; ++f) u[f] = t.charCodeAt(f);
|
||
t = u
|
||
}
|
||
mr.chmod(s, 146 | c);
|
||
var d = mr.open(s, 577);
|
||
mr.write(d, t, 0, t.length, 0, i), mr.close(d), mr.chmod(s, c)
|
||
}
|
||
},
|
||
createDevice: function (e, r, t, n) {
|
||
var o, i, a = Ge.join2("string" == typeof e ? e : mr.getPath(e), r),
|
||
c = pr(!!t, !!n);
|
||
null !== (i = (o = mr.createDevice).major) && void 0 !== i || (o.major = 64);
|
||
var s = mr.makedev(mr.createDevice.major++, 0);
|
||
return mr.registerDevice(s, {
|
||
open: function (e) {
|
||
e.seekable = !1
|
||
},
|
||
close: function (e) {
|
||
var r;
|
||
(null == n || null === (r = n.buffer) || void 0 === r ? void 0 : r.length) && n(10)
|
||
},
|
||
read: function (e, r, n, o, i) {
|
||
for (var a = 0, c = 0; c < o; c++) {
|
||
var s;
|
||
try {
|
||
s = t()
|
||
} catch (e) {
|
||
throw new mr.ErrnoError(29)
|
||
}
|
||
if (void 0 === s && 0 === a) throw new mr.ErrnoError(6);
|
||
if (null == s) break;
|
||
a++, r[n + c] = s
|
||
}
|
||
return a && (e.node.atime = Date.now()), a
|
||
},
|
||
write: function (e, r, t, o, i) {
|
||
for (var a = 0; a < o; a++) try {
|
||
n(r[t + a])
|
||
} catch (e) {
|
||
throw new mr.ErrnoError(29)
|
||
}
|
||
return o && (e.node.mtime = e.node.ctime = Date.now()), a
|
||
}
|
||
}), mr.mkdev(a, c, s)
|
||
},
|
||
forceLoadFile: function (e) {
|
||
if (e.isDevice || e.isFolder || e.link || e.contents) return !0;
|
||
if ("undefined" != typeof XMLHttpRequest) throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
|
||
try {
|
||
e.contents = D(e.url), e.usedBytes = e.contents.length
|
||
} catch (e) {
|
||
throw new mr.ErrnoError(29)
|
||
}
|
||
},
|
||
createLazyFile: function (e, r, t, i, a) {
|
||
var c = function () {
|
||
return n((function e() {
|
||
o(this, e), this.lengthKnown = !1, this.chunks = []
|
||
}), [{
|
||
key: "get",
|
||
value: function (e) {
|
||
if (!(e > this.length - 1 || e < 0)) {
|
||
var r = e % this.chunkSize,
|
||
t = e / this.chunkSize | 0;
|
||
return this.getter(t)[r]
|
||
}
|
||
}
|
||
}, {
|
||
key: "setDataGetter",
|
||
value: function (e) {
|
||
this.getter = e
|
||
}
|
||
}, {
|
||
key: "cacheLength",
|
||
value: function () {
|
||
var e = new XMLHttpRequest;
|
||
if (e.open("HEAD", t, !1), e.send(null), !(e.status >= 200 && e.status < 300 || 304 === e.status)) throw new Error("Couldn't load " + t + ". Status: " + e.status);
|
||
var r, n = Number(e.getResponseHeader("Content-length")),
|
||
o = (r = e.getResponseHeader("Accept-Ranges")) && "bytes" === r,
|
||
i = (r = e.getResponseHeader("Content-Encoding")) && "gzip" === r,
|
||
a = 1048576;
|
||
o || (a = n);
|
||
var c = function (e, r) {
|
||
if (e > r) throw new Error("invalid range (" + e + ", " + r + ") or no bytes requested!");
|
||
if (r > n - 1) throw new Error("only " + n + " bytes available! programmer error!");
|
||
var o = new XMLHttpRequest;
|
||
if (o.open("GET", t, !1), n !== a && o.setRequestHeader("Range", "bytes=" + e + "-" + r), o.responseType = "arraybuffer", o.overrideMimeType && o.overrideMimeType("text/plain; charset=x-user-defined"), o.send(null), !(o.status >= 200 && o.status < 300 || 304 === o.status)) throw new Error("Couldn't load " + t + ". Status: " + o.status);
|
||
return void 0 !== o.response ? new Uint8Array(o.response || []) : tr(o.responseText || "", !0)
|
||
},
|
||
s = this;
|
||
s.setDataGetter((function (e) {
|
||
var r = e * a,
|
||
t = (e + 1) * a - 1;
|
||
if (t = Math.min(t, n - 1), void 0 === s.chunks[e] && (s.chunks[e] = c(r, t)), void 0 === s.chunks[e]) throw new Error("doXHR failed!");
|
||
return s.chunks[e]
|
||
})), !i && n || (a = n = 1, n = this.getter(0).length, a = n, R("LazyFiles on gzip forces download of the whole file when length is accessed")), this._length = n, this._chunkSize = a, this.lengthKnown = !0
|
||
}
|
||
}, {
|
||
key: "length",
|
||
get: function () {
|
||
return this.lengthKnown || this.cacheLength(), this._length
|
||
}
|
||
}, {
|
||
key: "chunkSize",
|
||
get: function () {
|
||
return this.lengthKnown || this.cacheLength(), this._chunkSize
|
||
}
|
||
}])
|
||
}();
|
||
if ("undefined" != typeof XMLHttpRequest) {
|
||
if (!p) throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
|
||
var s = {
|
||
isDevice: !1,
|
||
contents: new c
|
||
}
|
||
} else s = {
|
||
isDevice: !1,
|
||
url: t
|
||
};
|
||
var u = mr.createFile(e, r, s, i, a);
|
||
s.contents ? u.contents = s.contents : s.url && (u.contents = null, u.url = s.url), Object.defineProperties(u, {
|
||
usedBytes: {
|
||
get: function () {
|
||
return this.contents.length
|
||
}
|
||
}
|
||
});
|
||
var f = {};
|
||
|
||
function l(e, r, t, n, o) {
|
||
var i = e.node.contents;
|
||
if (o >= i.length) return 0;
|
||
var a = Math.min(i.length - o, n);
|
||
if (i.slice)
|
||
for (var c = 0; c < a; c++) r[t + c] = i[o + c];
|
||
else
|
||
for (c = 0; c < a; c++) r[t + c] = i.get(o + c);
|
||
return a
|
||
}
|
||
return Object.keys(u.stream_ops).forEach((function (e) {
|
||
var r = u.stream_ops[e];
|
||
f[e] = function () {
|
||
return mr.forceLoadFile(u), r.apply(void 0, arguments)
|
||
}
|
||
})), f.read = function (e, r, t, n, o) {
|
||
return mr.forceLoadFile(u), l(e, r, t, n, o)
|
||
}, f.mmap = function (e, r, t, n, o) {
|
||
mr.forceLoadFile(u);
|
||
var i = cr(r);
|
||
if (!i) throw new mr.ErrnoError(48);
|
||
return l(e, B, i, r, t), {
|
||
ptr: i,
|
||
allocated: !0
|
||
}
|
||
}, u.stream_ops = f, u
|
||
}
|
||
},
|
||
wr = {
|
||
DEFAULT_POLLMASK: 5,
|
||
calculateAt: function (e, r, t) {
|
||
if (Ge.isAbs(r)) return r;
|
||
var n; - 100 === e ? n = mr.cwd() : n = wr.getStreamFromFD(e).path;
|
||
if (0 == r.length) {
|
||
if (!t) throw new mr.ErrnoError(44);
|
||
return n
|
||
}
|
||
return n + "/" + r
|
||
},
|
||
doStat: function (e, r, t) {
|
||
var n = e(r);
|
||
L[t >> 2] = n.dev, L[t + 4 >> 2] = n.mode, H[t + 8 >> 2] = n.nlink, L[t + 12 >> 2] = n.uid, L[t + 16 >> 2] = n.gid, L[t + 20 >> 2] = n.rdev, le = [n.size >>> 0, (fe = n.size, +Math.abs(fe) >= 1 ? fe > 0 ? +Math.floor(fe / 4294967296) >>> 0 : ~~+Math.ceil((fe - +(~~fe >>> 0)) / 4294967296) >>> 0 : 0)], L[t + 24 >> 2] = le[0], L[t + 28 >> 2] = le[1], L[t + 32 >> 2] = 4096, L[t + 36 >> 2] = n.blocks;
|
||
var o = n.atime.getTime(),
|
||
i = n.mtime.getTime(),
|
||
a = n.ctime.getTime();
|
||
return le = [Math.floor(o / 1e3) >>> 0, (fe = Math.floor(o / 1e3), +Math.abs(fe) >= 1 ? fe > 0 ? +Math.floor(fe / 4294967296) >>> 0 : ~~+Math.ceil((fe - +(~~fe >>> 0)) / 4294967296) >>> 0 : 0)], L[t + 40 >> 2] = le[0], L[t + 44 >> 2] = le[1], H[t + 48 >> 2] = o % 1e3 * 1e3 * 1e3, le = [Math.floor(i / 1e3) >>> 0, (fe = Math.floor(i / 1e3), +Math.abs(fe) >= 1 ? fe > 0 ? +Math.floor(fe / 4294967296) >>> 0 : ~~+Math.ceil((fe - +(~~fe >>> 0)) / 4294967296) >>> 0 : 0)], L[t + 56 >> 2] = le[0], L[t + 60 >> 2] = le[1], H[t + 64 >> 2] = i % 1e3 * 1e3 * 1e3, le = [Math.floor(a / 1e3) >>> 0, (fe = Math.floor(a / 1e3), +Math.abs(fe) >= 1 ? fe > 0 ? +Math.floor(fe / 4294967296) >>> 0 : ~~+Math.ceil((fe - +(~~fe >>> 0)) / 4294967296) >>> 0 : 0)], L[t + 72 >> 2] = le[0], L[t + 76 >> 2] = le[1], H[t + 80 >> 2] = a % 1e3 * 1e3 * 1e3, le = [n.ino >>> 0, (fe = n.ino, +Math.abs(fe) >= 1 ? fe > 0 ? +Math.floor(fe / 4294967296) >>> 0 : ~~+Math.ceil((fe - +(~~fe >>> 0)) / 4294967296) >>> 0 : 0)], L[t + 88 >> 2] = le[0], L[t + 92 >> 2] = le[1], 0
|
||
},
|
||
doMsync: function (e, r, t, n, o) {
|
||
if (!mr.isFile(r.node.mode)) throw new mr.ErrnoError(43);
|
||
if (2 & n) return 0;
|
||
var i = z.slice(e, e + t);
|
||
mr.msync(r, i, o, t, n)
|
||
},
|
||
getStreamFromFD: function (e) {
|
||
return mr.getStreamChecked(e)
|
||
},
|
||
varargs: void 0,
|
||
getStr: function (e) {
|
||
return De(e)
|
||
}
|
||
},
|
||
_r = function (e, r, t, n, o) {
|
||
try {
|
||
for (var i = 0, a = r ? L[r >> 2] : 0, c = r ? L[r + 4 >> 2] : 0, s = t ? L[t >> 2] : 0, u = t ? L[t + 4 >> 2] : 0, f = n ? L[n >> 2] : 0, l = n ? L[n + 4 >> 2] : 0, d = 0, h = 0, v = 0, p = 0, m = 0, w = 0, _ = (r ? L[r >> 2] : 0) | (t ? L[t >> 2] : 0) | (n ? L[n >> 2] : 0), y = (r ? L[r + 4 >> 2] : 0) | (t ? L[t + 4 >> 2] : 0) | (n ? L[n + 4 >> 2] : 0), g = function (e, r, t, n) {
|
||
return e < 32 ? r & n : t & n
|
||
}, E = 0; E < e; E++) {
|
||
var b = 1 << E % 32;
|
||
if (g(E, _, y, b)) {
|
||
var k = wr.getStreamFromFD(E),
|
||
j = wr.DEFAULT_POLLMASK;
|
||
if (k.stream_ops.poll) {
|
||
var S = -1;
|
||
if (o) S = 1e3 * ((r ? L[o >> 2] : 0) + (r ? L[o + 4 >> 2] : 0) / 1e6);
|
||
j = k.stream_ops.poll(k, S)
|
||
}
|
||
1 & j && g(E, a, c, b) && (E < 32 ? d |= b : h |= b, i++), 4 & j && g(E, s, u, b) && (E < 32 ? v |= b : p |= b, i++), 2 & j && g(E, f, l, b) && (E < 32 ? m |= b : w |= b, i++)
|
||
}
|
||
}
|
||
return r && (L[r >> 2] = d, L[r + 4 >> 2] = h), t && (L[t >> 2] = v, L[t + 4 >> 2] = p), n && (L[n >> 2] = m, L[n + 4 >> 2] = w), i
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
};
|
||
|
||
function yr(e) {
|
||
try {
|
||
return e = wr.getStr(e), mr.chdir(e), 0
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
|
||
function gr(e) {
|
||
try {
|
||
var r = wr.getStreamFromFD(e);
|
||
return mr.dupStream(r).fd
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
|
||
function Er(e, r, t) {
|
||
try {
|
||
var n = wr.getStreamFromFD(e);
|
||
if (n.fd === r) return -28;
|
||
if (r < 0 || r >= mr.MAX_OPEN_FDS) return -8;
|
||
var o = mr.getStream(r);
|
||
return o && mr.close(o), mr.dupStream(n, r).fd
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
var br = function () {
|
||
var e = L[+wr.varargs >> 2];
|
||
return wr.varargs += 4, e
|
||
},
|
||
kr = br;
|
||
|
||
function jr(e, r, t) {
|
||
wr.varargs = t;
|
||
try {
|
||
var n = wr.getStreamFromFD(e);
|
||
switch (r) {
|
||
case 0:
|
||
var o = br();
|
||
if (o < 0) return -28;
|
||
for (; mr.streams[o];) o++;
|
||
return mr.dupStream(n, o).fd;
|
||
case 1:
|
||
case 2:
|
||
return 0;
|
||
case 3:
|
||
return n.flags;
|
||
case 4:
|
||
return o = br(), n.flags |= o, 0;
|
||
case 12:
|
||
o = kr();
|
||
return O[o + 0 >> 1] = 2, 0;
|
||
case 13:
|
||
case 14:
|
||
return 0
|
||
}
|
||
return -28
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
|
||
function Sr(e, r) {
|
||
try {
|
||
var t = wr.getStreamFromFD(e);
|
||
return wr.doStat(mr.stat, t.path, r)
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
var Cr = function (e, r, t) {
|
||
return rr(e, z, r, t)
|
||
};
|
||
|
||
function Fr(e, r) {
|
||
try {
|
||
if (0 === r) return -28;
|
||
var t = mr.cwd(),
|
||
n = er(t) + 1;
|
||
return r < n ? -68 : (Cr(t, e, r), n)
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
|
||
function Ar(e, r, t) {
|
||
try {
|
||
var n = wr.getStreamFromFD(e);
|
||
n.getdents || (n.getdents = mr.readdir(n.path));
|
||
for (var o = 280, i = 0, a = mr.llseek(n, 0, 1), c = Math.floor(a / o), s = Math.min(n.getdents.length, c + Math.floor(t / o)), u = c; u < s; u++) {
|
||
var f, l, d = n.getdents[u];
|
||
if ("." === d) f = n.node.id, l = 4;
|
||
else if (".." === d) {
|
||
f = mr.lookupPath(n.path, {
|
||
parent: !0
|
||
}).node.id, l = 4
|
||
} else {
|
||
var h;
|
||
try {
|
||
h = mr.lookupNode(n.node, d)
|
||
} catch (e) {
|
||
if (28 === (null == e ? void 0 : e.errno)) continue;
|
||
throw e
|
||
}
|
||
f = h.id, l = mr.isChrdev(h.mode) ? 2 : mr.isDir(h.mode) ? 4 : mr.isLink(h.mode) ? 10 : 8
|
||
}
|
||
le = [f >>> 0, (fe = f, +Math.abs(fe) >= 1 ? fe > 0 ? +Math.floor(fe / 4294967296) >>> 0 : ~~+Math.ceil((fe - +(~~fe >>> 0)) / 4294967296) >>> 0 : 0)], L[r + i >> 2] = le[0], L[r + i + 4 >> 2] = le[1], le = [(u + 1) * o >>> 0, (fe = (u + 1) * o, +Math.abs(fe) >= 1 ? fe > 0 ? +Math.floor(fe / 4294967296) >>> 0 : ~~+Math.ceil((fe - +(~~fe >>> 0)) / 4294967296) >>> 0 : 0)], L[r + i + 8 >> 2] = le[0], L[r + i + 12 >> 2] = le[1], O[r + i + 16 >> 1] = 280, B[r + i + 18] = l, Cr(d, r + i + 19, 256), i += o
|
||
}
|
||
return mr.llseek(n, u * o, 0), i
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
|
||
function xr(e, r, t) {
|
||
wr.varargs = t;
|
||
try {
|
||
var n = wr.getStreamFromFD(e);
|
||
switch (r) {
|
||
case 21509:
|
||
return n.tty ? 0 : -59;
|
||
case 21505:
|
||
if (!n.tty) return -59;
|
||
if (n.tty.ops.ioctl_tcgets) {
|
||
var o = n.tty.ops.ioctl_tcgets(n),
|
||
i = kr();
|
||
L[i >> 2] = o.c_iflag || 0, L[i + 4 >> 2] = o.c_oflag || 0, L[i + 8 >> 2] = o.c_cflag || 0, L[i + 12 >> 2] = o.c_lflag || 0;
|
||
for (var a = 0; a < 32; a++) B[i + a + 17] = o.c_cc[a] || 0;
|
||
return 0
|
||
}
|
||
return 0;
|
||
case 21510:
|
||
case 21511:
|
||
case 21512:
|
||
return n.tty ? 0 : -59;
|
||
case 21506:
|
||
case 21507:
|
||
case 21508:
|
||
if (!n.tty) return -59;
|
||
if (n.tty.ops.ioctl_tcsets) {
|
||
i = kr();
|
||
var c = L[i >> 2],
|
||
s = L[i + 4 >> 2],
|
||
u = L[i + 8 >> 2],
|
||
f = L[i + 12 >> 2],
|
||
l = [];
|
||
for (a = 0; a < 32; a++) l.push(B[i + a + 17]);
|
||
return n.tty.ops.ioctl_tcsets(n.tty, r, {
|
||
c_iflag: c,
|
||
c_oflag: s,
|
||
c_cflag: u,
|
||
c_lflag: f,
|
||
c_cc: l
|
||
})
|
||
}
|
||
return 0;
|
||
case 21519:
|
||
return n.tty ? (i = kr(), L[i >> 2] = 0, 0) : -59;
|
||
case 21520:
|
||
return n.tty ? -28 : -59;
|
||
case 21531:
|
||
return i = kr(), mr.ioctl(n, r, i);
|
||
case 21523:
|
||
if (!n.tty) return -59;
|
||
if (n.tty.ops.ioctl_tiocgwinsz) {
|
||
var d = n.tty.ops.ioctl_tiocgwinsz(n.tty);
|
||
i = kr(), O[i >> 1] = d[0], O[i + 2 >> 1] = d[1]
|
||
}
|
||
return 0;
|
||
case 21524:
|
||
case 21515:
|
||
return n.tty ? 0 : -59;
|
||
default:
|
||
return -28
|
||
}
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
|
||
function Dr(e, r) {
|
||
try {
|
||
return e = wr.getStr(e), wr.doStat(mr.lstat, e, r)
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
|
||
function Ir(e, r, t) {
|
||
try {
|
||
return r = wr.getStr(r), r = wr.calculateAt(e, r), mr.mkdir(r, t, 0), 0
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
|
||
function Mr(e, r, t, n) {
|
||
try {
|
||
r = wr.getStr(r);
|
||
var o = 256 & n,
|
||
i = 4096 & n;
|
||
return n &= -6401, r = wr.calculateAt(e, r, i), wr.doStat(o ? mr.lstat : mr.stat, r, t)
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
|
||
function Pr(e, r, t, n) {
|
||
wr.varargs = n;
|
||
try {
|
||
r = wr.getStr(r), r = wr.calculateAt(e, r);
|
||
var o = n ? br() : 0;
|
||
return mr.open(r, t, o).fd
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
var Tr = {
|
||
BUCKET_BUFFER_SIZE: 8192,
|
||
mount: function (e) {
|
||
return mr.createNode(null, "/", 16895, 0)
|
||
},
|
||
createPipe: function () {
|
||
var e = {
|
||
buckets: [],
|
||
refcnt: 2
|
||
};
|
||
e.buckets.push({
|
||
buffer: new Uint8Array(Tr.BUCKET_BUFFER_SIZE),
|
||
offset: 0,
|
||
roffset: 0
|
||
});
|
||
var r = Tr.nextname(),
|
||
t = Tr.nextname(),
|
||
n = mr.createNode(Tr.root, r, 4096, 0),
|
||
o = mr.createNode(Tr.root, t, 4096, 0);
|
||
n.pipe = e, o.pipe = e;
|
||
var i = mr.createStream({
|
||
path: r,
|
||
node: n,
|
||
flags: 0,
|
||
seekable: !1,
|
||
stream_ops: Tr.stream_ops
|
||
});
|
||
n.stream = i;
|
||
var a = mr.createStream({
|
||
path: t,
|
||
node: o,
|
||
flags: 1,
|
||
seekable: !1,
|
||
stream_ops: Tr.stream_ops
|
||
});
|
||
return o.stream = a, {
|
||
readable_fd: i.fd,
|
||
writable_fd: a.fd
|
||
}
|
||
},
|
||
stream_ops: {
|
||
poll: function (e) {
|
||
var r = e.node.pipe;
|
||
if (1 == (2097155 & e.flags)) return 260;
|
||
if (r.buckets.length > 0)
|
||
for (var t = 0; t < r.buckets.length; t++) {
|
||
var n = r.buckets[t];
|
||
if (n.offset - n.roffset > 0) return 65
|
||
}
|
||
return 0
|
||
},
|
||
ioctl: function (e, r, t) {
|
||
return 28
|
||
},
|
||
fsync: function (e) {
|
||
return 28
|
||
},
|
||
read: function (e, r, t, n, o) {
|
||
for (var i = e.node.pipe, a = 0, c = 0; c < i.buckets.length; c++) {
|
||
var s = i.buckets[c];
|
||
a += s.offset - s.roffset
|
||
}
|
||
var u = r.subarray(t, t + n);
|
||
if (n <= 0) return 0;
|
||
if (0 == a) throw new mr.ErrnoError(6);
|
||
var f = Math.min(a, n),
|
||
l = f,
|
||
d = 0;
|
||
for (c = 0; c < i.buckets.length; c++) {
|
||
var h = i.buckets[c],
|
||
v = h.offset - h.roffset;
|
||
if (f <= v) {
|
||
var p = h.buffer.subarray(h.roffset, h.offset);
|
||
f < v ? (p = p.subarray(0, f), h.roffset += f) : d++, u.set(p);
|
||
break
|
||
}
|
||
p = h.buffer.subarray(h.roffset, h.offset), u.set(p), u = u.subarray(p.byteLength), f -= p.byteLength, d++
|
||
}
|
||
return d && d == i.buckets.length && (d--, i.buckets[d].offset = 0, i.buckets[d].roffset = 0), i.buckets.splice(0, d), l
|
||
},
|
||
write: function (e, r, t, n, o) {
|
||
var i = e.node.pipe,
|
||
a = r.subarray(t, t + n),
|
||
c = a.byteLength;
|
||
if (c <= 0) return 0;
|
||
var s = null;
|
||
0 == i.buckets.length ? (s = {
|
||
buffer: new Uint8Array(Tr.BUCKET_BUFFER_SIZE),
|
||
offset: 0,
|
||
roffset: 0
|
||
}, i.buckets.push(s)) : s = i.buckets[i.buckets.length - 1], V(s.offset <= Tr.BUCKET_BUFFER_SIZE);
|
||
var u = Tr.BUCKET_BUFFER_SIZE - s.offset;
|
||
if (u >= c) return s.buffer.set(a, s.offset), s.offset += c, c;
|
||
u > 0 && (s.buffer.set(a.subarray(0, u), s.offset), s.offset += u, a = a.subarray(u, a.byteLength));
|
||
for (var f = a.byteLength / Tr.BUCKET_BUFFER_SIZE | 0, l = a.byteLength % Tr.BUCKET_BUFFER_SIZE, d = 0; d < f; d++) {
|
||
var h = {
|
||
buffer: new Uint8Array(Tr.BUCKET_BUFFER_SIZE),
|
||
offset: Tr.BUCKET_BUFFER_SIZE,
|
||
roffset: 0
|
||
};
|
||
i.buckets.push(h), h.buffer.set(a.subarray(0, Tr.BUCKET_BUFFER_SIZE)), a = a.subarray(Tr.BUCKET_BUFFER_SIZE, a.byteLength)
|
||
}
|
||
return l > 0 && (h = {
|
||
buffer: new Uint8Array(Tr.BUCKET_BUFFER_SIZE),
|
||
offset: a.byteLength,
|
||
roffset: 0
|
||
}, i.buckets.push(h), h.buffer.set(a)), c
|
||
},
|
||
close: function (e) {
|
||
var r = e.node.pipe;
|
||
r.refcnt--, 0 === r.refcnt && (r.buckets = null)
|
||
}
|
||
},
|
||
nextname: function () {
|
||
return Tr.nextname.current || (Tr.nextname.current = 0), "pipe[" + Tr.nextname.current++ + "]"
|
||
}
|
||
};
|
||
|
||
function Rr(e) {
|
||
try {
|
||
if (0 == e) throw new mr.ErrnoError(21);
|
||
var r = Tr.createPipe();
|
||
return L[e >> 2] = r.readable_fd, L[e + 4 >> 2] = r.writable_fd, 0
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
|
||
function Nr(e, r, t, n) {
|
||
try {
|
||
if (r = wr.getStr(r), r = wr.calculateAt(e, r), n <= 0) return -28;
|
||
var o = mr.readlink(r),
|
||
i = Math.min(n, er(o)),
|
||
a = B[t + i];
|
||
return Cr(o, t, n + 1), B[t + i] = a, i
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
|
||
function Ur(e, r, t, n) {
|
||
try {
|
||
return r = wr.getStr(r), n = wr.getStr(n), r = wr.calculateAt(e, r), n = wr.calculateAt(t, n), mr.rename(r, n), 0
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
|
||
function Br(e) {
|
||
try {
|
||
return e = wr.getStr(e), mr.rmdir(e), 0
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
|
||
function zr(e, r) {
|
||
try {
|
||
return e = wr.getStr(e), wr.doStat(mr.stat, e, r)
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
|
||
function Or(e, r, t) {
|
||
try {
|
||
return e = wr.getStr(e), t = wr.getStr(t), t = wr.calculateAt(r, t), mr.symlink(e, t), 0
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
|
||
function Lr(e, r, t) {
|
||
try {
|
||
return r = wr.getStr(r), r = wr.calculateAt(e, r), 0 === t ? mr.unlink(r) : 512 === t ? mr.rmdir(r) : se("Invalid flags passed to unlinkat"), 0
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
var Hr = function (e) {
|
||
return H[e >> 2] + 4294967296 * L[e + 4 >> 2]
|
||
};
|
||
|
||
function qr(e, r, t, n) {
|
||
try {
|
||
var o;
|
||
r = wr.getStr(r), r = wr.calculateAt(e, r, !0);
|
||
var i, a, c = Date.now();
|
||
if (t) {
|
||
var s = Hr(t),
|
||
u = L[t + 8 >> 2];
|
||
i = 1073741823 == u ? c : 1073741822 == u ? null : 1e3 * s + u / 1e6, s = Hr(t += 16), a = 1073741823 == (u = L[t + 8 >> 2]) ? c : 1073741822 == u ? null : 1e3 * s + u / 1e6
|
||
} else i = c, a = c;
|
||
return null !== (null !== (o = a) && void 0 !== o ? o : i) && mr.utime(r, i, a), 0
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
var Kr = function () {
|
||
return se("")
|
||
},
|
||
Wr = function (e, r, t) {
|
||
return z.copyWithin(e, r, r + t)
|
||
},
|
||
Zr = 0,
|
||
Vr = function () {
|
||
ke = !1, Zr = 0
|
||
},
|
||
Xr = function (e) {
|
||
return e % 4 == 0 && (e % 100 != 0 || e % 400 == 0)
|
||
},
|
||
Gr = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335],
|
||
Jr = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
|
||
Yr = function (e) {
|
||
return (Xr(e.getFullYear()) ? Gr : Jr)[e.getMonth()] + e.getDate() - 1
|
||
},
|
||
$r = function (e, r) {
|
||
return r + 2097152 >>> 0 < 4194305 - !!e ? (e >>> 0) + 4294967296 * r : NaN
|
||
};
|
||
|
||
function Qr(e, r, t) {
|
||
var n = $r(e, r),
|
||
o = new Date(1e3 * n);
|
||
L[t >> 2] = o.getSeconds(), L[t + 4 >> 2] = o.getMinutes(), L[t + 8 >> 2] = o.getHours(), L[t + 12 >> 2] = o.getDate(), L[t + 16 >> 2] = o.getMonth(), L[t + 20 >> 2] = o.getFullYear() - 1900, L[t + 24 >> 2] = o.getDay();
|
||
var i = 0 | Yr(o);
|
||
L[t + 28 >> 2] = i, L[t + 36 >> 2] = -60 * o.getTimezoneOffset();
|
||
var a = new Date(o.getFullYear(), 0, 1),
|
||
c = new Date(o.getFullYear(), 6, 1).getTimezoneOffset(),
|
||
s = a.getTimezoneOffset(),
|
||
u = 0 | (c != s && o.getTimezoneOffset() == Math.min(s, c));
|
||
L[t + 32 >> 2] = u
|
||
}
|
||
|
||
function et(e, r, t, n, o, i, a) {
|
||
var c = $r(i, a);
|
||
try {
|
||
var s = wr.getStreamFromFD(o);
|
||
2 & t && wr.doMsync(e, s, r, n, c)
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return -e.errno
|
||
}
|
||
}
|
||
var rt = function (e, r, t, n) {
|
||
var o = (new Date).getFullYear(),
|
||
i = new Date(o, 0, 1),
|
||
a = new Date(o, 6, 1),
|
||
c = i.getTimezoneOffset(),
|
||
s = a.getTimezoneOffset(),
|
||
u = Math.max(c, s);
|
||
H[e >> 2] = 60 * u, L[r >> 2] = Number(c != s);
|
||
var f = function (e) {
|
||
var r = e >= 0 ? "-" : "+",
|
||
t = Math.abs(e),
|
||
n = String(Math.floor(t / 60)).padStart(2, "0"),
|
||
o = String(t % 60).padStart(2, "0");
|
||
return "UTC".concat(r).concat(n).concat(o)
|
||
},
|
||
l = f(c),
|
||
d = f(s);
|
||
s < c ? (Cr(l, t, 17), Cr(d, n, 17)) : (Cr(l, n, 17), Cr(d, t, 17))
|
||
},
|
||
tt = function () {
|
||
return Date.now()
|
||
},
|
||
nt = function () {
|
||
return Date.now()
|
||
},
|
||
ot = 1,
|
||
it = function (e) {
|
||
return e >= 0 && e <= 3
|
||
};
|
||
|
||
function at(e, r, t, n) {
|
||
var o;
|
||
if ($r(r, t), !it(e)) return 28;
|
||
if (0 === e) o = nt();
|
||
else {
|
||
if (!ot) return 52;
|
||
o = tt()
|
||
}
|
||
var i = Math.round(1e3 * o * 1e3);
|
||
return le = [i >>> 0, (fe = i, +Math.abs(fe) >= 1 ? fe > 0 ? +Math.floor(fe / 4294967296) >>> 0 : ~~+Math.ceil((fe - +(~~fe >>> 0)) / 4294967296) >>> 0 : 0)], L[n >> 2] = le[0], L[n + 4 >> 2] = le[1], 0
|
||
}
|
||
var ct = function () {
|
||
return 2147483648
|
||
},
|
||
st = function () {
|
||
return ct()
|
||
},
|
||
ut = function (e) {
|
||
var r = (e - U.buffer.byteLength + 65535) / 65536 | 0;
|
||
try {
|
||
return U.grow(r), X(), 1
|
||
} catch (e) {}
|
||
},
|
||
ft = function (e) {
|
||
var r = z.length;
|
||
e >>>= 0;
|
||
var t = ct();
|
||
if (e > t) return !1;
|
||
for (var n = 1; n <= 4; n *= 2) {
|
||
var o = r * (1 + .2 / n);
|
||
o = Math.min(o, e + 100663296);
|
||
var i = Math.min(t, ar(Math.max(e, o), 65536));
|
||
if (ut(i)) return !0
|
||
}
|
||
return !1
|
||
},
|
||
lt = {},
|
||
dt = function () {
|
||
return M || "./this.program"
|
||
},
|
||
ht = function () {
|
||
if (!ht.strings) {
|
||
var e = {
|
||
USER: "web_user",
|
||
LOGNAME: "web_user",
|
||
PATH: "/",
|
||
PWD: "/",
|
||
HOME: "/home/web_user",
|
||
LANG: ("object" == ("undefined" == typeof navigator ? "undefined" : c(navigator)) && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8",
|
||
_: dt()
|
||
};
|
||
for (var r in lt) void 0 === lt[r] ? delete e[r] : e[r] = lt[r];
|
||
var t = [];
|
||
for (var r in e) t.push("".concat(r, "=").concat(e[r]));
|
||
ht.strings = t
|
||
}
|
||
return ht.strings
|
||
},
|
||
vt = function (e, r) {
|
||
for (var t = 0; t < e.length; ++t) B[r++] = e.charCodeAt(t);
|
||
B[r] = 0
|
||
},
|
||
pt = function (e, r) {
|
||
var t = 0;
|
||
return ht().forEach((function (n, o) {
|
||
var i = r + t;
|
||
H[e + 4 * o >> 2] = i, vt(n, i), t += n.length + 1
|
||
})), 0
|
||
},
|
||
mt = function (e, r) {
|
||
var t = ht();
|
||
H[e >> 2] = t.length;
|
||
var n = 0;
|
||
return t.forEach((function (e) {
|
||
return n += e.length + 1
|
||
})), H[r >> 2] = n, 0
|
||
},
|
||
wt = function () {
|
||
return ke || Zr > 0
|
||
},
|
||
_t = function (e) {
|
||
var r;
|
||
wt() || (null !== (r = d.onExit) && void 0 !== r && r.call(d, e), Z = !0), P(e, new Ee(e))
|
||
},
|
||
yt = function (e, r) {
|
||
_t(e)
|
||
},
|
||
gt = yt;
|
||
|
||
function Et(e) {
|
||
try {
|
||
var r = wr.getStreamFromFD(e);
|
||
return mr.close(r), 0
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return e.errno
|
||
}
|
||
}
|
||
|
||
function bt(e, r) {
|
||
try {
|
||
var t = wr.getStreamFromFD(e),
|
||
n = t.tty ? 2 : mr.isDir(t.mode) ? 3 : mr.isLink(t.mode) ? 7 : 4;
|
||
return B[r] = n, O[r + 2 >> 1] = 0, le = [0, (fe = 0, +Math.abs(fe) >= 1 ? fe > 0 ? +Math.floor(fe / 4294967296) >>> 0 : ~~+Math.ceil((fe - +(~~fe >>> 0)) / 4294967296) >>> 0 : 0)], L[r + 8 >> 2] = le[0], L[r + 12 >> 2] = le[1], le = [0, (fe = 0, +Math.abs(fe) >= 1 ? fe > 0 ? +Math.floor(fe / 4294967296) >>> 0 : ~~+Math.ceil((fe - +(~~fe >>> 0)) / 4294967296) >>> 0 : 0)], L[r + 16 >> 2] = le[0], L[r + 20 >> 2] = le[1], 0
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return e.errno
|
||
}
|
||
}
|
||
var kt = function (e, r, t, n) {
|
||
for (var o = 0, i = 0; i < t; i++) {
|
||
var a = H[r >> 2],
|
||
c = H[r + 4 >> 2];
|
||
r += 8;
|
||
var s = mr.read(e, B, a, c, n);
|
||
if (s < 0) return -1;
|
||
if (o += s, s < c) break;
|
||
void 0 !== n && (n += s)
|
||
}
|
||
return o
|
||
};
|
||
|
||
function jt(e, r, t, n) {
|
||
try {
|
||
var o = wr.getStreamFromFD(e),
|
||
i = kt(o, r, t);
|
||
return H[n >> 2] = i, 0
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return e.errno
|
||
}
|
||
}
|
||
|
||
function St(e, r, t, n, o) {
|
||
var i = $r(r, t);
|
||
try {
|
||
if (isNaN(i)) return 61;
|
||
var a = wr.getStreamFromFD(e);
|
||
return mr.llseek(a, i, n), le = [a.position >>> 0, (fe = a.position, +Math.abs(fe) >= 1 ? fe > 0 ? +Math.floor(fe / 4294967296) >>> 0 : ~~+Math.ceil((fe - +(~~fe >>> 0)) / 4294967296) >>> 0 : 0)], L[o >> 2] = le[0], L[o + 4 >> 2] = le[1], a.getdents && 0 === i && 0 === n && (a.getdents = null), 0
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return e.errno
|
||
}
|
||
}
|
||
var Ct = function (e, r, t, n) {
|
||
for (var o = 0, i = 0; i < t; i++) {
|
||
var a = H[r >> 2],
|
||
c = H[r + 4 >> 2];
|
||
r += 8;
|
||
var s = mr.write(e, B, a, c, n);
|
||
if (s < 0) return -1;
|
||
if (o += s, s < c) break;
|
||
void 0 !== n && (n += s)
|
||
}
|
||
return o
|
||
};
|
||
|
||
function Ft(e, r, t, n) {
|
||
try {
|
||
var o = wr.getStreamFromFD(e),
|
||
i = Ct(o, r, t);
|
||
return H[n >> 2] = i, 0
|
||
} catch (e) {
|
||
if (void 0 === mr || "ErrnoError" !== e.name) throw e;
|
||
return e.errno
|
||
}
|
||
}
|
||
var At = function (e) {
|
||
return d["_" + e]
|
||
},
|
||
xt = function (e, r) {
|
||
B.set(e, r)
|
||
},
|
||
Dt = function (e) {
|
||
return Zt(e)
|
||
},
|
||
It = function (e) {
|
||
var r = er(e) + 1,
|
||
t = Dt(r);
|
||
return Cr(e, t, r), t
|
||
},
|
||
Mt = function (e, r, t, n, o) {
|
||
var i = {
|
||
string: function (e) {
|
||
var r = 0;
|
||
return null != e && 0 !== e && (r = It(e)), r
|
||
},
|
||
array: function (e) {
|
||
var r = Dt(e.length);
|
||
return xt(e, r), r
|
||
}
|
||
};
|
||
var a = At(e),
|
||
c = [],
|
||
s = 0;
|
||
if (n)
|
||
for (var u = 0; u < n.length; u++) {
|
||
var f = i[t[u]];
|
||
f ? (0 === s && (s = Fe()), c[u] = f(n[u])) : c[u] = n[u]
|
||
}
|
||
var l = a.apply(void 0, c);
|
||
return l = function (e) {
|
||
return 0 !== s && Ce(s),
|
||
function (e) {
|
||
return "string" === r ? De(e) : "boolean" === r ? Boolean(e) : e
|
||
}(e)
|
||
}(l)
|
||
},
|
||
Pt = function (e, r, t, n) {
|
||
var o = !t || t.every((function (e) {
|
||
return "number" === e || "boolean" === e
|
||
}));
|
||
return "string" !== r && o && !n ? At(e) : function () {
|
||
for (var o = arguments.length, i = new Array(o), a = 0; a < o; a++) i[a] = arguments[a];
|
||
return Mt(e, r, t, i, n)
|
||
}
|
||
},
|
||
Tt = function (e) {
|
||
return Gt(e)
|
||
};
|
||
d.incrementExceptionRefcount = Tt;
|
||
var Rt = function (e) {
|
||
return Xt(e)
|
||
};
|
||
d.decrementExceptionRefcount = Rt;
|
||
var Nt = function (e) {
|
||
var r = Fe(),
|
||
t = Dt(4),
|
||
n = Dt(4);
|
||
Jt(e, t, n);
|
||
var o, i = H[t >> 2],
|
||
a = H[n >> 2],
|
||
c = De(i);
|
||
return Lt(i), a && (o = De(a), Lt(a)), Ce(r), [c, o]
|
||
},
|
||
Ut = function (e) {
|
||
return Nt(e)
|
||
};
|
||
d.getExceptionMessage = Ut, mr.createPreloadedFile = hr, mr.staticInit(), sr.doesNotExistError = new mr.ErrnoError(44), sr.doesNotExistError.stack = "<generic error, no stack>";
|
||
var Bt, zt = {
|
||
__assert_fail: Ie,
|
||
__call_sighandler: Te,
|
||
__cxa_begin_catch: Ue,
|
||
__cxa_end_catch: ze,
|
||
__cxa_find_matching_catch_2: Ke,
|
||
__cxa_find_matching_catch_3: We,
|
||
__cxa_rethrow: Ze,
|
||
__cxa_throw: Ve,
|
||
__cxa_uncaught_exceptions: Xe,
|
||
__resumeException: Le,
|
||
__syscall__newselect: _r,
|
||
__syscall_chdir: yr,
|
||
__syscall_dup: gr,
|
||
__syscall_dup3: Er,
|
||
__syscall_fcntl64: jr,
|
||
__syscall_fstat64: Sr,
|
||
__syscall_getcwd: Fr,
|
||
__syscall_getdents64: Ar,
|
||
__syscall_ioctl: xr,
|
||
__syscall_lstat64: Dr,
|
||
__syscall_mkdirat: Ir,
|
||
__syscall_newfstatat: Mr,
|
||
__syscall_openat: Pr,
|
||
__syscall_pipe: Rr,
|
||
__syscall_readlinkat: Nr,
|
||
__syscall_renameat: Ur,
|
||
__syscall_rmdir: Br,
|
||
__syscall_stat64: zr,
|
||
__syscall_symlinkat: Or,
|
||
__syscall_unlinkat: Lr,
|
||
__syscall_utimensat: qr,
|
||
_abort_js: Kr,
|
||
_emscripten_memcpy_js: Wr,
|
||
_emscripten_runtime_keepalive_clear: Vr,
|
||
_localtime_js: Qr,
|
||
_munmap_js: et,
|
||
_tzset_js: rt,
|
||
clock_time_get: at,
|
||
emscripten_date_now: nt,
|
||
emscripten_get_heap_max: st,
|
||
emscripten_get_now: tt,
|
||
emscripten_resize_heap: ft,
|
||
environ_get: pt,
|
||
environ_sizes_get: mt,
|
||
exit: gt,
|
||
fd_close: Et,
|
||
fd_fdstat_get: bt,
|
||
fd_read: jt,
|
||
fd_seek: St,
|
||
fd_write: Ft,
|
||
invoke_diii: mn,
|
||
invoke_fiii: pn,
|
||
invoke_i: wn,
|
||
invoke_ii: rn,
|
||
invoke_iii: tn,
|
||
invoke_iiii: en,
|
||
invoke_iiiii: hn,
|
||
invoke_iiiiii: un,
|
||
invoke_iiiiiii: cn,
|
||
invoke_iiiiiiii: ln,
|
||
invoke_iiiiiiiiiii: dn,
|
||
invoke_iiiiiiiiiiii: yn,
|
||
invoke_iiiiiiiiiiiii: vn,
|
||
invoke_jiiii: bn,
|
||
invoke_v: an,
|
||
invoke_vi: on,
|
||
invoke_vii: nn,
|
||
invoke_viii: fn,
|
||
invoke_viiii: sn,
|
||
invoke_viiiiiii: _n,
|
||
invoke_viiiiiiiiii: gn,
|
||
invoke_viiiiiiiiiiiiiii: En,
|
||
proc_exit: _t
|
||
};
|
||
ye(), d._malloc = function (e) {
|
||
return (d._malloc = Bt.malloc)(e)
|
||
};
|
||
var Ot, Lt = d._free = function (e) {
|
||
return (Lt = d._free = Bt.free)(e)
|
||
},
|
||
Ht = (d._Encrypter = function (e, r, t, n, o, i, a) {
|
||
return (d._Encrypter = Bt.Encrypter)(e, r, t, n, o, i, a)
|
||
}, d._addFunc = function (e) {
|
||
return (d._addFunc = Bt.addFunc)(e)
|
||
}, d._evaljs = function (e, r, t, n) {
|
||
return (d._evaljs = Bt.evaljs)(e, r, t, n)
|
||
}, d._dispose = function () {
|
||
return (d._dispose = Bt.dispose)()
|
||
}, d._evalcode = function (e) {
|
||
return (d._evalcode = Bt.evalcode)(e)
|
||
}, d._setPubKey = function (e, r, t, n, o) {
|
||
return (d._setPubKey = Bt.setPubKey)(e, r, t, n, o)
|
||
}, d._init = function () {
|
||
return (d._init = Bt.init)()
|
||
}, d._loadTA = function (e, r) {
|
||
return (d._loadTA = Bt.loadTA)(e, r)
|
||
}, function (e, r) {
|
||
return (Ht = Bt.emscripten_builtin_memalign)(e, r)
|
||
}),
|
||
qt = function (e, r) {
|
||
return (qt = Bt.setThrew)(e, r)
|
||
},
|
||
Kt = function (e) {
|
||
return (Kt = Bt._emscripten_tempret_set)(e)
|
||
},
|
||
Wt = function (e) {
|
||
return (Wt = Bt._emscripten_stack_restore)(e)
|
||
},
|
||
Zt = function (e) {
|
||
return (Zt = Bt._emscripten_stack_alloc)(e)
|
||
},
|
||
Vt = function () {
|
||
return (Vt = Bt.emscripten_stack_get_current)()
|
||
},
|
||
Xt = function (e) {
|
||
return (Xt = Bt.__cxa_decrement_exception_refcount)(e)
|
||
},
|
||
Gt = function (e) {
|
||
return (Gt = Bt.__cxa_increment_exception_refcount)(e)
|
||
},
|
||
Jt = function (e, r, t) {
|
||
return (Jt = Bt.__get_exception_message)(e, r, t)
|
||
},
|
||
Yt = function (e, r, t) {
|
||
return (Yt = Bt.__cxa_can_catch)(e, r, t)
|
||
},
|
||
$t = function (e) {
|
||
return ($t = Bt.__cxa_get_exception_ptr)(e)
|
||
},
|
||
Qt = (d.dynCall_jijii = function (e, r, t, n, o, i) {
|
||
return (d.dynCall_jijii = Bt.dynCall_jijii)(e, r, t, n, o, i)
|
||
}, d.dynCall_jijjiii = function (e, r, t, n, o, i, a, c, s) {
|
||
return (d.dynCall_jijjiii = Bt.dynCall_jijjiii)(e, r, t, n, o, i, a, c, s)
|
||
}, d.dynCall_jijiii = function (e, r, t, n, o, i, a) {
|
||
return (d.dynCall_jijiii = Bt.dynCall_jijiii)(e, r, t, n, o, i, a)
|
||
}, d.dynCall_jijiiiii = function (e, r, t, n, o, i, a, c, s) {
|
||
return (d.dynCall_jijiiiii = Bt.dynCall_jijiiiii)(e, r, t, n, o, i, a, c, s)
|
||
}, d.dynCall_jijj = function (e, r, t, n, o, i) {
|
||
return (d.dynCall_jijj = Bt.dynCall_jijj)(e, r, t, n, o, i)
|
||
}, d.dynCall_jiii = function (e, r, t, n) {
|
||
return (d.dynCall_jiii = Bt.dynCall_jiii)(e, r, t, n)
|
||
}, d.dynCall_jijiiii = function (e, r, t, n, o, i, a, c) {
|
||
return (d.dynCall_jijiiii = Bt.dynCall_jijiiii)(e, r, t, n, o, i, a, c)
|
||
}, d.dynCall_jii = function (e, r, t) {
|
||
return (d.dynCall_jii = Bt.dynCall_jii)(e, r, t)
|
||
}, d.dynCall_vij = function (e, r, t, n) {
|
||
return (d.dynCall_vij = Bt.dynCall_vij)(e, r, t, n)
|
||
}, d.dynCall_viji = function (e, r, t, n, o) {
|
||
return (d.dynCall_viji = Bt.dynCall_viji)(e, r, t, n, o)
|
||
}, d.dynCall_iijijjji = function (e, r, t, n, o, i, a, c, s, u, f, l) {
|
||
return (d.dynCall_iijijjji = Bt.dynCall_iijijjji)(e, r, t, n, o, i, a, c, s, u, f, l)
|
||
}, d.dynCall_iiiji = function (e, r, t, n, o, i) {
|
||
return (d.dynCall_iiiji = Bt.dynCall_iiiji)(e, r, t, n, o, i)
|
||
}, d.dynCall_iiji = function (e, r, t, n, o) {
|
||
return (d.dynCall_iiji = Bt.dynCall_iiji)(e, r, t, n, o)
|
||
}, d.dynCall_iiiij = function (e, r, t, n, o, i) {
|
||
return (d.dynCall_iiiij = Bt.dynCall_iiiij)(e, r, t, n, o, i)
|
||
}, d.dynCall_jijij = function (e, r, t, n, o, i, a) {
|
||
return (d.dynCall_jijij = Bt.dynCall_jijij)(e, r, t, n, o, i, a)
|
||
}, d.dynCall_iijijji = function (e, r, t, n, o, i, a, c, s, u) {
|
||
return (d.dynCall_iijijji = Bt.dynCall_iijijji)(e, r, t, n, o, i, a, c, s, u)
|
||
}, d.dynCall_jiiii = function (e, r, t, n, o) {
|
||
return (Qt = d.dynCall_jiiii = Bt.dynCall_jiiii)(e, r, t, n, o)
|
||
});
|
||
|
||
function en(e, r, t, n) {
|
||
var o = Fe();
|
||
try {
|
||
return Pe(e)(r, t, n)
|
||
} catch (e) {
|
||
if (Ce(o), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function rn(e, r) {
|
||
var t = Fe();
|
||
try {
|
||
return Pe(e)(r)
|
||
} catch (e) {
|
||
if (Ce(t), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function tn(e, r, t) {
|
||
var n = Fe();
|
||
try {
|
||
return Pe(e)(r, t)
|
||
} catch (e) {
|
||
if (Ce(n), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function nn(e, r, t) {
|
||
var n = Fe();
|
||
try {
|
||
Pe(e)(r, t)
|
||
} catch (e) {
|
||
if (Ce(n), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function on(e, r) {
|
||
var t = Fe();
|
||
try {
|
||
Pe(e)(r)
|
||
} catch (e) {
|
||
if (Ce(t), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function an(e) {
|
||
var r = Fe();
|
||
try {
|
||
Pe(e)()
|
||
} catch (e) {
|
||
if (Ce(r), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function cn(e, r, t, n, o, i, a) {
|
||
var c = Fe();
|
||
try {
|
||
return Pe(e)(r, t, n, o, i, a)
|
||
} catch (e) {
|
||
if (Ce(c), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function sn(e, r, t, n, o) {
|
||
var i = Fe();
|
||
try {
|
||
Pe(e)(r, t, n, o)
|
||
} catch (e) {
|
||
if (Ce(i), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function un(e, r, t, n, o, i) {
|
||
var a = Fe();
|
||
try {
|
||
return Pe(e)(r, t, n, o, i)
|
||
} catch (e) {
|
||
if (Ce(a), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function fn(e, r, t, n) {
|
||
var o = Fe();
|
||
try {
|
||
Pe(e)(r, t, n)
|
||
} catch (e) {
|
||
if (Ce(o), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function ln(e, r, t, n, o, i, a, c) {
|
||
var s = Fe();
|
||
try {
|
||
return Pe(e)(r, t, n, o, i, a, c)
|
||
} catch (e) {
|
||
if (Ce(s), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function dn(e, r, t, n, o, i, a, c, s, u, f) {
|
||
var l = Fe();
|
||
try {
|
||
return Pe(e)(r, t, n, o, i, a, c, s, u, f)
|
||
} catch (e) {
|
||
if (Ce(l), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function hn(e, r, t, n, o) {
|
||
var i = Fe();
|
||
try {
|
||
return Pe(e)(r, t, n, o)
|
||
} catch (e) {
|
||
if (Ce(i), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function vn(e, r, t, n, o, i, a, c, s, u, f, l, d) {
|
||
var h = Fe();
|
||
try {
|
||
return Pe(e)(r, t, n, o, i, a, c, s, u, f, l, d)
|
||
} catch (e) {
|
||
if (Ce(h), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function pn(e, r, t, n) {
|
||
var o = Fe();
|
||
try {
|
||
return Pe(e)(r, t, n)
|
||
} catch (e) {
|
||
if (Ce(o), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function mn(e, r, t, n) {
|
||
var o = Fe();
|
||
try {
|
||
return Pe(e)(r, t, n)
|
||
} catch (e) {
|
||
if (Ce(o), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function wn(e) {
|
||
var r = Fe();
|
||
try {
|
||
return Pe(e)()
|
||
} catch (e) {
|
||
if (Ce(r), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function _n(e, r, t, n, o, i, a, c) {
|
||
var s = Fe();
|
||
try {
|
||
Pe(e)(r, t, n, o, i, a, c)
|
||
} catch (e) {
|
||
if (Ce(s), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function yn(e, r, t, n, o, i, a, c, s, u, f, l) {
|
||
var d = Fe();
|
||
try {
|
||
return Pe(e)(r, t, n, o, i, a, c, s, u, f, l)
|
||
} catch (e) {
|
||
if (Ce(d), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function gn(e, r, t, n, o, i, a, c, s, u, f) {
|
||
var l = Fe();
|
||
try {
|
||
Pe(e)(r, t, n, o, i, a, c, s, u, f)
|
||
} catch (e) {
|
||
if (Ce(l), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function En(e, r, t, n, o, i, a, c, s, u, f, l, d, h, v, p) {
|
||
var m = Fe();
|
||
try {
|
||
Pe(e)(r, t, n, o, i, a, c, s, u, f, l, d, h, v, p)
|
||
} catch (e) {
|
||
if (Ce(m), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function bn(e, r, t, n, o) {
|
||
var i = Fe();
|
||
try {
|
||
return Qt(e, r, t, n, o)
|
||
} catch (e) {
|
||
if (Ce(i), e !== e + 0) throw e;
|
||
qt(1, 0)
|
||
}
|
||
}
|
||
|
||
function kn() {
|
||
function e() {
|
||
var e;
|
||
Ot || (Ot = !0, d.calledRun = !0, Z || (Q(), s(d), null !== (e = d.onRuntimeInitialized) && void 0 !== e && e.call(d), ee()))
|
||
}
|
||
oe > 0 || ($(), oe > 0 || (d.setStatus ? (d.setStatus("Running..."), setTimeout((function () {
|
||
setTimeout((function () {
|
||
return d.setStatus("")
|
||
}), 1), e()
|
||
}), 1)) : e()))
|
||
}
|
||
if (d.dynCall_jij = function (e, r, t, n) {
|
||
return (d.dynCall_jij = Bt.dynCall_jij)(e, r, t, n)
|
||
}, d.dynCall_jiji = function (e, r, t, n, o) {
|
||
return (d.dynCall_jiji = Bt.dynCall_jiji)(e, r, t, n, o)
|
||
}, d.dynCall_viijii = function (e, r, t, n, o, i, a) {
|
||
return (d.dynCall_viijii = Bt.dynCall_viijii)(e, r, t, n, o, i, a)
|
||
}, d.dynCall_iiiiij = function (e, r, t, n, o, i, a) {
|
||
return (d.dynCall_iiiiij = Bt.dynCall_iiiiij)(e, r, t, n, o, i, a)
|
||
}, d.dynCall_iiiiijj = function (e, r, t, n, o, i, a, c, s) {
|
||
return (d.dynCall_iiiiijj = Bt.dynCall_iiiiijj)(e, r, t, n, o, i, a, c, s)
|
||
}, d.dynCall_iiiiiijj = function (e, r, t, n, o, i, a, c, s, u) {
|
||
return (d.dynCall_iiiiiijj = Bt.dynCall_iiiiiijj)(e, r, t, n, o, i, a, c, s, u)
|
||
}, d.ccall = Mt, d.cwrap = Pt, d.stringToUTF8 = Cr, ie = function e() {
|
||
Ot || kn(), Ot || (ie = e)
|
||
}, d.preInit)
|
||
for ("function" == typeof d.preInit && (d.preInit = [d.preInit]); d.preInit.length > 0;) d.preInit.pop()();
|
||
|
||
function jn() {
|
||
var e = A;
|
||
return Promise.resolve(e)
|
||
}
|
||
return kn(), d.UTF8ToString = De, h
|
||
}
|
||
}();
|
||
return "object" === ("undefined" == typeof exports ? "undefined" : c(exports)) && "object" === ("undefined" == typeof module ? "undefined" : c(module)) ? (module.exports = s, module.exports.default = s) : "function" == typeof define && define.amd && define([], (function () {
|
||
return s
|
||
})), s
|
||
}(function (e, r, t, n, o, u, f, l) {
|
||
console.log('aaaa')
|
||
function d(e) {
|
||
function i(e) {
|
||
return c(e)
|
||
}
|
||
|
||
function a(e) {
|
||
var t = 9;
|
||
e: for (; void 0 !== t;) {
|
||
var i = 3 & t >> 2;
|
||
switch (3 & t) {
|
||
case 0:
|
||
switch (i) {
|
||
case 0:
|
||
m = u[2], t = 12;
|
||
continue e;
|
||
case 1:
|
||
var a = v;
|
||
t = a ? 13 : 8;
|
||
continue e;
|
||
case 2:
|
||
var s = a;
|
||
t = s ? 2 : 6;
|
||
continue e;
|
||
case 3:
|
||
return m
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (i) {
|
||
case 0:
|
||
h = "undefined" == typeof Symbol ? "undefined" : c(Symbol);
|
||
var d = o[0];
|
||
d += r[3], v = (d += l[1]) == h, t = 4;
|
||
continue e;
|
||
case 1:
|
||
m = c(e), t = 12;
|
||
continue e;
|
||
case 2:
|
||
var h = r[0],
|
||
v = (r[0], e);
|
||
t = v ? 1 : 4;
|
||
continue e;
|
||
case 3:
|
||
var p = n[1];
|
||
p += r[4], p += o[1], a = (h = e[p = (p += l[2])[o[2]](u[1])[o[3]]()[o[4]](f[5])]) === Symbol, t = 8;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 2:
|
||
switch (i) {
|
||
case 0:
|
||
s = (h = e) !== Symbol[r[5]], t = 6;
|
||
continue e;
|
||
case 1:
|
||
var m = s;
|
||
t = m ? 0 : 5;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
}
|
||
var s = 13;
|
||
e: for (; void 0 !== s;) {
|
||
var h = 3 & s >> 2;
|
||
switch (3 & s) {
|
||
case 0:
|
||
switch (h) {
|
||
case 0:
|
||
w = y == m, s = 6;
|
||
continue e;
|
||
case 1:
|
||
var v = parseInt(n[0], r[2]),
|
||
p = _[f[2]](g) - (f[3] + v);
|
||
y += u[0][f[4]](p), s = 9;
|
||
continue e;
|
||
case 2:
|
||
E = i, s = 12;
|
||
continue e;
|
||
case 3:
|
||
return (d = E)(e)
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (h) {
|
||
case 0:
|
||
E = a, s = 12;
|
||
continue e;
|
||
case 1:
|
||
s = g < _[r[1]] ? 4 : 0;
|
||
continue e;
|
||
case 2:
|
||
g++, s = 5;
|
||
continue e;
|
||
case 3:
|
||
var m = "undefined" == typeof Symbol ? "undefined" : c(Symbol),
|
||
w = t[0] == m;
|
||
s = w ? 2 : 6;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 2:
|
||
switch (h) {
|
||
case 0:
|
||
m = c(m = Symbol[l[0]]);
|
||
var _ = f[1],
|
||
y = t[1],
|
||
g = t[2];
|
||
s = 5;
|
||
continue e;
|
||
case 1:
|
||
var E = w;
|
||
s = E ? 8 : 1;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
}
|
||
|
||
function h(i, a) {
|
||
function c(e) {
|
||
var o = l[5];
|
||
return o += t[4], o += r[6], o += t[5], o += r[7], o += l[6], o = (o += t[6])[u[3]](t[1])[t[7]]()[f[9]](t[1]), n[3][o](i, e)[r[8]]
|
||
}
|
||
var s = 1;
|
||
e: for (; void 0 !== s;) {
|
||
var d = 3 & s >> 2;
|
||
switch (3 & s) {
|
||
case 0:
|
||
switch (d) {
|
||
case 0:
|
||
s = (p = f[7][y]) ? 10 : 2;
|
||
continue e;
|
||
case 1:
|
||
g = f[8] - parseInt(e[2], e[3]), s = 5;
|
||
continue e;
|
||
case 2:
|
||
var h = parseInt(f[10], f[11]),
|
||
v = j[n[4]](C) - (parseInt(u[4], e[3]) + h);
|
||
S += t[8][o[8]](v), s = 3;
|
||
continue e;
|
||
case 3:
|
||
s = C < j[r[1]] ? 8 : 7;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (d) {
|
||
case 0:
|
||
var p = l[3],
|
||
m = o[5];
|
||
m = m[u[3]](t[1])[f[6]]()[l[4]](n[2]);
|
||
var w = f[7][m](i),
|
||
_ = o[6],
|
||
y = e[1],
|
||
g = l[3],
|
||
E = e[0];
|
||
s = 9;
|
||
continue e;
|
||
case 1:
|
||
var b = _[o[7]](E),
|
||
k = ~(~(b & ~g) & ~(~b & g));
|
||
g = b, y += u[0][o[8]](k), s = 11;
|
||
continue e;
|
||
case 2:
|
||
s = E < _[t[3]] ? 13 : 0;
|
||
continue e;
|
||
case 3:
|
||
s = E ? 5 : 4;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 2:
|
||
switch (d) {
|
||
case 0:
|
||
return w;
|
||
case 1:
|
||
p = c;
|
||
var j = l[7],
|
||
S = f[5],
|
||
C = l[3];
|
||
s = 12;
|
||
continue e;
|
||
case 2:
|
||
var F = o[9][e[4]](i),
|
||
A = a;
|
||
s = A ? 6 : 14;
|
||
continue e;
|
||
case 3:
|
||
var x = r[9];
|
||
x += t[9], p = w[x += n[5]];
|
||
var D = f[12];
|
||
D += t[10], p[D += o[10]](w, F), s = 2;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 3:
|
||
switch (d) {
|
||
case 0:
|
||
C++, s = 12;
|
||
continue e;
|
||
case 1:
|
||
p = F[S](p), F = p, A = p, s = 14;
|
||
continue e;
|
||
case 2:
|
||
E++, s = 9;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
}
|
||
|
||
function v(i) {
|
||
function a(r) {
|
||
var t = i;
|
||
f[14], e[0], p(t, r, x[r])
|
||
}
|
||
|
||
function c(a) {
|
||
var c = 5;
|
||
e: for (; void 0 !== c;) {
|
||
var s = 3 & c >> 2;
|
||
switch (3 & c) {
|
||
case 0:
|
||
switch (s) {
|
||
case 0:
|
||
c = g < _[r[1]] ? 4 : 1;
|
||
continue e;
|
||
case 1:
|
||
var d = parseInt(r[13], u[11]),
|
||
h = _[f[2]](g) - (r[14] + d);
|
||
y += l[13][n[11]](h), c = 8;
|
||
continue e;
|
||
case 2:
|
||
g++, c = 0;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (s) {
|
||
case 0:
|
||
l[9][y](v, p, m), c = void 0;
|
||
continue e;
|
||
case 1:
|
||
var v = i,
|
||
p = n[6],
|
||
m = r[0];
|
||
p = a;
|
||
var w = o[12];
|
||
w += f[15], w += u[10], w += n[10], w += o[13], w += t[14], w += o[14], w = (w += l[11])[e[8]](f[5])[f[6]]()[r[11]](r[12]), m = l[9][w](x, a);
|
||
var _ = l[12],
|
||
y = e[1],
|
||
g = o[15];
|
||
c = 0;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
}
|
||
var s = 25;
|
||
e: for (; void 0 !== s;) {
|
||
var d = 7 & s,
|
||
v = s >> 3,
|
||
m = 7 & v;
|
||
switch (d) {
|
||
case 0:
|
||
switch (m) {
|
||
case 0:
|
||
s = j ? 27 : 9;
|
||
continue e;
|
||
case 1:
|
||
s = 17;
|
||
continue e;
|
||
case 2:
|
||
E = i;
|
||
var w = u[8];
|
||
w += e[6], w += t[12], w += e[7], w += u[9], w += n[9], w += t[13], b = e[5][w](x), _ = e[5][l[10]](E, b), s = 18;
|
||
continue e;
|
||
case 3:
|
||
var _ = l[9][F];
|
||
s = _ ? 16 : 3;
|
||
continue e;
|
||
case 4:
|
||
s = f[13] ? 0 : 17;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (m) {
|
||
case 0:
|
||
var y = I[t[15]](T),
|
||
g = ~(~(y & ~P) & ~(~y & P));
|
||
P = y, M += e[11][u[13]](g), s = 35;
|
||
continue e;
|
||
case 1:
|
||
j = n[7], s = (E = (E = k) < (b = arguments[S])) ? 19 : 8;
|
||
continue e;
|
||
case 2:
|
||
return i;
|
||
case 3:
|
||
var E = n[6],
|
||
b = u[5],
|
||
k = t[11],
|
||
j = n[6],
|
||
S = o[11],
|
||
C = r[10],
|
||
F = u[6];
|
||
s = 32;
|
||
continue e;
|
||
case 4:
|
||
var A = u[12];
|
||
P = A - parseInt(e[9], e[10]), s = 1;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 2:
|
||
switch (m) {
|
||
case 0:
|
||
var x = R,
|
||
D = k % l[8];
|
||
s = D ? 26 : 24;
|
||
continue e;
|
||
case 1:
|
||
R = {}, s = 2;
|
||
continue e;
|
||
case 2:
|
||
D = _, s = 32;
|
||
continue e;
|
||
case 3:
|
||
E = h(E = e[5](x), b = !r[0]), b = a, D = E[C](b), s = 32;
|
||
continue e;
|
||
case 4:
|
||
_ = E[M](b), s = 18;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 3:
|
||
switch (m) {
|
||
case 0:
|
||
E = h(E = o[9](x)), b = c;
|
||
var I = n[12],
|
||
M = t[1],
|
||
P = n[6],
|
||
T = f[14];
|
||
s = 4;
|
||
continue e;
|
||
case 1:
|
||
s = T ? 1 : 33;
|
||
continue e;
|
||
case 2:
|
||
E = arguments[k];
|
||
var R = n[8] != E;
|
||
s = R ? 12 : 10;
|
||
continue e;
|
||
case 3:
|
||
k += u[7], s = 9;
|
||
continue e;
|
||
case 4:
|
||
T++, s = 4;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 4:
|
||
switch (m) {
|
||
case 0:
|
||
s = T < I[n[13]] ? 11 : 34;
|
||
continue e;
|
||
case 1:
|
||
R = arguments[k], s = 2;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
}
|
||
|
||
function p(i, a, c) {
|
||
var s = 3;
|
||
e: for (; void 0 !== s;) {
|
||
var d = 1 & s >> 1;
|
||
switch (1 & s) {
|
||
case 0:
|
||
switch (d) {
|
||
case 0:
|
||
_ = c, (p = i)[w = a] = _, y = _, s = 2;
|
||
continue e;
|
||
case 1:
|
||
return i
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (d) {
|
||
case 0:
|
||
p = i, w = a;
|
||
var h = {};
|
||
h[u[14]] = c, h[f[16]] = !e[0], h[l[14]] = !n[6], h[t[16]] = !u[5], _ = h;
|
||
var v = u[15];
|
||
v = v[o[2]](t[1])[r[15]]()[u[16]](t[1]), y = l[9][v](p, w, _), s = 2;
|
||
continue e;
|
||
case 1:
|
||
var p = m(a),
|
||
w = t[2],
|
||
_ = t[2];
|
||
a = p;
|
||
var y = p in (w = i);
|
||
s = y ? 1 : 0;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
}
|
||
|
||
function m(i) {
|
||
var a = 3;
|
||
e: for (; void 0 !== a;) {
|
||
var c = 1 & a >> 1;
|
||
switch (1 & a) {
|
||
case 0:
|
||
switch (c) {
|
||
case 0:
|
||
v = l + n[2], a = 2;
|
||
continue e;
|
||
case 1:
|
||
return v
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (c) {
|
||
case 0:
|
||
v = l, a = 2;
|
||
continue e;
|
||
case 1:
|
||
var s = u[5],
|
||
l = w(i, o[16]);
|
||
s = d(l);
|
||
var h = t[17];
|
||
h += f[17];
|
||
var v = (h = (h += r[16])[u[3]](o[17])[u[17]]()[e[12]](f[5])) == s;
|
||
a = v ? 1 : 0;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
}
|
||
|
||
function w(i, a) {
|
||
var c = 24;
|
||
e: for (; void 0 !== c;) {
|
||
var s = 7 & c >> 3;
|
||
switch (7 & c) {
|
||
case 0:
|
||
switch (s) {
|
||
case 0:
|
||
var h = i[v = Symbol[u[19]]];
|
||
c = (v = (v = void e[0]) !== (p = h)) ? 25 : 11;
|
||
continue e;
|
||
case 1:
|
||
w = !i, c = 34;
|
||
continue e;
|
||
case 2:
|
||
_ = u[20], c = 33;
|
||
continue e;
|
||
case 3:
|
||
var v = d(i),
|
||
p = n[6],
|
||
m = n[14];
|
||
m += o[18], m += o[19];
|
||
var w = (m += u[18]) != v;
|
||
c = w ? 34 : 8;
|
||
continue e;
|
||
case 4:
|
||
return i
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (s) {
|
||
case 0:
|
||
b = l[15] - t[18], c = 28;
|
||
continue e;
|
||
case 1:
|
||
c = k ? 28 : 1;
|
||
continue e;
|
||
case 2:
|
||
throw new TypeError(F);
|
||
case 3:
|
||
v = i;
|
||
var _ = a;
|
||
c = _ ? 33 : 16;
|
||
continue e;
|
||
case 4:
|
||
p = _;
|
||
var y = h.call(v, p);
|
||
v = d(y);
|
||
var g = n[15],
|
||
E = t[1],
|
||
b = r[0],
|
||
k = u[5];
|
||
c = 18;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 2:
|
||
switch (s) {
|
||
case 0:
|
||
S = o[20], c = 10;
|
||
continue e;
|
||
case 1:
|
||
return (v = S)(i);
|
||
case 2:
|
||
c = k < g[t[3]] ? 9 : 12;
|
||
continue e;
|
||
case 3:
|
||
c = A < C[n[13]] ? 27 : 17;
|
||
continue e;
|
||
case 4:
|
||
c = (v = w) ? 32 : 0;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 3:
|
||
switch (s) {
|
||
case 0:
|
||
A++, c = 26;
|
||
continue e;
|
||
case 1:
|
||
var j = r[19];
|
||
j += f[19];
|
||
var S = (j += r[20]) === a;
|
||
c = S ? 2 : 20;
|
||
continue e;
|
||
case 2:
|
||
var C = f[18],
|
||
F = e[1],
|
||
A = l[3];
|
||
c = 26;
|
||
continue e;
|
||
case 3:
|
||
var x = r[17],
|
||
D = C[r[18]](A) - (parseInt(n[16], t[20]) + x);
|
||
F += t[8][t[19]](D), c = 3;
|
||
continue e;
|
||
case 4:
|
||
k++, c = 18;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 4:
|
||
switch (s) {
|
||
case 0:
|
||
return y;
|
||
case 1:
|
||
c = (v = E != v) ? 4 : 19;
|
||
continue e;
|
||
case 2:
|
||
S = t[21], c = 10;
|
||
continue e;
|
||
case 3:
|
||
var I = g[l[16]](k),
|
||
M = ~(~(I & ~b) & ~(~I & b));
|
||
b = I, E += t[8][t[19]](M), c = 35;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
} [][f[0]]([]);
|
||
var _ = r[0],
|
||
y = e[0];
|
||
y = function (e) {
|
||
return e[r[21]](), e
|
||
};
|
||
var g = (_ = (_ = s())())[t[22]](y),
|
||
E = function (t) {
|
||
var i = n[17];
|
||
i += o[21], i += r[22], i = (i += e[14])[l[17]](r[12])[n[18]]()[r[11]](o[17]), worker[i](t)
|
||
},
|
||
b = function (i) {
|
||
var a = 12;
|
||
e: for (; void 0 !== a;) {
|
||
var s = 7 & a >> 3;
|
||
switch (7 & a) {
|
||
case 0:
|
||
switch (s) {
|
||
case 0:
|
||
var d = k[r[18]](C),
|
||
h = ~(~(d & ~S) & ~(~d & S));
|
||
S = d, j += l[13][l[24]](h), a = 42;
|
||
continue e;
|
||
case 1:
|
||
return (L = new TextEncoder)[u[22]](i);
|
||
case 2:
|
||
a = X < Z[e[28]] ? 2 : 11;
|
||
continue e;
|
||
case 3:
|
||
var v = parseInt(u[25], o[28]);
|
||
P = parseInt(l[19], t[20]) + v, a = 41;
|
||
continue e;
|
||
case 4:
|
||
T++, a = 27;
|
||
continue e;
|
||
case 5:
|
||
a = K < H[u[21]] ? 36 : 4;
|
||
continue e;
|
||
case 6:
|
||
K++, a = 40;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (s) {
|
||
case 0:
|
||
var p = [],
|
||
m = r[0],
|
||
w = o[15],
|
||
_ = u[23];
|
||
_ += r[24], _ += f[20];
|
||
var y = _ += e[15],
|
||
g = r[25],
|
||
E = e[16];
|
||
a = 25;
|
||
continue e;
|
||
case 1:
|
||
var b = parseInt(e[17], e[18]);
|
||
a = (L = Q <= t[25] + b) ? 13 : 28;
|
||
continue e;
|
||
case 2:
|
||
L = ~(~(parseInt(N, n[21]) & parseInt(N, t[29])) & ~L);
|
||
var k = o[29],
|
||
j = t[1],
|
||
S = o[15],
|
||
C = r[0];
|
||
a = 43;
|
||
continue e;
|
||
case 3:
|
||
a = t[11] ? 44 : 52;
|
||
continue e;
|
||
case 4:
|
||
w = o[24], a = (L = (L = m) < i[y]) ? 45 : 50;
|
||
continue e;
|
||
case 5:
|
||
var F = I[r[18]](T),
|
||
A = ~(~(F & ~P) & ~(~F & P));
|
||
P = F, M += t[8][n[11]](A), a = 32;
|
||
continue e;
|
||
case 6:
|
||
a = T ? 41 : 24;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 2:
|
||
switch (s) {
|
||
case 0:
|
||
var x = ~(~(Z[t[15]](X) & ~parseInt(o[32], e[10])) & ~(~(Z[o[7]](X) & Z[r[18]](X)) & parseInt(t[33], e[18])));
|
||
V += o[20][f[4]](x), a = 19;
|
||
continue e;
|
||
case 1:
|
||
L = Q >> parseInt(o[25], e[3]), L = ~(~parseInt(e[22], r[26]) & ~L);
|
||
var D = t[27];
|
||
D += o[26], p[D += r[28]](L), L = ~(~((L = Q >> e[23]) & o[27]) & ~(L & parseInt(f[24], t[28]))), L = ~(~r[29] & ~L);
|
||
var I = l[18],
|
||
M = r[12],
|
||
P = l[3],
|
||
T = e[0];
|
||
a = 27;
|
||
continue e;
|
||
case 2:
|
||
m += n[7], a = 33;
|
||
continue e;
|
||
case 3:
|
||
p[M](L), L = ~(~(u[26] & Q) & ~(parseInt(f[25], l[20]) & Q));
|
||
var R = l[21],
|
||
N = o[17],
|
||
U = r[0];
|
||
a = 3;
|
||
continue e;
|
||
case 4:
|
||
var B = r[31];
|
||
S = e[24] + B, a = 0;
|
||
continue e;
|
||
case 5:
|
||
C++, a = 43;
|
||
continue e;
|
||
case 6:
|
||
a = 52;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 3:
|
||
switch (s) {
|
||
case 0:
|
||
a = U < R[t[3]] ? 51 : 17;
|
||
continue e;
|
||
case 1:
|
||
p[V](L), L = ~(~(parseInt(u[32], t[29]) & Q) & ~(parseInt(n[20], o[33]) & Q)), L = ~(~parseInt(n[23], o[34]) & ~L), p[o[31]](L), a = 25;
|
||
continue e;
|
||
case 2:
|
||
X++, a = 16;
|
||
continue e;
|
||
case 3:
|
||
a = T < I[r[1]] ? 49 : 26;
|
||
continue e;
|
||
case 4:
|
||
p[E](Q), a = 25;
|
||
continue e;
|
||
case 5:
|
||
a = C < k[l[23]] ? 53 : 29;
|
||
continue e;
|
||
case 6:
|
||
var z = parseInt(l[22], u[27]),
|
||
O = R[l[16]](U) - (f[26] + z);
|
||
N += t[8][r[30]](O), a = 37;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 4:
|
||
switch (s) {
|
||
case 0:
|
||
a = (L = q !== L) ? 8 : 1;
|
||
continue e;
|
||
case 1:
|
||
var L = "undefined" == typeof TextEncoder ? "undefined" : c(TextEncoder),
|
||
H = (l[3], o[22]),
|
||
q = r[12],
|
||
K = n[6];
|
||
a = 40;
|
||
continue e;
|
||
case 2:
|
||
L = Q >> t[30] - parseInt(r[32], e[10]), L = ~(~(parseInt(f[27], n[21]) & parseInt(u[28], u[29])) & ~L), p[l[25]](L);
|
||
var W = f[28];
|
||
W = W[l[17]](l[26])[r[15]]()[r[11]](t[1]), L = ~(~((L = Q >> parseInt(W, o[28])) & e[26]) & ~(L & parseInt(u[30], t[20]))), L = ~(~parseInt(o[30], l[8]) & ~L), p[o[31]](L), L = ~(~((L = Q >> parseInt(t[31], n[22])) & f[29]) & ~(L & parseInt(e[27], r[33]))), L = ~(~t[32] & ~L);
|
||
var Z = u[31],
|
||
V = f[5],
|
||
X = u[5];
|
||
a = 16;
|
||
continue e;
|
||
case 3:
|
||
var G = parseInt(r[27], r[26]);
|
||
a = (L = Q <= e[21] + G) ? 10 : 21;
|
||
continue e;
|
||
case 4:
|
||
var J = parseInt(r[23], n[19]),
|
||
Y = H[t[15]](K) - (J - o[23]);
|
||
q += u[0][n[11]](Y), a = 48;
|
||
continue e;
|
||
case 5:
|
||
var $ = t[24];
|
||
a = w ? 18 : 33;
|
||
continue e;
|
||
case 6:
|
||
return new Uint8Array(p)
|
||
}
|
||
continue e;
|
||
case 5:
|
||
switch (s) {
|
||
case 0:
|
||
a = void 0;
|
||
continue e;
|
||
case 1:
|
||
L = Q >> parseInt(f[21], r[26]), L = ~(~e[19] & ~L), p[u[24]](L), L = ~(~(parseInt(n[20], f[11]) & Q) & ~(parseInt(e[20], f[11]) & Q)), L = ~(~(parseInt(f[22], f[23]) & parseInt(f[22], e[18])) & ~L), p[t[26]](L), a = 25;
|
||
continue e;
|
||
case 2:
|
||
a = (L = Q <= parseInt(e[25], l[8])) ? 20 : 25;
|
||
continue e;
|
||
case 3:
|
||
p[j](L), a = 25;
|
||
continue e;
|
||
case 4:
|
||
U++, a = 3;
|
||
continue e;
|
||
case 5:
|
||
var Q = i[g](m);
|
||
a = (L = Q <= u[5] + $) ? 35 : 9;
|
||
continue e;
|
||
case 6:
|
||
a = C ? 0 : 34;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
},
|
||
k = function (i) {
|
||
var a = 9;
|
||
e: for (; void 0 !== a;) {
|
||
var c = 7 & a >> 3;
|
||
switch (7 & a) {
|
||
case 0:
|
||
switch (c) {
|
||
case 0:
|
||
var s = parseInt(f[30], r[2]),
|
||
d = X[r[18]](J) - (parseInt(f[31], e[18]) + s);
|
||
G += u[0][u[13]](d), a = 26;
|
||
continue e;
|
||
case 1:
|
||
ve++, a = 2;
|
||
continue e;
|
||
case 2:
|
||
var h = ~(~(N[u[40]](B) & ~parseInt(o[40], o[33])) & ~(~(N[f[2]](B) & N[r[18]](B)) & parseInt(u[41], f[23])));
|
||
U += f[34][r[30]](h), a = 4;
|
||
continue e;
|
||
case 3:
|
||
a = ve ? 19 : 25;
|
||
continue e;
|
||
case 4:
|
||
var v = ~(~(M[n[4]](T) & ~parseInt(e[33], t[38])) & ~(~(M[o[7]](T) & M[f[2]](T)) & parseInt(o[39], f[33])));
|
||
P += u[0][f[4]](v), a = 17;
|
||
continue e;
|
||
case 5:
|
||
var p = parseInt(f[36], l[20]),
|
||
m = ne[t[15]](ie) - (parseInt(n[31], f[37]) + p);
|
||
oe += o[20][f[4]](m), a = 36;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (c) {
|
||
case 0:
|
||
a = T < M[t[3]] ? 32 : 42;
|
||
continue e;
|
||
case 1:
|
||
var w = e[0],
|
||
_ = i[n[24]],
|
||
y = r[34],
|
||
g = r[12],
|
||
E = f[14],
|
||
k = u[5];
|
||
a = 41;
|
||
continue e;
|
||
case 2:
|
||
T++, a = 1;
|
||
continue e;
|
||
case 3:
|
||
he = l[31] - o[37], a = 19;
|
||
continue e;
|
||
case 4:
|
||
var j = fe[de],
|
||
S = o[38];
|
||
S += l[32], S += n[14];
|
||
var C = q[S += r[39]](j),
|
||
F = u[38];
|
||
V[F += l[33]](fe, C);
|
||
var A = b(ue),
|
||
x = ue[l[23]];
|
||
w = A[t[3]];
|
||
var D = q[n[27]](w);
|
||
V[r[40]](A, D);
|
||
var I = {};
|
||
I[n[28]] = L;
|
||
var M = n[29],
|
||
P = e[1],
|
||
T = u[5];
|
||
a = 1;
|
||
continue e;
|
||
case 5:
|
||
a = k < y[e[28]] ? 10 : 3;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 2:
|
||
switch (c) {
|
||
case 0:
|
||
a = ve < le[n[13]] ? 24 : 33;
|
||
continue e;
|
||
case 1:
|
||
a = k ? 28 : 11;
|
||
continue e;
|
||
case 2:
|
||
a = B < N[u[21]] ? 16 : 27;
|
||
continue e;
|
||
case 3:
|
||
J++, a = 35;
|
||
continue e;
|
||
case 4:
|
||
k++, a = 41;
|
||
continue e;
|
||
case 5:
|
||
I[P] = H, w = [I];
|
||
var R = n[30];
|
||
R += r[41], R += e[34], R += e[35], w = JSON[R](w);
|
||
var N = u[39],
|
||
U = o[17],
|
||
B = r[0];
|
||
a = 18;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 3:
|
||
switch (c) {
|
||
case 0:
|
||
var z = i[g],
|
||
O = i[t[34]],
|
||
L = i[o[35]],
|
||
H = i[r[35]],
|
||
q = i[r[36]],
|
||
K = r[37],
|
||
W = i[K = K[t[35]](e[1])[o[3]]()[e[12]](r[12])],
|
||
Z = e[29];
|
||
w = (w = q[u[34]])[n[25]];
|
||
var V = new Uint8Array(w),
|
||
X = t[36],
|
||
G = u[1],
|
||
J = e[0];
|
||
a = 35;
|
||
continue e;
|
||
case 1:
|
||
var Y = parseInt(u[33], l[27]);
|
||
E = l[28] + Y, a = 28;
|
||
continue e;
|
||
case 2:
|
||
var $ = le[l[16]](ve),
|
||
Q = ~(~($ & ~he) & ~(~$ & he));
|
||
he = $, de += t[8][l[24]](Q), a = 8;
|
||
continue e;
|
||
case 3:
|
||
var ee = l[26][U](w),
|
||
re = b(ee),
|
||
te = re[t[3]],
|
||
ne = f[35],
|
||
oe = u[1],
|
||
ie = u[5];
|
||
a = 43;
|
||
continue e;
|
||
case 4:
|
||
a = J < X[e[28]] ? 0 : 12;
|
||
continue e;
|
||
case 5:
|
||
a = ie < ne[r[1]] ? 40 : 20;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 4:
|
||
switch (c) {
|
||
case 0:
|
||
B++, a = 18;
|
||
continue e;
|
||
case 1:
|
||
w = o[17][o[36]](L, G);
|
||
var ae = u[35];
|
||
ae += e[30], w = w[ae += r[38]](H, u[36]);
|
||
var ce = e[31];
|
||
ce += l[29], w = w[e[32]](_, ce);
|
||
var se = u[37];
|
||
se = se[o[2]](f[5])[u[17]]()[n[26]](l[26]);
|
||
var ue = (w = w[f[32]](z, se))[l[30]](O),
|
||
fe = new Uint8Array(W),
|
||
le = t[37],
|
||
de = t[1],
|
||
he = l[3],
|
||
ve = n[6];
|
||
a = 2;
|
||
continue e;
|
||
case 2:
|
||
var pe = q[oe](te),
|
||
me = l[34];
|
||
V[me = me[r[42]](u[1])[l[35]]()[u[16]](e[1])](re, pe);
|
||
var we = {};
|
||
we[l[36]] = Z;
|
||
var _e = l[37];
|
||
_e += t[39], we[_e += f[38]] = C, we[l[38]] = j;
|
||
var ye = t[13];
|
||
ye += n[32], we[ye += o[41]] = D, we[n[33]] = x;
|
||
var ge = f[19];
|
||
ge += t[40], ge += u[42], we[ge = (ge += u[43])[o[2]](r[12])[u[17]]()[u[16]](o[17])] = pe;
|
||
var Ee = e[30];
|
||
return Ee += e[36], Ee += e[37], Ee += t[41], we[Ee = (Ee += u[43])[o[2]](e[1])[e[38]]()[o[4]](l[26])] = te, we;
|
||
case 3:
|
||
var be = y[t[15]](k),
|
||
ke = ~(~(be & ~E) & ~(~be & E));
|
||
E = be, g += o[20][o[8]](ke), a = 34;
|
||
continue e;
|
||
case 4:
|
||
ie++, a = 43;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
},
|
||
j = function (r, i, a) {
|
||
var c = 9;
|
||
e: for (; void 0 !== c;) {
|
||
var s = 3 & c >> 2;
|
||
switch (3 & c) {
|
||
case 0:
|
||
switch (s) {
|
||
case 0:
|
||
h = i[n[34]](r), c = 13;
|
||
continue e;
|
||
case 1:
|
||
p = i[t[42]], c = 1;
|
||
continue e;
|
||
case 2:
|
||
m = v, c = 6;
|
||
continue e;
|
||
case 3:
|
||
var d = f[39];
|
||
d += t[43], v = r[d = (d += u[44])[l[17]](t[1])[o[3]]()[e[12]](t[1])], c = 8;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (s) {
|
||
case 0:
|
||
var h = p;
|
||
c = h ? 0 : 13;
|
||
continue e;
|
||
case 1:
|
||
var v = r;
|
||
c = v ? 12 : 8;
|
||
continue e;
|
||
case 2:
|
||
e[0];
|
||
var p = i;
|
||
c = p ? 4 : 1;
|
||
continue e;
|
||
case 3:
|
||
var m = h;
|
||
c = m ? 6 : 5;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 2:
|
||
switch (s) {
|
||
case 0:
|
||
return w;
|
||
case 1:
|
||
var w = m;
|
||
c = w ? 2 : 10;
|
||
continue e;
|
||
case 2:
|
||
w = a, c = 2;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
},
|
||
S = function (i) {
|
||
var a = function (a) {
|
||
var c = n[6],
|
||
s = (r[0], t[44]);
|
||
s += n[35], s += t[45];
|
||
var d = a[s += t[46]];
|
||
try {
|
||
var h = 32;
|
||
e: for (; void 0 !== h;) {
|
||
var p = 7 & h >> 3;
|
||
switch (7 & h) {
|
||
case 0:
|
||
switch (p) {
|
||
case 0:
|
||
var m = O[n[4]](q),
|
||
w = ~(~(m & ~H) & ~(~m & H));
|
||
H = m, L += f[34][r[30]](w), h = 16;
|
||
continue e;
|
||
case 1:
|
||
var _ = A[L],
|
||
y = n[8];
|
||
c = d(a[f[42]](I, M, P, B, z, _, D));
|
||
var g = l[40];
|
||
g += t[48], y = JSON[g](c);
|
||
var b = u[47],
|
||
S = t[1],
|
||
C = e[0];
|
||
h = 26;
|
||
continue e;
|
||
case 2:
|
||
q++, h = 34;
|
||
continue e;
|
||
case 3:
|
||
X++, h = 25;
|
||
continue e;
|
||
case 4:
|
||
var F = {};
|
||
F[o[42]] = a, c = v(c = F, i);
|
||
var A = k(c),
|
||
x = u[45],
|
||
D = A[x += o[43]],
|
||
I = A[r[43]],
|
||
M = A[u[46]],
|
||
P = A[e[39]],
|
||
T = o[44],
|
||
R = l[26],
|
||
N = e[0],
|
||
U = t[2];
|
||
h = 1;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (p) {
|
||
case 0:
|
||
h = U < T[n[13]] ? 35 : 17;
|
||
continue e;
|
||
case 1:
|
||
N = parseInt(f[40], o[45]) - parseInt(t[47], e[3]), h = 19;
|
||
continue e;
|
||
case 2:
|
||
var B = A[R],
|
||
z = A[l[39]],
|
||
O = f[41],
|
||
L = e[1],
|
||
H = e[0],
|
||
q = n[6];
|
||
h = 34;
|
||
continue e;
|
||
case 3:
|
||
h = X < Z[l[23]] ? 18 : 33;
|
||
continue e;
|
||
case 4:
|
||
a[V](z), h = y ? 4 : 10;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 2:
|
||
switch (p) {
|
||
case 0:
|
||
U++, h = 1;
|
||
continue e;
|
||
case 1:
|
||
h = void 0;
|
||
continue e;
|
||
case 2:
|
||
var K = parseInt(o[46], o[34]),
|
||
W = Z[l[16]](X) - (u[49] + K);
|
||
V += t[8][t[19]](W), h = 24;
|
||
continue e;
|
||
case 3:
|
||
h = C < b[u[21]] ? 27 : 3;
|
||
continue e;
|
||
case 4:
|
||
h = q < O[t[3]] ? 12 : 8;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 3:
|
||
switch (p) {
|
||
case 0:
|
||
a[S](I), a[r[45]](P);
|
||
var Z = u[48],
|
||
V = l[26],
|
||
X = o[15];
|
||
h = 25;
|
||
continue e;
|
||
case 1:
|
||
C++, h = 26;
|
||
continue e;
|
||
case 2:
|
||
var G = T[f[2]](U),
|
||
J = ~(~(G & ~N) & ~(~G & N));
|
||
N = G, R += e[11][u[13]](J), h = 2;
|
||
continue e;
|
||
case 3:
|
||
var Y = parseInt(r[44], t[20]),
|
||
$ = b[l[16]](C) - (n[37] + Y);
|
||
S += n[38][r[30]]($), h = 11;
|
||
continue e;
|
||
case 4:
|
||
h = U ? 19 : 9;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 4:
|
||
switch (p) {
|
||
case 0:
|
||
var Q = {},
|
||
ee = e[41];
|
||
ee += f[43], ee += o[47], ee += o[48], ee += l[41], ee += e[42], Q[u[50]] = ee, Q[u[51]] = r[46];
|
||
var re = e[43];
|
||
return Q[re = re[f[44]](n[2])[e[38]]()[r[11]](l[26])] = y, void E(c = Q);
|
||
case 1:
|
||
h = q ? 0 : 20;
|
||
continue e;
|
||
case 2:
|
||
var te = parseInt(n[36], u[27]);
|
||
H = e[40] + te, h = 0;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
} catch (i) {
|
||
for (var ne = r[47], oe = f[5], ie = r[0], ae = o[15]; ae < ne[u[21]]; ae++) {
|
||
if (!ae) {
|
||
var ce = t[49];
|
||
ie = parseInt(f[45], n[39]) + ce
|
||
}
|
||
var se = ne[e[44]](ae),
|
||
ue = ~(~(se & ~ie) & ~(~se & ie));
|
||
ie = se, oe += l[13][l[24]](ue)
|
||
}
|
||
var fe = j(i, a, oe),
|
||
le = e[45];
|
||
E({
|
||
type: t[50],
|
||
code: le,
|
||
msg: fe
|
||
})
|
||
}
|
||
},
|
||
c = r[0];
|
||
c = function (i) {
|
||
var a = 4;
|
||
e: for (; void 0 !== a;) {
|
||
var c = 3 & a >> 2;
|
||
switch (3 & a) {
|
||
case 0:
|
||
switch (c) {
|
||
case 0:
|
||
a = h < s[r[1]] ? 1 : 5;
|
||
continue e;
|
||
case 1:
|
||
u[5];
|
||
var s = n[40],
|
||
d = u[1],
|
||
h = o[15];
|
||
a = 0;
|
||
continue e;
|
||
case 2:
|
||
h++, a = 0;
|
||
continue e;
|
||
case 3:
|
||
F++, a = 10;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (c) {
|
||
case 0:
|
||
var v = ~(~(s[r[18]](h) & ~parseInt(u[52], t[28])) & ~(~(s[r[18]](h) & s[f[2]](h)) & parseInt(t[51], u[11])));
|
||
d += r[48][n[11]](v), a = 8;
|
||
continue e;
|
||
case 1:
|
||
var p = j(i, n[8], d),
|
||
m = {},
|
||
w = l[42],
|
||
_ = e[1],
|
||
y = n[6];
|
||
a = 2;
|
||
continue e;
|
||
case 2:
|
||
var g = t[54];
|
||
g = g[r[42]](n[2])[o[3]]()[n[26]](l[26]), m[C] = g, m[u[54]] = p, E(m), a = void 0;
|
||
continue e;
|
||
case 3:
|
||
var b = u[53],
|
||
k = w[e[44]](y) - (b - t[52]);
|
||
_ += r[48][e[46]](k), a = 14;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 2:
|
||
switch (c) {
|
||
case 0:
|
||
a = y < w[e[28]] ? 13 : 6;
|
||
continue e;
|
||
case 1:
|
||
m[e[47]] = _;
|
||
var S = o[49],
|
||
C = t[1],
|
||
F = r[0];
|
||
a = 10;
|
||
continue e;
|
||
case 2:
|
||
a = F < S[t[3]] ? 3 : 9;
|
||
continue e;
|
||
case 3:
|
||
y++, a = 2;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 3:
|
||
switch (c) {
|
||
case 0:
|
||
var A = parseInt(t[53], t[29]),
|
||
x = S[n[4]](F) - (parseInt(o[50], n[22]) + A);
|
||
C += e[11][o[8]](x), a = 12;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
}, (a = g[f[46]](a))[f[47]](c)
|
||
},
|
||
C = function (c) {
|
||
function s() {
|
||
return (s = a(i().mark((function a(s) {
|
||
var d, h, p, m, w, _, y, g, b, S, C, F, A, x, D, I, M, P, T, R, N, U, B, z, O, L, H, q, K, W, Z, V, X, G, J, Y, $, Q, ee, re, te, ne, oe, ie, ae, ce, se, ue, fe;
|
||
return i().wrap((function (i) {
|
||
for (;;) switch (i.prev = i.next) {
|
||
case 0:
|
||
d = t[2], h = n[6], p = f[14], i.prev = 1, m = 19;
|
||
case 3:
|
||
if (void 0 === m) {
|
||
i.next = 91;
|
||
break
|
||
}
|
||
w = 7 & m >> 3, i.t0 = 7 & m, i.next = 0 === i.t0 ? 8 : 1 === i.t0 ? 35 : 2 === i.t0 ? 51 : 3 === i.t0 ? 72 : 89;
|
||
break;
|
||
case 8:
|
||
i.t1 = w, i.next = 0 === i.t1 ? 11 : 1 === i.t1 ? 14 : 2 === i.t1 ? 16 : 3 === i.t1 ? 19 : 4 === i.t1 ? 22 : 34;
|
||
break;
|
||
case 11:
|
||
return _ = q[e[44]](Z), y = ~(~(_ & ~W) & ~(~_ & W)), W = _, K += r[48][n[11]](y), m = 34, i.abrupt("continue", 89);
|
||
case 14:
|
||
return ne++, m = 11, i.abrupt("continue", 89);
|
||
case 16:
|
||
return g = parseInt(o[53], t[28]), b = B[u[40]](O) - (g - parseInt(o[54], r[49])), z += l[13][l[24]](b), m = 3, i.abrupt("continue", 89);
|
||
case 19:
|
||
return S = e[51], A[M] = S, A[r[52]] = F, E(d = A), m = void 0, i.abrupt("continue", 89);
|
||
case 22:
|
||
return d = c[K], h = c[o[55]], C = e[30], C += f[50], C += n[41], C += r[50], p = c[C], H[n[42]](d, h, p), d = H, F = s[t[56]](n[43], d), s[l[49]](Y), s[u[55]](Q), s[n[44]](ee), A = {}, x = (x = u[56])[t[35]](u[1])[e[38]]()[n[26]](t[1]), D = (D = f[51])[l[17]](l[26])[t[7]]()[e[12]](o[17]), A[x] = D, I = t[57], M = t[1], P = r[0], m = 33, i.abrupt("continue", 89);
|
||
case 34:
|
||
return i.abrupt("continue", 89);
|
||
case 35:
|
||
i.t2 = w, i.next = 0 === i.t2 ? 38 : 1 === i.t2 ? 40 : 2 === i.t2 ? 42 : 3 === i.t2 ? 45 : 4 === i.t2 ? 48 : 50;
|
||
break;
|
||
case 38:
|
||
return m = Z ? 0 : 25, i.abrupt("continue", 89);
|
||
case 40:
|
||
return m = Z < q[l[23]] ? 1 : 32, i.abrupt("continue", 89);
|
||
case 42:
|
||
return T = r[51], R = I[e[44]](P) - (parseInt(u[57], u[27]) + T), M += r[48][l[24]](R), m = 27, i.abrupt("continue", 89);
|
||
case 45:
|
||
return N = f[49], W = parseInt(l[48], u[27]) + N, m = 0, i.abrupt("continue", 89);
|
||
case 48:
|
||
return m = P < I[f[52]] ? 17 : 24, i.abrupt("continue", 89);
|
||
case 50:
|
||
return i.abrupt("continue", 89);
|
||
case 51:
|
||
i.t3 = w, i.next = 0 === i.t3 ? 54 : 1 === i.t3 ? 59 : 2 === i.t3 ? 61 : 3 === i.t3 ? 64 : 4 === i.t3 ? 69 : 71;
|
||
break;
|
||
case 54:
|
||
return U = X[te], d = c[l[47]], s[e[49]](d), B = o[52], z = f[5], O = e[0], m = 10, i.abrupt("continue", 89);
|
||
case 59:
|
||
return m = O < B[n[13]] ? 16 : 26, i.abrupt("continue", 89);
|
||
case 61:
|
||
return L = ~(~(re[t[15]](ne) & ~o[51]) & ~(~(re[t[15]](ne) & re[r[18]](ne)) & l[46])), te += f[34][u[13]](L), m = 8, i.abrupt("continue", 89);
|
||
case 64:
|
||
return i.next = 66, s[z](Y, $, ee, U, J);
|
||
case 66:
|
||
return H = [], q = e[50], K = l[26], W = t[2], Z = l[3], m = 9, i.abrupt("continue", 89);
|
||
case 69:
|
||
return Z++, m = 9, i.abrupt("continue", 89);
|
||
case 71:
|
||
return i.abrupt("continue", 89);
|
||
case 72:
|
||
i.t4 = w, i.next = 0 === i.t4 ? 75 : 1 === i.t4 ? 77 : 2 === i.t4 ? 79 : 3 === i.t4 ? 86 : 88;
|
||
break;
|
||
case 75:
|
||
return O++, m = 10, i.abrupt("continue", 89);
|
||
case 77:
|
||
return m = ne < re[r[1]] ? 18 : 2, i.abrupt("continue", 89);
|
||
case 79:
|
||
return (V = {})[l[43]] = s, d = v(d = V, h = c), X = k(d), G = t[55], G += l[44], J = X[G += l[45]], Y = X[f[48]], $ = X[u[46]], Q = X[e[39]], ee = X[l[39]], re = e[48], te = l[26], ne = l[3], m = 11, i.abrupt("continue", 89);
|
||
case 86:
|
||
return P++, m = 33, i.abrupt("continue", 89);
|
||
case 88:
|
||
return i.abrupt("continue", 89);
|
||
case 89:
|
||
i.next = 3;
|
||
break;
|
||
case 91:
|
||
i.next = 100;
|
||
break;
|
||
case 93:
|
||
for (i.prev = 93, i.t5 = i.catch(1), oe = n[45], ie = t[1], ae = n[6]; ae < oe[r[1]]; ae++) ce = ~(~(oe[r[18]](ae) & ~parseInt(r[53], t[29])) & ~(~(oe[o[7]](ae) & oe[n[4]](ae)) & parseInt(l[50], e[3]))), ie += o[20][n[11]](ce);
|
||
se = j(i.t5, s, ie), ue = n[46], ue += r[50], ue += e[52], fe = l[51], fe += e[53], E({
|
||
type: ue,
|
||
code: fe,
|
||
msg: se
|
||
});
|
||
case 100:
|
||
case "end":
|
||
return i.stop()
|
||
}
|
||
}), a, null, [
|
||
[1, 93]
|
||
])
|
||
})))).apply(this, arguments)
|
||
}
|
||
var d = function (e) {
|
||
return s.apply(this, arguments)
|
||
},
|
||
h = o[15],
|
||
p = l[52];
|
||
p += f[53], p += u[58], h = function (i) {
|
||
t[2];
|
||
var a = j(i, u[59], o[56]),
|
||
c = {},
|
||
s = n[47];
|
||
c[s += t[58]] = u[60], c[e[54]] = r[54], c[l[53]] = a, E(c)
|
||
}, (d = g[p](d))[f[47]](h)
|
||
},
|
||
F = function (i) {
|
||
var a = function (a) {
|
||
var c = 4;
|
||
e: for (; void 0 !== c;) {
|
||
var s = 3 & c >> 2;
|
||
switch (3 & c) {
|
||
case 0:
|
||
switch (s) {
|
||
case 0:
|
||
var d = a[u[61]](k, y),
|
||
h = {},
|
||
v = e[55];
|
||
v += f[56], v += f[57];
|
||
var p = e[56];
|
||
p = p[u[3]](e[1])[l[35]]()[n[26]](n[2]), h[v] = p;
|
||
var m = o[57],
|
||
w = r[12],
|
||
_ = t[2];
|
||
c = 10;
|
||
continue e;
|
||
case 1:
|
||
var y = i[l[54]],
|
||
g = t[59];
|
||
a[g = g[n[48]](e[1])[f[6]]()[t[60]](u[1])](y), y = [];
|
||
var b = f[54],
|
||
k = r[12],
|
||
j = e[0];
|
||
c = 8;
|
||
continue e;
|
||
case 2:
|
||
c = j < b[f[52]] ? 5 : 0;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (s) {
|
||
case 0:
|
||
var S = l[55],
|
||
C = m[r[18]](_) - (o[58] + S);
|
||
w += n[38][o[8]](C), c = 2;
|
||
continue e;
|
||
case 1:
|
||
var F = ~(~(b[e[44]](j) & ~parseInt(t[61], f[37])) & ~(~(b[f[2]](j) & b[u[40]](j)) & parseInt(f[55], r[33])));
|
||
k += u[0][n[11]](F), c = 6;
|
||
continue e;
|
||
case 2:
|
||
h[w] = e[51];
|
||
var A = r[55];
|
||
h[A = A[u[3]](u[1])[t[7]]()[u[16]](l[26])] = d, E(y = h), c = void 0;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 2:
|
||
switch (s) {
|
||
case 0:
|
||
_++, c = 10;
|
||
continue e;
|
||
case 1:
|
||
j++, c = 8;
|
||
continue e;
|
||
case 2:
|
||
c = _ < m[o[11]] ? 1 : 9;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
},
|
||
c = e[0],
|
||
s = t[62];
|
||
s = (s += r[56])[t[35]](o[17])[f[6]]()[e[12]](t[1]), c = function (i) {
|
||
var a = 0;
|
||
e: for (; void 0 !== a;) {
|
||
var c = 3 & a >> 2;
|
||
switch (3 & a) {
|
||
case 0:
|
||
switch (c) {
|
||
case 0:
|
||
e[0];
|
||
var s = n[49],
|
||
d = e[1],
|
||
h = n[6];
|
||
a = 4;
|
||
continue e;
|
||
case 1:
|
||
a = h < s[t[3]] ? 1 : 9;
|
||
continue e;
|
||
case 2:
|
||
A++, a = 2;
|
||
continue e;
|
||
case 3:
|
||
var v = S[u[40]](A),
|
||
p = ~(~(v & ~F) & ~(~v & F));
|
||
F = v, C += t[8][e[46]](p), a = 8;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (c) {
|
||
case 0:
|
||
var m = e[57],
|
||
w = s[o[7]](h) - (o[59] + m);
|
||
d += r[48][u[13]](w), a = 5;
|
||
continue e;
|
||
case 1:
|
||
h++, a = 4;
|
||
continue e;
|
||
case 2:
|
||
var _ = j(i, l[56], d),
|
||
y = {},
|
||
g = l[44];
|
||
g = (g += n[50])[t[35]](r[12])[l[35]]()[n[26]](e[1]);
|
||
var b = r[57];
|
||
b += e[54], b += f[58], y[g] = b;
|
||
var k = t[63];
|
||
k += t[64];
|
||
var S = f[59],
|
||
C = u[1],
|
||
F = o[15],
|
||
A = o[15];
|
||
a = 2;
|
||
continue e;
|
||
case 3:
|
||
y[k] = C, y[f[60]] = _, E(y), a = void 0;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 2:
|
||
switch (c) {
|
||
case 0:
|
||
a = A < S[n[13]] ? 6 : 13;
|
||
continue e;
|
||
case 1:
|
||
a = A ? 12 : 10;
|
||
continue e;
|
||
case 2:
|
||
var x = parseInt(u[62], e[18]);
|
||
F = r[58] + x, a = 12;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
}, (a = g[s](a))[n[51]](c)
|
||
};
|
||
_ = function (i) {
|
||
var a = 11;
|
||
e: for (; void 0 !== a;) {
|
||
var c = 3 & a >> 2;
|
||
switch (3 & a) {
|
||
case 0:
|
||
switch (c) {
|
||
case 0:
|
||
k++, a = 13;
|
||
continue e;
|
||
case 1:
|
||
var s = parseInt(f[61], u[27]),
|
||
d = b[u[40]](k) - (parseInt(f[62], n[21]) + s);
|
||
u[0][e[46]](d), a = 0;
|
||
continue e;
|
||
case 2:
|
||
var h = parseInt(t[65], f[37]);
|
||
D = parseInt(u[66], r[2]) + h, a = 3;
|
||
continue e;
|
||
case 3:
|
||
a = I < A[e[28]] ? 6 : 14;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 1:
|
||
switch (c) {
|
||
case 0:
|
||
v(i), a = 7;
|
||
continue e;
|
||
case 1:
|
||
I++, a = 12;
|
||
continue e;
|
||
case 2:
|
||
var v = w[_];
|
||
a = v ? 1 : 10;
|
||
continue e;
|
||
case 3:
|
||
a = k < b[n[13]] ? 4 : 15;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 2:
|
||
switch (c) {
|
||
case 0:
|
||
_ = i[f[65]], a = 9;
|
||
continue e;
|
||
case 1:
|
||
a = I ? 3 : 8;
|
||
continue e;
|
||
case 2:
|
||
var p = {};
|
||
p[o[64]] = n[53];
|
||
var m = n[54];
|
||
p[m = m[u[3]](e[1])[r[15]]()[o[4]](r[12])] = e[58], p[o[65]] = i, E(p), a = 7;
|
||
continue e;
|
||
case 3:
|
||
j[x] = F, j[o[63]] = S;
|
||
var w = j,
|
||
_ = i;
|
||
a = _ ? 2 : 9;
|
||
continue e
|
||
}
|
||
continue e;
|
||
case 3:
|
||
switch (c) {
|
||
case 0:
|
||
var y = A[n[4]](I),
|
||
g = ~(~(y & ~D) & ~(~y & D));
|
||
D = y, x += f[34][u[13]](g), a = 5;
|
||
continue e;
|
||
case 1:
|
||
a = void 0;
|
||
continue e;
|
||
case 2:
|
||
r[0];
|
||
var b = o[60],
|
||
k = (r[12], r[0]);
|
||
a = 13;
|
||
continue e;
|
||
case 3:
|
||
f[63], u[63], u[64], r[59], f[64], n[52], o[61];
|
||
var j = {};
|
||
j[o[62]] = C;
|
||
var A = u[65],
|
||
x = l[26],
|
||
D = f[14],
|
||
I = t[2];
|
||
a = 12;
|
||
continue e
|
||
}
|
||
continue e
|
||
}
|
||
}
|
||
}, worker[f[66]](_)
|
||
}).call(void 0, [0, "", "111011010", 2, "getOwnPropertySymbols", Object, "etOw", "perty", "split", "187", 16, String, "join", "log", "Mtsop", "h", "push", "30", 8, 192, "3f", 65424, "11100000", 6, 387, "100001111111111111111", 63, "77", "length", 1, "n", "&t", "concat", "1310", "ng", "ify", "el_", "y", "reverse", "str_ptr", 380, "en", "er", "atad", "charCodeAt", "-1", "fromCharCode", "type", "\b3\t3\0\t", "loadTACode", "ȶɂȧɟȫ", "0", "rify", "1", "code", "t", "ciPedoced", 390, "[wasm_worker]fun is empty"], [0, "length", 16, "ncti", "t", "prototype", "rcseD", "trepor", "enumerable", "p", "forEach", "join", "", "674", 185, "reverse", "s", 108, "charCodeAt", "st", "ing", "initInstance", "sse", "227", "ng", "codePointAt", 2, "1101111", "h", 128, "fromCharCode", 423, "1e9", 8, "ȿɖȻɞ", "idx_val", "instance", "reffuBegami", "cat", "c", "set", "ri", "split", "img_ptr", "426", "_free", "0", "ɬȂɡȓɪȚɮȦɃȢɆȣɑȎɫșɫ", String, 10, "e", 503, "data", "261", "-1", "atad", "ht", "de", 639, "ork"], ["function", "", 0, "length", "otpi", "y", "g", "reverse", String, "us", "p", 1, "nPro", "s", "repor", "charCodeAt", "writable", "lo", 173, "fromCharCode", 10, Number, "then", "[wasm_worker]postMsg", 127, 2023, "push", "pu", 2, 16, 507, "110", 128, "1613", "userId", "split", "ī", "N7C&jar", 8, "mg_", "t", "ek", "getExceptionMessage", "a", "UT", "8ToStr", "ing", "10001000", "rse", 189, "encryptHeader", "1033", 247, "81", "1-", "se", "invokerTAFunc", "˴̀˵˶", "pe", "edoCATdaol", "join", "1010101101", "ne", "c", "ode", "10000101"], ["47", "ro", "", Object, "charCodeAt", "h", 0, 1, null, "iptor", "seDy", "fromCharCode", "9V$a\0c\v", "length", "o", "
çèÿ", "565", "eg", "reverse", 8, "3f", 16, 2, "200", "sid", "buffer", "join", "_malloc", "key", "ʾʩʤʽʭ", "st", "1000011000", "t", "str_len", "getExceptionMessage", "F", "111001001", 96, String, 10, "ɾɵɸɩɢɫɯɓɾɺɿɾɩɄɾɩɩ", "m", "push", "jsVerifySignature", "_free", "ȗȄȓȈȇȘȾȄȓȓ", "v", "ty", "split", "ϙϚϘϤϙϚυϞϘϔϚϧϧ", "pyt", "catch", "Messa", "-1", "gsm"], ["fu", "curt", "split", "reverse", "join", "syek", "m\b|3D*z\bgr\0t\r^'J(G+X", "charCodeAt", "fromCharCode", Object, "ly", "length", "ro", "t", "PnwO", 0, "string", "", "b", "jec", String, "a", "
~tuvy~ut", 135, 1, "1100", "s", 63, 10, "̴͚̯͜", "10000000", "push", "38b", 16, 8, "idx_key", "concat", 78, "_", "712", "2df", "r_ptr", "instance", "ed", "ĔŠĒōġńĪ", 2, "27", "ry", "pt", "ϕϡϖϗ", "1011110001", 108, "ºÎÀϫн¦ÀÔ", "100001101", "178", "text", "verify_err", "ϡϭϢϣ", 696, 495, "ʫʮʦ", "ge", "verify", "encryptHeader", "code", "data"], [String, "", "symbol", "split", "110000", 0, "getOwnPropertyDescriptors", 1, "g", "Descr", "c", 8, 486, "fromCharCode", "value", "ytreporPenifed", "join", "reverse", "t", "toPrimitive", "default", "length", "encode", "le", "push", "448", 63, 2, "f0", 16, "63", "ϻϾϸϣ", "3f", "673", "HEAPU8", "co", "&sid=", "=dIresu&", "s", "ʼʰʱʼʾʫ", "charCodeAt", "1337", "p_yek", "_xdi", "ssem", "se", "img_len", "ɩɰɼɯɯ", "ĔěħĚĚ", 158, "type", "code", "1000011011", 472, "msg", "_free", "epyt", "10011010", "en", null, "verify", "invokerTAFunc", "114", "asm_", "w", "ĖųĐſěžĮŇĤ", "ed"], ["unshift", "ħĭġĖģĠ", "charCodeAt", 109, "fromCharCode", "", "reverse", Object, 484, "join", "aa", 16, "ap", 1, 0, "tpir", "enumerable", "bmy", "ˡˡ̐̕˱̗̓̊̎̊̊̆̕ˁ̖̎̔̕ˁ̖̓̆̓̏̕ˁ̂ˁ̗̑̓̊̎̊̊̆̕ˁ̗̖̂̍̆ˏ", "r", "t", "110", "200", 8, "111111", "3f", 188, "f0", "21", 63, "ac", "102", "concat", 10, String, "˄˒ˆˑˑ˔ˈ", "4d", 2, "ptr", "eg", "111101111", "̬͈̰̘͇̫͎̠ͯ̄͡", "_Encrypter", "c", "split", "332", "then", "catch", "img_ptr", 147, "a", "yfirev", "length", "h", "ˊˈ˙˸˟ˁ˞", "1255", "yp", "e", "Pic", "˦˗", "msg", "10110010", "18d", "[w", "er]on", "type", "onMessage"], ["iterator", "on", "snoc", 0, "join", "r", "PnwOte", "ŀŃņŎĿŌ", 2, Object, "defineProperties", "teg", "˙˚˛˞ˣ˚˅˧ˤ˥˚˧˩ˮ", String, "configurable", 407, "charCodeAt", "split", "̦͓̠͈", "406", 16, "ĒĊ", "11110", "length", "fromCharCode", "push", "", 8, 144, "ime=", "concat", 122, "mall", "et", "tes", "reverse", "seed", "i", "img_len", "idx_key_ptr", "pa", "Head", "ņŏńœŚőŕĩņłŅņœ", "instance", "e", "d", 108, "ptt", "111000010", "_free", "1001100001", "-", "t", "msg", "data", 198, null]);
|
||
});
|