『回复列表(11|显示机器人聊天)』
这样能领多少
https://github.com/WebAssembly/wabt/blob/main/docs/decompiler.md
小米MIX2s(白)
var Module = typeof Module != "undefined" ? Module : {};
var moduleOverrides = Object.assign({}, Module);
var arguments_ = [];
var thisProgram = "./this.program";
var quit_ = (status, toThrow) => {
throw toThrow;
};
var ENVIRONMENT_IS_WEB = typeof window == "object";
var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
var ENVIRONMENT_IS_NODE =
typeof process == "object" &&
typeof process.versions == "object" &&
typeof process.versions.node == "string";
var scriptDirectory = "";
function locateFile(path) {
if (Module["locateFile"]) {
return Module["locateFile"](path, scriptDirectory);
}
return scriptDirectory + path;
}
var read_, readAsync, readBinary, setWindowTitle;
function logExceptionOnExit(e) {
if (e instanceof ExitStatus) return;
let toLog = e;
err("exiting due to exception: " + toLog);
}
if (ENVIRONMENT_IS_NODE) {
if (ENVIRONMENT_IS_WORKER) {
scriptDirectory = require("path").dirname(scriptDirectory) + "/";
} else {
scriptDirectory = __dirname + "/";
}
var fs, nodePath;
if (typeof require === "function") {
fs = require("fs");
nodePath = require("path");
}
read_ = (filename, binary) => {
filename = nodePath["normalize"](filename);
return fs.readFileSync(filename, binary ? undefined : "utf8");
};
readBinary = (filename) => {
var ret = read_(filename, true);
if (!ret.buffer) {
ret = new Uint8Array(ret);
}
return ret;
};
readAsync = (filename, onload, onerror) => {
filename = nodePath["normalize"](filename);
fs.readFile(filename, function (err, data) {
if (err) onerror(err);
else onload(data.buffer);
});
};
if (process["argv"].length > 1) {
thisProgram = process["argv"][1].replace(/\\/g, "/");
}
arguments_ = process["argv"].slice(2);
if (typeof module != "undefined") {
module["exports"] = Module;
}
process["on"]("uncaughtException", function (ex) {
if (!(ex instanceof ExitStatus)) {
throw ex;
}
});
process["on"]("unhandledRejection", function (reason) {
throw reason;
});
quit_ = (status, toThrow) => {
if (keepRuntimeAlive()) {
process["exitCode"] = status;
throw toThrow;
}
logExceptionOnExit(toThrow);
process["exit"](status);
};
Module["inspect"] = function () {
return "[Emscripten Module object]";
};
} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
if (ENVIRONMENT_IS_WORKER) {
scriptDirectory = self.location.href;
} else if (typeof document != "undefined" && document.currentScript) {
scriptDirectory = document.currentScript.src;
}
if (scriptDirectory.indexOf("blob:") !== 0) {
scriptDirectory = scriptDirectory.substr(
0,
scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1
);
} else {
scriptDirectory = "";
}
{
read_ = (url) => {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.send(null);
return xhr.responseText;
};
if (ENVIRONMENT_IS_WORKER) {
readBinary = (url) => {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.responseType = "arraybuffer";
xhr.send(null);
return new Uint8Array(xhr.response);
};
}
readAsync = (url, onload, onerror) => {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, true);
xhr.responseType = "arraybuffer";
xhr.onload = () => {
if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
onload(xhr.response);
return;
}
onerror();
};
xhr.onerror = onerror;
xhr.send(null);
};
}
setWindowTitle = (title) => (document.title = title);
} else {
}
var out = Module["print"] || console.log.bind(console);
var err = Module["printErr"] || console.warn.bind(console);
Object.assign(Module, moduleOverrides);
moduleOverrides = null;
if (Module["arguments"]) arguments_ = Module["arguments"];
if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
if (Module["quit"]) quit_ = Module["quit"];
var wasmBinary;
if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
var noExitRuntime = Module["noExitRuntime"] || true;
if (typeof WebAssembly != "object") {
abort("no native wasm support detected");
}
var wasmMemory;
var ABORT = false;
var EXITSTATUS;
var UTF8Decoder =
typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
var endIdx = idx + maxBytesToRead;
var endPtr = idx;
while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
}
var str = "";
while (idx < endPtr) {
var u0 = heapOrArray[idx++];
if (!(u0 & 128)) {
str += String.fromCharCode(u0);
continue;
}
var u1 = heapOrArray[idx++] & 63;
if ((u0 & 224) == 192) {
str += String.fromCharCode(((u0 & 31) << 6) | u1);
continue;
}
var u2 = heapOrArray[idx++] & 63;
if ((u0 & 240) == 224) {
u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
} else {
u0 =
((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
}
if (u0 < 65536) {
str += String.fromCharCode(u0);
} else {
var ch = u0 - 65536;
str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
}
}
return str;
}
function UTF8ToString(ptr, maxBytesToRead) {
return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
}
function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
if (!(maxBytesToWrite > 0)) return 0;
var startIdx = outIdx;
var endIdx = outIdx + maxBytesToWrite - 1;
for (var i = 0; i < str.length; ++i) {
var u = str.charCodeAt(i);
if (u >= 55296 && u <= 57343) {
var u1 = str.charCodeAt(++i);
u = (65536 + ((u & 1023) << 10)) | (u1 & 1023);
}
if (u <= 127) {
if (outIdx >= endIdx) break;
heap[outIdx++] = u;
} else if (u <= 2047) {
if (outIdx + 1 >= endIdx) break;
heap[outIdx++] = 192 | (u >> 6);
heap[outIdx++] = 128 | (u & 63);
} else if (u <= 65535) {
if (outIdx + 2 >= endIdx) break;
heap[outIdx++] = 224 | (u >> 12);
heap[outIdx++] = 128 | ((u >> 6) & 63);
heap[outIdx++] = 128 | (u & 63);
} else {
if (outIdx + 3 >= endIdx) break;
heap[outIdx++] = 240 | (u >> 18);
heap[outIdx++] = 128 | ((u >> 12) & 63);
heap[outIdx++] = 128 | ((u >> 6) & 63);
heap[outIdx++] = 128 | (u & 63);
}
}
heap[outIdx] = 0;
return outIdx - startIdx;
}
function stringToUTF8(str, outPtr, maxBytesToWrite) {
return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
}
function lengthBytesUTF8(str) {
var len = 0;
for (var i = 0; i < str.length; ++i) {
var c = str.charCodeAt(i);
if (c <= 127) {
len++;
} else if (c <= 2047) {
len += 2;
} else if (c >= 55296 && c <= 57343) {
len += 4;
++i;
} else {
len += 3;
}
}
return len;
}
var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
function updateGlobalBufferAndViews(buf) {
buffer = buf;
Module["HEAP8"] = HEAP8 = new Int8Array(buf);
Module["HEAP16"] = HEAP16 = new Int16Array(buf);
Module["HEAP32"] = HEAP32 = new Int32Array(buf);
Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);
Module["HEAPF64"] = HEAPF64 = new Float64Array(buf);
}
var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
var wasmTable;
var __ATPRERUN__ = [];
var __ATINIT__ = [];
var __ATMAIN__ = [];
var __ATPOSTRUN__ = [];
var runtimeInitialized = false;
function keepRuntimeAlive() {
return noExitRuntime;
}
function preRun() {
if (Module["preRun"]) {
if (typeof Module["preRun"] == "function")
Module["preRun"] = [Module["preRun"]];
while (Module["preRun"].length) {
addOnPreRun(Module["preRun"].shift());
}
}
callRuntimeCallbacks(__ATPRERUN__);
}
function initRuntime() {
runtimeInitialized = true;
callRuntimeCallbacks(__ATINIT__);
}
function preMain() {
callRuntimeCallbacks(__ATMAIN__);
}
function postRun() {
if (Module["postRun"]) {
if (typeof Module["postRun"] == "function")
Module["postRun"] = [Module["postRun"]];
while (Module["postRun"].length) {
addOnPostRun(Module["postRun"].shift());
}
}
callRuntimeCallbacks(__ATPOSTRUN__);
}
function addOnPreRun(cb) {
__ATPRERUN__.unshift(cb);
}
function addOnInit(cb) {
__ATINIT__.unshift(cb);
}
function addOnPostRun(cb) {
__ATPOSTRUN__.unshift(cb);
}
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null;
function addRunDependency(id) {
runDependencies++;
if (Module["monitorRunDependencies"]) {
Module["monitorRunDependencies"](runDependencies);
}
}
function removeRunDependency(id) {
runDependencies--;
if (Module["monitorRunDependencies"]) {
Module["monitorRunDependencies"](runDependencies);
}
if (runDependencies == 0) {
if (runDependencyWatcher !== null) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null;
}
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback();
}
}
}
function abort(what) {
{
if (Module["onAbort"]) {
Module["onAbort"](what);
}
}
what = "Aborted(" + what + ")";
err(what);
ABORT = true;
EXITSTATUS = 1;
what += ". Build with -sASSERTIONS for more info.";
var e = new WebAssembly.RuntimeError(what);
throw e;
}
var dataURIPrefix = "data:application/octet-stream;base64,";
function isDataURI(filename) {
return filename.startsWith(dataURIPrefix);
}
function isFileURI(filename) {
return filename.startsWith("file://");
}
var wasmBinaryFile;
wasmBinaryFile = "magic.wasm";
if (!isDataURI(wasmBinaryFile)) {
wasmBinaryFile = locateFile(wasmBinaryFile);
}
function getBinary(file) {
try {
if (file == wasmBinaryFile && wasmBinary) {
return new Uint8Array(wasmBinary);
}
if (readBinary) {
return readBinary(file);
}
throw "both async and sync fetching of the wasm failed";
} catch (err) {
abort(err);
}
}
function getBinaryPromise() {
if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
if (typeof fetch == "function" && !isFileURI(wasmBinaryFile)) {
return fetch(wasmBinaryFile, { credentials: "same-origin" })
.then(function (response) {
if (!response["ok"]) {
throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
}
return response["arrayBuffer"]();
})
.catch(function () {
return getBinary(wasmBinaryFile);
});
} else {
if (readAsync) {
return new Promise(function (resolve, reject) {
readAsync(
wasmBinaryFile,
function (response) {
resolve(new Uint8Array(response));
},
reject
);
});
}
}
}
return Promise.resolve().then(function () {
return getBinary(wasmBinaryFile);
});
}
function createWasm() {
var info = { a: asmLibraryArg };
function receiveInstance(instance, module) {
var exports = instance.exports;
Module["asm"] = exports;
wasmMemory = Module["asm"]["v"];
updateGlobalBufferAndViews(wasmMemory.buffer);
wasmTable = Module["asm"]["x"];
addOnInit(Module["asm"]["w"]);
removeRunDependency("wasm-instantiate");
}
addRunDependency("wasm-instantiate");
function receiveInstantiationResult(result) {
receiveInstance(result["instance"]);
}
function instantiateArrayBuffer(receiver) {
return getBinaryPromise()
.then(function (binary) {
return WebAssembly.instantiate(binary, info);
})
.then(function (instance) {
return instance;
})
.then(receiver, function (reason) {
err("failed to asynchronously prepare wasm: " + reason);
abort(reason);
});
}
function instantiateAsync() {
if (
!wasmBinary &&
typeof WebAssembly.instantiateStreaming == "function" &&
!isDataURI(wasmBinaryFile) &&
!isFileURI(wasmBinaryFile) &&
!ENVIRONMENT_IS_NODE &&
typeof fetch == "function"
) {
return fetch(wasmBinaryFile, { credentials: "same-origin" }).then(
function (response) {
var result = WebAssembly.instantiateStreaming(response, info);
return result.then(receiveInstantiationResult, function (reason) {
err("wasm streaming compile failed: " + reason);
err("falling back to ArrayBuffer instantiation");
return instantiateArrayBuffer(receiveInstantiationResult);
});
}
);
} else {
return instantiateArrayBuffer(receiveInstantiationResult);
}
}
if (Module["instantiateWasm"]) {
try {
var exports = Module["instantiateWasm"](info, receiveInstance);
return exports;
} catch (e) {
err("Module.instantiateWasm callback failed with error: " + e);
return false;
}
}
instantiateAsync();
return {};
}
function ExitStatus(status) {
this.name = "ExitStatus";
this.message = "Program terminated with exit(" + status + ")";
this.status = status;
}
function callRuntimeCallbacks(callbacks) {
while (callbacks.length > 0) {
callbacks.shift()(Module);
}
}
function ___cxa_allocate_exception(size) {
return _malloc(size + 24) + 24;
}
function ExceptionInfo(excPtr) {
this.excPtr = excPtr;
this.ptr = excPtr - 24;
this.set_type = function (type) {
HEAPU32[(this.ptr + 4) >> 2] = type;
};
this.get_type = function () {
return HEAPU32[(this.ptr + 4) >> 2];
};
this.set_destructor = function (destructor) {
HEAPU32[(this.ptr + 8) >> 2] = destructor;
};
this.get_destructor = function () {
return HEAPU32[(this.ptr + 8) >> 2];
};
this.set_refcount = function (refcount) {
HEAP32[this.ptr >> 2] = refcount;
};
this.set_caught = function (caught) {
caught = caught ? 1 : 0;
HEAP8[(this.ptr + 12) >> 0] = caught;
};
this.get_caught = function () {
return HEAP8[(this.ptr + 12) >> 0] != 0;
};
this.set_rethrown = function (rethrown) {
rethrown = rethrown ? 1 : 0;
HEAP8[(this.ptr + 13) >> 0] = rethrown;
};
this.get_rethrown = function () {
return HEAP8[(this.ptr + 13) >> 0] != 0;
};
this.init = function (type, destructor) {
this.set_adjusted_ptr(0);
this.set_type(type);
this.set_destructor(destructor);
this.set_refcount(0);
this.set_caught(false);
this.set_rethrown(false);
};
this.add_ref = function () {
var value = HEAP32[this.ptr >> 2];
HEAP32[this.ptr >> 2] = value + 1;
};
this.release_ref = function () {
var prev = HEAP32[this.ptr >> 2];
HEAP32[this.ptr >> 2] = prev - 1;
return prev === 1;
};
this.set_adjusted_ptr = function (adjustedPtr) {
HEAPU32[(this.ptr + 16) >> 2] = adjustedPtr;
};
this.get_adjusted_ptr = function () {
return HEAPU32[(this.ptr + 16) >> 2];
};
this.get_exception_ptr = function () {
var isPointer = ___cxa_is_pointer_type(this.get_type());
if (isPointer) {
return HEAPU32[this.excPtr >> 2];
}
var adjusted = this.get_adjusted_ptr();
if (adjusted !== 0) return adjusted;
return this.excPtr;
};
}
var exceptionLast = 0;
var uncaughtExceptionCount = 0;
function ___cxa_throw(ptr, type, destructor) {
var info = new ExceptionInfo(ptr);
info.init(type, destructor);
exceptionLast = ptr;
uncaughtExceptionCount++;
throw ptr;
}
function __embind_register_bigint(
primitiveType,
name,
size,
minRange,
maxRange
) {}
function getShiftFromSize(size) {
switch (size) {
case 1:
return 0;
case 2:
return 1;
case 4:
return 2;
case 8:
return 3;
default:
throw new TypeError("Unknown type size: " + size);
}
}
function embind_init_charCodes() {
var codes = new Array(256);
for (var i = 0; i < 256; ++i) {
codes[i] = String.fromCharCode(i);
}
embind_charCodes = codes;
}
var embind_charCodes = undefined;
function readLatin1String(ptr) {
var ret = "";
var c = ptr;
while (HEAPU8[c]) {
ret += embind_charCodes[HEAPU8[c++]];
}
return ret;
}
var awaitingDependencies = {};
var registeredTypes = {};
var typeDependencies = {};
var char_0 = 48;
var char_9 = 57;
function makeLegalFunctionName(name) {
if (undefined === name) {
return "_unknown";
}
name = name.replace(/[^a-zA-Z0-9_]/g, "$");
var f = name.charCodeAt(0);
if (f >= char_0 && f <= char_9) {
return "_" + name;
}
return name;
}
function createNamedFunction(name, body) {
name = makeLegalFunctionName(name);
return new Function(
"body",
"return function " +
name +
"() {\n" +
' "use strict";' +
" return body.apply(this, arguments);\n" +
"};\n"
)(body);
}
function extendError(baseErrorType, errorName) {
var errorClass = createNamedFunction(errorName, function (message) {
this.name = errorName;
this.message = message;
var stack = new Error(message).stack;
if (stack !== undefined) {
this.stack =
this.toString() + "\n" + stack.replace(/^Error(:[^\n]*)?\n/, "");
}
});
errorClass.prototype = Object.create(baseErrorType.prototype);
errorClass.prototype.constructor = errorClass;
errorClass.prototype.toString = function () {
if (this.message === undefined) {
return this.name;
} else {
return this.name + ": " + this.message;
}
};
return errorClass;
}
var BindingError = undefined;
function throwBindingError(message) {
throw new BindingError(message);
}
var InternalError = undefined;
function throwInternalError(message) {
throw new InternalError(message);
}
function whenDependentTypesAreResolved(
myTypes,
dependentTypes,
getTypeConverters
) {
myTypes.forEach(function (type) {
typeDependencies[type] = dependentTypes;
});
function onComplete(typeConverters) {
var myTypeConverters = getTypeConverters(typeConverters);
if (myTypeConverters.length !== myTypes.length) {
throwInternalError("Mismatched type converter count");
}
for (var i = 0; i < myTypes.length; ++i) {
registerType(myTypes[i], myTypeConverters[i]);
}
}
var typeConverters = new Array(dependentTypes.length);
var unregisteredTypes = [];
var registered = 0;
dependentTypes.forEach((dt, i) => {
if (registeredTypes.hasOwnProperty(dt)) {
typeConverters[i] = registeredTypes[dt];
} else {
unregisteredTypes.push(dt);
if (!awaitingDependencies.hasOwnProperty(dt)) {
awaitingDependencies[dt] = [];
}
awaitingDependencies[dt].push(() => {
typeConverters[i] = registeredTypes[dt];
++registered;
if (registered === unregisteredTypes.length) {
onComplete(typeConverters);
}
});
}
});
if (0 === unregisteredTypes.length) {
onComplete(typeConverters);
}
}
function registerType(rawType, registeredInstance, options = {}) {
if (!("argPackAdvance" in registeredInstance)) {
throw new TypeError(
"registerType registeredInstance requires argPackAdvance"
);
}
var name = registeredInstance.name;
if (!rawType) {
throwBindingError(
'type "' + name + '" must have a positive integer typeid pointer'
);
}
if (registeredTypes.hasOwnProperty(rawType)) {
if (options.ignoreDuplicateRegistrations) {
return;
} else {
throwBindingError("Cannot register type '" + name + "' twice");
}
}
registeredTypes[rawType] = registeredInstance;
delete typeDependencies[rawType];
if (awaitingDependencies.hasOwnProperty(rawType)) {
var callbacks = awaitingDependencies[rawType];
delete awaitingDependencies[rawType];
callbacks.forEach((cb) => cb());
}
}
function __embind_register_bool(rawType, name, size, trueValue, falseValue) {
var shift = getShiftFromSize(size);
name = readLatin1String(name);
registerType(rawType, {
name: name,
fromWireType: function (wt) {
return !!wt;
},
toWireType: function (destructors, o) {
return o ? trueValue : falseValue;
},
argPackAdvance: 8,
readValueFromPointer: function (pointer) {
var heap;
if (size === 1) {
heap = HEAP8;
} else if (size === 2) {
heap = HEAP16;
} else if (size === 4) {
heap = HEAP32;
} else {
throw new TypeError("Unknown boolean type size: " + name);
}
return this["fromWireType"](heap[pointer >> shift]);
},
destructorFunction: null
});
}
var emval_free_list = [];
var emval_handle_array = [
{},
{ value: undefined },
{ value: null },
{ value: true },
{ value: false }
];
function __emval_decref(handle) {
if (handle > 4 && 0 === --emval_handle_array[handle].refcount) {
emval_handle_array[handle] = undefined;
emval_free_list.push(handle);
}
}
function count_emval_handles() {
var count = 0;
for (var i = 5; i < emval_handle_array.length; ++i) {
if (emval_handle_array[i] !== undefined) {
++count;
}
}
return count;
}
function get_first_emval() {
for (var i = 5; i < emval_handle_array.length; ++i) {
if (emval_handle_array[i] !== undefined) {
return emval_handle_array[i];
}
}
return null;
}
function init_emval() {
Module["count_emval_handles"] = count_emval_handles;
Module["get_first_emval"] = get_first_emval;
}
var Emval = {
toValue: (handle) => {
if (!handle) {
throwBindingError("Cannot use deleted val. handle = " + handle);
}
return emval_handle_array[handle].value;
},
toHandle: (value) => {
switch (value) {
case undefined:
return 1;
case null:
return 2;
case true:
return 3;
case false:
return 4;
default: {
var handle = emval_free_list.length
? emval_free_list.pop()
: emval_handle_array.length;
emval_handle_array[handle] = { refcount: 1, value: value };
return handle;
}
}
}
};
function simpleReadValueFromPointer(pointer) {
return this["fromWireType"](HEAP32[pointer >> 2]);
}
function __embind_register_emval(rawType, name) {
name = readLatin1String(name);
registerType(rawType, {
name: name,
fromWireType: function (handle) {
var rv = Emval.toValue(handle);
__emval_decref(handle);
return rv;
},
toWireType: function (destructors, value) {
return Emval.toHandle(value);
},
argPackAdvance: 8,
readValueFromPointer: simpleReadValueFromPointer,
destructorFunction: null
});
}
function floatReadValueFromPointer(name, shift) {
switch (shift) {
case 2:
return function (pointer) {
return this["fromWireType"](HEAPF32[pointer >> 2]);
};
case 3:
return function (pointer) {
return this["fromWireType"](HEAPF64[pointer >> 3]);
};
default:
throw new TypeError("Unknown float type: " + name);
}
}
function __embind_register_float(rawType, name, size) {
var shift = getShiftFromSize(size);
name = readLatin1String(name);
registerType(rawType, {
name: name,
fromWireType: function (value) {
return value;
},
toWireType: function (destructors, value) {
return value;
},
argPackAdvance: 8,
readValueFromPointer: floatReadValueFromPointer(name, shift),
destructorFunction: null
});
}
function new_(constructor, argumentList) {
if (!(constructor instanceof Function)) {
throw new TypeError(
"new_ called with constructor type " +
typeof constructor +
" which is not a function"
);
}
var dummy = createNamedFunction(
constructor.name || "unknownFunctionName",
function () {}
);
dummy.prototype = constructor.prototype;
var obj = new dummy();
var r = constructor.apply(obj, argumentList);
return r instanceof Object ? r : obj;
}
function runDestructors(destructors) {
while (destructors.length) {
var ptr = destructors.pop();
var del = destructors.pop();
del(ptr);
}
}
function craftInvokerFunction(
humanName,
argTypes,
classType,
cppInvokerFunc,
cppTargetFunc
) {
var argCount = argTypes.length;
if (argCount < 2) {
throwBindingError(
"argTypes array size mismatch! Must at least get return value and 'this' types!"
);
}
var isClassMethodFunc = argTypes[1] !== null && classType !== null;
var needsDestructorStack = false;
for (var i = 1; i < argTypes.length; ++i) {
if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {
needsDestructorStack = true;
break;
}
}
var returns = argTypes[0].name !== "void";
var argsList = "";
var argsListWired = "";
for (var i = 0; i < argCount - 2; ++i) {
argsList += (i !== 0 ? ", " : "") + "arg" + i;
argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired";
}
var invokerFnBody =
"return function " +
makeLegalFunctionName(humanName) +
"(" +
argsList +
") {\n" +
"if (arguments.length !== " +
(argCount - 2) +
") {\n" +
"throwBindingError('function " +
humanName +
" called with ' + arguments.length + ' arguments, expected " +
(argCount - 2) +
" args!');\n" +
"}\n";
if (needsDestructorStack) {
invokerFnBody += "var destructors = [];\n";
}
var dtorStack = needsDestructorStack ? "destructors" : "null";
var args1 = [
"throwBindingError",
"invoker",
"fn",
"runDestructors",
"retType",
"classParam"
];
var args2 = [
throwBindingError,
cppInvokerFunc,
cppTargetFunc,
runDestructors,
argTypes[0],
argTypes[1]
];
if (isClassMethodFunc) {
invokerFnBody +=
"var thisWired = classParam.toWireType(" + dtorStack + ", this);\n";
}
for (var i = 0; i < argCount - 2; ++i) {
invokerFnBody +=
"var arg" +
i +
"Wired = argType" +
i +
".toWireType(" +
dtorStack +
", arg" +
i +
"); // " +
argTypes[i + 2].name +
"\n";
args1.push("argType" + i);
args2.push(argTypes[i + 2]);
}
if (isClassMethodFunc) {
argsListWired =
"thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired;
}
invokerFnBody +=
(returns ? "var rv = " : "") +
"invoker(fn" +
(argsListWired.length > 0 ? ", " : "") +
argsListWired +
");\n";
if (needsDestructorStack) {
invokerFnBody += "runDestructors(destructors);\n";
} else {
for (var i = isClassMethodFunc ? 1 : 2; i < .length; ++i) {
var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired";
if (argTypes[i].destructorFunction !== null) {
invokerFnBody +=
paramName + "_dtor(" + paramName + "); // " + argTypes[i].name + "\n";
args1.push(paramName + "_dtor");
args2.push(argTypes[i].destructorFunction);
}
}
}
if (returns) {
invokerFnBody += "var ret = retType.fromWireType(rv);\n" + "return ret;\n";
} else {
}
invokerFnBody += "}\n";
args1.push(invokerFnBody);
var invokerFunction = new_(Function, args1).apply(null, args2);
console.log('invokerFnBody:', invokerFnBody, invokerFunction);
return invokerFunction;
}
function ensureOverloadTable(proto, methodName, humanName) {
if (undefined === proto[methodName].overloadTable) {
var prevFunc = proto[methodName];
proto[methodName] = function () {
if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
throwBindingError(
"Function '" +
humanName +
"' called with an invalid number of arguments (" +
arguments.length +
") - expects one of (" +
proto[methodName].overloadTable +
")!"
);
}
return proto[methodName].overloadTable[arguments.length].apply(
this,
arguments
);
};
proto[methodName].overloadTable = [];
proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
}
}
function exposePublicSymbol(name, value, numArguments) {
if (Module.hasOwnProperty(name)) {
if (
undefined === numArguments ||
(undefined !== Module[name].overloadTable &&
undefined !== Module[name].overloadTable[numArguments])
) {
throwBindingError("Cannot register public name '" + name + "' twice");
}
ensureOverloadTable(Module, name, name);
if (Module.hasOwnProperty(numArguments)) {
throwBindingError(
"Cannot register multiple overloads of a function with the same number of arguments (" +
numArguments +
")!"
);
}
Module[name].overloadTable[numArguments] = value;
} else {
Module[name] = value;
if (undefined !== numArguments) {
Module[name].numArguments = numArguments;
}
}
}
function heap32VectorToArray(count, firstElement) {
var array = [];
for (var i = 0; i < count; i++) {
array.push(HEAPU32[(firstElement + i * 4) >> 2]);
}
return array;
}
function replacePublicSymbol(name, value, numArguments) {
if (!Module.hasOwnProperty(name)) {
throwInternalError("Replacing nonexistant public symbol");
}
if (undefined !== Module[name].overloadTable && undefined !== numArguments) {
Module[name].overloadTable[numArguments] = value;
} else {
Module[name] = value;
Module[name].argCount = numArguments;
}
}
function dynCallLegacy(sig, ptr, args) {
var f = Module["dynCall_" + sig];
return args && args.length
? f.apply(null, [ptr].concat(args))
: f.call(null, ptr);
}
function getWasmTableEntry(funcPtr) {
return wasmTable.get(funcPtr);
}
function dynCall(sig, ptr, args) {
if (sig.includes("j")) {
return dynCallLegacy(sig, ptr, args);
}
var rtn = getWasmTableEntry(ptr).apply(null, args);
return rtn;
}
function getDynCaller(sig, ptr) {
var argCache = [];
return function () {
argCache.length = 0;
Object.assign(argCache, arguments);
return dynCall(sig, ptr, argCache);
};
}
function embind__requireFunction(signature, rawFunction) {
signature = readLatin1String(signature);
function makeDynCaller() {
if (signature.includes("j")) {
return getDynCaller(signature, rawFunction);
}
return getWasmTableEntry(rawFunction);
}
var fp = makeDynCaller();
if (typeof fp != "function") {
throwBindingError(
"unknown function pointer with signature " +
signature +
": " +
rawFunction
);
}
return fp;
}
var UnboundTypeError = undefined;
function getTypeName(type) {
var ptr = ___getTypeName(type);
var rv = readLatin1String(ptr);
_free(ptr);
return rv;
}
function throwUnboundTypeError(message, types) {
var unboundTypes = [];
var seen = {};
function visit(type) {
if (seen[type]) {
return;
}
if (registeredTypes[type]) {
return;
}
if (typeDependencies[type]) {
typeDependencies[type].forEach(visit);
return;
}
unboundTypes.push(type);
seen[type] = true;
}
types.forEach(visit);
throw new UnboundTypeError(
message + ": " + unboundTypes.map(getTypeName).join([", "])
);
}
function __embind_register_function(
name,
argCount,
rawArgTypesAddr,
signature,
rawInvoker,
fn
) {
var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
name = readLatin1String(name);
rawInvoker = embind__requireFunction(signature, rawInvoker);
exposePublicSymbol(
name,
function () {
throwUnboundTypeError(
"Cannot call " + name + " due to unbound types",
argTypes
);
},
argCount - 1
);
whenDependentTypesAreResolved([], argTypes, function (argTypes) {
var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1));
replacePublicSymbol(
name,
craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn),
argCount - 1
);
return [];
});
}
function integerReadValueFromPointer(name, shift, signed) {
switch (shift) {
case 0:
return signed
? function readS8FromPointer(pointer) {
return HEAP8[pointer];
}
: function readU8FromPointer(pointer) {
return HEAPU8[pointer];
};
case 1:
return signed
? function readS16FromPointer(pointer) {
return HEAP16[pointer >> 1];
}
: function readU16FromPointer(pointer) {
return HEAPU16[pointer >> 1];
};
case 2:
return signed
? function readS32FromPointer(pointer) {
return HEAP32[pointer >> 2];
}
: function readU32FromPointer(pointer) {
return HEAPU32[pointer >> 2];
};
default:
throw new TypeError("Unknown integer type: " + name);
}
}
function __embind_register_integer(
primitiveType,
name,
size,
minRange,
maxRange
) {
name = readLatin1String(name);
if (maxRange === -1) {
maxRange = 4294967295;
}
var shift = getShiftFromSize(size);
var fromWireType = (value) => value;
if (minRange === 0) {
var bitshift = 32 - 8 * size;
fromWireType = (value) => (value << bitshift) >>> bitshift;
}
var isUnsignedType = name.includes("unsigned");
var checkAssertions = (value, toTypeName) => {};
var toWireType;
if (isUnsignedType) {
toWireType = function (destructors, value) {
checkAssertions(value, this.name);
return value >>> 0;
};
} else {
toWireType = function (destructors, value) {
checkAssertions(value, this.name);
return value;
};
}
registerType(primitiveType, {
name: name,
fromWireType: fromWireType,
toWireType: toWireType,
argPackAdvance: 8,
readValueFromPointer: integerReadValueFromPointer(
name,
shift,
minRange !== 0
),
destructorFunction: null
});
}
function __embind_register_memory_view(rawType, dataTypeIndex, name) {
var typeMapping = [
Int8Array,
Uint8Array,
Int16Array,
Uint16Array,
Int32Array,
Uint32Array,
Float32Array,
Float64Array
];
var TA = typeMapping[dataTypeIndex];
function decodeMemoryView(handle) {
handle = handle >> 2;
var heap = HEAPU32;
var size = heap[handle];
var data = heap[handle + 1];
return new TA(buffer, data, size);
}
name = readLatin1String(name);
registerType(
rawType,
{
name: name,
fromWireType: decodeMemoryView,
argPackAdvance: 8,
readValueFromPointer: decodeMemoryView
},
{ ignoreDuplicateRegistrations: true }
);
}
function __embind_register_std_string(rawType, name) {
name = readLatin1String(name);
var stdStringIsUTF8 = name === "std::string";
registerType(rawType, {
name: name,
fromWireType: function (value) {
var length = HEAPU32[value >> 2];
var payload = value + 4;
var str;
if (stdStringIsUTF8) {
var decodeStartPtr = payload;
for (var i = 0; i <= length; ++i) {
var currentBytePtr = payload + i;
if (i == length || HEAPU8[currentBytePtr] == 0) {
var maxRead = currentBytePtr - decodeStartPtr;
var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
if (str === undefined) {
str = stringSegment;
} else {
str += String.fromCharCode(0);
str += stringSegment;
}
decodeStartPtr = currentBytePtr + 1;
}
}
} else {
var a = new Array(length);
for (var i = 0; i < length; ++i) {
a[i] = String.fromCharCode(HEAPU8[payload + i]);
}
str = a.join("");
}
_free(value);
return str;
},
toWireType: function (destructors, value) {
if (value instanceof ArrayBuffer) {
value = new Uint8Array(value);
}
var length;
var valueIsOfTypeString = typeof value == "string";
if (
!(
valueIsOfTypeString ||
value instanceof Uint8Array ||
value instanceof Uint8ClampedArray ||
value instanceof Int8Array
)
) {
throwBindingError("Cannot pass non-string to std::string");
}
if (stdStringIsUTF8 && valueIsOfTypeString) {
length = lengthBytesUTF8(value);
} else {
length = value.length;
}
var base = _malloc(4 + length + 1);
var ptr = base + 4;
HEAPU32[base >> 2] = length;
if (stdStringIsUTF8 && valueIsOfTypeString) {
stringToUTF8(value, ptr, length + 1);
} else {
if (valueIsOfTypeString) {
for (var i = 0; i < length; ++i) {
var charCode = value.charCodeAt(i);
if (charCode > 255) {
_free(ptr);
throwBindingError(
"String has UTF-16 code units that do not fit in 8 bits"
);
}
HEAPU8[ptr + i] = charCode;
}
} else {
for (var i = 0; i < length; ++i) {
HEAPU8[ptr + i] = value[i];
}
}
}
if (destructors !== null) {
destructors.push(_free, base);
}
return base;
},
argPackAdvance: 8,
readValueFromPointer: simpleReadValueFromPointer,
destructorFunction: function (ptr) {
_free(ptr);
}
});
}
var UTF16Decoder =
typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : undefined;
function UTF16ToString(ptr, maxBytesToRead) {
var endPtr = ptr;
var idx = endPtr >> 1;
var maxIdx = idx + maxBytesToRead / 2;
while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx;
endPtr = idx << 1;
if (endPtr - ptr > 32 && UTF16Decoder)
return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
var str = "";
for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
var codeUnit = HEAP16[(ptr + i * 2) >> 1];
if (codeUnit == 0) break;
str += String.fromCharCode(codeUnit);
}
return str;
}
function stringToUTF16(str, outPtr, maxBytesToWrite) {
if (maxBytesToWrite === undefined) {
maxBytesToWrite = 2147483647;
}
if (maxBytesToWrite < 2) return 0;
maxBytesToWrite -= 2;
var startPtr = outPtr;
var numCharsToWrite =
maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
for (var i = 0; i < numCharsToWrite; ++i) {
var codeUnit = str.charCodeAt(i);
HEAP16[outPtr >> 1] = codeUnit;
outPtr += 2;
}
HEAP16[outPtr >> 1] = 0;
return outPtr - startPtr;
}
function lengthBytesUTF16(str) {
return str.length * 2;
}
function UTF32ToString(ptr, maxBytesToRead) {
var i = 0;
var str = "";
while (!(i >= maxBytesToRead / 4)) {
var utf32 = HEAP32[(ptr + i * 4) >> 2];
if (utf32 == 0) break;
++i;
if (utf32 >= 65536) {
var ch = utf32 - 65536;
str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
} else {
str += String.fromCharCode(utf32);
}
}
return str;
}
function stringToUTF32(str, outPtr, maxBytesToWrite) {
if (maxBytesToWrite === undefined) {
maxBytesToWrite = 2147483647;
}
if (maxBytesToWrite < 4) return 0;
var startPtr = outPtr;
var endPtr = startPtr + maxBytesToWrite - 4;
for (var i = 0; i < str.length; ++i) {
var codeUnit = str.charCodeAt(i);
if (codeUnit >= 55296 && codeUnit <= 57343) {
var trailSurrogate = str.charCodeAt(++i);
codeUnit = (65536 + ((codeUnit & 1023) << 10)) | (trailSurrogate & 1023);
}
HEAP32[outPtr >> 2] = codeUnit;
outPtr += 4;
if (outPtr + 4 > endPtr) break;
}
HEAP32[outPtr >> 2] = 0;
return outPtr - startPtr;
}
function lengthBytesUTF32(str) {
var len = 0;
for (var i = 0; i < str.length; ++i) {
var codeUnit = str.charCodeAt(i);
if (codeUnit >= 55296 && codeUnit <= 57343) ++i;
len += 4;
}
return len;
}
function __embind_register_std_wstring(rawType, charSize, name) {
name = readLatin1String(name);
var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
if (charSize === 2) {
decodeString = UTF16ToString;
encodeString = stringToUTF16;
lengthBytesUTF = lengthBytesUTF16;
getHeap = () => HEAPU16;
shift = 1;
} else if (charSize === 4) {
decodeString = UTF32ToString;
encodeString = stringToUTF32;
lengthBytesUTF = lengthBytesUTF32;
getHeap = () => HEAPU32;
shift = 2;
}
registerType(rawType, {
name: name,
fromWireType: function (value) {
var length = HEAPU32[value >> 2];
var HEAP = getHeap();
var str;
var decodeStartPtr = value + 4;
for (var i = 0; i <= length; ++i) {
var currentBytePtr = value + 4 + i * charSize;
if (i == length || HEAP[currentBytePtr >> shift] == 0) {
var maxReadBytes = currentBytePtr - decodeStartPtr;
var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
if (str === undefined) {
str = stringSegment;
} else {
str += String.fromCharCode(0);
str += stringSegment;
}
decodeStartPtr = currentBytePtr + charSize;
}
}
_free(value);
return str;
},
toWireType: function (destructors, value) {
if (!(typeof value == "string")) {
throwBindingError("Cannot pass non-string to C++ string type " + name);
}
var length = lengthBytesUTF(value);
var ptr = _malloc(4 + length + charSize);
HEAPU32[ptr >> 2] = length >> shift;
encodeString(value, ptr + 4, length + charSize);
if (destructors !== null) {
destructors.push(_free, ptr);
}
return ptr;
},
argPackAdvance: 8,
readValueFromPointer: simpleReadValueFromPointer,
destructorFunction: function (ptr) {
_free(ptr);
}
});
}
function __embind_register_void(rawType, name) {
name = readLatin1String(name);
registerType(rawType, {
isVoid: true,
name: name,
argPackAdvance: 0,
fromWireType: function () {
return undefined;
},
toWireType: function (destructors, o) {
return undefined;
}
});
}
function requireRegisteredType(rawType, humanName) {
var impl = registeredTypes[rawType];
if (undefined === impl) {
throwBindingError(humanName + " has unknown type " + getTypeName(rawType));
}
return impl;
}
function __emval_as(handle, returnType, destructorsRef) {
handle = Emval.toValue(handle);
returnType = requireRegisteredType(returnType, "emval::as");
var destructors = [];
var rd = Emval.toHandle(destructors);
HEAPU32[destructorsRef >> 2] = rd;
return returnType["toWireType"](destructors, handle);
}
var emval_symbols = {};
function getStringOrSymbol(address) {
var symbol = emval_symbols[address];
if (symbol === undefined) {
return readLatin1String(address);
}
return symbol;
}
function emval_get_global() {
if (typeof globalThis == "object") {
return globalThis;
}
return (function () {
return Function;
})()("return this")();
}
function __emval_get_global(name) {
if (name === 0) {
return Emval.toHandle(emval_get_global());
} else {
name = getStringOrSymbol(name);
return Emval.toHandle(emval_get_global()[name]);
}
}
function __emval_get_property(handle, key) {
handle = Emval.toValue(handle);
key = Emval.toValue(key);
return Emval.toHandle(handle[key]);
}
function __emval_run_destructors(handle) {
var destructors = Emval.toValue(handle);
runDestructors(destructors);
__emval_decref(handle);
}
function __emval_take_value(type, arg) {
type = requireRegisteredType(type, "_emval_take_value");
var v = type["readValueFromPointer"](arg);
return Emval.toHandle(v);
}
function _abort() {
abort("");
}
function abortOnCannotGrowMemory(requestedSize) {
abort("OOM");
}
function _emscripten_resize_heap(requestedSize) {
var oldSize = HEAPU8.length;
requestedSize = requestedSize >>> 0;
abortOnCannotGrowMemory(requestedSize);
}
var printCharBuffers = [null, [], []];
function printChar(stream, curr) {
var buffer = printCharBuffers[stream];
if (curr === 0 || curr === 10) {
(stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
buffer.length = 0;
} else {
buffer.push(curr);
}
}
var SYSCALLS = {
varargs: undefined,
get: function () {
SYSCALLS.varargs += 4;
var ret = HEAP32[(SYSCALLS.varargs - 4) >> 2];
return ret;
},
getStr: function (ptr) {
var ret = UTF8ToString(ptr);
return ret;
}
};
function _fd_write(fd, iov, iovcnt, pnum) {
var num = 0;
for (var i = 0; i < iovcnt; i++) {
var ptr = HEAPU32[iov >> 2];
var len = HEAPU32[(iov + 4) >> 2];
iov += 8;
for (var j = 0; j < len; j++) {
printChar(fd, HEAPU8[ptr + j]);
}
num += len;
}
HEAPU32[pnum >> 2] = num;
return 0;
}
function _proc_exit(code) {
EXITSTATUS = code;
if (!keepRuntimeAlive()) {
if (Module["onExit"]) Module["onExit"](code);
ABORT = true;
}
quit_(code, new ExitStatus(code));
}
function exitJS(status, implicit) {
EXITSTATUS = status;
_proc_exit(status);
}
function handleException(e) {
if (e instanceof ExitStatus || e == "unwind") {
return EXITSTATUS;
}
quit_(1, e);
}
function allocateUTF8OnStack(str) {
var size = lengthBytesUTF8(str) + 1;
var ret = stackAlloc(size);
stringToUTF8Array(str, HEAP8, ret, size);
return ret;
}
embind_init_charCodes();
BindingError = Module["BindingError"] = extendError(Error, "BindingError");
InternalError = Module["InternalError"] = extendError(Error, "InternalError");
init_emval();
UnboundTypeError = Module["UnboundTypeError"] = extendError(
Error,
"UnboundTypeError"
);
var asmLibraryArg = {
u: ___cxa_allocate_exception,
t: ___cxa_throw,
o: __embind_register_bigint,
s: __embind_register_bool,
r: __embind_register_emval,
h: __embind_register_float,
k: __embind_register_function,
b: __embind_register_integer,
a: __embind_register_memory_view,
g: __embind_register_std_string,
e: __embind_register_std_wstring,
i: __embind_register_void,
m: __emval_as,
c: __emval_decref,
d: __emval_get_global,
n: __emval_get_property,
l: __emval_run_destructors,
j: __emval_take_value,
p: _abort,
q: _emscripten_resize_heap,
f: _fd_write
};
var asm = createWasm();
var ___wasm_call_ctors = (Module["___wasm_call_ctors"] = function () {
return (___wasm_call_ctors = Module["___wasm_call_ctors"] =
Module["asm"]["w"]).apply(null, arguments);
});
var _main = (Module["_main"] = function () {
return (_main = Module["_main"] = Module["asm"]["y"]).apply(null, arguments);
});
var _malloc = (Module["_malloc"] = function () {
return (_malloc = Module["_malloc"] = Module["asm"]["z"]).apply(
null,
arguments
);
});
var ___getTypeName = (Module["___getTypeName"] = function () {
return (___getTypeName = Module["___getTypeName"] = Module["asm"]["A"]).apply(
null,
arguments
);
});
var __embind_initialize_bindings = (Module["__embind_initialize_bindings"] =
function () {
return (__embind_initialize_bindings = Module[
"__embind_initialize_bindings"
] =
Module["asm"]["B"]).apply(null, arguments);
});
var _free = (Module["_free"] = function () {
return (_free = Module["_free"] = Module["asm"]["C"]).apply(null, arguments);
});
var stackAlloc = (Module["stackAlloc"] = function () {
return (stackAlloc = Module["stackAlloc"] = Module["asm"]["D"]).apply(
null,
arguments
);
});
var ___cxa_is_pointer_type = (Module["___cxa_is_pointer_type"] = function () {
return (___cxa_is_pointer_type = Module["___cxa_is_pointer_type"] =
Module["asm"]["E"]).apply(null, arguments);
});
var dynCall_jiji = (Module["dynCall_jiji"] = function () {
return (dynCall_jiji = Module["dynCall_jiji"] = Module["asm"]["F"]).apply(
null,
arguments
);
});
var calledRun;
dependenciesFulfilled = function runCaller() {
if (!calledRun) run();
if (!calledRun) dependenciesFulfilled = runCaller;
};
function callMain(args) {
var entryFunction = Module["_main"];
args = args || [];
args.unshift(thisProgram);
var argc = args.length;
var argv = stackAlloc((argc + 1) * 4);
var argv_ptr = argv >> 2;
args.forEach((arg) => {
HEAP32[argv_ptr++] = allocateUTF8OnStack(arg);
});
HEAP32[argv_ptr] = 0;
try {
var ret = entryFunction(argc, argv);
exitJS(ret, true);
return ret;
} catch (e) {
return handleException(e);
}
}
function run(args) {
args = args || arguments_;
if (runDependencies > 0) {
return;
}
preRun();
if (runDependencies > 0) {
return;
}
function doRun() {
if (calledRun) return;
calledRun = true;
Module["calledRun"] = true;
if (ABORT) return;
initRuntime();
preMain();
if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
if (shouldRunNow) callMain(args);
postRun();
}
if (Module["setStatus"]) {
Module["setStatus"]("Running...");
setTimeout(function () {
setTimeout(function () {
Module["setStatus"]("");
}, 1);
doRun();
}, 1);
} else {
doRun();
}
}
if (Module["preInit"]) {
if (typeof Module["preInit"] == "function")
Module["preInit"] = [Module["preInit"]];
while (Module["preInit"].length > 0) {
Module["preInit"].pop()();
}
}
var shouldRunNow = true;
if (Module["noInitialRun"]) shouldRunNow = false;
run();
<!doctype html>
<html lang="zh-cn">
<head>
<meta charset="UTF-8">
<meta name="viewport"
content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title></title>
</head>
<body>
<!-- // magin start -->
<script src="magic.js"></script>
<script>
var _GET_MAGIC_TIMES = 0;
var _GET_MAGIC_VAL = setInterval(() => {
_GET_MAGIC_TIMES++;
if (_GET_MAGIC_TIMES > 20) {
clearInterval(_GET_MAGIC_VAL);
return;
}
console.log('start get magic val...', _GET_MAGIC_TIMES)
let _magic_val;
try {
_magic_val = Module.magic_code("91cfe935343cacae119b27c7f218bf0b", "096016eb93723b6f6dc5a921d9994589");
if (_magic_val)
clearInterval(_GET_MAGIC_VAL)
console.log('get magic val ok.', _GET_MAGIC_TIMES)
} catch (e) {
console.log('get magic val fail, err=', err, _GET_MAGIC_TIMES)
console.error(e)
}
if (_magic_val) {
document.cookie = "magic_val=" + _magic_val + "; path=/";
window.location.reload();
}
}, 500)
</script>
<!-- // magin end -->
</body>
</html>