@wasm-fmt/clang-format
Version:
A tool to format C/C++/Java/JavaScript/JSON/Objective-C/Protobuf/C# code
1,496 lines (1,495 loc) • 126 kB
JavaScript
#!/usr/bin/env node
var Module = typeof Module != "undefined" ? Module : {};
var ENVIRONMENT_IS_WORKER = false;
var ENVIRONMENT_IS_NODE = true;
Module.preRun = function customPreRun() {
ENV.PWD = process.cwd()
};
var arguments_ = [];
var thisProgram = "./this.program";
var quit_ = (status, toThrow) => {
throw toThrow
};
var _scriptName;
if (typeof __filename != "undefined") {
_scriptName = __filename
} else {
}
var scriptDirectory = "";
function locateFile(path) {
if (Module["locateFile"]) {
return Module["locateFile"](path, scriptDirectory)
}
return scriptDirectory + path
}
var readAsync, readBinary;
if (ENVIRONMENT_IS_NODE) {
var fs = require("fs");
scriptDirectory = __dirname + "/";
readBinary = filename => {
filename = isFileURI(filename) ? new URL(filename) : filename;
var ret = fs.readFileSync(filename);
return ret
};
readAsync = async (filename, binary = true) => {
filename = isFileURI(filename) ? new URL(filename) : filename;
var ret = fs.readFileSync(filename, binary ? undefined : "utf8");
return ret
};
if (process.argv.length > 1) {
thisProgram = process.argv[1].replace(/\\/g, "/")
}
arguments_ = process.argv.slice(2);
if (typeof module != "undefined") {
module["exports"] = Module
}
quit_ = (status, toThrow) => {
process.exitCode = status;
throw toThrow
}
} else {
}
var out = console.log.bind(console);
var err = console.error.bind(console);
var wasmBinary;
var ABORT = false;
var EXITSTATUS;
var isFileURI = filename => filename.startsWith("file://");
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);
HEAPU8 = new Uint8Array(b);
HEAPU16 = new Uint16Array(b);
HEAP32 = new Int32Array(b);
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;
if (!Module["noFSInit"] && !FS.initialized)
FS.init();
TTY.init();
wasmExports["Q"]();
FS.ignorePermissions = false
}
function preMain() {}
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);
throw e
}
var wasmBinaryFile;
function findWasmBinary() { return locateFile("clang-format-cli.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 && !ENVIRONMENT_IS_NODE) {
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();
removeRunDependency("wasm-instantiate");
return wasmExports
}
addRunDependency("wasm-instantiate");
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 runDependencies = 0;
var dependenciesFulfilled = null;
var removeRunDependency = id => {
runDependencies--;
Module["monitorRunDependencies"]?.(runDependencies);
if (runDependencies == 0) {
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback()
}
}
};
var addRunDependency = id => {
runDependencies++;
Module["monitorRunDependencies"]?.(runDependencies)
};
var noExitRuntime = true;
var getWasmTableEntry = funcPtr => wasmTable.get(funcPtr);
var ___call_sighandler = (fp, sig) => getWasmTableEntry(fp)(sig);
class ExceptionInfo {
constructor(excPtr) {
this.excPtr = excPtr;
this.ptr = excPtr - 24
}
set_type(type) { HEAPU32[this.ptr + 4 >> 2] = type }
get_type() { return HEAPU32[this.ptr + 4 >> 2] }
set_destructor(destructor) { HEAPU32[this.ptr + 8 >> 2] = destructor }
get_destructor() { return HEAPU32[this.ptr + 8 >> 2] }
set_caught(caught) {
caught = caught ? 1 : 0;
HEAP8[this.ptr + 12] = caught
}
get_caught() { return HEAP8[this.ptr + 12] != 0 }
set_rethrown(rethrown) {
rethrown = rethrown ? 1 : 0;
HEAP8[this.ptr + 13] = rethrown
}
get_rethrown() { return HEAP8[this.ptr + 13] != 0 }
init(type, destructor) {
this.set_adjusted_ptr(0);
this.set_type(type);
this.set_destructor(destructor)
}
set_adjusted_ptr(adjustedPtr) { HEAPU32[this.ptr + 16 >> 2] = adjustedPtr }
get_adjusted_ptr() { return HEAPU32[this.ptr + 16 >> 2] }
}
var exceptionLast = 0;
var uncaughtExceptionCount = 0;
var ___cxa_throw = (ptr, type, destructor) => {
var info = new ExceptionInfo(ptr);
info.init(type, destructor);
exceptionLast = ptr;
uncaughtExceptionCount++;
throw exceptionLast
};
var nodePath = require("path");
var PATH = {
isAbs: nodePath.isAbsolute,
normalize: nodePath.normalize,
dirname: nodePath.dirname,
basename: nodePath.basename,
join: nodePath.join,
join2: nodePath.join
};
var initRandomFill = () => {
if (ENVIRONMENT_IS_NODE) {
var nodeCrypto = require("crypto");
return view => nodeCrypto.randomFillSync(view)
}
return view => crypto.getRandomValues(view)
};
var randomFill = view => {
(randomFill = initRandomFill())(view)
};
var PATH_FS = {
resolve: (...paths) => {
paths.unshift(FS.cwd());
return nodePath.posix.resolve(...paths)
},
relative: (from, to) => nodePath.posix.relative(from || FS.cwd(), to || FS.cwd())
};
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 FS_stdin_getChar_buffer = [];
var 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 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.codePointAt(i);
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;
i++
}
}
heap[outIdx] = 0;
return outIdx - startIdx
};
var 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 FS_stdin_getChar = () => {
if (!FS_stdin_getChar_buffer.length) {
var result = null;
if (ENVIRONMENT_IS_NODE) {
var BUFSIZE = 256;
var buf = Buffer.alloc(BUFSIZE);
var bytesRead = 0;
var fd = process.stdin.fd;
try {
bytesRead = fs.readSync(fd, buf, 0, BUFSIZE)
} catch (e) {
if (e.toString().includes("EOF"))
bytesRead = 0;
else
throw e
}
if (bytesRead > 0) {
result = buf.slice(0, bytesRead).toString("utf-8")
}
} else {
}
if (!result) {
return null
}
FS_stdin_getChar_buffer = intArrayFromString(result, true)
}
return FS_stdin_getChar_buffer.shift()
};
var TTY = {
ttys: [],
init() {},
shutdown() {},
register(dev, ops) {
TTY.ttys[dev] = { input: [], output: [], ops };
FS.registerDevice(dev, TTY.stream_ops)
},
stream_ops: {
open(stream) {
var tty = TTY.ttys[stream.node.rdev];
if (!tty) {
throw new FS.ErrnoError(43)
}
stream.tty = tty;
stream.seekable = false
},
close(stream) { stream.tty.ops.fsync(stream.tty) },
fsync(stream) { stream.tty.ops.fsync(stream.tty) },
read(stream, buffer, offset, length, pos) {
if (!stream.tty || !stream.tty.ops.get_char) {
throw new FS.ErrnoError(60)
}
var bytesRead = 0;
for (var i = 0; i < length; i++) {
var result;
try {
result = stream.tty.ops.get_char(stream.tty)
} catch (e) {
throw new FS.ErrnoError(29)
}
if (result === undefined && bytesRead === 0) {
throw new FS.ErrnoError(6)
}
if (result === null || result === undefined)
break;
bytesRead++;
buffer[offset + i] = result
}
if (bytesRead) {
stream.node.atime = Date.now()
}
return bytesRead
},
write(stream, buffer, offset, length, pos) {
if (!stream.tty || !stream.tty.ops.put_char) {
throw new FS.ErrnoError(60)
}
try {
for (var i = 0; i < length; i++) {
stream.tty.ops.put_char(stream.tty, buffer[offset + i])
}
} catch (e) {
throw new FS.ErrnoError(29)
}
if (length) {
stream.node.mtime = stream.node.ctime = Date.now()
}
return i
}
},
default_tty_ops: {
get_char(tty) { return FS_stdin_getChar() },
put_char(tty, val) {
if (val === null || val === 10) {
out(UTF8ArrayToString(tty.output));
tty.output = []
} else {
if (val != 0)
tty.output.push(val)
}
},
fsync(tty) {
if (tty.output?.length > 0) {
out(UTF8ArrayToString(tty.output));
tty.output = []
}
},
ioctl_tcgets(tty) {
return {
c_iflag: 25856, c_oflag: 5, c_cflag: 191, c_lflag: 35387, c_cc: [
3, 28, 127, 21, 4, 0, 1, 0, 17, 19, 26, 0, 18, 15, 23, 22,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
}
},
ioctl_tcsets(tty, optional_actions, data) { return 0 },
ioctl_tiocgwinsz(tty) { return [24, 80] }
},
default_tty1_ops: {
put_char(tty, val) {
if (val === null || val === 10) {
err(UTF8ArrayToString(tty.output));
tty.output = []
} else {
if (val != 0)
tty.output.push(val)
}
},
fsync(tty) {
if (tty.output?.length > 0) {
err(UTF8ArrayToString(tty.output));
tty.output = []
}
}
}
};
var zeroMemory = (ptr, size) => HEAPU8.fill(0, ptr, ptr + size);
var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
var mmapAlloc = size => {
size = alignMemory(size, 65536);
var ptr = _emscripten_builtin_memalign(65536, size);
if (ptr)
zeroMemory(ptr, size);
return ptr
};
var MEMFS = {
ops_table: null,
mount(mount) { return MEMFS.createNode(null, "/", 16895, 0) },
createNode(parent, name, mode, dev) {
if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
throw new FS.ErrnoError(63)
}
MEMFS.ops_table ||= {
dir: {
node: {
getattr: MEMFS.node_ops.getattr,
setattr: MEMFS.node_ops.setattr,
lookup: MEMFS.node_ops.lookup,
mknod: MEMFS.node_ops.mknod,
rename: MEMFS.node_ops.rename,
unlink: MEMFS.node_ops.unlink,
rmdir: MEMFS.node_ops.rmdir,
readdir: MEMFS.node_ops.readdir,
symlink: MEMFS.node_ops.symlink
},
stream: { llseek: MEMFS.stream_ops.llseek }
},
file: {
node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr },
stream: {
llseek: MEMFS.stream_ops.llseek,
read: MEMFS.stream_ops.read,
write: MEMFS.stream_ops.write,
mmap: MEMFS.stream_ops.mmap,
msync: MEMFS.stream_ops.msync
}
},
link: {
node: {
getattr: MEMFS.node_ops.getattr,
setattr: MEMFS.node_ops.setattr,
readlink: MEMFS.node_ops.readlink
},
stream: {}
},
chrdev: {
node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr },
stream: FS.chrdev_stream_ops
}
};
var node = FS.createNode(parent, name, mode, dev);
if (FS.isDir(node.mode)) {
node.node_ops = MEMFS.ops_table.dir.node;
node.stream_ops = MEMFS.ops_table.dir.stream;
node.contents = {}
} else if (FS.isFile(node.mode)) {
node.node_ops = MEMFS.ops_table.file.node;
node.stream_ops = MEMFS.ops_table.file.stream;
node.usedBytes = 0;
node.contents = null
} else if (FS.isLink(node.mode)) {
node.node_ops = MEMFS.ops_table.link.node;
node.stream_ops = MEMFS.ops_table.link.stream
} else if (FS.isChrdev(node.mode)) {
node.node_ops = MEMFS.ops_table.chrdev.node;
node.stream_ops = MEMFS.ops_table.chrdev.stream
}
node.atime = node.mtime = node.ctime = Date.now();
if (parent) {
parent.contents[name] = node;
parent.atime = parent.mtime = parent.ctime = node.atime
}
return node
},
getFileDataAsTypedArray(node) {
if (!node.contents)
return new Uint8Array(0);
if (node.contents.subarray)
return node.contents.subarray(0, node.usedBytes);
return new Uint8Array(node.contents)
},
expandFileStorage(node, newCapacity) {
var prevCapacity = node.contents ? node.contents.length : 0;
if (prevCapacity >= newCapacity)
return;
var CAPACITY_DOUBLING_MAX = 1024 * 1024;
newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0);
if (prevCapacity != 0)
newCapacity = Math.max(newCapacity, 256);
var oldContents = node.contents;
node.contents = new Uint8Array(newCapacity);
if (node.usedBytes > 0)
node.contents.set(oldContents.subarray(0, node.usedBytes), 0)
},
resizeFileStorage(node, newSize) {
if (node.usedBytes == newSize)
return;
if (newSize == 0) {
node.contents = null;
node.usedBytes = 0
} else {
var oldContents = node.contents;
node.contents = new Uint8Array(newSize);
if (oldContents) {
node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)))
}
node.usedBytes = newSize
}
},
node_ops: {
getattr(node) {
var attr = {};
attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
attr.ino = node.id;
attr.mode = node.mode;
attr.nlink = 1;
attr.uid = 0;
attr.gid = 0;
attr.rdev = node.rdev;
if (FS.isDir(node.mode)) {
attr.size = 4096
} else if (FS.isFile(node.mode)) {
attr.size = node.usedBytes
} else if (FS.isLink(node.mode)) {
attr.size = node.link.length
} else {
attr.size = 0
}
attr.atime = new Date(node.atime);
attr.mtime = new Date(node.mtime);
attr.ctime = new Date(node.ctime);
attr.blksize = 4096;
attr.blocks = Math.ceil(attr.size / attr.blksize);
return attr
},
setattr(node, attr) {
for (const key of ["mode", "atime", "mtime", "ctime"]) {
if (attr[key] != null) {
node[key] = attr[key]
}
}
if (attr.size !== undefined) {
MEMFS.resizeFileStorage(node, attr.size)
}
},
lookup(parent, name) {
if (!MEMFS.doesNotExistError) {
MEMFS.doesNotExistError = new FS.ErrnoError(44);
MEMFS.doesNotExistError.stack = "<generic error, no stack>"
}
throw MEMFS.doesNotExistError
},
mknod(parent, name, mode, dev) { return MEMFS.createNode(parent, name, mode, dev) },
rename(old_node, new_dir, new_name) {
var new_node;
try {
new_node = FS.lookupNode(new_dir, new_name)
} catch (e) {
}
if (new_node) {
if (FS.isDir(old_node.mode)) {
for (var i in new_node.contents) {
throw new FS.ErrnoError(55)
}
}
FS.hashRemoveNode(new_node)
}
delete old_node.parent.contents[old_node.name];
new_dir.contents[new_name] = old_node;
old_node.name = new_name;
new_dir.ctime = new_dir.mtime = old_node.parent.ctime = old_node.parent.mtime = Date.now()
},
unlink(parent, name) {
delete parent.contents[name];
parent.ctime = parent.mtime = Date.now()
},
rmdir(parent, name) {
var node = FS.lookupNode(parent, name);
for (var i in node.contents) {
throw new FS.ErrnoError(55)
}
delete parent.contents[name];
parent.ctime = parent.mtime = Date.now()
},
readdir(node) { return [".", "..", ...Object.keys(node.contents)] },
symlink(parent, newname, oldpath) {
var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
node.link = oldpath;
return node
},
readlink(node) {
if (!FS.isLink(node.mode)) {
throw new FS.ErrnoError(28)
}
return node.link
}
},
stream_ops: {
read(stream, buffer, offset, length, position) {
var contents = stream.node.contents;
if (position >= stream.node.usedBytes)
return 0;
var size = Math.min(stream.node.usedBytes - position, length);
if (size > 8 && contents.subarray) {
buffer.set(contents.subarray(position, position + size), offset)
} else {
for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i]
}
return size
},
write(stream, buffer, offset, length, position, canOwn) {
if (buffer.buffer === HEAP8.buffer) {
canOwn = false
}
if (!length)
return 0;
var node = stream.node;
node.mtime = node.ctime = Date.now();
if (buffer.subarray && (!node.contents || node.contents.subarray)) {
if (canOwn) {
node.contents = buffer.subarray(offset, offset + length);
node.usedBytes = length;
return length
} else if (node.usedBytes === 0 && position === 0) {
node.contents = buffer.slice(offset, offset + length);
node.usedBytes = length;
return length
} else if (position + length <= node.usedBytes) {
node.contents.set(buffer.subarray(offset, offset + length), position);
return length
}
}
MEMFS.expandFileStorage(node, position + length);
if (node.contents.subarray && buffer.subarray) {
node.contents.set(buffer.subarray(offset, offset + length), position)
} else {
for (var i = 0; i < length; i++) {
node.contents[position + i] = buffer[offset + i]
}
}
node.usedBytes = Math.max(node.usedBytes, position + length);
return length
},
llseek(stream, offset, whence) {
var position = offset;
if (whence === 1) {
position += stream.position
} else if (whence === 2) {
if (FS.isFile(stream.node.mode)) {
position += stream.node.usedBytes
}
}
if (position < 0) {
throw new FS.ErrnoError(28)
}
return position
},
mmap(stream, length, position, prot, flags) {
if (!FS.isFile(stream.node.mode)) {
throw new FS.ErrnoError(43)
}
var ptr;
var allocated;
var contents = stream.node.contents;
if (!(flags & 2) && contents && contents.buffer === HEAP8.buffer) {
allocated = false;
ptr = contents.byteOffset
} else {
allocated = true;
ptr = mmapAlloc(length);
if (!ptr) {
throw new FS.ErrnoError(48)
}
if (contents) {
if (position > 0 || position + length < contents.length) {
if (contents.subarray) {
contents = contents.subarray(position, position + length)
} else {
contents = Array.prototype.slice.call(contents, position, position + length)
}
}
HEAP8.set(contents, ptr)
}
}
return { ptr, allocated }
},
msync(stream, buffer, offset, length, mmapFlags) {
MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
return 0
}
}
};
var FS_modeStringToFlags = str => {
var flagModes = { r: 0, "r+": 2, w: 512 | 64 | 1, "w+": 512 | 64 | 2, a: 1024 | 64 | 1, "a+": 1024 | 64 | 2 };
var flags = flagModes[str];
if (typeof flags == "undefined") {
throw new Error(`Unknown file open mode: ${str}`)
}
return flags
};
var FS_getMode = (canRead, canWrite) => {
var mode = 0;
if (canRead)
mode |= 292 | 73;
if (canWrite)
mode |= 146;
return mode
};
var ERRNO_CODES = {
EPERM: 63,
ENOENT: 44,
ESRCH: 71,
EINTR: 27,
EIO: 29,
ENXIO: 60,
E2BIG: 1,
ENOEXEC: 45,
EBADF: 8,
ECHILD: 12,
EAGAIN: 6,
EWOULDBLOCK: 6,
ENOMEM: 48,
EACCES: 2,
EFAULT: 21,
ENOTBLK: 105,
EBUSY: 10,
EEXIST: 20,
EXDEV: 75,
ENODEV: 43,
ENOTDIR: 54,
EISDIR: 31,
EINVAL: 28,
ENFILE: 41,
EMFILE: 33,
ENOTTY: 59,
ETXTBSY: 74,
EFBIG: 22,
ENOSPC: 51,
ESPIPE: 70,
EROFS: 69,
EMLINK: 34,
EPIPE: 64,
EDOM: 18,
ERANGE: 68,
ENOMSG: 49,
EIDRM: 24,
ECHRNG: 106,
EL2NSYNC: 156,
EL3HLT: 107,
EL3RST: 108,
ELNRNG: 109,
EUNATCH: 110,
ENOCSI: 111,
EL2HLT: 112,
EDEADLK: 16,
ENOLCK: 46,
EBADE: 113,
EBADR: 114,
EXFULL: 115,
ENOANO: 104,
EBADRQC: 103,
EBADSLT: 102,
EDEADLOCK: 16,
EBFONT: 101,
ENOSTR: 100,
ENODATA: 116,
ETIME: 117,
ENOSR: 118,
ENONET: 119,
ENOPKG: 120,
EREMOTE: 121,
ENOLINK: 47,
EADV: 122,
ESRMNT: 123,
ECOMM: 124,
EPROTO: 65,
EMULTIHOP: 36,
EDOTDOT: 125,
EBADMSG: 9,
ENOTUNIQ: 126,
EBADFD: 127,
EREMCHG: 128,
ELIBACC: 129,
ELIBBAD: 130,
ELIBSCN: 131,
ELIBMAX: 132,
ELIBEXEC: 133,
ENOSYS: 52,
ENOTEMPTY: 55,
ENAMETOOLONG: 37,
ELOOP: 32,
EOPNOTSUPP: 138,
EPFNOSUPPORT: 139,
ECONNRESET: 15,
ENOBUFS: 42,
EAFNOSUPPORT: 5,
EPROTOTYPE: 67,
ENOTSOCK: 57,
ENOPROTOOPT: 50,
ESHUTDOWN: 140,
ECONNREFUSED: 14,
EADDRINUSE: 3,
ECONNABORTED: 13,
ENETUNREACH: 40,
ENETDOWN: 38,
ETIMEDOUT: 73,
EHOSTDOWN: 142,
EHOSTUNREACH: 23,
EINPROGRESS: 26,
EALREADY: 7,
EDESTADDRREQ: 17,
EMSGSIZE: 35,
EPROTONOSUPPORT: 66,
ESOCKTNOSUPPORT: 137,
EADDRNOTAVAIL: 4,
ENETRESET: 39,
EISCONN: 30,
ENOTCONN: 53,
ETOOMANYREFS: 141,
EUSERS: 136,
EDQUOT: 19,
ESTALE: 72,
ENOTSUP: 138,
ENOMEDIUM: 148,
EILSEQ: 25,
EOVERFLOW: 61,
ECANCELED: 11,
ENOTRECOVERABLE: 56,
EOWNERDEAD: 62,
ESTRPIPE: 135
};
var NODEFS = {
isWindows: false,
staticInit() {
NODEFS.isWindows = !!process.platform.match(/^win/);
var flags = process.binding("constants")["fs"];
NODEFS.flagsForNodeMap = {
1024: flags["O_APPEND"],
64: flags["O_CREAT"],
128: flags["O_EXCL"],
256: flags["O_NOCTTY"],
0: flags["O_RDONLY"],
2: flags["O_RDWR"],
4096: flags["O_SYNC"],
512: flags["O_TRUNC"],
1: flags["O_WRONLY"],
131072: flags["O_NOFOLLOW"]
}
},
convertNodeCode(e) {
var code = e.code;
return ERRNO_CODES[code]
},
tryFSOperation(f) {
try {
return f()
} catch (e) {
if (!e.code)
throw e;
if (e.code === "UNKNOWN")
throw new FS.ErrnoError(28);
throw new FS.ErrnoError(NODEFS.convertNodeCode(e))
}
},
mount(mount) { return NODEFS.createNode(null, "/", NODEFS.getMode(mount.opts.root), 0) },
createNode(parent, name, mode, dev) {
if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
throw new FS.ErrnoError(28)
}
var node = FS.createNode(parent, name, mode);
node.node_ops = NODEFS.node_ops;
node.stream_ops = NODEFS.stream_ops;
return node
},
getMode(path) {
return NODEFS.tryFSOperation(() => {
var mode = fs.lstatSync(path).mode;
if (NODEFS.isWindows) {
mode |= (mode & 292) >> 2
}
return mode
})
},
realPath(node) {
var parts = [];
while (node.parent !== node) {
parts.push(node.name);
node = node.parent
}
parts.push(node.mount.opts.root);
parts.reverse();
return PATH.join(...parts)
},
flagsForNode(flags) {
flags &= ~2097152;
flags &= ~2048;
flags &= ~32768;
flags &= ~524288;
flags &= ~65536;
var newFlags = 0;
for (var k in NODEFS.flagsForNodeMap) {
if (flags & k) {
newFlags |= NODEFS.flagsForNodeMap[k];
flags ^= k
}
}
if (flags) {
throw new FS.ErrnoError(28)
}
return newFlags
},
getattr(func, node) {
var stat = NODEFS.tryFSOperation(func);
if (NODEFS.isWindows) {
if (!stat.blksize) {
stat.blksize = 4096
}
if (!stat.blocks) {
stat.blocks = (stat.size + stat.blksize - 1) / stat.blksize | 0
}
stat.mode |= (stat.mode & 292) >> 2
}
return {
dev: stat.dev, ino: node.id, mode: stat.mode, nlink: stat.nlink, uid: stat.uid, gid: stat.gid,
rdev: stat.rdev, size: stat.size, atime: stat.atime, mtime: stat.mtime, ctime: stat.ctime,
blksize: stat.blksize, blocks: stat.blocks
}
},
setattr(arg, node, attr, chmod, utimes, truncate, stat) {
NODEFS.tryFSOperation(() => {
if (attr.mode !== undefined) {
var mode = attr.mode;
if (NODEFS.isWindows) {
mode &= 384
}
chmod(arg, mode);
node.mode = attr.mode
}
if (typeof (attr.atime ?? attr.mtime) === "number") {
var atime = new Date(attr.atime ?? stat(arg).atime);
var mtime = new Date(attr.mtime ?? stat(arg).mtime);
utimes(arg, atime, mtime)
}
if (attr.size !== undefined) {
truncate(arg, attr.size)
}
})
},
node_ops: {
getattr(node) {
var path = NODEFS.realPath(node);
return NODEFS.getattr(() => fs.lstatSync(path), node)
},
setattr(node, attr) {
var path = NODEFS.realPath(node);
if (attr.mode != null && attr.dontFollow) {
throw new FS.ErrnoError(52)
}
NODEFS.setattr(path, node, attr, fs.chmodSync, fs.utimesSync, fs.truncateSync, fs.lstatSync)
},
lookup(parent, name) {
var path = PATH.join2(NODEFS.realPath(parent), name);
var mode = NODEFS.getMode(path);
return NODEFS.createNode(parent, name, mode)
},
mknod(parent, name, mode, dev) {
var node = NODEFS.createNode(parent, name, mode, dev);
var path = NODEFS.realPath(node);
NODEFS.tryFSOperation(() => {
if (FS.isDir(node.mode)) {
fs.mkdirSync(path, node.mode)
} else {
fs.writeFileSync(path, "", { mode: node.mode })
}
});
return node
},
rename(oldNode, newDir, newName) {
var oldPath = NODEFS.realPath(oldNode);
var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
try {
FS.unlink(newPath)
} catch (e) {
}
NODEFS.tryFSOperation(() => fs.renameSync(oldPath, newPath));
oldNode.name = newName
},
unlink(parent, name) {
var path = PATH.join2(NODEFS.realPath(parent), name);
NODEFS.tryFSOperation(() => fs.unlinkSync(path))
},
rmdir(parent, name) {
var path = PATH.join2(NODEFS.realPath(parent), name);
NODEFS.tryFSOperation(() => fs.rmdirSync(path))
},
readdir(node) {
var path = NODEFS.realPath(node);
return NODEFS.tryFSOperation(() => fs.readdirSync(path))
},
symlink(parent, newName, oldPath) {
var newPath = PATH.join2(NODEFS.realPath(parent), newName);
NODEFS.tryFSOperation(() => fs.symlinkSync(oldPath, newPath))
},
readlink(node) {
var path = NODEFS.realPath(node);
return NODEFS.tryFSOperation(() => fs.readlinkSync(path))
},
statfs(path) {
var stats = NODEFS.tryFSOperation(() => fs.statfsSync(path));
stats.frsize = stats.bsize;
return stats
}
},
stream_ops: {
getattr(stream) { return NODEFS.getattr(() => fs.fstatSync(stream.nfd), stream.node) },
setattr(stream, attr) {
NODEFS.setattr(stream.nfd, stream.node, attr, fs.fchmodSync, fs.futimesSync, fs.ftruncateSync, fs.fstatSync)
},
open(stream) {
var path = NODEFS.realPath(stream.node);
NODEFS.tryFSOperation(() => {
stream.shared.refcount = 1;
stream.nfd = fs.openSync(path, NODEFS.flagsForNode(stream.flags))
})
},
close(stream) {
NODEFS.tryFSOperation(() => {
if (stream.nfd && --stream.shared.refcount === 0) {
fs.closeSync(stream.nfd)
}
})
},
dup(stream) { stream.shared.refcount++ },
read(
stream, buffer, offset, length,
position) { return NODEFS.tryFSOperation(() => fs.readSync(stream.nfd, buffer, offset, length, position)) },
write(stream, buffer, offset, length, position) {
return NODEFS.tryFSOperation(() => fs.writeSync(stream.nfd, buffer, offset, length, position))
},
llseek(stream, offset, whence) {
var position = offset;
if (whence === 1) {
position += stream.position
} else if (whence === 2) {
if (FS.isFile(stream.node.mode)) {
NODEFS.tryFSOperation(() => {
var stat = fs.fstatSync(stream.nfd);
position += stat.size
})
}
}
if (position < 0) {
throw new FS.ErrnoError(28)
}
return position
},
mmap(stream, length, position, prot, flags) {
if (!FS.isFile(stream.node.mode)) {
throw new FS.ErrnoError(43)
}
var ptr = mmapAlloc(length);
NODEFS.stream_ops.read(stream, HEAP8, ptr, length, position);
return { ptr, allocated: true }
},
msync(stream, buffer, offset, length, mmapFlags) {
NODEFS.stream_ops.write(stream, buffer, 0, length, offset, false);
return 0
}
}
};
var NODERAWFS = {
lookup(parent, name) { return FS.lookupPath(`${parent.path}/${name}`).node },
lookupPath(path, opts = {}) {
if (opts.parent) {
path = PATH.dirname(path)
}
var st = fs.lstatSync(path);
var mode = NODEFS.getMode(path);
return { path, node: { id: st.ino, mode, node_ops: NODERAWFS, path } }
},
createStandardStreams() {
FS.createStream({ nfd: 0, position: 0, path: "/dev/stdin", flags: 0, tty: true, seekable: false }, 0);
var paths = [, "/dev/stdout", "/dev/stderr"];
for (var i = 1; i < 3; i++) {
FS.createStream({ nfd: i, position: 0, path: paths[i], flags: 577, tty: true, seekable: false }, i)
}
},
cwd() { return process.cwd() },
chdir(...args) { process.chdir(...args) },
mknod(path, mode) {
if (FS.isDir(path)) {
fs.mkdirSync(path, mode)
} else {
fs.writeFileSync(path, "", { mode })
}
},
mkdir(...args) { fs.mkdirSync(...args) },
symlink(...args) { fs.symlinkSync(...args) },
rename(...args) { fs.renameSync(...args) },
rmdir(...args) { fs.rmdirSync(...args) },
readdir(...args) { return [".", ".."].concat(fs.readdirSync(...args)) },
unlink(...args) { fs.unlinkSync(...args) },
readlink(...args) { return fs.readlinkSync(...args) },
stat(path, dontFollow) {
var stat = dontFollow ? fs.lstatSync(path) : fs.statSync(path);
if (NODEFS.isWindows) {
stat.mode |= (stat.mode & 292) >> 2
}
return stat
},
fstat(fd) {
var stream = FS.getStreamChecked(fd);
return fs.fstatSync(stream.nfd)
},
statfs(path) {
var defaults = { fsid: 42, flags: 2, namelen: 255 };
return Object.assign(defaults, fs.statfsSync(path))
},
statfsStream(stream) { return FS.statfs(stream.path) },
chmod(path, mode, dontFollow) {
mode &= 4095;
if (NODEFS.isWindows) {
mode &= 384
}
if (dontFollow && fs.lstatSync(path).isSymbolicLink()) {
throw new FS.ErrnoError(138)
}
fs.chmodSync(path, mode)
},
fchmod(fd, mode) {
var stream = FS.getStreamChecked(fd);
fs.fchmodSync(stream.nfd, mode)
},
chown(...args) { fs.chownSync(...args) },
fchown(fd, owner, group) {
var stream = FS.getStreamChecked(fd);
fs.fchownSync(stream.nfd, owner, group)
},
truncate(path, len) {
if (len < 0) {
throw new FS.ErrnoError(28)
}
return fs.truncateSync(path, len)
},
ftruncate(fd, len) {
if (len < 0) {
throw new FS.ErrnoError(28)
}
var stream = FS.getStreamChecked(fd);
fs.ftruncateSync(stream.nfd, len)
},
utime(path, atime, mtime) {
if (atime === null || mtime === null) {
var st = fs.statSync(path);
atime ||= st.atimeMs;
mtime ||= st.mtimeMs
}
fs.utimesSync(path, atime / 1e3, mtime / 1e3)
},
open(path, flags, mode) {
if (typeof flags == "string") {
flags = FS_modeStringToFlags(flags)
}
var pathTruncated = path.split("/").map(s => s.slice(0, 255)).join("/");
var nfd = fs.openSync(pathTruncated, NODEFS.flagsForNode(flags), mode);
var st = fs.fstatSync(nfd);
if (flags & 65536 && !st.isDirectory()) {
fs.closeSync(nfd);
throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR)
}
var newMode = NODEFS.getMode(pathTruncated);
var node = { id: st.ino, mode: newMode, node_ops: NODERAWFS, path };
return FS.createStream({ nfd, position: 0, path, flags, node, seekable: true })
},
createStream(stream, fd) {
var rtn = VFS.createStream(stream, fd);
if (typeof rtn.shared.refcnt == "undefined") {
rtn.shared.refcnt = 1
} else {
rtn.shared.refcnt++
}
return rtn
},
close(stream) {
VFS.closeStream(stream.fd);
if (!stream.stream_ops && --stream.shared.refcnt <= 0 && stream.nfd > 2) {
fs.closeSync(stream.nfd)
}
},
llseek(stream, offset, whence) {
if (stream.stream_ops) {
return VFS.llseek(stream, offset, whence)
}
var position = offset;
if (whence === 1) {
position += stream.position
} else if (whence === 2) {
position += fs.fstatSync(stream.nfd).size
} else if (whence !== 0) {
throw new FS.ErrnoError(28)
}
if (position < 0) {
throw new FS.ErrnoError(28)
}
stream.position = position;
return position
},
read(stream, buffer, offset, length, position) {
if (stream.stream_ops) {
return VFS.read(stream, buffer, offset, length, position)
}
var seeking = typeof position != "undefined";
if (!seeking && stream.seekable)
position = stream.position;
var bytesRead = fs.readSync(stream.nfd, buffer, offset, length, position);
if (!seeking)
stream.position += bytesRead;
return bytesRead
},
write(stream, buffer, offset, length, position) {
if (stream.stream_ops) {
return VFS.write(stream, buffer, offset, length, position)
}
if (stream.flags & +"1024") {
FS.llseek(stream, 0, +"2")
}
var seeking = typeof position != "undefined";
if (!seeking && stream.seekable)
position = stream.position;
var bytesWritten = fs.writeSync(stream.nfd, buffer, offset, length, position);
if (!seeking)
stream.position += bytesWritten;
return bytesWritten
},
mmap(stream, length, position, prot, flags) {
if (!length) {
throw new FS.ErrnoError(28)
}
if (stream.stream_ops) {
return VFS.mmap(stream, length, position, prot, flags)
}
var ptr = mmapAlloc(length);
FS.read(stream, HEAP8, ptr, length, position);
return { ptr, allocated: true }
},
msync(stream, buffer, offset, length, mmapFlags) {
if (stream.stream_ops) {
return VFS.msync(stream, buffer, offset, length, mmapFlags)
}
FS.write(stream, buffer, 0, length, offset);
return 0
},
ioctl() { throw new FS.ErrnoError(59) }
};
var asyncLoad = async url => {
var arrayBuffer = await readAsync(url);
return new Uint8Array(arrayBuffer)
};
var FS_createDataFile = (...args) => FS.createDataFile(...args);
var getUniqueRunDependency = id => id;
var preloadPlugins = [];
var FS_handledByPreloadPlugin = async (byteArray, fullname) => {
if (typeof Browser != "undefined")
Browser.init();
for (var plugin of preloadPlugins) {
if (plugin["canHandle"](fullname)) {
return plugin["handle"](byteArray, fullname)
}
}
return byteArray
};
var FS_preloadFile = async (parent, name, url, canRead, canWrite, dontCreateFile, canOwn, preFinish) => {
var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
var dep = getUniqueRunDependency(`cp ${fullname}`);
addRunDependency(dep);
try {
var byteArray = url;
if (typeof url == "string") {
byteArray = await asyncLoad(url)
}
byteArray = await FS_handledByPreloadPlugin(byteArray, fullname);
preFinish?.();
if (!dontCreateFile) {
FS_createDataFile(parent, name, byteArray, canRead, canWrite, canOwn)
}
} finally {
removeRunDependency(dep)
}
};
var FS_createPreloadedFile =
(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
FS_preloadFile(parent, name, url, canRead, canWrite, dontCreateFile, canOwn, preFinish)
.then(onload)
.catch(onerror)
};
var FS = {
root: null,
mounts: [],
devices: {},
streams: [],
nextInode: 1,
nameTable: null,
currentPath: "/",
initialized: false,
ignorePermissions: true,
filesystems: null,
syncFSRequests: 0,
readFiles: {},
ErrnoError: class {
name = "ErrnoError";
constructor(errno) { this.errno = errno }
},
FSStream: class {
shared = {};
get object() { return this.node }
set object(val) { this.node = val }
get isRead() { return (this.flags & 2097155) !== 1 }
get isWrite() { return (this.flags & 2097155) !== 0 }
get isAppend() { return this.flags & 1024 }
get flags() { return this.shared.flags }
set flags(val) { this.shared.flags = val }
get position() { return this.shared.position }
set position(val) { this.shared.position = val }
},
FSNode: class {
node_ops = {};
stream_ops = {};
readMode = 292 | 73;
writeMode = 146;
mounted = null;
constructor(parent, name, mode, rdev) {
if (!parent) {
parent = this
}
this.parent = parent;
this.mount = parent.mount;
this.id = FS.nextInode++;
this.name = name;
this.mode = mode;
this.rdev = rdev;
this.atime = this.mtime = this.ctime = Date.now()
}
get read() { return (this.mode & this.readMode) === this.readMode }
set read(val) { val ? this.mode |= this.readMode : this.mode &= ~this.readMode }
get write() { return (this.mode & this.writeMode) === this.writeMode }
set write(val) { val ? this.mode |= this.writeMode : this.mode &= ~this.writeMode }
get isFolder() { return FS.isDir(this.mode) }
get isDevice() { return FS.isChrdev(this.mode) }
},
lookupPath(path, opts = {}) {
if (!path) {
throw new FS.ErrnoError(44)
}
opts.follow_mount ??= true;
if (!PATH.isAbs(path)) {
path = FS.cwd() + "/" + path
}
linkloop: for (var nlinks = 0; nlinks < 40; nlinks++) {
var parts = path.split("/").filter(p => !!p);
var current = FS.root;
var current_path = "/";
for (var i = 0; i < parts.length; i++) {
var islast = i === parts.length - 1;
if (islast && opts.parent) {
break
}
if (parts[i] === ".") {
continue
}
if (parts[i] === "..") {
current_path = PATH.dirname(current_path);
if (FS.isRoot(current)) {
path = current_path + "/" + parts.slice(i + 1).join("/");
nlinks--;
continue linkloop
} else {
current = current.parent