tasmota-esp-web-tools
Version:
Web tools for ESP devices
506 lines (505 loc) • 16.6 kB
JavaScript
export default (() => {
var _scriptName = globalThis.document?.currentScript?.src;
return async function (moduleArg = {}) {
var moduleRtn;
var Module = moduleArg;
var ENVIRONMENT_IS_WEB = !!globalThis.window;
var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
var ENVIRONMENT_IS_NODE =
globalThis.process?.versions?.node &&
globalThis.process?.type != "renderer";
var arguments_ = [];
var thisProgram = "./this.program";
var quit_ = (status, toThrow) => {
throw toThrow;
};
if (ENVIRONMENT_IS_WORKER) {
_scriptName = self.location.href;
}
var scriptDirectory = "";
function locateFile(path) {
if (Module["locateFile"]) {
return Module["locateFile"](path, scriptDirectory);
}
return scriptDirectory + path;
}
var readAsync, readBinary;
if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
try {
scriptDirectory = new URL(".", _scriptName).href;
} catch {}
{
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 = async (url) => {
var response = await fetch(url, { credentials: "same-origin" });
if (response.ok) {
return response.arrayBuffer();
}
throw new Error(response.status + " : " + response.url);
};
}
} else {
}
var out = console.log.bind(console);
var err = console.error.bind(console);
var wasmBinary;
var ABORT = false;
var EXITSTATUS;
var readyPromiseResolve, readyPromiseReject;
var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
var HEAP64, HEAPU64;
var runtimeInitialized = false;
function updateMemoryViews() {
var b = wasmMemory.buffer;
HEAP8 = new Int8Array(b);
HEAP16 = new Int16Array(b);
Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
HEAPU16 = new Uint16Array(b);
Module["HEAP32"] = HEAP32 = new Int32Array(b);
Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
HEAPF32 = new Float32Array(b);
HEAPF64 = new Float64Array(b);
HEAP64 = new BigInt64Array(b);
HEAPU64 = new BigUint64Array(b);
}
function preRun() {
if (Module["preRun"]) {
if (typeof Module["preRun"] == "function")
Module["preRun"] = [Module["preRun"]];
while (Module["preRun"].length) {
addOnPreRun(Module["preRun"].shift());
}
}
callRuntimeCallbacks(onPreRuns);
}
function initRuntime() {
runtimeInitialized = true;
wasmExports["i"]();
}
function postRun() {
if (Module["postRun"]) {
if (typeof Module["postRun"] == "function")
Module["postRun"] = [Module["postRun"]];
while (Module["postRun"].length) {
addOnPostRun(Module["postRun"].shift());
}
}
callRuntimeCallbacks(onPostRuns);
}
function abort(what) {
Module["onAbort"]?.(what);
what = "Aborted(" + what + ")";
err(what);
ABORT = true;
what += ". Build with -sASSERTIONS for more info.";
var e = new WebAssembly.RuntimeError(what);
readyPromiseReject?.(e);
throw e;
}
var wasmBinaryFile;
function findWasmBinary() {
return locateFile("littlefs.wasm");
}
function getBinarySync(file) {
if (file == wasmBinaryFile && wasmBinary) {
return new Uint8Array(wasmBinary);
}
if (readBinary) {
return readBinary(file);
}
throw "both async and sync fetching of the wasm failed";
}
async function getWasmBinary(binaryFile) {
if (!wasmBinary) {
try {
var response = await readAsync(binaryFile);
return new Uint8Array(response);
} catch {}
}
return getBinarySync(binaryFile);
}
async function instantiateArrayBuffer(binaryFile, imports) {
try {
var binary = await getWasmBinary(binaryFile);
var instance = await WebAssembly.instantiate(binary, imports);
return instance;
} catch (reason) {
err(`failed to asynchronously prepare wasm: ${reason}`);
abort(reason);
}
}
async function instantiateAsync(binary, binaryFile, imports) {
if (!binary) {
try {
var response = fetch(binaryFile, { credentials: "same-origin" });
var instantiationResult = await WebAssembly.instantiateStreaming(
response,
imports,
);
return instantiationResult;
} catch (reason) {
err(`wasm streaming compile failed: ${reason}`);
err("falling back to ArrayBuffer instantiation");
}
}
return instantiateArrayBuffer(binaryFile, imports);
}
function getWasmImports() {
var imports = { a: wasmImports };
return imports;
}
async function createWasm() {
function receiveInstance(instance, module) {
wasmExports = instance.exports;
assignWasmExports(wasmExports);
updateMemoryViews();
return wasmExports;
}
function receiveInstantiationResult(result) {
return receiveInstance(result["instance"]);
}
var info = getWasmImports();
if (Module["instantiateWasm"]) {
return new Promise((resolve, reject) => {
Module["instantiateWasm"](info, (inst, mod) => {
resolve(receiveInstance(inst, mod));
});
});
}
wasmBinaryFile ??= findWasmBinary();
var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
var exports = receiveInstantiationResult(result);
return exports;
}
class ExitStatus {
name = "ExitStatus";
constructor(status) {
this.message = `Program terminated with exit(${status})`;
this.status = status;
}
}
var callRuntimeCallbacks = (callbacks) => {
while (callbacks.length > 0) {
callbacks.shift()(Module);
}
};
var onPostRuns = [];
var addOnPostRun = (cb) => onPostRuns.push(cb);
var onPreRuns = [];
var addOnPreRun = (cb) => onPreRuns.push(cb);
var noExitRuntime = true;
var UTF8Decoder = globalThis.TextDecoder && new TextDecoder();
var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
var maxIdx = idx + maxBytesToRead;
if (ignoreNul) return maxIdx;
while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
return idx;
};
var UTF8ArrayToString = (
heapOrArray,
idx = 0,
maxBytesToRead,
ignoreNul,
) => {
var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
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;
};
var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) =>
ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : "";
var ___assert_fail = (condition, filename, line, func) =>
abort(
`Assertion failed: ${UTF8ToString(condition)}, at: ` +
[
filename ? UTF8ToString(filename) : "unknown filename",
line,
func ? UTF8ToString(func) : "unknown function",
],
);
var __abort_js = () => abort("");
var runtimeKeepaliveCounter = 0;
var __emscripten_runtime_keepalive_clear = () => {
noExitRuntime = false;
runtimeKeepaliveCounter = 0;
};
var timers = {};
var handleException = (e) => {
if (e instanceof ExitStatus || e == "unwind") {
return EXITSTATUS;
}
quit_(1, e);
};
var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
var _proc_exit = (code) => {
EXITSTATUS = code;
if (!keepRuntimeAlive()) {
Module["onExit"]?.(code);
ABORT = true;
}
quit_(code, new ExitStatus(code));
};
var exitJS = (status, implicit) => {
EXITSTATUS = status;
_proc_exit(status);
};
var _exit = exitJS;
var maybeExit = () => {
if (!keepRuntimeAlive()) {
try {
_exit(EXITSTATUS);
} catch (e) {
handleException(e);
}
}
};
var callUserCallback = (func) => {
if (ABORT) {
return;
}
try {
func();
maybeExit();
} catch (e) {
handleException(e);
}
};
var _emscripten_get_now = () => performance.now();
var __setitimer_js = (which, timeout_ms) => {
if (timers[which]) {
clearTimeout(timers[which].id);
delete timers[which];
}
if (!timeout_ms) return 0;
var id = setTimeout(() => {
delete timers[which];
callUserCallback(() =>
__emscripten_timeout(which, _emscripten_get_now()),
);
}, timeout_ms);
timers[which] = { id, timeout_ms };
return 0;
};
var getHeapMax = () => 67108864;
var alignMemory = (size, alignment) =>
Math.ceil(size / alignment) * alignment;
var growMemory = (size) => {
var oldHeapSize = wasmMemory.buffer.byteLength;
var pages = ((size - oldHeapSize + 65535) / 65536) | 0;
try {
wasmMemory.grow(pages);
updateMemoryViews();
return 1;
} catch (e) {}
};
var _emscripten_resize_heap = (requestedSize) => {
var oldSize = HEAPU8.length;
requestedSize >>>= 0;
var maxHeapSize = getHeapMax();
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,
alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536),
);
var replacement = growMemory(newSize);
if (replacement) {
return true;
}
}
return false;
};
var printCharBuffers = [null, [], []];
var printChar = (stream, curr) => {
var buffer = printCharBuffers[stream];
if (curr === 0 || curr === 10) {
(stream === 1 ? out : err)(UTF8ArrayToString(buffer));
buffer.length = 0;
} else {
buffer.push(curr);
}
};
var _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;
};
{
if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
if (Module["print"]) out = Module["print"];
if (Module["printErr"]) err = Module["printErr"];
if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
if (Module["arguments"]) arguments_ = Module["arguments"];
if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
if (Module["preInit"]) {
if (typeof Module["preInit"] == "function")
Module["preInit"] = [Module["preInit"]];
while (Module["preInit"].length > 0) {
Module["preInit"].shift()();
}
}
}
var _lfs_wasm_set_disk_version,
_lfs_wasm_get_disk_version,
_lfs_wasm_init,
_free,
_malloc,
_lfs_wasm_init_from_image,
_lfs_wasm_get_fs_info,
_lfs_wasm_mount,
_lfs_wasm_unmount,
_lfs_wasm_format,
_lfs_wasm_mkdir,
_lfs_wasm_remove,
_lfs_wasm_rename,
_lfs_wasm_stat,
_lfs_wasm_dir_open,
_lfs_wasm_dir_read,
_lfs_wasm_dir_close,
_lfs_wasm_write_file,
_lfs_wasm_read_file,
_lfs_wasm_file_size,
_lfs_wasm_get_image,
_lfs_wasm_get_image_size,
_lfs_wasm_fs_stat,
_lfs_wasm_cleanup,
__emscripten_timeout,
memory,
__indirect_function_table,
wasmMemory;
function assignWasmExports(wasmExports) {
_lfs_wasm_set_disk_version = Module["_lfs_wasm_set_disk_version"] =
wasmExports["j"];
_lfs_wasm_get_disk_version = Module["_lfs_wasm_get_disk_version"] =
wasmExports["k"];
_lfs_wasm_init = Module["_lfs_wasm_init"] = wasmExports["l"];
_free = Module["_free"] = wasmExports["m"];
_malloc = Module["_malloc"] = wasmExports["n"];
_lfs_wasm_init_from_image = Module["_lfs_wasm_init_from_image"] =
wasmExports["o"];
_lfs_wasm_get_fs_info = Module["_lfs_wasm_get_fs_info"] =
wasmExports["p"];
_lfs_wasm_mount = Module["_lfs_wasm_mount"] = wasmExports["q"];
_lfs_wasm_unmount = Module["_lfs_wasm_unmount"] = wasmExports["r"];
_lfs_wasm_format = Module["_lfs_wasm_format"] = wasmExports["s"];
_lfs_wasm_mkdir = Module["_lfs_wasm_mkdir"] = wasmExports["t"];
_lfs_wasm_remove = Module["_lfs_wasm_remove"] = wasmExports["u"];
_lfs_wasm_rename = Module["_lfs_wasm_rename"] = wasmExports["v"];
_lfs_wasm_stat = Module["_lfs_wasm_stat"] = wasmExports["w"];
_lfs_wasm_dir_open = Module["_lfs_wasm_dir_open"] = wasmExports["x"];
_lfs_wasm_dir_read = Module["_lfs_wasm_dir_read"] = wasmExports["y"];
_lfs_wasm_dir_close = Module["_lfs_wasm_dir_close"] = wasmExports["z"];
_lfs_wasm_write_file = Module["_lfs_wasm_write_file"] = wasmExports["A"];
_lfs_wasm_read_file = Module["_lfs_wasm_read_file"] = wasmExports["B"];
_lfs_wasm_file_size = Module["_lfs_wasm_file_size"] = wasmExports["C"];
_lfs_wasm_get_image = Module["_lfs_wasm_get_image"] = wasmExports["D"];
_lfs_wasm_get_image_size = Module["_lfs_wasm_get_image_size"] =
wasmExports["E"];
_lfs_wasm_fs_stat = Module["_lfs_wasm_fs_stat"] = wasmExports["F"];
_lfs_wasm_cleanup = Module["_lfs_wasm_cleanup"] = wasmExports["G"];
__emscripten_timeout = wasmExports["H"];
memory = wasmMemory = wasmExports["h"];
__indirect_function_table = wasmExports["__indirect_function_table"];
}
var wasmImports = {
a: ___assert_fail,
d: __abort_js,
c: __emscripten_runtime_keepalive_clear,
e: __setitimer_js,
f: _emscripten_resize_heap,
g: _fd_write,
b: _proc_exit,
};
function run() {
preRun();
function doRun() {
Module["calledRun"] = true;
if (ABORT) return;
initRuntime();
readyPromiseResolve?.(Module);
Module["onRuntimeInitialized"]?.();
postRun();
}
if (Module["setStatus"]) {
Module["setStatus"]("Running...");
setTimeout(() => {
setTimeout(() => Module["setStatus"](""), 1);
doRun();
}, 1);
} else {
doRun();
}
}
var wasmExports;
wasmExports = await createWasm();
run();
if (runtimeInitialized) {
moduleRtn = Module;
} else {
moduleRtn = new Promise((resolve, reject) => {
readyPromiseResolve = resolve;
readyPromiseReject = reject;
});
}
return moduleRtn;
};
})();
if (typeof exports === "object" && typeof module === "object") {
module.exports = createLittleFS;
module.exports.default = createLittleFS;
} else if (typeof define === "function" && define["amd"])
define([], () => createLittleFS);