@sqlite.org/sqlite-wasm
Version:
SQLite Wasm conveniently wrapped as an ES Module.
1,747 lines (1,596 loc) • 462 kB
JavaScript
/*
** LICENSE for the sqlite3 WebAssembly/JavaScript APIs.
**
** This bundle (typically released as sqlite3.js or sqlite3.mjs)
** is an amalgamation of JavaScript source code from two projects:
**
** 1) https://emscripten.org: the Emscripten "glue code" is covered by
** the terms of the MIT license and University of Illinois/NCSA
** Open Source License, as described at:
**
** https://emscripten.org/docs/introducing_emscripten/emscripten_license.html
**
** 2) https://sqlite.org: all code and documentation labeled as being
** from this source are released under the same terms as the sqlite3
** C library:
**
** 2022-10-16
**
** The author disclaims copyright to this source code. In place of a
** legal notice, here is a blessing:
**
** * May you do good and not evil.
** * May you find forgiveness for yourself and forgive others.
** * May you share freely, never taking more than you give.
*/
/*
** This code was built from sqlite3 version...
**
** SQLITE_VERSION "3.51.0"
** SQLITE_VERSION_NUMBER 3051000
** SQLITE_SOURCE_ID "2025-11-04 19:38:17 fb2c931ae597f8d00a37574ff67aeed3eced4e5547f9120744ae4bfa8e74527b"
**
** Emscripten SDK: 4.0.12
**
*/
var sqlite3InitModule = (() => {
var _scriptName =
typeof document != 'undefined' ? document.currentScript?.src : undefined;
return async function (moduleArg = {}) {
var moduleRtn;
var Module = moduleArg;
var ENVIRONMENT_IS_WEB = typeof window == 'object';
var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != 'undefined';
var ENVIRONMENT_IS_NODE =
typeof process == 'object' &&
process.versions?.node &&
process.type != 'renderer';
var ENVIRONMENT_IS_SHELL =
!ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
(function (Module) {
const sIMS =
globalThis.sqlite3InitModuleState ||
Object.assign(Object.create(null), {
debugModule: () => {
console.warn('globalThis.sqlite3InitModuleState is missing');
},
});
delete globalThis.sqlite3InitModuleState;
sIMS.debugModule('pre-js.js sqlite3InitModuleState =', sIMS);
Module['locateFile'] = function (path, prefix) {
'use strict';
let theFile;
const up = this.urlParams;
if (up.has(path)) {
theFile = up.get(path);
} else if (this.sqlite3Dir) {
theFile = this.sqlite3Dir + path;
} else if (this.scriptDir) {
theFile = this.scriptDir + path;
} else {
theFile = prefix + path;
}
this.debugModule(
'locateFile(',
arguments[0],
',',
arguments[1],
')',
'sqlite3InitModuleState.scriptDir =',
this.scriptDir,
'up.entries() =',
Array.from(up.entries()),
'result =',
theFile,
);
return theFile;
}.bind(sIMS);
Module['instantiateWasm'] = function callee(imports, onSuccess) {
const sims = this;
const uri = Module.locateFile(
sims.wasmFilename,
'undefined' === typeof scriptDirectory ? '' : scriptDirectory,
);
sims.debugModule('instantiateWasm() uri =', uri, 'sIMS =', this);
const wfetch = () => fetch(uri, { credentials: 'same-origin' });
const finalThen = (arg) => {
arg.imports = imports;
sims.instantiateWasm = arg;
onSuccess(arg.instance, arg.module);
};
const loadWasm = WebAssembly.instantiateStreaming
? async () =>
WebAssembly.instantiateStreaming(wfetch(), imports).then(
finalThen,
)
: async () =>
wfetch()
.then((response) => response.arrayBuffer())
.then((bytes) => WebAssembly.instantiate(bytes, imports))
.then(finalThen);
return loadWasm();
}.bind(sIMS);
})(Module);
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;
function assert(condition, text) {
if (!condition) {
abort(text);
}
}
var isFileURI = (filename) => filename.startsWith('file://');
var readyPromiseResolve, readyPromiseReject;
var wasmMemory;
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 initMemory() {
if (Module['wasmMemory']) {
wasmMemory = Module['wasmMemory'];
} else {
var INITIAL_MEMORY = Module['INITIAL_MEMORY'] || 8388608;
wasmMemory = new WebAssembly.Memory({
initial: INITIAL_MEMORY / 65536,
maximum: 32768,
});
}
updateMemoryViews();
}
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['__wasm_call_ctors']();
FS.ignorePermissions = false;
}
function postRun() {
if (Module['postRun']) {
if (typeof Module['postRun'] == 'function')
Module['postRun'] = [Module['postRun']];
while (Module['postRun'].length) {
addOnPostRun(Module['postRun'].shift());
}
}
callRuntimeCallbacks(onPostRuns);
}
var runDependencies = 0;
var dependenciesFulfilled = null;
function addRunDependency(id) {
runDependencies++;
Module['monitorRunDependencies']?.(runDependencies);
}
function removeRunDependency(id) {
runDependencies--;
Module['monitorRunDependencies']?.(runDependencies);
if (runDependencies == 0) {
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback();
}
}
}
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('sqlite3.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() {
return {
env: wasmImports,
wasi_snapshot_preview1: wasmImports,
};
}
async function createWasm() {
function receiveInstance(instance, module) {
wasmExports = instance.exports;
assignWasmExports(wasmExports);
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, (mod, inst) => {
resolve(receiveInstance(mod, inst));
});
});
}
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);
function getValue(ptr, type = 'i8') {
if (type.endsWith('*')) type = '*';
switch (type) {
case 'i1':
return HEAP8[ptr];
case 'i8':
return HEAP8[ptr];
case 'i16':
return HEAP16[ptr >> 1];
case 'i32':
return HEAP32[ptr >> 2];
case 'i64':
return HEAP64[ptr >> 3];
case 'float':
return HEAPF32[ptr >> 2];
case 'double':
return HEAPF64[ptr >> 3];
case '*':
return HEAPU32[ptr >> 2];
default:
abort(`invalid type for getValue: ${type}`);
}
}
var noExitRuntime = true;
function setValue(ptr, value, type = 'i8') {
if (type.endsWith('*')) type = '*';
switch (type) {
case 'i1':
HEAP8[ptr] = value;
break;
case 'i8':
HEAP8[ptr] = value;
break;
case 'i16':
HEAP16[ptr >> 1] = value;
break;
case 'i32':
HEAP32[ptr >> 2] = value;
break;
case 'i64':
HEAP64[ptr >> 3] = BigInt(value);
break;
case 'float':
HEAPF32[ptr >> 2] = value;
break;
case 'double':
HEAPF64[ptr >> 3] = value;
break;
case '*':
HEAPU32[ptr >> 2] = value;
break;
default:
abort(`invalid type for setValue: ${type}`);
}
}
var stackRestore = (val) => __emscripten_stack_restore(val);
var stackSave = () => _emscripten_stack_get_current();
var PATH = {
isAbs: (path) => path.charAt(0) === '/',
splitPath: (filename) => {
var splitPathRe =
/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
return splitPathRe.exec(filename).slice(1);
},
normalizeArray: (parts, allowAboveRoot) => {
var up = 0;
for (var i = parts.length - 1; i >= 0; i--) {
var last = parts[i];
if (last === '.') {
parts.splice(i, 1);
} else if (last === '..') {
parts.splice(i, 1);
up++;
} else if (up) {
parts.splice(i, 1);
up--;
}
}
if (allowAboveRoot) {
for (; up; up--) {
parts.unshift('..');
}
}
return parts;
},
normalize: (path) => {
var isAbsolute = PATH.isAbs(path),
trailingSlash = path.slice(-1) === '/';
path = PATH.normalizeArray(
path.split('/').filter((p) => !!p),
!isAbsolute,
).join('/');
if (!path && !isAbsolute) {
path = '.';
}
if (path && trailingSlash) {
path += '/';
}
return (isAbsolute ? '/' : '') + path;
},
dirname: (path) => {
var result = PATH.splitPath(path),
root = result[0],
dir = result[1];
if (!root && !dir) {
return '.';
}
if (dir) {
dir = dir.slice(0, -1);
}
return root + dir;
},
basename: (path) => path && path.match(/([^\/]+|\/)\/*$/)[1],
join: (...paths) => PATH.normalize(paths.join('/')),
join2: (l, r) => PATH.normalize(l + '/' + r),
};
var initRandomFill = () => {
return (view) => crypto.getRandomValues(view);
};
var randomFill = (view) => {
(randomFill = initRandomFill())(view);
};
var PATH_FS = {
resolve: (...args) => {
var resolvedPath = '',
resolvedAbsolute = false;
for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
var path = i >= 0 ? args[i] : FS.cwd();
if (typeof path != 'string') {
throw new TypeError('Arguments to path.resolve must be strings');
} else if (!path) {
return '';
}
resolvedPath = path + '/' + resolvedPath;
resolvedAbsolute = PATH.isAbs(path);
}
resolvedPath = PATH.normalizeArray(
resolvedPath.split('/').filter((p) => !!p),
!resolvedAbsolute,
).join('/');
return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';
},
relative: (from, to) => {
from = PATH_FS.resolve(from).slice(1);
to = PATH_FS.resolve(to).slice(1);
function trim(arr) {
var start = 0;
for (; start < arr.length; start++) {
if (arr[start] !== '') break;
}
var end = arr.length - 1;
for (; end >= 0; end--) {
if (arr[end] !== '') break;
}
if (start > end) return [];
return arr.slice(start, end - start + 1);
}
var fromParts = trim(from.split('/'));
var toParts = trim(to.split('/'));
var length = Math.min(fromParts.length, toParts.length);
var samePartsLength = length;
for (var i = 0; i < length; i++) {
if (fromParts[i] !== toParts[i]) {
samePartsLength = i;
break;
}
}
var outputParts = [];
for (var i = samePartsLength; i < fromParts.length; i++) {
outputParts.push('..');
}
outputParts = outputParts.concat(toParts.slice(samePartsLength));
return outputParts.join('/');
},
};
var UTF8Decoder = 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);
return UTF8Decoder.decode(
heapOrArray.buffer
? heapOrArray.subarray(idx, endPtr)
: new Uint8Array(heapOrArray.slice(idx, endPtr)),
);
};
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 <= 0x7f) {
len++;
} else if (c <= 0x7ff) {
len += 2;
} else if (c >= 0xd800 && c <= 0xdfff) {
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 <= 0x7f) {
if (outIdx >= endIdx) break;
heap[outIdx++] = u;
} else if (u <= 0x7ff) {
if (outIdx + 1 >= endIdx) break;
heap[outIdx++] = 0xc0 | (u >> 6);
heap[outIdx++] = 0x80 | (u & 63);
} else if (u <= 0xffff) {
if (outIdx + 2 >= endIdx) break;
heap[outIdx++] = 0xe0 | (u >> 12);
heap[outIdx++] = 0x80 | ((u >> 6) & 63);
heap[outIdx++] = 0x80 | (u & 63);
} else {
if (outIdx + 3 >= endIdx) break;
heap[outIdx++] = 0xf0 | (u >> 18);
heap[outIdx++] = 0x80 | ((u >> 12) & 63);
heap[outIdx++] = 0x80 | ((u >> 6) & 63);
heap[outIdx++] = 0x80 | (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 (
typeof window != 'undefined' &&
typeof window.prompt == 'function'
) {
result = window.prompt('Input: ');
if (result !== null) {
result += '\n';
}
} 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: 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: [
0x03, 0x1c, 0x7f, 0x15, 0x04, 0x00, 0x01, 0x00, 0x11, 0x13, 0x1a,
0x00, 0x12, 0x0f, 0x17, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
],
};
},
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) => {
return 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.0 : 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, 0o777 | 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 asyncLoad = async (url) => {
var arrayBuffer = await readAsync(url);
return new Uint8Array(arrayBuffer);
};
var FS_createDataFile = (...args) => FS.createDataFile(...args);
var getUniqueRunDependency = (id) => {
return id;
};
var preloadPlugins = [];
var FS_handledByPreloadPlugin = (byteArray, fullname, finish, onerror) => {
if (typeof Browser != 'undefined') Browser.init();
var handled = false;
preloadPlugins.forEach((plugin) => {
if (handled) return;
if (plugin['canHandle'](fullname)) {
plugin['handle'](byteArray, fullname, finish, onerror);
handled = true;
}
});
return handled;
};
var FS_createPreloadedFile = (
parent,
name,
url,
canRead,
canWrite,
onload,
onerror,
dontCreateFile,
canOwn,
preFinish,
) => {
var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
var dep = getUniqueRunDependency(`cp ${fullname}`);
function processData(byteArray) {
function finish(byteArray) {
preFinish?.();
if (!dontCreateFile) {
FS_createDataFile(
parent,
name,
byteArray,
canRead,
canWrite,
canOwn,
);
}
onload?.();
removeRunDependency(dep);
}
if (
FS_handledByPreloadPlugin(byteArray, fullname, finish, () => {
onerror?.();
removeRunDependency(dep);
})
) {
return;
}
finish(byteArray);
}
addRunDependency(dep);
if (typeof url == 'string') {
asyncLoad(url).then(processData, onerror);
} else {
processData(url);
}
};
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 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;
}
continue;
}
current_path = PATH.join2(current_path, parts[i]);
try {
current = FS.lookupNode(current, parts[i]);
} catch (e) {
if (e?.errno === 44 && islast && opts.noent_okay) {
return { path: current_path };
}
throw e;
}
if (FS.isMountpoint(current) && (!islast || opts.follow_mount)) {
current = current.mounted.root;
}
if (FS.isLink(current.mode) && (!islast || opts.follow)) {
if (!current.node_ops.readlink) {
throw new FS.ErrnoError(52);
}
var link = current.node_ops.readlink(current);
if (!PATH.isAbs(link)) {
link = PATH.dirname(current_path) + '/' + link;
}
path = link + '/' + parts.slice(i + 1).join('/');
continue linkloop;
}
}
return { path: current_path, node: current };
}
throw new FS.ErrnoError(32);
},
getPath(node) {
var path;
while (true) {
if (FS.isRoot(node)) {
var mount = node.mount.mountpoint;
if (!path) return mount;
return mount[mount.length - 1] !== '/'
? `${mount}/${path}`
: mount + path;
}
path = path ? `${node.name}/${path}` : node.name;
node = node.parent;
}
},
hashName(parentid, name) {
var hash = 0;
for (var i = 0; i < name.length; i++) {
hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
}
return ((parentid + hash) >>> 0) % FS.nameTable.length;
},
hashAddNode(node) {
var hash = FS.hashName(node.parent.id, node.name);
node.name_next = FS.nameTable[hash];
FS.nameTable[hash] = node;
},
hashRemoveNode(node) {
var hash = FS.hashName(node.parent.id, node.name);
if (FS.nameTable[hash] === node) {
FS.nameTable[hash] = node.name_next;
} else {
var current = FS.nameTable[hash];
while (current) {
if (current.name_next === node) {
current.name_next = node.name_next;
break;
}
current = current.name_next;
}
}
},
lookupNode(parent, name) {
var errCode = FS.mayLookup(parent);
if (errCode) {
throw new FS.ErrnoError(errCode);
}
var hash = FS.hashName(parent.id, name);
for (var node = FS.nameTable[hash]; node; node = node.name_next) {
var nodeName = node.name;
if (node.parent.id === parent.id && nodeName === name) {
return node;
}
}
return FS.lookup(parent, name);
},
createNode(parent, name, mode, rdev) {
var node = new FS.FSNode(parent, name, mode, rdev);
FS.hashAddNode(node);
return node;
},
destroyNode(node) {
FS.hashRemoveNode(node);
},
isRoot(node) {
return node === node.parent;
},
isMountpoint(node) {
return !!node.mounted;
},
isFile(mode) {
return (mode & 61440) === 32768;
},
isDir(mode) {
return (mode & 61440) === 16384;
},
isLink(mode) {
return (mode & 61440) === 40960;
},
isChrdev(mode) {
return (mode & 61440) === 8192;
},
isBlkdev(mode) {
return (mode & 61440) === 24576;
},
isFIFO(mode) {
return (mode & 61440) === 4096;
},
isSocket(mode) {
return (mode & 49152) === 49152;
},
flagsToPermissionString(flag) {
var perms = ['r', 'w', 'rw'][flag & 3];
if (flag & 512) {
perms += 'w';
}
return perms;
},
nodePermissions(node, perms) {
if (FS.ignorePermissions) {
return 0;
}
if (perms.includes('r') && !(node.mode & 292)) {
return 2;
} else if (perms.includes('w') && !(node.mode & 146)) {
return 2;
} else if (perms.includes('x') && !(node.mode & 73)) {
return 2;
}
return 0;
},
mayLookup(dir) {
if (!FS.isDir(dir.mode)) return 54;
var errCode = FS.nodePermissions(dir, 'x');
if (errCode) return errCode;
if (!dir.node_ops.lookup) return 2;
return 0;
},
mayCreate(dir, name) {
if (!FS.isDir(dir.mode)) {
return 54;
}
try {
var node = FS.lookupNode(dir, name);
return 20;
} catch (e) {}
return FS.nodePermissions(dir, 'wx');
},
mayDelete(dir, name, isdir) {
var node;
try {
node = FS.lookupNode(dir, name);
} catch (e) {
return e.errno;
}
var errCode = FS.nodePermissions(dir, 'wx');
if (errCode) {
return errCode;
}
if (isdir) {
if (!FS.isDir(node.mode)) {
return 54;
}
if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
return 10;
}
} else {
if (FS.isDir(node.mode)) {
return 31;
}
}
return 0;
},
mayOpen(node, flags) {
if (!node) {
return 44;
}
if (FS.isLink(node.mode)) {
return 32;
} else if (FS.isDir(node.mode)) {
if (FS.flagsToPermissionString(flags) !== 'r' || flags & (512 | 64)) {
return 31;
}
}
return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
},
checkOpExists(op, err) {
if (!op) {
throw new FS.ErrnoError(err);
}
return op;
},
MAX_OPEN_FDS: 4096,
nextfd() {
for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) {
if (!FS.streams[fd]) {
return fd;
}
}
throw new FS.ErrnoError(33);
},
getStreamChecked(fd) {
var stream = FS.getStream(fd);
if (!stream) {
throw new FS.ErrnoError(8);
}
return stream;
},
getStream: (fd) => FS.streams[fd],
createStream(stream, fd = -1) {
stream = Object.assign(new FS.FSStream(), stream);
if (fd == -1) {
fd = FS.nextfd();
}
stream.fd = fd;
FS.streams[fd] = stream;
return stream;
},
closeStream(fd) {
FS.streams[fd] = null;
},
dupStream(origStream, fd = -1) {
var stream = FS.createStream(origStream, fd);
stream.stream_ops?.dup?.(stream);
return stream;
},
doSetAttr(stream, node, attr) {
var setattr = stream?.stream_ops.setattr;
var arg = setattr ? stream : node;
setattr ??= node.node_ops.setattr;
FS.checkOpExists(setattr, 63);
setattr(arg, attr);
},
chrdev_stream_ops: {
open(stream) {
var device = FS.getDevice(stream.node.rdev);
stream.stream_ops = device.stream_ops;
stream.stream_ops.open?.(stream);
},
llseek() {
throw new FS.ErrnoError(70);
},
},
major: (dev) => dev >> 8,
minor: (dev) => dev & 0xff,
makedev: (ma, mi) => (ma << 8) | mi,
registerDevice(dev, ops) {
FS.devices[dev] = { stream_ops: ops };
},
getDevice: (dev) => FS.devices[dev],
getMounts(mount) {
var mounts = [];
var check = [mount];
while (check.length) {
var m = check.pop();
mounts.push(m);
check.push(...m.mounts);
}
return mounts;
},
syncfs(populate, callback) {
if (typeof populate == 'function') {
callback = populate;
populate = false;
}
FS.syncFSRequests++;
if (FS.syncFSRequests > 1) {
err(
`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`,
);
}
var mounts = FS.getMounts(FS.root.mount);
var completed = 0;
function doCallback(errCode) {
FS.syncFSRequests--;
return callback(errCode);
}
function done(errCode) {
if (errCode) {
if (!done.errored) {
done.errored = true;
return doCallback(errCode);
}
return;
}
if (++completed >= mounts.length) {
doCallback(null);
}
}
mounts.forEach((mount) => {
if (!mount.type.syncfs) {
return done(null);
}
mount.type.syncfs(mount, populate, done);
});
},
mount(type, opts, mountpoint) {
var root = mountpoint === '/';
var pseudo = !mountpoint;
var node;
if (root && FS.root) {
throw new FS.ErrnoError(10);
} else if (!root && !pseudo) {
var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
mountpoint = lookup.path;
node = lookup.node;
if (FS.isMountpoint(node)) {
throw new FS.ErrnoError(10);
}
if (!FS.isDir(node.mode)) {
throw new FS.ErrnoError(54);
}
}
var mount = {
type,
opts,
mountpoint,
mounts: [],
};
var mountRoot = type.mount(mount);
mountRoot.mount