@coherentglobal/wasm-runner 0.0.22

package/dist/browser/template/runtime.template.js

@@ -0,0 +1,926 @@
+function runtime(wasmBinaryFile) {
+    return function (Module) {
+        Module = typeof Module !== "undefined" ? Module : {};
+        let readyPromiseResolve, readyPromiseReject;
+        Module.ready = new Promise((resolve, reject) => {
+            readyPromiseResolve = resolve;
+            readyPromiseReject = reject;
+        });
+        var moduleOverrides = {};
+        var key;
+        for (key in Module) {
+            if (Module.hasOwnProperty(key)) {
+                moduleOverrides[key] = Module[key];
+            }
+        }
+        var arguments_ = [];
+        var thisProgram = "./this.program";
+        var quit_ = function (status, toThrow) {
+            throw toThrow;
+        };
+        var ENVIRONMENT_IS_WEB = typeof window === "object";
+        var ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
+        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;
+            var toLog = e;
+            err("exiting due to exception: " + toLog);
+        }
+        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_ = function (url) {
+                var xhr = new XMLHttpRequest();
+                xhr.open("GET", url, false);
+                xhr.send(null);
+                return xhr.responseText;
+            };
+            if (ENVIRONMENT_IS_WORKER) {
+                readBinary = function (url) {
+                    var xhr = new XMLHttpRequest();
+                    xhr.open("GET", url, false);
+                    xhr.responseType = "arraybuffer";
+                    xhr.send(null);
+                    return new Uint8Array(xhr.response);
+                };
+            }
+            readAsync = function (url, onload, onerror) {
+                var xhr = new XMLHttpRequest();
+                xhr.open("GET", url, true);
+                xhr.responseType = "arraybuffer";
+                xhr.onload = function () {
+                    if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
+                        onload(xhr.response);
+                        return;
+                    }
+                    onerror();
+                };
+                xhr.onerror = onerror;
+                xhr.send(null);
+            };
+        }
+        setWindowTitle = function (title) {
+            document.title = title;
+        };
+        var out = Module["print"] || console.log.bind(console);
+        var err = Module["printErr"] || console.warn.bind(console);
+        for (key in moduleOverrides) {
+            if (moduleOverrides.hasOwnProperty(key)) {
+                Module[key] = moduleOverrides[key];
+            }
+        }
+        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;
+        function getValue(ptr, type, noSafe) {
+            type = type || "i8";
+            if (type.charAt(type.length - 1) === "*")
+                type = "i32";
+            switch (type) {
+                case "i1":
+                    return HEAP8[ptr >> 0];
+                case "i8":
+                    return HEAP8[ptr >> 0];
+                case "i16":
+                    return HEAP16[ptr >> 1];
+                case "i32":
+                    return HEAP32[ptr >> 2];
+                case "i64":
+                    return HEAP32[ptr >> 2];
+                case "float":
+                    return HEAPF32[ptr >> 2];
+                case "double":
+                    return Number(HEAPF64[ptr >> 3]);
+                default:
+                    abort("invalid type for getValue: " + type);
+            }
+            return null;
+        }
+        var wasmMemory;
+        var ABORT = false;
+        var EXITSTATUS;
+        function assert(condition, text) {
+            if (!condition) {
+                abort("Assertion failed: " + text);
+            }
+        }
+        function getCFunc(ident) {
+            var func = Module["_" + ident];
+            assert(func, "Cannot call unknown function " + ident + ", make sure it is exported");
+            return func;
+        }
+        function ccall(ident, returnType, argTypes, args, opts) {
+            var toC = {
+                string: function (str) {
+                    var ret = 0;
+                    if (str !== null && str !== undefined && str !== 0) {
+                        var len = (str.length << 2) + 1;
+                        ret = stackAlloc(len);
+                        stringToUTF8(str, ret, len);
+                    }
+                    return ret;
+                },
+                array: function (arr) {
+                    var ret = stackAlloc(arr.length);
+                    writeArrayToMemory(arr, ret);
+                    return ret;
+                },
+            };
+            function convertReturnValue(ret) {
+                if (returnType === "string")
+                    return UTF8ToString(ret);
+                if (returnType === "boolean")
+                    return Boolean(ret);
+                return ret;
+            }
+            var func = getCFunc(ident);
+            var cArgs = [];
+            var stack = 0;
+            if (args) {
+                for (var i = 0; i < args.length; i++) {
+                    var converter = toC[argTypes[i]];
+                    if (converter) {
+                        if (stack === 0)
+                            stack = stackSave();
+                        cArgs[i] = converter(args[i]);
+                    }
+                    else {
+                        cArgs[i] = args[i];
+                    }
+                }
+            }
+            var ret = func.apply(null, cArgs);
+            function onDone(ret) {
+                if (stack !== 0)
+                    stackRestore(stack);
+                return convertReturnValue(ret);
+            }
+            ret = onDone(ret);
+            return ret;
+        }
+        function cwrap(ident, returnType, argTypes, opts) {
+            argTypes = argTypes || [];
+            var numericArgs = argTypes.every(function (type) {
+                return type === "number";
+            });
+            var numericRet = returnType !== "string";
+            if (numericRet && numericArgs && !opts) {
+                return getCFunc(ident);
+            }
+            return function () {
+                return ccall(ident, returnType, argTypes, arguments, opts);
+            };
+        }
+        var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
+        function UTF8ArrayToString(heap, idx, maxBytesToRead) {
+            var endIdx = idx + maxBytesToRead;
+            var endPtr = idx;
+            while (heap[endPtr] && !(endPtr >= endIdx))
+                ++endPtr;
+            if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
+                return UTF8Decoder.decode(heap.subarray(idx, endPtr));
+            }
+            else {
+                var str = "";
+                while (idx < endPtr) {
+                    var u0 = heap[idx++];
+                    if (!(u0 & 128)) {
+                        str += String.fromCharCode(u0);
+                        continue;
+                    }
+                    var u1 = heap[idx++] & 63;
+                    if ((u0 & 224) == 192) {
+                        str += String.fromCharCode(((u0 & 31) << 6) | u1);
+                        continue;
+                    }
+                    var u2 = heap[idx++] & 63;
+                    if ((u0 & 240) == 224) {
+                        u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+                    }
+                    else {
+                        u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heap[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 u = str.charCodeAt(i);
+                if (u >= 55296 && u <= 57343)
+                    u = (65536 + ((u & 1023) << 10)) | (str.charCodeAt(++i) & 1023);
+                if (u <= 127)
+                    ++len;
+                else if (u <= 2047)
+                    len += 2;
+                else if (u <= 65535)
+                    len += 3;
+                else
+                    len += 4;
+            }
+            return len;
+        }
+        function writeArrayToMemory(array, buffer) {
+            HEAP8.set(array, buffer);
+        }
+        function writeAsciiToMemory(str, buffer, dontAddNull) {
+            for (var i = 0; i < str.length; ++i) {
+                HEAP8[buffer++ >> 0] = str.charCodeAt(i);
+            }
+            if (!dontAddNull)
+                HEAP8[buffer >> 0] = 0;
+        }
+        function alignUp(x, multiple) {
+            if (x % multiple > 0) {
+                x += multiple - (x % multiple);
+            }
+            return x;
+        }
+        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 __ATPOSTRUN__ = [];
+        var runtimeInitialized = false;
+        var runtimeExited = false;
+        var runtimeKeepaliveCounter = 0;
+        function keepRuntimeAlive() {
+            return noExitRuntime || runtimeKeepaliveCounter > 0;
+        }
+        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 exitRuntime() {
+            runtimeExited = true;
+        }
+        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 getUniqueRunDependency(id) {
+            return id;
+        }
+        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();
+                }
+            }
+        }
+        Module["preloadedImages"] = {};
+        Module["preloadedAudios"] = {};
+        function abort(what) {
+            {
+                if (Module["onAbort"]) {
+                    Module["onAbort"](what);
+                }
+            }
+            what = "Aborted(" + what + ")";
+            err(what);
+            ABORT = true;
+            EXITSTATUS = 1;
+            what += ". Build with -s ASSERTIONS=1 for more info.";
+            var e = new WebAssembly.RuntimeError(what);
+            readyPromiseReject(e);
+            throw e;
+        }
+        var dataURIPrefix = "data:application/octet-stream;base64,";
+        function isDataURI(filename) {
+            return filename.startsWith(dataURIPrefix);
+        }
+        function isFileURI(filename) {
+            return filename.startsWith("file://");
+        }
+        function getBinary(file) {
+            try {
+                if (file == wasmBinaryFile && wasmBinary) {
+                    return new Uint8Array(wasmBinary);
+                }
+                if (readBinary) {
+                    return readBinary(file);
+                }
+                else {
+                    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"]["p"];
+                updateGlobalBufferAndViews(wasmMemory.buffer);
+                wasmTable = Module["asm"]["r"];
+                addOnInit(Module["asm"]["q"]);
+                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) &&
+                    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().catch(readyPromiseReject);
+            return {};
+        }
+        var tempDouble;
+        var tempI64;
+        function callRuntimeCallbacks(callbacks) {
+            while (callbacks.length > 0) {
+                var callback = callbacks.shift();
+                if (typeof callback == "function") {
+                    callback(Module);
+                    continue;
+                }
+                var func = callback.func;
+                if (typeof func === "number") {
+                    if (callback.arg === undefined) {
+                        getWasmTableEntry(func)();
+                    }
+                    else {
+                        getWasmTableEntry(func)(callback.arg);
+                    }
+                }
+                else {
+                    func(callback.arg === undefined ? null : callback.arg);
+                }
+            }
+        }
+        var wasmTableMirror = [];
+        function getWasmTableEntry(funcPtr) {
+            var func = wasmTableMirror[funcPtr];
+            if (!func) {
+                if (funcPtr >= wasmTableMirror.length)
+                    wasmTableMirror.length = funcPtr + 1;
+                wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
+            }
+            return func;
+        }
+        function ___cxa_allocate_exception(size) {
+            return _malloc(size + 16) + 16;
+        }
+        function ExceptionInfo(excPtr) {
+            this.excPtr = excPtr;
+            this.ptr = excPtr - 16;
+            this.set_type = function (type) {
+                HEAP32[(this.ptr + 4) >> 2] = type;
+            };
+            this.get_type = function () {
+                return HEAP32[(this.ptr + 4) >> 2];
+            };
+            this.set_destructor = function (destructor) {
+                HEAP32[(this.ptr + 8) >> 2] = destructor;
+            };
+            this.get_destructor = function () {
+                return HEAP32[(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_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;
+            };
+        }
+        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 _abort() {
+            abort("");
+        }
+        var _emscripten_get_now = function () {
+            return performance.now();
+        };
+        var _emscripten_get_now_is_monotonic = true;
+        function setErrNo(value) {
+            HEAP32[___errno_location() >> 2] = value;
+            return value;
+        }
+        function _clock_gettime(clk_id, tp) {
+            var now;
+            if (clk_id === 0) {
+                now = Date.now();
+            }
+            else if ((clk_id === 1 || clk_id === 4) &&
+                _emscripten_get_now_is_monotonic) {
+                now = _emscripten_get_now();
+            }
+            else {
+                setErrNo(28);
+                return -1;
+            }
+            HEAP32[tp >> 2] = (now / 1e3) | 0;
+            HEAP32[(tp + 4) >> 2] = ((now % 1e3) * 1e3 * 1e3) | 0;
+            return 0;
+        }
+        function _emscripten_memcpy_big(dest, src, num) {
+            HEAPU8.copyWithin(dest, src, src + num);
+        }
+        function emscripten_realloc_buffer(size) {
+            try {
+                wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16);
+                updateGlobalBufferAndViews(wasmMemory.buffer);
+                return 1;
+            }
+            catch (e) { }
+        }
+        function _emscripten_resize_heap(requestedSize) {
+            var oldSize = HEAPU8.length;
+            requestedSize = requestedSize >>> 0;
+            var maxHeapSize = 2147483648;
+            if (requestedSize > maxHeapSize) {
+                return false;
+            }
+            for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+                var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+                overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+                var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
+                var replacement = emscripten_realloc_buffer(newSize);
+                if (replacement) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        var ENV = {};
+        function getExecutableName() {
+            return thisProgram || "./this.program";
+        }
+        function getEnvStrings() {
+            if (!getEnvStrings.strings) {
+                var lang = ((typeof navigator === "object" &&
+                    navigator.languages &&
+                    navigator.languages[0]) ||
+                    "C").replace("-", "_") + ".UTF-8";
+                var env = {
+                    USER: "web_user",
+                    LOGNAME: "web_user",
+                    PATH: "/",
+                    PWD: "/",
+                    HOME: "/home/web_user",
+                    LANG: lang,
+                    _: getExecutableName(),
+                };
+                for (var x in ENV) {
+                    if (ENV[x] === undefined)
+                        delete env[x];
+                    else
+                        env[x] = ENV[x];
+                }
+                var strings = [];
+                for (var x in env) {
+                    strings.push(x + "=" + env[x]);
+                }
+                getEnvStrings.strings = strings;
+            }
+            return getEnvStrings.strings;
+        }
+        function getRandomDevice() {
+            if (typeof crypto === "object" &&
+                typeof crypto["getRandomValues"] === "function") {
+                var randomBuffer = new Uint8Array(1);
+                return function () {
+                    crypto.getRandomValues(randomBuffer);
+                    return randomBuffer[0];
+                };
+            }
+            return function () {
+                abort("randomDevice");
+            };
+        }
+        function mmapAlloc(size) {
+            abort();
+        }
+        var SYSCALLS = {
+            mappings: {},
+            DEFAULT_POLLMASK: 5,
+            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;
+            },
+            get64: function (low, high) {
+                return low;
+            },
+        };
+        function _environ_get(__environ, environ_buf) {
+            var bufSize = 0;
+            getEnvStrings().forEach(function (string, i) {
+                var ptr = environ_buf + bufSize;
+                HEAP32[(__environ + i * 4) >> 2] = ptr;
+                writeAsciiToMemory(string, ptr);
+                bufSize += string.length + 1;
+            });
+            return 0;
+        }
+        function _environ_sizes_get(penviron_count, penviron_buf_size) {
+            var strings = getEnvStrings();
+            HEAP32[penviron_count >> 2] = strings.length;
+            var bufSize = 0;
+            strings.forEach(function (string) {
+                bufSize += string.length + 1;
+            });
+            HEAP32[penviron_buf_size >> 2] = bufSize;
+            return 0;
+        }
+        function _exit(status) {
+            exit(status);
+        }
+        function __arraySum(array, index) {
+            var sum = 0;
+            for (var i = 0; i <= index; sum += array[i++]) { }
+            return sum;
+        }
+        function intArrayFromString(stringy, dontAddNull, length) {
+            var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
+            var u8array = new Array(len);
+            var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
+            if (dontAddNull)
+                u8array.length = numBytesWritten;
+            return u8array;
+        }
+        var asmLibraryArg = {
+            a: ___cxa_allocate_exception,
+            b: ___cxa_throw,
+            c: _abort,
+            n: _clock_gettime,
+            f: _emscripten_get_now,
+            l: _emscripten_memcpy_big,
+            m: _emscripten_resize_heap,
+            i: _environ_get,
+            j: _environ_sizes_get,
+            d: _exit,
+            e: function noop() { },
+            g: function noop() { },
+            h: function noop() { },
+            k: function noop() { },
+            o: function noop() { },
+        };
+        var asm = createWasm();
+        var ___wasm_call_ctors = (Module["___wasm_call_ctors"] = function () {
+            return (___wasm_call_ctors = Module["___wasm_call_ctors"] =
+                Module["asm"]["q"]).apply(null, arguments);
+        });
+        var _construct = (Module["_construct"] = function () {
+            return (_construct = Module["_construct"] = Module["asm"]["s"]).apply(null, arguments);
+        });
+        var _destroy = (Module["_destroy"] = function () {
+            return (_destroy = Module["_destroy"] = Module["asm"]["t"]).apply(null, arguments);
+        });
+        var _node_calc_v3 = (Module["_node_calc_v3"] = function () {
+            return (_node_calc_v3 = Module["_node_calc_v3"] =
+                Module["asm"]["u"]).apply(null, arguments);
+        });
+        var _malloc = (Module["_malloc"] = function () {
+            return (_malloc = Module["_malloc"] = Module["asm"]["v"]).apply(null, arguments);
+        });
+        var ___errno_location = (Module["___errno_location"] = function () {
+            return (___errno_location = Module["___errno_location"] =
+                Module["asm"]["w"]).apply(null, arguments);
+        });
+        var _free = (Module["_free"] = function () {
+            return (_free = Module["_free"] = Module["asm"]["x"]).apply(null, arguments);
+        });
+        var stackSave = (Module["stackSave"] = function () {
+            return (stackSave = Module["stackSave"] = Module["asm"]["y"]).apply(null, arguments);
+        });
+        var stackRestore = (Module["stackRestore"] = function () {
+            return (stackRestore = Module["stackRestore"] = Module["asm"]["z"]).apply(null, arguments);
+        });
+        var stackAlloc = (Module["stackAlloc"] = function () {
+            return (stackAlloc = Module["stackAlloc"] = Module["asm"]["A"]).apply(null, arguments);
+        });
+        Module["ccall"] = ccall;
+        Module["cwrap"] = cwrap;
+        Module["getValue"] = getValue;
+        var calledRun;
+        function ExitStatus(status) {
+            this.name = "ExitStatus";
+            this.message = "Program terminated with exit(" + status + ")";
+            this.status = status;
+        }
+        dependenciesFulfilled = function runCaller() {
+            if (!calledRun)
+                run();
+            if (!calledRun)
+                dependenciesFulfilled = runCaller;
+        };
+        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();
+                readyPromiseResolve(Module);
+                if (Module["onRuntimeInitialized"])
+                    Module["onRuntimeInitialized"]();
+                postRun();
+            }
+            if (Module["setStatus"]) {
+                Module["setStatus"]("Running...");
+                setTimeout(function () {
+                    setTimeout(function () {
+                        Module["setStatus"]("");
+                    }, 1);
+                    doRun();
+                }, 1);
+            }
+            else {
+                doRun();
+            }
+        }
+        Module["run"] = run;
+        function exit(status, implicit) {
+            EXITSTATUS = status;
+            if (keepRuntimeAlive()) {
+            }
+            else {
+                exitRuntime();
+            }
+            procExit(status);
+        }
+        function procExit(code) {
+            EXITSTATUS = code;
+            if (!keepRuntimeAlive()) {
+                if (Module["onExit"])
+                    Module["onExit"](code);
+                ABORT = true;
+            }
+            quit_(code, new ExitStatus(code));
+        }
+        if (Module["preInit"]) {
+            if (typeof Module["preInit"] == "function")
+                Module["preInit"] = [Module["preInit"]];
+            while (Module["preInit"].length > 0) {
+                Module["preInit"].pop()();
+            }
+        }
+        run();
+        return Module.ready;
+    };
+}
+//# sourceMappingURL=runtime.template.js.map