talib-web
Version:
TA-Lib C code ported to WebAssembly
1,469 lines (1,468 loc) • 196 kB
JavaScript
"use strict";
var __INIT__ = (function () {
var _scriptDir =
typeof document !== "undefined" && document.currentScript
? document.currentScript.src
: undefined;
if (typeof __filename !== "undefined") _scriptDir = _scriptDir || __filename;
return function (__INIT__) {
__INIT__ = __INIT__ || {};
var Module = typeof __INIT__ !== "undefined" ? __INIT__ : {};
var readyPromiseResolve, readyPromiseReject;
Module["ready"] = new Promise(function (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 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;
var toLog = e;
err("exiting due to exception: " + toLog);
}
var nodeFS;
var nodePath;
if (ENVIRONMENT_IS_NODE) {
if (ENVIRONMENT_IS_WORKER) {
scriptDirectory = require("path").dirname(scriptDirectory) + "/";
} else {
scriptDirectory = __dirname + "/";
}
read_ = function shell_read(filename, binary) {
if (!nodeFS) nodeFS = require("fs");
if (!nodePath) nodePath = require("path");
filename = nodePath["normalize"](filename);
return nodeFS["readFileSync"](filename, binary ? null : "utf8");
};
readBinary = function readBinary(filename) {
var ret = read_(filename, true);
if (!ret.buffer) {
ret = new Uint8Array(ret);
}
assert(ret.buffer);
return ret;
};
readAsync = function readAsync(filename, onload, onerror) {
if (!nodeFS) nodeFS = require("fs");
if (!nodePath) nodePath = require("path");
filename = nodePath["normalize"](filename);
nodeFS["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);
process["on"]("uncaughtException", function (ex) {
if (!(ex instanceof ExitStatus)) {
throw ex;
}
});
process["on"]("unhandledRejection", function (reason) {
throw reason;
});
quit_ = function (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 (_scriptDir) {
scriptDirectory = _scriptDir;
}
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;
};
} else {
}
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 STACK_ALIGN = 16;
function convertJsFunctionToWasm(func, sig) {
if (typeof WebAssembly.Function === "function") {
var typeNames = { i: "i32", j: "i64", f: "f32", d: "f64" };
var type = {
parameters: [],
results: sig[0] == "v" ? [] : [typeNames[sig[0]]],
};
for (var i = 1; i < sig.length; ++i) {
type.parameters.push(typeNames[sig[i]]);
}
return new WebAssembly.Function(type, func);
}
var typeSection = [1, 0, 1, 96];
var sigRet = sig.slice(0, 1);
var sigParam = sig.slice(1);
var typeCodes = { i: 127, j: 126, f: 125, d: 124 };
typeSection.push(sigParam.length);
for (var i = 0; i < sigParam.length; ++i) {
typeSection.push(typeCodes[sigParam[i]]);
}
if (sigRet == "v") {
typeSection.push(0);
} else {
typeSection = typeSection.concat([1, typeCodes[sigRet]]);
}
typeSection[1] = typeSection.length - 2;
var bytes = new Uint8Array(
[0, 97, 115, 109, 1, 0, 0, 0].concat(
typeSection,
[2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0]
)
);
var module = new WebAssembly.Module(bytes);
var instance = new WebAssembly.Instance(module, { e: { f: func } });
var wrappedFunc = instance.exports["f"];
return wrappedFunc;
}
var freeTableIndexes = [];
var functionsInTableMap;
function getEmptyTableSlot() {
if (freeTableIndexes.length) {
return freeTableIndexes.pop();
}
try {
wasmTable.grow(1);
} catch (err) {
if (!(err instanceof RangeError)) {
throw err;
}
throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
}
return wasmTable.length - 1;
}
function updateTableMap(offset, count) {
for (var i = offset; i < offset + count; i++) {
var item = getWasmTableEntry(i);
if (item) {
functionsInTableMap.set(item, i);
}
}
}
function addFunction(func, sig) {
if (!functionsInTableMap) {
functionsInTableMap = new WeakMap();
updateTableMap(0, wasmTable.length);
}
if (functionsInTableMap.has(func)) {
return functionsInTableMap.get(func);
}
var ret = getEmptyTableSlot();
try {
setWasmTableEntry(ret, func);
} catch (err) {
if (!(err instanceof TypeError)) {
throw err;
}
var wrapped = convertJsFunctionToWasm(func, sig);
setWasmTableEntry(ret, wrapped);
}
functionsInTableMap.set(func, ret);
return ret;
}
var dynamicLibraries = Module["dynamicLibraries"] || [];
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;
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;
}
var ALLOC_STACK = 1;
function allocate(slab, allocator) {
var ret;
if (allocator == ALLOC_STACK) {
ret = stackAlloc(slab.length);
} else {
ret = _malloc(slab.length);
}
if (slab.subarray || slab.slice) {
HEAPU8.set(slab, ret);
} else {
HEAPU8.set(new Uint8Array(slab), ret);
}
return ret;
}
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 allocateUTF8OnStack(str) {
var size = lengthBytesUTF8(str) + 1;
var ret = stackAlloc(size);
stringToUTF8Array(str, HEAP8, ret, size);
return ret;
}
function writeArrayToMemory(array, buffer) {
HEAP8.set(array, buffer);
}
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;
if (Module["wasmMemory"]) {
wasmMemory = Module["wasmMemory"];
} else {
wasmMemory = new WebAssembly.Memory({
initial: INITIAL_MEMORY / 65536,
maximum: INITIAL_MEMORY / 65536,
});
}
if (wasmMemory) {
buffer = wasmMemory.buffer;
}
INITIAL_MEMORY = buffer.byteLength;
updateGlobalBufferAndViews(buffer);
var wasmTable = new WebAssembly.Table({ initial: 1, element: "anyfunc" });
var __ATPRERUN__ = [];
var __ATINIT__ = [];
var __ATMAIN__ = [];
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 preMain() {
callRuntimeCallbacks(__ATMAIN__);
}
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 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"] = {};
Module["preloadedWasm"] = {};
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://");
}
var wasmBinaryFile;
wasmBinaryFile = "talib.wasm";
if (!isDataURI(wasmBinaryFile)) {
wasmBinaryFile = locateFile(wasmBinaryFile);
}
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 = {
env: asmLibraryArg,
wasi_snapshot_preview1: asmLibraryArg,
"GOT.mem": new Proxy(asmLibraryArg, GOTHandler),
"GOT.func": new Proxy(asmLibraryArg, GOTHandler),
};
function receiveInstance(instance, module) {
var exports = instance.exports;
exports = relocateExports(exports, 1024);
Module["asm"] = exports;
var metadata = getDylinkMetadata(module);
if (metadata.neededDynlibs) {
dynamicLibraries = metadata.neededDynlibs.concat(dynamicLibraries);
}
mergeLibSymbols(exports, "main");
addOnInit(Module["asm"]["__wasm_call_ctors"]);
removeRunDependency("wasm-instantiate");
}
addRunDependency("wasm-instantiate");
function receiveInstantiationResult(result) {
receiveInstance(result["instance"], result["module"]);
}
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 GOT = {};
var GOTHandler = {
get: function (obj, symName) {
if (!GOT[symName]) {
GOT[symName] = new WebAssembly.Global({
value: "i32",
mutable: true,
});
}
return GOT[symName];
},
};
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);
}
}
}
function getDylinkMetadata(binary) {
var offset = 0;
var end = 0;
function getU8() {
return binary[offset++];
}
function getLEB() {
var ret = 0;
var mul = 1;
while (1) {
var byte = binary[offset++];
ret += (byte & 127) * mul;
mul *= 128;
if (!(byte & 128)) break;
}
return ret;
}
function getString() {
var len = getLEB();
offset += len;
return UTF8ArrayToString(binary, offset - len, len);
}
var name = "dylink.0";
if (binary instanceof WebAssembly.Module) {
var dylinkSection = WebAssembly.Module.customSections(binary, name);
if (dylinkSection.length === 0) {
name = "dylink";
dylinkSection = WebAssembly.Module.customSections(binary, name);
}
assert(dylinkSection.length != 0, "need dylink section");
binary = new Uint8Array(dylinkSection[0]);
end = binary.length;
} else {
var int32View = new Uint32Array(
new Uint8Array(binary.subarray(0, 24)).buffer
);
assert(int32View[0] == 1836278016, "need to see wasm magic number");
assert(binary[8] === 0, "need the dylink section to be first");
offset = 9;
var section_size = getLEB();
end = offset + section_size;
name = getString();
}
var customSection = { neededDynlibs: [], tlsExports: {} };
if (name == "dylink") {
customSection.memorySize = getLEB();
customSection.memoryAlign = getLEB();
customSection.tableSize = getLEB();
customSection.tableAlign = getLEB();
var neededDynlibsCount = getLEB();
for (var i = 0; i < neededDynlibsCount; ++i) {
var name = getString();
customSection.neededDynlibs.push(name);
}
} else {
assert(name === "dylink.0");
var WASM_DYLINK_MEM_INFO = 1;
var WASM_DYLINK_NEEDED = 2;
var WASM_DYLINK_EXPORT_INFO = 3;
var WASM_SYMBOL_TLS = 256;
while (offset < end) {
var subsectionType = getU8();
var subsectionSize = getLEB();
if (subsectionType === WASM_DYLINK_MEM_INFO) {
customSection.memorySize = getLEB();
customSection.memoryAlign = getLEB();
customSection.tableSize = getLEB();
customSection.tableAlign = getLEB();
} else if (subsectionType === WASM_DYLINK_NEEDED) {
var neededDynlibsCount = getLEB();
for (var i = 0; i < neededDynlibsCount; ++i) {
var name = getString();
customSection.neededDynlibs.push(name);
}
} else if (subsectionType === WASM_DYLINK_EXPORT_INFO) {
var count = getLEB();
while (count--) {
var name = getString();
var flags = getLEB();
if (flags & WASM_SYMBOL_TLS) {
customSection.tlsExports[name] = 1;
}
}
} else {
offset += subsectionSize;
}
}
}
assert(offset == end);
return customSection;
}
function getWasmTableEntry(funcPtr) {
return wasmTable.get(funcPtr);
}
function handleException(e) {
if (e instanceof ExitStatus || e == "unwind") {
return EXITSTATUS;
}
quit_(1, e);
}
function asmjsMangle(x) {
var unmangledSymbols = ["stackAlloc", "stackSave", "stackRestore"];
return x.indexOf("dynCall_") == 0 || unmangledSymbols.includes(x)
? x
: "_" + x;
}
function mergeLibSymbols(exports, libName) {
for (var sym in exports) {
if (!exports.hasOwnProperty(sym)) {
continue;
}
if (!asmLibraryArg.hasOwnProperty(sym)) {
asmLibraryArg[sym] = exports[sym];
}
var module_sym = asmjsMangle(sym);
if (!Module.hasOwnProperty(module_sym)) {
Module[module_sym] = exports[sym];
}
}
}
var LDSO = { loadedLibsByName: {}, loadedLibsByHandle: {} };
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 dynCall(sig, ptr, args) {
if (sig.includes("j")) {
return dynCallLegacy(sig, ptr, args);
}
return getWasmTableEntry(ptr).apply(null, args);
}
function createInvokeFunction(sig) {
return function () {
var sp = stackSave();
try {
return dynCall(
sig,
arguments[0],
Array.prototype.slice.call(arguments, 1)
);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
};
}
var ___heap_base = 5247776;
Module["___heap_base"] = ___heap_base;
function getMemory(size) {
if (runtimeInitialized) return _malloc(size);
var ret = ___heap_base;
var end = (ret + size + 15) & -16;
___heap_base = end;
GOT["__heap_base"].value = end;
return ret;
}
function isInternalSym(symName) {
return [
"__cpp_exception",
"__c_longjmp",
"__wasm_apply_data_relocs",
"__dso_handle",
"__tls_size",
"__tls_align",
"__set_stack_limits",
"emscripten_tls_init",
"__wasm_init_tls",
"__wasm_call_ctors",
].includes(symName);
}
function updateGOT(exports, replace) {
for (var symName in exports) {
if (isInternalSym(symName)) {
continue;
}
var value = exports[symName];
if (symName.startsWith("orig$")) {
symName = symName.split("$")[1];
replace = true;
}
if (!GOT[symName]) {
GOT[symName] = new WebAssembly.Global({
value: "i32",
mutable: true,
});
}
if (replace || GOT[symName].value == 0) {
if (typeof value === "function") {
GOT[symName].value = addFunction(value);
} else if (typeof value === "number") {
GOT[symName].value = value;
} else if (typeof value === "bigint") {
GOT[symName].value = Number(value);
} else {
err("unhandled export type for `" + symName + "`: " + typeof value);
}
}
}
}
function relocateExports(exports, memoryBase, replace) {
var relocated = {};
for (var e in exports) {
var value = exports[e];
if (typeof value === "object") {
value = value.value;
}
if (typeof value === "number") {
value += memoryBase;
}
relocated[e] = value;
}
updateGOT(relocated, replace);
return relocated;
}
function resolveGlobalSymbol(symName, direct) {
var sym;
if (direct) {
sym = asmLibraryArg["orig$" + symName];
}
if (!sym) {
sym = asmLibraryArg[symName];
}
if (!sym) {
sym = Module[asmjsMangle(symName)];
}
if (!sym && symName.startsWith("invoke_")) {
sym = createInvokeFunction(symName.split("_")[1]);
}
return sym;
}
function alignMemory(size, alignment) {
return Math.ceil(size / alignment) * alignment;
}
function loadWebAssemblyModule(binary, flags, handle) {
var metadata = getDylinkMetadata(binary);
function loadModule() {
var needsAllocation = !handle || !HEAP8[(handle + 24) >> 0];
if (needsAllocation) {
var memAlign = Math.pow(2, metadata.memoryAlign);
memAlign = Math.max(memAlign, STACK_ALIGN);
var memoryBase = metadata.memorySize
? alignMemory(getMemory(metadata.memorySize + memAlign), memAlign)
: 0;
var tableBase = metadata.tableSize ? wasmTable.length : 0;
if (handle) {
HEAP8[(handle + 24) >> 0] = 1;
HEAP32[(handle + 28) >> 2] = memoryBase;
HEAP32[(handle + 32) >> 2] = metadata.memorySize;
HEAP32[(handle + 36) >> 2] = tableBase;
HEAP32[(handle + 40) >> 2] = metadata.tableSize;
}
} else {
memoryBase = HEAP32[(handle + 28) >> 2];
tableBase = HEAP32[(handle + 36) >> 2];
}
var tableGrowthNeeded =
tableBase + metadata.tableSize - wasmTable.length;
if (tableGrowthNeeded > 0) {
wasmTable.grow(tableGrowthNeeded);
}
var moduleExports;
function resolveSymbol(sym) {
var resolved = resolveGlobalSymbol(sym, false);
if (!resolved) {
resolved = moduleExports[sym];
}
return resolved;
}
var proxyHandler = {
get: function (stubs, prop) {
switch (prop) {
case "__memory_base":
return memoryBase;
case "__table_base":
return tableBase;
}
if (prop in asmLibraryArg) {
return asmLibraryArg[prop];
}
if (!(prop in stubs)) {
var resolved;
stubs[prop] = function () {
if (!resolved) resolved = resolveSymbol(prop, true);
return resolved.apply(null, arguments);
};
}
return stubs[prop];
},
};
var proxy = new Proxy({}, proxyHandler);
var info = {
"GOT.mem": new Proxy({}, GOTHandler),
"GOT.func": new Proxy({}, GOTHandler),
env: proxy,
wasi_snapshot_preview1: proxy,
};
function postInstantiation(instance) {
updateTableMap(tableBase, metadata.tableSize);
moduleExports = relocateExports(instance.exports, memoryBase);
if (!flags.allowUndefined) {
reportUndefinedSymbols();
}
var init = moduleExports["__wasm_call_ctors"];
if (init) {
if (runtimeInitialized) {
init();
} else {
__ATINIT__.push(init);
}
}
return moduleExports;
}
if (flags.loadAsync) {
if (binary instanceof WebAssembly.Module) {
var instance = new WebAssembly.Instance(binary, info);
return Promise.resolve(postInstantiation(instance));
}
return WebAssembly.instantiate(binary, info).then(function (result) {
return postInstantiation(result.instance);
});
}
var module =
binary instanceof WebAssembly.Module
? binary
: new WebAssembly.Module(binary);
var instance = new WebAssembly.Instance(module, info);
return postInstantiation(instance);
}
if (flags.loadAsync) {
return metadata.neededDynlibs
.reduce(function (chain, dynNeeded) {
return chain.then(function () {
return loadDynamicLibrary(dynNeeded, flags);
});
}, Promise.resolve())
.then(function () {
return loadModule();
});
}
metadata.neededDynlibs.forEach(function (dynNeeded) {
loadDynamicLibrary(dynNeeded, flags);
});
return loadModule();
}
function loadDynamicLibrary(lib, flags, handle) {
if (lib == "__main__" && !LDSO.loadedLibsByName[lib]) {
LDSO.loadedLibsByName[lib] = {
refcount: Infinity,
name: "__main__",
module: Module["asm"],
global: true,
};
}
flags = flags || { global: true, nodelete: true };
var dso = LDSO.loadedLibsByName[lib];
if (dso) {
if (flags.global && !dso.global) {
dso.global = true;
if (dso.module !== "loading") {
mergeLibSymbols(dso.module, lib);
}
}
if (flags.nodelete && dso.refcount !== Infinity) {
dso.refcount = Infinity;
}
dso.refcount++;
if (handle) {
LDSO.loadedLibsByHandle[handle] = dso;
}
return flags.loadAsync ? Promise.resolve(true) : true;
}
dso = {
refcount: flags.nodelete ? Infinity : 1,
name: lib,
module: "loading",
global: flags.global,
};
LDSO.loadedLibsByName[lib] = dso;
if (handle) {
LDSO.loadedLibsByHandle[handle] = dso;
}
function loadLibData(libFile) {
if (flags.fs && flags.fs.findObject(libFile)) {
var libData = flags.fs.readFile(libFile, { encoding: "binary" });
if (!(libData instanceof Uint8Array)) {
libData = new Uint8Array(libData);
}
return flags.loadAsync ? Promise.resolve(libData) : libData;
}
if (flags.loadAsync) {
return new Promise(function (resolve, reject) {
readAsync(
libFile,
function (data) {
resolve(new Uint8Array(data));
},
reject
);
});
}
if (!readBinary) {
throw new Error(
libFile +
": file not found, and synchronous loading of external files is not available"
);
}
return readBinary(libFile);
}
function getLibModule() {
if (
Module["preloadedWasm"] !== undefined &&
Module["preloadedWasm"][lib] !== undefined
) {
var libModule = Module["preloadedWasm"][lib];
return flags.loadAsync ? Promise.resolve(libModule) : libModule;
}
if (flags.loadAsync) {
return loadLibData(lib).then(function (libData) {
return loadWebAssemblyModule(libData, flags, handle);
});
}
return loadWebAssemblyModule(loadLibData(lib), flags, handle);
}
function moduleLoaded(libModule) {
if (dso.global) {
mergeLibSymbols(libModule, lib);
}
dso.module = libModule;
}
if (flags.loadAsync) {
return getLibModule().then(function (libModule) {
moduleLoaded(libModule);
return true;
});
}
moduleLoaded(getLibModule());
return true;
}
function reportUndefinedSymbols() {
for (var symName in GOT) {
if (GOT[symName].value == 0) {
var value = resolveGlobalSymbol(symName, true);
if (typeof value === "function") {
GOT[symName].value = addFunction(value, value.sig);
} else if (typeof value === "number") {
GOT[symName].value = value;
} else {
assert(
false,
"bad export type for `" + symName + "`: " + typeof value
);
}
}
}
}
function preloadDylibs() {
if (!dynamicLibraries.length) {
reportUndefinedSymbols();
return;
}
addRunDependency("preloadDylibs");
dynamicLibraries
.reduce(function (chain, lib) {
return chain.then(function () {
return loadDynamicLibrary(lib, {
loadAsync: true,
global: true,
nodelete: true,
allowUndefined: true,
});
});
}, Promise.resolve())
.then(function () {
reportUndefinedSymbols();
removeRunDependency("preloadDylibs");
});
}
function setWasmTableEntry(idx, func) {
wasmTable.set(idx, func);
}
var ___memory_base = new WebAssembly.Global(
{ value: "i32", mutable: false },
1024
);
var ___stack_pointer = new WebAssembly.Global(
{ value: "i32", mutable: true },
5247776
);
var ___table_base = new WebAssembly.Global(
{ value: "i32", mutable: false },
1
);
function abortOnCannotGrowMemory(requestedSize) {
abort("OOM");
}
function _emscripten_resize_heap(requestedSize) {
var oldSize = HEAPU8.length;
requestedSize = requestedSize >>> 0;
abortOnCannotGrowMemory(requestedSize);
}
var asmLibraryArg = {
__heap_base: ___heap_base,
__indirect_function_table: wasmTable,
__memory_base: ___memory_base,
__stack_pointer: ___stack_pointer,
emscripten_resize_heap: _emscripten_resize_heap,
memory: wasmMemory,
};
var asm = createWasm();
var ___wasm_call_ctors = (Module["___wasm_call_ctors"] = function () {
return (___wasm_call_ctors = Module["___wasm_call_ctors"] =
Module["asm"]["__wasm_call_ctors"]).apply(null, arguments);
});
var _TA_ACCBANDS = (Module["_TA_ACCBANDS"] = function () {
return (_TA_ACCBANDS = Module["_TA_ACCBANDS"] =
Module["asm"]["TA_ACCBANDS"]).apply(null, arguments);
});
var _malloc = (Module["_malloc"] = function () {
return (_malloc = Module["_malloc"] = Module["asm"]["malloc"]).apply(
null,
arguments
);
});
var _free = (Module["_free"] = function () {
return (_free = Module["_free"] = Module["asm"]["free"]).apply(
null,
arguments
);
});
var _TA_SMA = (Module["_TA_SMA"] = function () {
return (_TA_SMA = Module["_TA_SMA"] = Module["asm"]["TA_SMA"]).apply(
null,
arguments
);
});
var _TA_ACOS = (Module["_TA_ACOS"] = function () {
return (_TA_ACOS = Module["_TA_ACOS"] = Module["asm"]["TA_ACOS"]).apply(
null,
arguments
);
});
var _TA_AD = (Module["_TA_AD"] = function () {
return (_TA_AD = Module["_TA_AD"] = Module["asm"]["TA_AD"]).apply(
null,
arguments
);
});
var _TA_ADD = (Module["_TA_ADD"] = function () {
return (_TA_ADD = Module["_TA_ADD"] = Module["asm"]["TA_ADD"]).apply(
null,
arguments
);
});
var _TA_ADOSC = (Module["_TA_ADOSC"] = function () {
return (_TA_ADOSC = Module["_TA_ADOSC"] =
Module["asm"]["TA_ADOSC"]).apply(null, arguments);
});
var _TA_ADX = (Module["_TA_ADX"] = function () {
return (_TA_ADX = Module["_TA_ADX"] = Module["asm"]["TA_ADX"]).apply(
null,
arguments
);
});
var _TA_ADXR = (Module["_TA_ADXR"] = function () {
return (_TA_ADXR = Module["_TA_ADXR"] = Module["asm"]["TA_ADXR"]).apply(
null,
arguments
);
});
var _TA_APO = (Module["_TA_APO"] = function () {
return (_TA_APO = Module["_TA_APO"] = Module["asm"]["TA_APO"]).apply(
null,
arguments
);
});
var _TA_MA = (Module["_TA_MA"] = function () {
return (_TA_MA = Module["_TA_MA"] = Module["asm"]["TA_MA"]).apply(
null,
arguments
);
});
var _TA_AROON = (Module["_TA_AROON"] = function () {
return (_TA_AROON = Module["_TA_AROON"] =
Module["asm"]["TA_AROON"]).apply(null, arguments);
});
var _TA_AROONOSC = (Module["_TA_AROONOSC"] = function () {
return (_TA_AROONOSC = Module["_TA_AROONOSC"] =
Module["asm"]["TA_AROONOSC"]).apply(null, arguments);
});
var _TA_ASIN = (Module["_TA_ASIN"] = function () {
return (_TA_ASIN = Module["_TA_ASIN"] = Module["asm"]["TA_ASIN"]).apply(
null,
arguments
);
});
var _TA_ATAN = (Module["_TA_ATAN"] = function () {
return (_TA_ATAN = Module["_TA_ATAN"] = Module["asm"]["TA_ATAN"]).apply(
null,
arguments
);
});
var _TA_ATR = (Module["_TA_ATR"] = function () {
return (_TA_ATR = Module["_TA_ATR"] = Module["asm"]["TA_ATR"]).apply(
null,
arguments
);
});
var _TA_TRANGE = (Module["_TA_TRANGE"] = function () {
return (_TA_TRANGE = Module["_TA_TRANGE"] =
Module["asm"]["TA_TRANGE"]).apply(null, arguments);
});
var _TA_AVGDEV = (Module["_TA_AVGDEV"] = function () {
return (_TA_AVGDEV = Module["_TA_AVGDEV"] =
Module["asm"]["TA_AVGDEV"]).apply(null, arguments);
});
var _TA_AVGPRICE = (Module["_TA_AVGPRICE"] = function () {
return (_TA_AVGPRICE = Module["_TA_AVGPRICE"] =
Module["asm"]["TA_AVGPRICE"]).apply(null, arguments);
});
var _TA_BBANDS = (Module["_TA_BBANDS"] = function () {
return (_TA_BBANDS = Module["_TA_BBANDS"] =
Module["asm"]["TA_BBANDS"]).apply(null, arguments);
});
var _TA_STDDEV = (Module["_TA_STDDEV"] = function () {
return (_TA_STDDEV = Module["_TA_STDDEV"] =
Module["asm"]["TA_STDDEV"]).apply(null, arguments);
});
var _TA_BETA = (Module["_TA_BETA"] = function () {
return (_TA_BETA = Module["_TA_BETA"] = Module["asm"]["TA_BETA"]).apply(
null,
arguments
);
});
var _TA_BOP = (Module["_TA_BOP"] = function () {
return (_TA_BOP = Module["_TA_BOP"] = Module["asm"]["TA_BOP"]).apply(
null,
arguments
);
});
var _TA_CCI = (Module["_TA_CCI"] = function () {
return (_TA_CCI = Module["_TA_CCI"] = Module["asm"]["TA_CCI"]).apply(
null,
arguments
);
});
var _TA_CDL2CROWS = (Module["_TA_CDL2CROWS"] = function () {
return (_TA_CDL2CROWS = Module["_TA_CDL2CROWS"] =
Module["asm"]["TA_CDL2CROWS"]).apply(null, arguments);
});
var _TA_CDL3BLACKCROWS = (Module["_TA_CDL3BLACKCROWS"] = function () {
return (_TA_CDL3BLACKCROWS = Module["_TA_CDL3BLACKCROWS"] =
Module["asm"]["TA_CDL3BLACKCROWS"]).apply(null, arguments);
});
var _TA_CDL3INSIDE = (Module["_TA_CDL3INSIDE"] = function () {
return (_TA_CDL3INSIDE = Module["_TA_CDL3INSIDE"] =
Module["asm"]["TA_CDL3INSIDE"]).apply(null, arguments);
});
var _TA_CDL3LINESTRIKE = (Module["_TA_CDL3LINESTRIKE"] = function () {
return (_TA_CDL3LINESTRIKE = Module["_TA_CDL3LINESTRIKE"] =
Module["asm"]["TA_CDL3LINESTRIKE"]).apply(null, arguments);
});
var _TA_CDL3OUTSIDE = (Module["_TA_CDL3OUTSIDE"] = function () {
return (_TA_CDL3OUTSIDE = Module["_TA_CDL3OUTSIDE"] =
Module["asm"]["TA_CDL3OUTSIDE"]).apply(null, arguments);
});
var _TA_CDL3STARSINSOUTH = (Module["_TA_CDL3STARSINSOUTH"] = function () {
return (_TA_CDL3STARSINSOUTH = Module["_TA_CDL3STARSINSOUTH"] =
Module["asm"]["TA_CDL3STARSINSOUTH"]).apply(null, arguments);
});
var _TA_CDL3WHITESOLDIERS = (Module["_TA_CDL3WHITESOLDIERS"] = function () {
return (_TA_CDL3WHITESOLDIERS = Module["_TA_CDL3WHITESOLDIERS"] =
Module["asm"]["TA_CDL3WHITESOLDIERS"]).apply(null, arguments);
});
var _TA_CDLABANDONEDBABY = (Module["_TA_CDLABANDONEDBABY"] = function () {
return (_TA_CDLABANDONEDBABY = Module["_TA_CDLABANDONEDBABY"] =
Module["asm"]["TA_CDLABANDONEDBABY"]).apply(null, arguments);
});
var _TA_CDLADVANCEBLOCK = (Module["_TA_CDLADVANCEBLOCK"] = function () {
return (_TA_CDLADVANCEBLOCK = Module["_TA_CDLADVANCEBLOCK"] =
Module["asm"]["TA_CDLADVANCEBLOCK"]).apply(null, arguments);
});
var _TA_CDLBELTHOLD = (Module["_TA_CDLBELTHOLD"] = function () {
return (_TA_CDLBELTHOLD = Module["_TA_CDLBELTHOLD"] =
Module["asm"]["TA_CDLBELTHOLD"]).apply(null, arguments);
});
var _TA_CDLBREAKAWAY = (Module["_TA_CDLBREAKAWAY"] = function () {
return (_TA_CDLBREAKAWAY = Module["_TA_CDLBREAKAWAY"] =
Module["asm"]["TA_CDLBREAKAWAY"]).apply(null, arguments);
});
var _TA_CDLCLOSINGMARUBOZU = (Module["_TA_CDLCLOSINGMARUBOZU"] =
function () {
return (_TA_CDLCLOSINGMARUBOZU = Module["_TA_CDLCLOSINGMARUBOZU"] =
Module["asm"]["TA_CDLCLOSINGMARUBOZU"]).apply(null, arguments);
});
var _TA_CDLCONCEALBABYSWALL = (Module["_TA_CDLCONCEALBABYSWALL"] =
function () {
return (_TA_CDLCONCEALBABYSWALL = Module["_TA_CDLCONCEALBABYSWALL"] =
Module["asm"]["TA_CDLCONCEALBABYSWALL"]).apply(null, arguments);
});
var _TA_CDLCOUNTERATTACK = (Module["_TA_CDLCOUNTERATTACK"] = function () {
return (_TA_CDLCOUNTERATTACK = Module["_TA_CDLCOUNTERATTACK"] =
Module["asm"]["TA_CDLCOUNTERATTACK"]).apply(null, arguments);
});
var _TA_CDLDARKCLOUDCOVER = (Module["_TA_CDLDARKCLOUDCOVER"] = function () {
return (_TA_CDLDARKCLOUDCOVER = Module["_TA_CDLDARKCLOUDCOVER"] =
Module["asm"]["TA_CDLDARKCLOUDCOVER"]).apply(null, arguments);
});
var _TA_CDLDOJI = (Module["_TA_CDLDOJI"] = function () {
return (_TA_CDLDOJI = Module["_TA_CDLDOJI"] =
Module["asm"]["TA_CDLDOJI"]).apply(null, arguments);
});
var _TA_CDLDOJISTAR = (Module["_TA_CDLDOJISTAR"] = function () {
return (_TA_CDLDOJISTAR = Module["_TA_CDLDOJISTAR"] =
Module["asm"]["TA_CDLDOJISTAR"]).apply(null, arguments);
});
var _TA_CDLDRAGONFLYDOJI = (Module["_TA_CDLDRAGONFLYDOJI"] = function () {
return (_TA_CDLDRAGONFLYDOJI = Module["_TA_CDLDRAGONFLYDOJI"] =
Module["asm"]["TA_CDLDRAGONFLYDOJI"]).apply(null, arguments);
});
var _TA_CDLENGULFING = (Module["_TA_CDLENGULFING"] = function () {
return (_TA_CDLENGULFING = Module["_TA_CDLENGULFING"] =
Module["asm"]["TA_CDLENGULFING"]).apply(null, arguments);
});
var _TA_CDLEVENINGDOJISTAR = (Module["_TA_CDLEVENINGDOJISTAR"] =
function () {
return (_TA_CDLEVENINGDOJISTAR = Module["_TA_CDLEVENINGDOJISTAR"] =
Module["asm"]["TA_CDLEVENINGDOJISTAR"]).apply(null, arguments);
});
var _TA_CDLEVENINGSTAR = (Module["_TA_CDLEVENINGSTAR"] = function () {
return (_TA_CDLEVENINGSTAR = Module["_TA_CDLEVENINGSTAR"] =
Module["asm"]["TA_CDLEVENINGSTAR"]).apply(null, arguments);
});
var _TA_CDLGAPSIDESIDEWHITE = (Module["_TA_CDLGAPSIDESIDEWHITE"] =
function () {
return (_TA_CDLGAPSIDESIDEWHITE = Module["_TA_CDLGAPSIDESIDEWHITE"] =
Module["asm"]["TA_CDLGAPSIDESIDEWHITE"]).apply(null, arguments);
});
var _TA_CDLGRAVESTONEDOJI = (Module["_TA_CDLGRAVESTONEDOJI"] = function () {
return (_TA_CDLGRAVESTONEDOJI = Module["_TA_CDLGRAVESTONEDOJI"] =
Module["asm"]["TA_CDLGRAVESTONEDOJI"]).apply(null, arguments);
});
var _TA_CDLHAMMER = (Module["_TA_CDLHAMMER"] = function () {
return (_TA_CDLHAMMER = Module["_TA_CDLHAMMER"] =
Module["asm"]["TA_CDLHAMMER"]).apply(null, arguments);
});
var _TA_CDLHANGINGMAN = (Module["_TA_CDLHANGINGMAN"] = function () {
return (_TA_CDLHANGINGMAN = Module["_TA_CDLHANGINGMAN"] =
Module["asm"]["TA_CDLHANGINGMAN"]).apply(null, arguments);
});
v