From 544e079033634ea6ed0d6cff881a8a480f6274bb Mon Sep 17 00:00:00 2001 From: "jeremy@jermolene.com" Date: Thu, 22 Jun 2023 14:27:37 +0100 Subject: [PATCH] Proof of concept of instantiating sqlite3 without needing external dependencies We get a reference to sqlite3 but we're not yet doing anything with it Also note that this approach leads to duplication - there will be two copies of sqlite3.js and sqlite3.wasm in each generated HTML file. The plan is to dynamically retrieve those tiddlers from the store area rather than baking them into the raw markup area --- boot/boot.js | 1 + .../configDemoAlternateStoreCurrentStore.tid | 2 +- .../engines/sqlite/files/sqlite3.js | 11806 ++++++++++++++++ .../engines/sqlite/files/sqlite3.wasm | Bin 0 -> 879655 bytes .../engines/sqlite/files/tiddlywiki.files | 19 + .../engines/sqlite/main.tid | 6 + .../engines/sqlite/rawmarkup.js | 450 + 7 files changed, 12283 insertions(+), 1 deletion(-) create mode 100644 plugins/tiddlywiki/demo-alternate-store/engines/sqlite/files/sqlite3.js create mode 100644 plugins/tiddlywiki/demo-alternate-store/engines/sqlite/files/sqlite3.wasm create mode 100755 plugins/tiddlywiki/demo-alternate-store/engines/sqlite/files/tiddlywiki.files create mode 100644 plugins/tiddlywiki/demo-alternate-store/engines/sqlite/main.tid create mode 100644 plugins/tiddlywiki/demo-alternate-store/engines/sqlite/rawmarkup.js diff --git a/boot/boot.js b/boot/boot.js index 1465da5e9..83b752617 100644 --- a/boot/boot.js +++ b/boot/boot.js @@ -2439,6 +2439,7 @@ $tw.boot.initStartup = function(options) { $tw.utils.registerFileType("image/svg+xml","utf8",".svg",{flags:["image"]}); $tw.utils.registerFileType("image/vnd.microsoft.icon","base64",".ico",{flags:["image"]}); $tw.utils.registerFileType("image/x-icon","base64",".ico",{flags:["image"]}); + $tw.utils.registerFileType("application/wasm","base64",".wasm"); $tw.utils.registerFileType("application/font-woff","base64",".woff"); $tw.utils.registerFileType("application/x-font-ttf","base64",".woff"); $tw.utils.registerFileType("application/font-woff2","base64",".woff2"); diff --git a/plugins/tiddlywiki/demo-alternate-store/configDemoAlternateStoreCurrentStore.tid b/plugins/tiddlywiki/demo-alternate-store/configDemoAlternateStoreCurrentStore.tid index f6116e534..ef96db0c3 100644 --- a/plugins/tiddlywiki/demo-alternate-store/configDemoAlternateStoreCurrentStore.tid +++ b/plugins/tiddlywiki/demo-alternate-store/configDemoAlternateStoreCurrentStore.tid @@ -1,2 +1,2 @@ title: $:/config/DemoAlternateStore/CurrentStore -text: $:/plugins/tiddlywiki/demo-alternate-store/engines/plain-js/rawmarkup.js \ No newline at end of file +text: $:/plugins/tiddlywiki/demo-alternate-store/engines/sqlite/main \ No newline at end of file diff --git a/plugins/tiddlywiki/demo-alternate-store/engines/sqlite/files/sqlite3.js b/plugins/tiddlywiki/demo-alternate-store/engines/sqlite/files/sqlite3.js new file mode 100644 index 000000000..6a737c6e1 --- /dev/null +++ b/plugins/tiddlywiki/demo-alternate-store/engines/sqlite/files/sqlite3.js @@ -0,0 +1,11806 @@ +/* +** 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... +** +** +** Using the Emscripten SDK version 3.1.30. +*/ + +var sqlite3InitModule = (() => { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + + return ( +function(config) { + var sqlite3InitModule = config || {}; + + + + + + + + + + + + + + + + +var Module = typeof sqlite3InitModule != 'undefined' ? sqlite3InitModule : {}; + + +var readyPromiseResolve, readyPromiseReject; +Module['ready'] = new Promise(function(resolve, reject) { + readyPromiseResolve = resolve; + readyPromiseReject = reject; +}); + + + + + + +const sqlite3InitModuleState = globalThis.sqlite3InitModuleState + || Object.assign(Object.create(null),{ + debugModule: ()=>{} + }); +delete globalThis.sqlite3InitModuleState; +sqlite3InitModuleState.debugModule('globalThis.location =',globalThis.location); + + +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; + } + sqlite3InitModuleState.debugModule( + "locateFile(",arguments[0], ',', arguments[1],")", + 'sqlite3InitModuleState.scriptDir =',this.scriptDir, + 'up.entries() =',Array.from(up.entries()), + "result =", theFile + ); + return theFile; +}.bind(sqlite3InitModuleState); + + +const xNameOfInstantiateWasm = false + ? 'instantiateWasm' + : 'emscripten-bug-17951'; +Module[xNameOfInstantiateWasm] = function callee(imports,onSuccess){ + imports.env.foo = function(){}; + const uri = Module.locateFile( + callee.uri, ( + ('undefined'===typeof scriptDirectory) + ? "" : scriptDirectory) + ); + sqlite3InitModuleState.debugModule( + "instantiateWasm() uri =", uri + ); + const wfetch = ()=>fetch(uri, {credentials: 'same-origin'}); + const loadWasm = WebAssembly.instantiateStreaming + ? async ()=>{ + return WebAssembly.instantiateStreaming(wfetch(), imports) + .then((arg)=>onSuccess(arg.instance, arg.module)); + } + : async ()=>{ + return wfetch() + .then(response => response.arrayBuffer()) + .then(bytes => WebAssembly.instantiate(bytes, imports)) + .then((arg)=>onSuccess(arg.instance, arg.module)); + }; + loadWasm(); + return {}; +}; + +Module[xNameOfInstantiateWasm].uri = 'sqlite3.wasm'; + + + + + + + + +var moduleOverrides = Object.assign({}, Module); + +var arguments_ = []; +var thisProgram = './this.program'; +var quit_ = (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 ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + + +var scriptDirectory = ''; +function locateFile(path) { + if (Module['locateFile']) { + return Module['locateFile'](path, scriptDirectory); + } + return scriptDirectory + path; +} + + +var read_, + readAsync, + readBinary, + setWindowTitle; + + + + +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_ = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + } + + 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 = (url, onload, onerror) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = () => { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + } + + + } + + setWindowTitle = (title) => document.title = title; +} else +{ +} + +var out = Module['print'] || console.log.bind(console); +var err = Module['printErr'] || console.warn.bind(console); + + +Object.assign(Module, moduleOverrides); + + +moduleOverrides = null; + + + + + + +if (Module['arguments']) arguments_ = Module['arguments']; + +if (Module['thisProgram']) thisProgram = Module['thisProgram']; + +if (Module['quit']) quit_ = Module['quit']; + + + + + + +var STACK_ALIGN = 16; +var POINTER_SIZE = 4; + +function getNativeTypeSize(type) { + switch (type) { + case 'i1': case 'i8': case 'u8': return 1; + case 'i16': case 'u16': return 2; + case 'i32': case 'u32': return 4; + case 'i64': case 'u64': return 8; + case 'float': return 4; + case 'double': return 8; + default: { + if (type[type.length - 1] === '*') { + return POINTER_SIZE; + } + if (type[0] === 'i') { + const bits = Number(type.substr(1)); + assert(bits % 8 === 0, 'getNativeTypeSize invalid bits ' + bits + ', type ' + type); + return bits / 8; + } + return 0; + } + } +} + + + + + + + + + + + + + + + + + + + +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(text); + } +} + + + + + + + +var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined; + + +function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + + + + + + while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr; + + 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 & 0x80)) { str += String.fromCharCode(u0); continue; } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63); + } + + if (u0 < 0x10000) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } + } + 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 >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + 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); + } + } + + 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 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 HEAP, + + HEAP8, + + HEAPU8, + + HEAP16, + + HEAPU16, + + HEAP32, + + HEAPU32, + + HEAPF32, + + HEAP64, + + HEAPU64, + + HEAPF64; + +function updateMemoryViews() { + var b = wasmMemory.buffer; + Module['HEAP8'] = HEAP8 = new Int8Array(b); + Module['HEAP16'] = HEAP16 = new Int16Array(b); + Module['HEAP32'] = HEAP32 = new Int32Array(b); + Module['HEAPU8'] = HEAPU8 = new Uint8Array(b); + Module['HEAPU16'] = HEAPU16 = new Uint16Array(b); + Module['HEAPU32'] = HEAPU32 = new Uint32Array(b); + Module['HEAPF32'] = HEAPF32 = new Float32Array(b); + Module['HEAPF64'] = HEAPF64 = new Float64Array(b); + Module['HEAP64'] = HEAP64 = new BigInt64Array(b); + Module['HEAPU64'] = HEAPU64 = new BigUint64Array(b); +} + +var STACK_SIZE = 524288; + +var INITIAL_MEMORY = Module['INITIAL_MEMORY'] || 16777216; + + + + + + + + if (Module['wasmMemory']) { + wasmMemory = Module['wasmMemory']; + } else + { + wasmMemory = new WebAssembly.Memory({ + 'initial': INITIAL_MEMORY / 65536, + + + + + + 'maximum': 2147483648 / 65536 + }); + } + +updateMemoryViews(); + + + +INITIAL_MEMORY = wasmMemory.buffer.byteLength; + + + + + + + +var wasmTable; + + + + + + + + + + +var __ATPRERUN__ = []; +var __ATINIT__ = []; +var __ATEXIT__ = []; +var __ATPOSTRUN__ = []; + +var runtimeInitialized = false; + +function keepRuntimeAlive() { + return noExitRuntime; +} + +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; + + +if (!Module["noFSInit"] && !FS.init.initialized) + FS.init(); +FS.ignorePermissions = false; + +TTY.init(); + callRuntimeCallbacks(__ATINIT__); +} + +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 addOnExit(cb) { +} + +function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + + + + + + + + + + + + + + + + + + + + +var runDependencies = 0; +var runDependencyWatcher = null; +var dependenciesFulfilled = null; + +function getUniqueRunDependency(id) { + return id; +} + +function addRunDependency(id) { + runDependencies++; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + +} + +function removeRunDependency(id) { + runDependencies--; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); + } + } +} + + +function abort(what) { + if (Module['onAbort']) { + Module['onAbort'](what); + } + + what = 'Aborted(' + what + ')'; + + + err(what); + + ABORT = true; + EXITSTATUS = 1; + + what += '. Build with -sASSERTIONS 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 = 'sqlite3.wasm'; + if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile); + } + +function getBinary(file) { + try { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary); + } + if (readBinary) { + return readBinary(file); + } + 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' + ) { + 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); + }); + } + } + + + return Promise.resolve().then(function() { return getBinary(wasmBinaryFile); }); +} + + + +function createWasm() { + + var info = { + 'env': asmLibraryArg, + 'wasi_snapshot_preview1': asmLibraryArg, + }; + + + + + function receiveInstance(instance, module) { + var exports = instance.exports; + + Module['asm'] = exports; + + wasmTable = Module['asm']['__indirect_function_table']; + + addOnInit(Module['asm']['__wasm_call_ctors']); + + removeRunDependency('wasm-instantiate'); + + } + + addRunDependency('wasm-instantiate'); + + + function receiveInstantiationResult(result) { + + + + + receiveInstance(result['instance']); + } + + function instantiateArrayBuffer(receiver) { + return getBinaryPromise().then(function(binary) { + return WebAssembly.instantiate(binary, info); + }).then(function (instance) { + return instance; + }).then(receiver, function(reason) { + err('failed to asynchronously prepare wasm: ' + reason); + + abort(reason); + }); + } + + function instantiateAsync() { + if (!wasmBinary && + typeof WebAssembly.instantiateStreaming == 'function' && + !isDataURI(wasmBinaryFile) && + 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); + + readyPromiseReject(e); + } + } + + + instantiateAsync().catch(readyPromiseReject); + return {}; +} + + +var tempDouble; +var tempI64; + + + +var ASM_CONSTS = { + +}; + + + + + + + function ExitStatus(status) { + this.name = 'ExitStatus'; + this.message = 'Program terminated with exit(' + status + ')'; + this.status = status; + } + + function callRuntimeCallbacks(callbacks) { + while (callbacks.length > 0) { + + callbacks.shift()(Module); + } + } + + + + function getValue(ptr, type = 'i8') { + if (type.endsWith('*')) type = '*'; + switch (type) { + case 'i1': return HEAP8[((ptr)>>0)]; + case 'i8': return HEAP8[((ptr)>>0)]; + case 'i16': return HEAP16[((ptr)>>1)]; + case 'i32': return HEAP32[((ptr)>>2)]; + case 'i64': return 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); + } + return null; + } + + + + function setValue(ptr, value, type = 'i8') { + if (type.endsWith('*')) type = '*'; + switch (type) { + case 'i1': HEAP8[((ptr)>>0)] = value; break; + case 'i8': HEAP8[((ptr)>>0)] = value; break; + case 'i16': HEAP16[((ptr)>>1)] = value; break; + case 'i32': HEAP32[((ptr)>>2)] = value; break; + case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)] = tempI64[0],HEAP32[(((ptr)+(4))>>2)] = tempI64[1]); 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 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.substr(-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.substr(0, dir.length - 1); + } + return root + dir; + },basename:(path) => { + + if (path === '/') return '/'; + path = PATH.normalize(path); + path = path.replace(/\/$/, ""); + var lastSlash = path.lastIndexOf('/'); + if (lastSlash === -1) return path; + return path.substr(lastSlash+1); + },join:function() { + var paths = Array.prototype.slice.call(arguments); + return PATH.normalize(paths.join('/')); + },join2:(l, r) => { + return PATH.normalize(l + '/' + r); + }}; + + function getRandomDevice() { + if (typeof crypto == 'object' && typeof crypto['getRandomValues'] == 'function') { + + var randomBuffer = new Uint8Array(1); + return () => { crypto.getRandomValues(randomBuffer); return randomBuffer[0]; }; + } else + + return () => abort("randomDevice"); + } + + + + var PATH_FS = {resolve:function() { + var resolvedPath = '', + resolvedAbsolute = false; + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = (i >= 0) ? arguments[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).substr(1); + to = PATH_FS.resolve(to).substr(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('/'); + }}; + + + + function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy)+1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; + } + var TTY = {ttys:[],init:function () { + + + + + + + + + },shutdown:function() { + + + + + + + + + + },register:function(dev, ops) { + TTY.ttys[dev] = { input: [], output: [], ops: ops }; + FS.registerDevice(dev, TTY.stream_ops); + },stream_ops:{open:function(stream) { + var tty = TTY.ttys[stream.node.rdev]; + if (!tty) { + throw new FS.ErrnoError(43); + } + stream.tty = tty; + stream.seekable = false; + },close:function(stream) { + + stream.tty.ops.fsync(stream.tty); + },fsync:function(stream) { + stream.tty.ops.fsync(stream.tty); + },read:function(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.timestamp = Date.now(); + } + return bytesRead; + },write:function(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.timestamp = Date.now(); + } + return i; + }},default_tty_ops:{get_char:function(tty) { + if (!tty.input.length) { + var result = null; + if (typeof window != 'undefined' && + typeof window.prompt == 'function') { + + result = window.prompt('Input: '); + if (result !== null) { + result += '\n'; + } + } else if (typeof readline == 'function') { + + result = readline(); + if (result !== null) { + result += '\n'; + } + } + if (!result) { + return null; + } + tty.input = intArrayFromString(result, true); + } + return tty.input.shift(); + },put_char:function(tty, val) { + if (val === null || val === 10) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + },fsync:function(tty) { + if (tty.output && tty.output.length > 0) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }},default_tty1_ops:{put_char:function(tty, val) { + if (val === null || val === 10) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + },fsync:function(tty) { + if (tty.output && tty.output.length > 0) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }}}; + + + function zeroMemory(address, size) { + HEAPU8.fill(0, address, address + size); + return address; + } + + function alignMemory(size, alignment) { + return Math.ceil(size / alignment) * alignment; + } + function mmapAlloc(size) { + abort(); + } + var MEMFS = {ops_table:null,mount:function(mount) { + return MEMFS.createNode(null, '/', 16384 | 511 , 0); + },createNode:function(parent, name, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + + throw new FS.ErrnoError(63); + } + if (!MEMFS.ops_table) { + 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, + allocate: MEMFS.stream_ops.allocate, + 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.timestamp = Date.now(); + + if (parent) { + parent.contents[name] = node; + parent.timestamp = node.timestamp; + } + return node; + },getFileDataAsTypedArray:function(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:function(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:function(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:function(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.timestamp); + attr.mtime = new Date(node.timestamp); + attr.ctime = new Date(node.timestamp); + + + attr.blksize = 4096; + attr.blocks = Math.ceil(attr.size / attr.blksize); + return attr; + },setattr:function(node, attr) { + if (attr.mode !== undefined) { + node.mode = attr.mode; + } + if (attr.timestamp !== undefined) { + node.timestamp = attr.timestamp; + } + if (attr.size !== undefined) { + MEMFS.resizeFileStorage(node, attr.size); + } + },lookup:function(parent, name) { + throw FS.genericErrors[44]; + },mknod:function(parent, name, mode, dev) { + return MEMFS.createNode(parent, name, mode, dev); + },rename:function(old_node, new_dir, new_name) { + + if (FS.isDir(old_node.mode)) { + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + } + if (new_node) { + for (var i in new_node.contents) { + throw new FS.ErrnoError(55); + } + } + } + + delete old_node.parent.contents[old_node.name]; + old_node.parent.timestamp = Date.now() + old_node.name = new_name; + new_dir.contents[new_name] = old_node; + new_dir.timestamp = old_node.parent.timestamp; + old_node.parent = new_dir; + },unlink:function(parent, name) { + delete parent.contents[name]; + parent.timestamp = Date.now(); + },rmdir:function(parent, name) { + var node = FS.lookupNode(parent, name); + for (var i in node.contents) { + throw new FS.ErrnoError(55); + } + delete parent.contents[name]; + parent.timestamp = Date.now(); + },readdir:function(node) { + var entries = ['.', '..']; + for (var key in node.contents) { + if (!node.contents.hasOwnProperty(key)) { + continue; + } + entries.push(key); + } + return entries; + },symlink:function(parent, newname, oldpath) { + var node = MEMFS.createNode(parent, newname, 511 | 40960, 0); + node.link = oldpath; + return node; + },readlink:function(node) { + if (!FS.isLink(node.mode)) { + throw new FS.ErrnoError(28); + } + return node.link; + }},stream_ops:{read:function(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:function(stream, buffer, offset, length, position, canOwn) { + + + + + if (buffer.buffer === HEAP8.buffer) { + canOwn = false; + } + + if (!length) return 0; + var node = stream.node; + node.timestamp = 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:function(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; + },allocate:function(stream, offset, length) { + MEMFS.expandFileStorage(stream.node, offset + length); + stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length); + },mmap:function(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.buffer === HEAP8.buffer) { + + + allocated = false; + ptr = contents.byteOffset; + } else { + + 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); + } + } + allocated = true; + ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + HEAP8.set(contents, ptr); + } + return { ptr: ptr, allocated: allocated }; + },msync:function(stream, buffer, offset, length, mmapFlags) { + MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + + return 0; + }}}; + + + function asyncLoad(url, onload, onerror, noRunDep) { + var dep = !noRunDep ? getUniqueRunDependency('al ' + url) : ''; + readAsync(url, (arrayBuffer) => { + assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).'); + onload(new Uint8Array(arrayBuffer)); + if (dep) removeRunDependency(dep); + }, (event) => { + if (onerror) { + onerror(); + } else { + throw 'Loading data file "' + url + '" failed.'; + } + }); + if (dep) addRunDependency(dep); + } + + var FS = {root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,lookupPath:(path, opts = {}) => { + path = PATH_FS.resolve(path); + + if (!path) return { path: '', node: null }; + + var defaults = { + follow_mount: true, + recurse_count: 0 + }; + opts = Object.assign(defaults, opts) + + if (opts.recurse_count > 8) { + throw new FS.ErrnoError(32); + } + + + 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; + } + + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + + + if (FS.isMountpoint(current)) { + if (!islast || (islast && opts.follow_mount)) { + current = current.mounted.root; + } + } + + + + if (!islast || opts.follow) { + var count = 0; + while (FS.isLink(current.mode)) { + var link = FS.readlink(current_path); + current_path = PATH_FS.resolve(PATH.dirname(current_path), link); + + var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 }); + current = lookup.node; + + if (count++ > 40) { + throw new FS.ErrnoError(32); + } + } + } + } + + return { path: current_path, node: current }; + },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, parent); + } + 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; + },flagModes:{"r":0,"r+":2,"w":577,"w+":578,"a":1089,"a+":1090},modeStringToFlags:(str) => { + var flags = FS.flagModes[str]; + if (typeof flags == 'undefined') { + throw new Error('Unknown file open mode: ' + str); + } + return flags; + },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) => { + var errCode = FS.nodePermissions(dir, 'x'); + if (errCode) return errCode; + if (!dir.node_ops.lookup) return 2; + return 0; + },mayCreate:(dir, name) => { + 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)) { + return 31; + } + } + return FS.nodePermissions(node, FS.flagsToPermissionString(flags)); + },MAX_OPEN_FDS:4096,nextfd:(fd_start = 0, fd_end = FS.MAX_OPEN_FDS) => { + for (var fd = fd_start; fd <= fd_end; fd++) { + if (!FS.streams[fd]) { + return fd; + } + } + throw new FS.ErrnoError(33); + },getStream:(fd) => FS.streams[fd],createStream:(stream, fd_start, fd_end) => { + if (!FS.FSStream) { + FS.FSStream = function() { + this.shared = { }; + }; + FS.FSStream.prototype = {}; + Object.defineProperties(FS.FSStream.prototype, { + object: { + + get: function() { return this.node; }, + + set: function(val) { this.node = val; } + }, + isRead: { + + get: function() { return (this.flags & 2097155) !== 1; } + }, + isWrite: { + + get: function() { return (this.flags & 2097155) !== 0; } + }, + isAppend: { + + get: function() { return (this.flags & 1024); } + }, + flags: { + + get: function() { return this.shared.flags; }, + + set: function(val) { this.shared.flags = val; }, + }, + position : { + + get: function() { return this.shared.position; }, + + set: function(val) { this.shared.position = val; }, + }, + }); + } + + stream = Object.assign(new FS.FSStream(), stream); + var fd = FS.nextfd(fd_start, fd_end); + stream.fd = fd; + FS.streams[fd] = stream; + return stream; + },closeStream:(fd) => { + FS.streams[fd] = null; + },chrdev_stream_ops:{open:(stream) => { + var device = FS.getDevice(stream.node.rdev); + + stream.stream_ops = device.stream_ops; + + if (stream.stream_ops.open) { + 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.apply(check, 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: type, + opts: opts, + mountpoint: mountpoint, + mounts: [] + }; + + + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + + if (root) { + FS.root = mountRoot; + } else if (node) { + + node.mounted = mount; + + + if (node.mount) { + node.mount.mounts.push(mount); + } + } + + return mountRoot; + },unmount:(mountpoint) => { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + + if (!FS.isMountpoint(lookup.node)) { + throw new FS.ErrnoError(28); + } + + + var node = lookup.node; + var mount = node.mounted; + var mounts = FS.getMounts(mount); + + Object.keys(FS.nameTable).forEach((hash) => { + var current = FS.nameTable[hash]; + + while (current) { + var next = current.name_next; + + if (mounts.includes(current.mount)) { + FS.destroyNode(current); + } + + current = next; + } + }); + + + node.mounted = null; + + + var idx = node.mount.mounts.indexOf(mount); + node.mount.mounts.splice(idx, 1); + },lookup:(parent, name) => { + return parent.node_ops.lookup(parent, name); + },mknod:(path, mode, dev) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + if (!name || name === '.' || name === '..') { + throw new FS.ErrnoError(28); + } + var errCode = FS.mayCreate(parent, name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.mknod) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.mknod(parent, name, mode, dev); + },create:(path, mode) => { + mode = mode !== undefined ? mode : 438 ; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + },mkdir:(path, mode) => { + mode = mode !== undefined ? mode : 511 ; + mode &= 511 | 512; + mode |= 16384; + return FS.mknod(path, mode, 0); + },mkdirTree:(path, mode) => { + var dirs = path.split('/'); + var d = ''; + for (var i = 0; i < dirs.length; ++i) { + if (!dirs[i]) continue; + d += '/' + dirs[i]; + try { + FS.mkdir(d, mode); + } catch(e) { + if (e.errno != 20) throw e; + } + } + },mkdev:(path, mode, dev) => { + if (typeof dev == 'undefined') { + dev = mode; + mode = 438 ; + } + mode |= 8192; + return FS.mknod(path, mode, dev); + },symlink:(oldpath, newpath) => { + if (!PATH_FS.resolve(oldpath)) { + throw new FS.ErrnoError(44); + } + var lookup = FS.lookupPath(newpath, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var newname = PATH.basename(newpath); + var errCode = FS.mayCreate(parent, newname); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.symlink(parent, newname, oldpath); + },rename:(old_path, new_path) => { + var old_dirname = PATH.dirname(old_path); + var new_dirname = PATH.dirname(new_path); + var old_name = PATH.basename(old_path); + var new_name = PATH.basename(new_path); + + var lookup, old_dir, new_dir; + + + lookup = FS.lookupPath(old_path, { parent: true }); + old_dir = lookup.node; + lookup = FS.lookupPath(new_path, { parent: true }); + new_dir = lookup.node; + + if (!old_dir || !new_dir) throw new FS.ErrnoError(44); + + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75); + } + + var old_node = FS.lookupNode(old_dir, old_name); + + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(28); + } + + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(55); + } + + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + + } + + if (old_node === new_node) { + return; + } + + var isdir = FS.isDir(old_node.mode); + var errCode = FS.mayDelete(old_dir, old_name, isdir); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + + + errCode = new_node ? + FS.mayDelete(new_dir, new_name, isdir) : + FS.mayCreate(new_dir, new_name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!old_dir.node_ops.rename) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) { + throw new FS.ErrnoError(10); + } + + if (new_dir !== old_dir) { + errCode = FS.nodePermissions(old_dir, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + + FS.hashRemoveNode(old_node); + + try { + old_dir.node_ops.rename(old_node, new_dir, new_name); + } catch (e) { + throw e; + } finally { + + + FS.hashAddNode(old_node); + } + },rmdir:(path) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, true); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.rmdir) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.rmdir(parent, name); + FS.destroyNode(node); + },readdir:(path) => { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + if (!node.node_ops.readdir) { + throw new FS.ErrnoError(54); + } + return node.node_ops.readdir(node); + },unlink:(path) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, false); + if (errCode) { + + + + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.unlink) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.unlink(parent, name); + FS.destroyNode(node); + },readlink:(path) => { + var lookup = FS.lookupPath(path); + var link = lookup.node; + if (!link) { + throw new FS.ErrnoError(44); + } + if (!link.node_ops.readlink) { + throw new FS.ErrnoError(28); + } + return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link)); + },stat:(path, dontFollow) => { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + var node = lookup.node; + if (!node) { + throw new FS.ErrnoError(44); + } + if (!node.node_ops.getattr) { + throw new FS.ErrnoError(63); + } + return node.node_ops.getattr(node); + },lstat:(path) => { + return FS.stat(path, true); + },chmod:(path, mode, dontFollow) => { + var node; + if (typeof path == 'string') { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + mode: (mode & 4095) | (node.mode & ~4095), + timestamp: Date.now() + }); + },lchmod:(path, mode) => { + FS.chmod(path, mode, true); + },fchmod:(fd, mode) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chmod(stream.node, mode); + },chown:(path, uid, gid, dontFollow) => { + var node; + if (typeof path == 'string') { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + timestamp: Date.now() + + }); + },lchown:(path, uid, gid) => { + FS.chown(path, uid, gid, true); + },fchown:(fd, uid, gid) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chown(stream.node, uid, gid); + },truncate:(path, len) => { + if (len < 0) { + throw new FS.ErrnoError(28); + } + var node; + if (typeof path == 'string') { + var lookup = FS.lookupPath(path, { follow: true }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + if (FS.isDir(node.mode)) { + throw new FS.ErrnoError(31); + } + if (!FS.isFile(node.mode)) { + throw new FS.ErrnoError(28); + } + var errCode = FS.nodePermissions(node, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + node.node_ops.setattr(node, { + size: len, + timestamp: Date.now() + }); + },ftruncate:(fd, len) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(28); + } + FS.truncate(stream.node, len); + },utime:(path, atime, mtime) => { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + node.node_ops.setattr(node, { + timestamp: Math.max(atime, mtime) + }); + },open:(path, flags, mode) => { + if (path === "") { + throw new FS.ErrnoError(44); + } + flags = typeof flags == 'string' ? FS.modeStringToFlags(flags) : flags; + mode = typeof mode == 'undefined' ? 438 : mode; + if ((flags & 64)) { + mode = (mode & 4095) | 32768; + } else { + mode = 0; + } + var node; + if (typeof path == 'object') { + node = path; + } else { + path = PATH.normalize(path); + try { + var lookup = FS.lookupPath(path, { + follow: !(flags & 131072) + }); + node = lookup.node; + } catch (e) { + + } + } + + var created = false; + if ((flags & 64)) { + if (node) { + + if ((flags & 128)) { + throw new FS.ErrnoError(20); + } + } else { + + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(44); + } + + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + + if ((flags & 65536) && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + + + + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + + if ((flags & 512) && !created) { + FS.truncate(node, 0); + } + + flags &= ~(128 | 512 | 131072); + + + var stream = FS.createStream({ + node: node, + path: FS.getPath(node), + flags: flags, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + + ungotten: [], + error: false + }); + + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + if (Module['logReadFiles'] && !(flags & 1)) { + if (!FS.readFiles) FS.readFiles = {}; + if (!(path in FS.readFiles)) { + FS.readFiles[path] = 1; + } + } + return stream; + },close:(stream) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (stream.getdents) stream.getdents = null; + try { + if (stream.stream_ops.close) { + stream.stream_ops.close(stream); + } + } catch (e) { + throw e; + } finally { + FS.closeStream(stream.fd); + } + stream.fd = null; + },isClosed:(stream) => { + return stream.fd === null; + },llseek:(stream, offset, whence) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (!stream.seekable || !stream.stream_ops.llseek) { + throw new FS.ErrnoError(70); + } + if (whence != 0 && whence != 1 && whence != 2) { + throw new FS.ErrnoError(28); + } + stream.position = stream.stream_ops.llseek(stream, offset, whence); + stream.ungotten = []; + return stream.position; + },read:(stream, buffer, offset, length, position) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28); + } + var seeking = typeof position != 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); + if (!seeking) stream.position += bytesRead; + return bytesRead; + },write:(stream, buffer, offset, length, position, canOwn) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28); + } + if (stream.seekable && stream.flags & 1024) { + + FS.llseek(stream, 0, 2); + } + var seeking = typeof position != 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn); + if (!seeking) stream.position += bytesWritten; + return bytesWritten; + },allocate:(stream, offset, length) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (offset < 0 || length <= 0) { + throw new FS.ErrnoError(28); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (!stream.stream_ops.allocate) { + throw new FS.ErrnoError(138); + } + stream.stream_ops.allocate(stream, offset, length); + },mmap:(stream, length, position, prot, flags) => { + + + + + + + if ((prot & 2) !== 0 + && (flags & 2) === 0 + && (stream.flags & 2097155) !== 2) { + throw new FS.ErrnoError(2); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(2); + } + if (!stream.stream_ops.mmap) { + throw new FS.ErrnoError(43); + } + return stream.stream_ops.mmap(stream, length, position, prot, flags); + },msync:(stream, buffer, offset, length, mmapFlags) => { + if (!stream.stream_ops.msync) { + return 0; + } + return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags); + },munmap:(stream) => 0,ioctl:(stream, cmd, arg) => { + if (!stream.stream_ops.ioctl) { + throw new FS.ErrnoError(59); + } + return stream.stream_ops.ioctl(stream, cmd, arg); + },readFile:(path, opts = {}) => { + opts.flags = opts.flags || 0; + opts.encoding = opts.encoding || 'binary'; + if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') { + throw new Error('Invalid encoding type "' + opts.encoding + '"'); + } + var ret; + var stream = FS.open(path, opts.flags); + var stat = FS.stat(path); + var length = stat.size; + var buf = new Uint8Array(length); + FS.read(stream, buf, 0, length, 0); + if (opts.encoding === 'utf8') { + ret = UTF8ArrayToString(buf, 0); + } else if (opts.encoding === 'binary') { + ret = buf; + } + FS.close(stream); + return ret; + },writeFile:(path, data, opts = {}) => { + opts.flags = opts.flags || 577; + var stream = FS.open(path, opts.flags, opts.mode); + if (typeof data == 'string') { + var buf = new Uint8Array(lengthBytesUTF8(data)+1); + var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length); + FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn); + } else if (ArrayBuffer.isView(data)) { + FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn); + } else { + throw new Error('Unsupported data type'); + } + FS.close(stream); + },cwd:() => FS.currentPath,chdir:(path) => { + var lookup = FS.lookupPath(path, { follow: true }); + if (lookup.node === null) { + throw new FS.ErrnoError(44); + } + if (!FS.isDir(lookup.node.mode)) { + throw new FS.ErrnoError(54); + } + var errCode = FS.nodePermissions(lookup.node, 'x'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + FS.currentPath = lookup.path; + },createDefaultDirectories:() => { + FS.mkdir('/tmp'); + FS.mkdir('/home'); + FS.mkdir('/home/web_user'); + },createDefaultDevices:() => { + + FS.mkdir('/dev'); + + FS.registerDevice(FS.makedev(1, 3), { + read: () => 0, + write: (stream, buffer, offset, length, pos) => length, + }); + FS.mkdev('/dev/null', FS.makedev(1, 3)); + + + + TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); + TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); + FS.mkdev('/dev/tty', FS.makedev(5, 0)); + FS.mkdev('/dev/tty1', FS.makedev(6, 0)); + + var random_device = getRandomDevice(); + FS.createDevice('/dev', 'random', random_device); + FS.createDevice('/dev', 'urandom', random_device); + + + FS.mkdir('/dev/shm'); + FS.mkdir('/dev/shm/tmp'); + },createSpecialDirectories:() => { + + + FS.mkdir('/proc'); + var proc_self = FS.mkdir('/proc/self'); + FS.mkdir('/proc/self/fd'); + FS.mount({ + mount: () => { + var node = FS.createNode(proc_self, 'fd', 16384 | 511 , 73); + node.node_ops = { + lookup: (parent, name) => { + var fd = +name; + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + var ret = { + parent: null, + mount: { mountpoint: 'fake' }, + node_ops: { readlink: () => stream.path }, + }; + ret.parent = ret; + return ret; + } + }; + return node; + } + }, {}, '/proc/self/fd'); + },createStandardStreams:() => { + + + + + + + + + if (Module['stdin']) { + FS.createDevice('/dev', 'stdin', Module['stdin']); + } else { + FS.symlink('/dev/tty', '/dev/stdin'); + } + if (Module['stdout']) { + FS.createDevice('/dev', 'stdout', null, Module['stdout']); + } else { + FS.symlink('/dev/tty', '/dev/stdout'); + } + if (Module['stderr']) { + FS.createDevice('/dev', 'stderr', null, Module['stderr']); + } else { + FS.symlink('/dev/tty1', '/dev/stderr'); + } + + + var stdin = FS.open('/dev/stdin', 0); + var stdout = FS.open('/dev/stdout', 1); + var stderr = FS.open('/dev/stderr', 1); + },ensureErrnoError:() => { + if (FS.ErrnoError) return; + FS.ErrnoError = function ErrnoError(errno, node) { + this.node = node; + this.setErrno = function(errno) { + this.errno = errno; + }; + this.setErrno(errno); + this.message = 'FS error'; + + }; + FS.ErrnoError.prototype = new Error(); + FS.ErrnoError.prototype.constructor = FS.ErrnoError; + + [44].forEach((code) => { + FS.genericErrors[code] = new FS.ErrnoError(code); + FS.genericErrors[code].stack = ''; + }); + },staticInit:() => { + FS.ensureErrnoError(); + + FS.nameTable = new Array(4096); + + FS.mount(MEMFS, {}, '/'); + + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + + FS.filesystems = { + 'MEMFS': MEMFS, + }; + },init:(input, output, error) => { + FS.init.initialized = true; + + FS.ensureErrnoError(); + + + Module['stdin'] = input || Module['stdin']; + Module['stdout'] = output || Module['stdout']; + Module['stderr'] = error || Module['stderr']; + + FS.createStandardStreams(); + },quit:() => { + FS.init.initialized = false; + + + for (var i = 0; i < FS.streams.length; i++) { + var stream = FS.streams[i]; + if (!stream) { + continue; + } + FS.close(stream); + } + },getMode:(canRead, canWrite) => { + var mode = 0; + if (canRead) mode |= 292 | 73; + if (canWrite) mode |= 146; + return mode; + },findObject:(path, dontResolveLastLink) => { + var ret = FS.analyzePath(path, dontResolveLastLink); + if (!ret.exists) { + return null; + } + return ret.object; + },analyzePath:(path, dontResolveLastLink) => { + + try { + var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + path = lookup.path; + } catch (e) { + } + var ret = { + isRoot: false, exists: false, error: 0, name: null, path: null, object: null, + parentExists: false, parentPath: null, parentObject: null + }; + try { + var lookup = FS.lookupPath(path, { parent: true }); + ret.parentExists = true; + ret.parentPath = lookup.path; + ret.parentObject = lookup.node; + ret.name = PATH.basename(path); + lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + ret.exists = true; + ret.path = lookup.path; + ret.object = lookup.node; + ret.name = lookup.node.name; + ret.isRoot = lookup.path === '/'; + } catch (e) { + ret.error = e.errno; + }; + return ret; + },createPath:(parent, path, canRead, canWrite) => { + parent = typeof parent == 'string' ? parent : FS.getPath(parent); + var parts = path.split('/').reverse(); + while (parts.length) { + var part = parts.pop(); + if (!part) continue; + var current = PATH.join2(parent, part); + try { + FS.mkdir(current); + } catch (e) { + + } + parent = current; + } + return current; + },createFile:(parent, name, properties, canRead, canWrite) => { + var path = PATH.join2(typeof parent == 'string' ? parent : FS.getPath(parent), name); + var mode = FS.getMode(canRead, canWrite); + return FS.create(path, mode); + },createDataFile:(parent, name, data, canRead, canWrite, canOwn) => { + var path = name; + if (parent) { + parent = typeof parent == 'string' ? parent : FS.getPath(parent); + path = name ? PATH.join2(parent, name) : parent; + } + var mode = FS.getMode(canRead, canWrite); + var node = FS.create(path, mode); + if (data) { + if (typeof data == 'string') { + var arr = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i); + data = arr; + } + + FS.chmod(node, mode | 146); + var stream = FS.open(node, 577); + FS.write(stream, data, 0, data.length, 0, canOwn); + FS.close(stream); + FS.chmod(node, mode); + } + return node; + },createDevice:(parent, name, input, output) => { + var path = PATH.join2(typeof parent == 'string' ? parent : FS.getPath(parent), name); + var mode = FS.getMode(!!input, !!output); + if (!FS.createDevice.major) FS.createDevice.major = 64; + var dev = FS.makedev(FS.createDevice.major++, 0); + + + FS.registerDevice(dev, { + open: (stream) => { + stream.seekable = false; + }, + close: (stream) => { + + if (output && output.buffer && output.buffer.length) { + output(10); + } + }, + read: (stream, buffer, offset, length, pos ) => { + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = input(); + } 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.timestamp = Date.now(); + } + return bytesRead; + }, + write: (stream, buffer, offset, length, pos) => { + for (var i = 0; i < length; i++) { + try { + output(buffer[offset+i]); + } catch (e) { + throw new FS.ErrnoError(29); + } + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + } + }); + return FS.mkdev(path, mode, dev); + },forceLoadFile:(obj) => { + if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true; + if (typeof XMLHttpRequest != 'undefined') { + throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread."); + } else if (read_) { + + try { + + + obj.contents = intArrayFromString(read_(obj.url), true); + obj.usedBytes = obj.contents.length; + } catch (e) { + throw new FS.ErrnoError(29); + } + } else { + throw new Error('Cannot load without read() or XMLHttpRequest.'); + } + },createLazyFile:(parent, name, url, canRead, canWrite) => { + + + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = []; + } + LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) { + if (idx > this.length-1 || idx < 0) { + return undefined; + } + var chunkOffset = idx % this.chunkSize; + var chunkNum = (idx / this.chunkSize)|0; + return this.getter(chunkNum)[chunkOffset]; + }; + LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) { + this.getter = getter; + }; + LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() { + + var xhr = new XMLHttpRequest(); + xhr.open('HEAD', url, false); + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; + + var chunkSize = 1024*1024; + + if (!hasByteServing) chunkSize = datalength; + + + var doXHR = (from, to) => { + if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!"); + + + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + + + xhr.responseType = 'arraybuffer'; + if (xhr.overrideMimeType) { + xhr.overrideMimeType('text/plain; charset=x-user-defined'); + } + + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + if (xhr.response !== undefined) { + return new Uint8Array((xhr.response || [])); + } + return intArrayFromString(xhr.responseText || '', true); + }; + var lazyArray = this; + lazyArray.setDataGetter((chunkNum) => { + var start = chunkNum * chunkSize; + var end = (chunkNum+1) * chunkSize - 1; + end = Math.min(end, datalength-1); + if (typeof lazyArray.chunks[chunkNum] == 'undefined') { + lazyArray.chunks[chunkNum] = doXHR(start, end); + } + if (typeof lazyArray.chunks[chunkNum] == 'undefined') throw new Error('doXHR failed!'); + return lazyArray.chunks[chunkNum]; + }); + + if (usesGzip || !datalength) { + + chunkSize = datalength = 1; + datalength = this.getter(0).length; + chunkSize = datalength; + out("LazyFiles on gzip forces download of the whole file when length is accessed"); + } + + this._length = datalength; + this._chunkSize = chunkSize; + this.lengthKnown = true; + }; + if (typeof XMLHttpRequest != 'undefined') { + if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc'; + var lazyArray = new LazyUint8Array(); + Object.defineProperties(lazyArray, { + length: { + get: function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + } + }, + chunkSize: { + get: function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._chunkSize; + } + } + }); + + var properties = { isDevice: false, contents: lazyArray }; + } else { + var properties = { isDevice: false, url: url }; + } + + var node = FS.createFile(parent, name, properties, canRead, canWrite); + + + + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + + Object.defineProperties(node, { + usedBytes: { + get: function() { return this.contents.length; } + } + }); + + var stream_ops = {}; + var keys = Object.keys(node.stream_ops); + keys.forEach((key) => { + var fn = node.stream_ops[key]; + stream_ops[key] = function forceLoadLazyFile() { + FS.forceLoadFile(node); + return fn.apply(null, arguments); + }; + }); + function writeChunks(stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= contents.length) + return 0; + var size = Math.min(contents.length - position, length); + if (contents.slice) { + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i]; + } + } else { + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents.get(position + i); + } + } + return size; + } + + stream_ops.read = (stream, buffer, offset, length, position) => { + FS.forceLoadFile(node); + return writeChunks(stream, buffer, offset, length, position) + }; + + stream_ops.mmap = (stream, length, position, prot, flags) => { + FS.forceLoadFile(node); + var ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + writeChunks(stream, HEAP8, ptr, length, position); + return { ptr: ptr, allocated: true }; + }; + node.stream_ops = stream_ops; + return node; + },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) { + if (preFinish) preFinish(); + if (!dontCreateFile) { + FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn); + } + if (onload) onload(); + removeRunDependency(dep); + } + if (Browser.handledByPreloadPlugin(byteArray, fullname, finish, () => { + if (onerror) onerror(); + removeRunDependency(dep); + })) { + return; + } + finish(byteArray); + } + addRunDependency(dep); + if (typeof url == 'string') { + asyncLoad(url, (byteArray) => processData(byteArray), onerror); + } else { + processData(url); + } + },indexedDB:() => { + return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; + },DB_NAME:() => { + return 'EM_FS_' + window.location.pathname; + },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:(paths, onload, onerror) => { + onload = onload || (() => {}); + onerror = onerror || (() => {}); + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = () => { + out('creating db'); + var db = openRequest.result; + db.createObjectStore(FS.DB_STORE_NAME); + }; + openRequest.onsuccess = () => { + var db = openRequest.result; + var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite'); + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, fail = 0, total = paths.length; + function finish() { + if (fail == 0) onload(); else onerror(); + } + paths.forEach((path) => { + var putRequest = files.put(FS.analyzePath(path).object.contents, path); + putRequest.onsuccess = () => { ok++; if (ok + fail == total) finish() }; + putRequest.onerror = () => { fail++; if (ok + fail == total) finish() }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + },loadFilesFromDB:(paths, onload, onerror) => { + onload = onload || (() => {}); + onerror = onerror || (() => {}); + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = onerror; + openRequest.onsuccess = () => { + var db = openRequest.result; + try { + var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly'); + } catch(e) { + onerror(e); + return; + } + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, fail = 0, total = paths.length; + function finish() { + if (fail == 0) onload(); else onerror(); + } + paths.forEach((path) => { + var getRequest = files.get(path); + getRequest.onsuccess = () => { + if (FS.analyzePath(path).exists) { + FS.unlink(path); + } + FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true); + ok++; + if (ok + fail == total) finish(); + }; + getRequest.onerror = () => { fail++; if (ok + fail == total) finish() }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + }}; + var SYSCALLS = {DEFAULT_POLLMASK:5,calculateAt:function(dirfd, path, allowEmpty) { + if (PATH.isAbs(path)) { + return path; + } + + var dir; + if (dirfd === -100) { + dir = FS.cwd(); + } else { + var dirstream = SYSCALLS.getStreamFromFD(dirfd); + dir = dirstream.path; + } + if (path.length == 0) { + if (!allowEmpty) { + throw new FS.ErrnoError(44);; + } + return dir; + } + return PATH.join2(dir, path); + },doStat:function(func, path, buf) { + try { + var stat = func(path); + } catch (e) { + if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) { + + return -54; + } + throw e; + } + HEAP32[((buf)>>2)] = stat.dev; + HEAP32[(((buf)+(8))>>2)] = stat.ino; + HEAP32[(((buf)+(12))>>2)] = stat.mode; + HEAPU32[(((buf)+(16))>>2)] = stat.nlink; + HEAP32[(((buf)+(20))>>2)] = stat.uid; + HEAP32[(((buf)+(24))>>2)] = stat.gid; + HEAP32[(((buf)+(28))>>2)] = stat.rdev; + (tempI64 = [stat.size>>>0,(tempDouble=stat.size,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[(((buf)+(40))>>2)] = tempI64[0],HEAP32[(((buf)+(44))>>2)] = tempI64[1]); + HEAP32[(((buf)+(48))>>2)] = 4096; + HEAP32[(((buf)+(52))>>2)] = stat.blocks; + var atime = stat.atime.getTime(); + var mtime = stat.mtime.getTime(); + var ctime = stat.ctime.getTime(); + (tempI64 = [Math.floor(atime / 1000)>>>0,(tempDouble=Math.floor(atime / 1000),(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[(((buf)+(56))>>2)] = tempI64[0],HEAP32[(((buf)+(60))>>2)] = tempI64[1]); + HEAPU32[(((buf)+(64))>>2)] = (atime % 1000) * 1000; + (tempI64 = [Math.floor(mtime / 1000)>>>0,(tempDouble=Math.floor(mtime / 1000),(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[(((buf)+(72))>>2)] = tempI64[0],HEAP32[(((buf)+(76))>>2)] = tempI64[1]); + HEAPU32[(((buf)+(80))>>2)] = (mtime % 1000) * 1000; + (tempI64 = [Math.floor(ctime / 1000)>>>0,(tempDouble=Math.floor(ctime / 1000),(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[(((buf)+(88))>>2)] = tempI64[0],HEAP32[(((buf)+(92))>>2)] = tempI64[1]); + HEAPU32[(((buf)+(96))>>2)] = (ctime % 1000) * 1000; + (tempI64 = [stat.ino>>>0,(tempDouble=stat.ino,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[(((buf)+(104))>>2)] = tempI64[0],HEAP32[(((buf)+(108))>>2)] = tempI64[1]); + return 0; + },doMsync:function(addr, stream, len, flags, offset) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (flags & 2) { + + return 0; + } + var buffer = HEAPU8.slice(addr, addr + len); + FS.msync(stream, buffer, offset, len, flags); + },varargs:undefined,get:function() { + SYSCALLS.varargs += 4; + var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)]; + return ret; + },getStr:function(ptr) { + var ret = UTF8ToString(ptr); + return ret; + },getStreamFromFD:function(fd) { + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + return stream; + }}; + function ___syscall_chmod(path, mode) { + try { + + path = SYSCALLS.getStr(path); + FS.chmod(path, mode); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_faccessat(dirfd, path, amode, flags) { + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + if (amode & ~7) { + + return -28; + } + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + if (!node) { + return -44; + } + var perms = ''; + if (amode & 4) perms += 'r'; + if (amode & 2) perms += 'w'; + if (amode & 1) perms += 'x'; + if (perms && FS.nodePermissions(node, perms)) { + return -2; + } + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_fchmod(fd, mode) { + try { + + FS.fchmod(fd, mode); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_fchown32(fd, owner, group) { + try { + + FS.fchown(fd, owner, group); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function setErrNo(value) { + HEAP32[((___errno_location())>>2)] = value; + return value; + } + + function ___syscall_fcntl64(fd, cmd, varargs) { + SYSCALLS.varargs = varargs; + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + switch (cmd) { + case 0: { + var arg = SYSCALLS.get(); + if (arg < 0) { + return -28; + } + var newStream; + newStream = FS.createStream(stream, arg); + return newStream.fd; + } + case 1: + case 2: + return 0; + case 3: + return stream.flags; + case 4: { + var arg = SYSCALLS.get(); + stream.flags |= arg; + return 0; + } + case 5: + { + + var arg = SYSCALLS.get(); + var offset = 0; + + HEAP16[(((arg)+(offset))>>1)] = 2; + return 0; + } + case 6: + case 7: + + + + + return 0; + case 16: + case 8: + return -28; + case 9: + + setErrNo(28); + return -1; + default: { + return -28; + } + } + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_fstat64(fd, buf) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + return SYSCALLS.doStat(FS.stat, stream.path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + var MAX_INT53 = 9007199254740992; + + var MIN_INT53 = -9007199254740992; + function bigintToI53Checked(num) { + return (num < MIN_INT53 || num > MAX_INT53) ? NaN : Number(num); + } + + + + + function ___syscall_ftruncate64(fd, length) { + try { + + length = bigintToI53Checked(length); if (isNaN(length)) return -61; + FS.ftruncate(fd, length); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_getcwd(buf, size) { + try { + + if (size === 0) return -28; + var cwd = FS.cwd(); + var cwdLengthInBytes = lengthBytesUTF8(cwd) + 1; + if (size < cwdLengthInBytes) return -68; + stringToUTF8(cwd, buf, size); + return cwdLengthInBytes; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_ioctl(fd, op, varargs) { + SYSCALLS.varargs = varargs; + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + switch (op) { + case 21509: + case 21505: { + if (!stream.tty) return -59; + return 0; + } + case 21510: + case 21511: + case 21512: + case 21506: + case 21507: + case 21508: { + if (!stream.tty) return -59; + return 0; + } + case 21519: { + if (!stream.tty) return -59; + var argp = SYSCALLS.get(); + HEAP32[((argp)>>2)] = 0; + return 0; + } + case 21520: { + if (!stream.tty) return -59; + return -28; + } + case 21531: { + var argp = SYSCALLS.get(); + return FS.ioctl(stream, op, argp); + } + case 21523: { + + + if (!stream.tty) return -59; + return 0; + } + case 21524: { + + + + if (!stream.tty) return -59; + return 0; + } + default: return -28; + } + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_lstat64(path, buf) { + try { + + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.lstat, path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_mkdirat(dirfd, path, mode) { + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + + + path = PATH.normalize(path); + if (path[path.length-1] === '/') path = path.substr(0, path.length-1); + FS.mkdir(path, mode, 0); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_newfstatat(dirfd, path, buf, flags) { + try { + + path = SYSCALLS.getStr(path); + var nofollow = flags & 256; + var allowEmpty = flags & 4096; + flags = flags & (~6400); + path = SYSCALLS.calculateAt(dirfd, path, allowEmpty); + return SYSCALLS.doStat(nofollow ? FS.lstat : FS.stat, path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_openat(dirfd, path, flags, varargs) { + SYSCALLS.varargs = varargs; + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + var mode = varargs ? SYSCALLS.get() : 0; + return FS.open(path, flags, mode).fd; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_readlinkat(dirfd, path, buf, bufsize) { + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + if (bufsize <= 0) return -28; + var ret = FS.readlink(path); + + var len = Math.min(bufsize, lengthBytesUTF8(ret)); + var endChar = HEAP8[buf+len]; + stringToUTF8(ret, buf, bufsize+1); + + + HEAP8[buf+len] = endChar; + return len; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_rmdir(path) { + try { + + path = SYSCALLS.getStr(path); + FS.rmdir(path); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_stat64(path, buf) { + try { + + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.stat, path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_unlinkat(dirfd, path, flags) { + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + if (flags === 0) { + FS.unlink(path); + } else if (flags === 512) { + FS.rmdir(path); + } else { + abort('Invalid flags passed to unlinkat'); + } + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function readI53FromI64(ptr) { + return HEAPU32[ptr>>2] + HEAP32[ptr+4>>2] * 4294967296; + } + + function ___syscall_utimensat(dirfd, path, times, flags) { + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path, true); + if (!times) { + var atime = Date.now(); + var mtime = atime; + } else { + var seconds = readI53FromI64(times); + var nanoseconds = HEAP32[(((times)+(8))>>2)]; + atime = (seconds*1000) + (nanoseconds/(1000*1000)); + times += 16; + seconds = readI53FromI64(times); + nanoseconds = HEAP32[(((times)+(8))>>2)]; + mtime = (seconds*1000) + (nanoseconds/(1000*1000)); + } + FS.utime(path, atime, mtime); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + var nowIsMonotonic = true;; + function __emscripten_get_now_is_monotonic() { + return nowIsMonotonic; + } + + + function __isLeapYear(year) { + return year%4 === 0 && (year%100 !== 0 || year%400 === 0); + } + + var __MONTH_DAYS_LEAP_CUMULATIVE = [0,31,60,91,121,152,182,213,244,274,305,335]; + + var __MONTH_DAYS_REGULAR_CUMULATIVE = [0,31,59,90,120,151,181,212,243,273,304,334]; + function __yday_from_date(date) { + var isLeapYear = __isLeapYear(date.getFullYear()); + var monthDaysCumulative = (isLeapYear ? __MONTH_DAYS_LEAP_CUMULATIVE : __MONTH_DAYS_REGULAR_CUMULATIVE); + var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1; + + return yday; + } + function __localtime_js(time, tmPtr) { + var date = new Date(readI53FromI64(time)*1000); + HEAP32[((tmPtr)>>2)] = date.getSeconds(); + HEAP32[(((tmPtr)+(4))>>2)] = date.getMinutes(); + HEAP32[(((tmPtr)+(8))>>2)] = date.getHours(); + HEAP32[(((tmPtr)+(12))>>2)] = date.getDate(); + HEAP32[(((tmPtr)+(16))>>2)] = date.getMonth(); + HEAP32[(((tmPtr)+(20))>>2)] = date.getFullYear()-1900; + HEAP32[(((tmPtr)+(24))>>2)] = date.getDay(); + + var yday = __yday_from_date(date)|0; + HEAP32[(((tmPtr)+(28))>>2)] = yday; + HEAP32[(((tmPtr)+(36))>>2)] = -(date.getTimezoneOffset() * 60); + + + var start = new Date(date.getFullYear(), 0, 1); + var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset(); + var winterOffset = start.getTimezoneOffset(); + var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset))|0; + HEAP32[(((tmPtr)+(32))>>2)] = dst; + } + + function allocateUTF8(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8Array(str, HEAP8, ret, size); + return ret; + } + function __tzset_js(timezone, daylight, tzname) { + + var currentYear = new Date().getFullYear(); + var winter = new Date(currentYear, 0, 1); + var summer = new Date(currentYear, 6, 1); + var winterOffset = winter.getTimezoneOffset(); + var summerOffset = summer.getTimezoneOffset(); + + + + + var stdTimezoneOffset = Math.max(winterOffset, summerOffset); + + + + + + + HEAPU32[((timezone)>>2)] = stdTimezoneOffset * 60; + + HEAP32[((daylight)>>2)] = Number(winterOffset != summerOffset); + + function extractZone(date) { + var match = date.toTimeString().match(/\(([A-Za-z ]+)\)$/); + return match ? match[1] : "GMT"; + }; + var winterName = extractZone(winter); + var summerName = extractZone(summer); + var winterNamePtr = allocateUTF8(winterName); + var summerNamePtr = allocateUTF8(summerName); + if (summerOffset < winterOffset) { + + HEAPU32[((tzname)>>2)] = winterNamePtr; + HEAPU32[(((tzname)+(4))>>2)] = summerNamePtr; + } else { + HEAPU32[((tzname)>>2)] = summerNamePtr; + HEAPU32[(((tzname)+(4))>>2)] = winterNamePtr; + } + } + + function _emscripten_date_now() { + return Date.now(); + } + + var _emscripten_get_now;_emscripten_get_now = () => performance.now(); + ; + + function getHeapMax() { + + + + + return 2147483648; + } + + function emscripten_realloc_buffer(size) { + var b = wasmMemory.buffer; + try { + + wasmMemory.grow((size - b.byteLength + 65535) >>> 16); + updateMemoryViews(); + return 1 ; + } catch(e) { + } + + + } + function _emscripten_resize_heap(requestedSize) { + var oldSize = HEAPU8.length; + requestedSize = requestedSize >>> 0; + + + + + + + + + + + + + + + + + + + + + + + var maxHeapSize = getHeapMax(); + if (requestedSize > maxHeapSize) { + return false; + } + + let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple; + + + + + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); + + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 ); + + var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536)); + + var replacement = emscripten_realloc_buffer(newSize); + if (replacement) { + + return true; + } + } + return false; + } + + var ENV = {}; + + function getExecutableName() { + return thisProgram || './this.program'; + } + function getEnvStrings() { + if (!getEnvStrings.strings) { + + + var lang = ((typeof navigator == 'object' && navigator.languages && navigator.languages[0]) || 'C').replace('-', '_') + '.UTF-8'; + var env = { + 'USER': 'web_user', + 'LOGNAME': 'web_user', + 'PATH': '/', + 'PWD': '/', + 'HOME': '/home/web_user', + 'LANG': lang, + '_': getExecutableName() + }; + + for (var x in ENV) { + + + + if (ENV[x] === undefined) delete env[x]; + else env[x] = ENV[x]; + } + var strings = []; + for (var x in env) { + strings.push(x + '=' + env[x]); + } + getEnvStrings.strings = strings; + } + return getEnvStrings.strings; + } + + + function writeAsciiToMemory(str, buffer, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + HEAP8[((buffer++)>>0)] = str.charCodeAt(i); + } + + if (!dontAddNull) HEAP8[((buffer)>>0)] = 0; + } + + function _environ_get(__environ, environ_buf) { + var bufSize = 0; + getEnvStrings().forEach(function(string, i) { + var ptr = environ_buf + bufSize; + HEAPU32[(((__environ)+(i*4))>>2)] = ptr; + writeAsciiToMemory(string, ptr); + bufSize += string.length + 1; + }); + return 0; + } + + + function _environ_sizes_get(penviron_count, penviron_buf_size) { + var strings = getEnvStrings(); + HEAPU32[((penviron_count)>>2)] = strings.length; + var bufSize = 0; + strings.forEach(function(string) { + bufSize += string.length + 1; + }); + HEAPU32[((penviron_buf_size)>>2)] = bufSize; + return 0; + } + + function _fd_close(fd) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + FS.close(stream); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + function _fd_fdstat_get(fd, pbuf) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + + + var type = stream.tty ? 2 : + FS.isDir(stream.mode) ? 3 : + FS.isLink(stream.mode) ? 7 : + 4; + HEAP8[((pbuf)>>0)] = type; + + + + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + + function doReadv(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[((iov)>>2)]; + var len = HEAPU32[(((iov)+(4))>>2)]; + iov += 8; + var curr = FS.read(stream, HEAP8,ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) break; + if (typeof offset !== 'undefined') { + offset += curr; + } + } + return ret; + } + + function _fd_read(fd, iov, iovcnt, pnum) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doReadv(stream, iov, iovcnt); + HEAPU32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + + + + + function _fd_seek(fd, offset, whence, newOffset) { + try { + + offset = bigintToI53Checked(offset); if (isNaN(offset)) return 61; + var stream = SYSCALLS.getStreamFromFD(fd); + FS.llseek(stream, offset, whence); + (tempI64 = [stream.position>>>0,(tempDouble=stream.position,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((newOffset)>>2)] = tempI64[0],HEAP32[(((newOffset)+(4))>>2)] = tempI64[1]); + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + function _fd_sync(fd) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + if (stream.stream_ops && stream.stream_ops.fsync) { + return stream.stream_ops.fsync(stream); + } + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + + function doWritev(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[((iov)>>2)]; + var len = HEAPU32[(((iov)+(4))>>2)]; + iov += 8; + var curr = FS.write(stream, HEAP8,ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (typeof offset !== 'undefined') { + offset += curr; + } + } + return ret; + } + + function _fd_write(fd, iov, iovcnt, pnum) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doWritev(stream, iov, iovcnt); + HEAPU32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + var FSNode = function(parent, name, mode, rdev) { + if (!parent) { + parent = this; + } + this.parent = parent; + this.mount = parent.mount; + this.mounted = null; + this.id = FS.nextInode++; + this.name = name; + this.mode = mode; + this.node_ops = {}; + this.stream_ops = {}; + this.rdev = rdev; + }; + var readMode = 292 | 73; + var writeMode = 146; + Object.defineProperties(FSNode.prototype, { + read: { + get: function() { + return (this.mode & readMode) === readMode; + }, + set: function(val) { + val ? this.mode |= readMode : this.mode &= ~readMode; + } + }, + write: { + get: function() { + return (this.mode & writeMode) === writeMode; + }, + set: function(val) { + val ? this.mode |= writeMode : this.mode &= ~writeMode; + } + }, + isFolder: { + get: function() { + return FS.isDir(this.mode); + } + }, + isDevice: { + get: function() { + return FS.isChrdev(this.mode); + } + } + }); + FS.FSNode = FSNode; + FS.staticInit();; +var ASSERTIONS = false; + +var asmLibraryArg = { + "__syscall_chmod": ___syscall_chmod, + "__syscall_faccessat": ___syscall_faccessat, + "__syscall_fchmod": ___syscall_fchmod, + "__syscall_fchown32": ___syscall_fchown32, + "__syscall_fcntl64": ___syscall_fcntl64, + "__syscall_fstat64": ___syscall_fstat64, + "__syscall_ftruncate64": ___syscall_ftruncate64, + "__syscall_getcwd": ___syscall_getcwd, + "__syscall_ioctl": ___syscall_ioctl, + "__syscall_lstat64": ___syscall_lstat64, + "__syscall_mkdirat": ___syscall_mkdirat, + "__syscall_newfstatat": ___syscall_newfstatat, + "__syscall_openat": ___syscall_openat, + "__syscall_readlinkat": ___syscall_readlinkat, + "__syscall_rmdir": ___syscall_rmdir, + "__syscall_stat64": ___syscall_stat64, + "__syscall_unlinkat": ___syscall_unlinkat, + "__syscall_utimensat": ___syscall_utimensat, + "_emscripten_get_now_is_monotonic": __emscripten_get_now_is_monotonic, + "_localtime_js": __localtime_js, + "_tzset_js": __tzset_js, + "emscripten_date_now": _emscripten_date_now, + "emscripten_get_now": _emscripten_get_now, + "emscripten_resize_heap": _emscripten_resize_heap, + "environ_get": _environ_get, + "environ_sizes_get": _environ_sizes_get, + "fd_close": _fd_close, + "fd_fdstat_get": _fd_fdstat_get, + "fd_read": _fd_read, + "fd_seek": _fd_seek, + "fd_sync": _fd_sync, + "fd_write": _fd_write, + "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 _sqlite3_status64 = Module["_sqlite3_status64"] = function() { + return (_sqlite3_status64 = Module["_sqlite3_status64"] = Module["asm"]["sqlite3_status64"]).apply(null, arguments); +}; + + +var _sqlite3_status = Module["_sqlite3_status"] = function() { + return (_sqlite3_status = Module["_sqlite3_status"] = Module["asm"]["sqlite3_status"]).apply(null, arguments); +}; + + +var _sqlite3_db_status = Module["_sqlite3_db_status"] = function() { + return (_sqlite3_db_status = Module["_sqlite3_db_status"] = Module["asm"]["sqlite3_db_status"]).apply(null, arguments); +}; + + +var _sqlite3_msize = Module["_sqlite3_msize"] = function() { + return (_sqlite3_msize = Module["_sqlite3_msize"] = Module["asm"]["sqlite3_msize"]).apply(null, arguments); +}; + + +var _sqlite3_vfs_find = Module["_sqlite3_vfs_find"] = function() { + return (_sqlite3_vfs_find = Module["_sqlite3_vfs_find"] = Module["asm"]["sqlite3_vfs_find"]).apply(null, arguments); +}; + + +var _sqlite3_initialize = Module["_sqlite3_initialize"] = function() { + return (_sqlite3_initialize = Module["_sqlite3_initialize"] = Module["asm"]["sqlite3_initialize"]).apply(null, arguments); +}; + + +var _sqlite3_malloc = Module["_sqlite3_malloc"] = function() { + return (_sqlite3_malloc = Module["_sqlite3_malloc"] = Module["asm"]["sqlite3_malloc"]).apply(null, arguments); +}; + + +var _sqlite3_free = Module["_sqlite3_free"] = function() { + return (_sqlite3_free = Module["_sqlite3_free"] = Module["asm"]["sqlite3_free"]).apply(null, arguments); +}; + + +var _sqlite3_vfs_register = Module["_sqlite3_vfs_register"] = function() { + return (_sqlite3_vfs_register = Module["_sqlite3_vfs_register"] = Module["asm"]["sqlite3_vfs_register"]).apply(null, arguments); +}; + + +var _sqlite3_vfs_unregister = Module["_sqlite3_vfs_unregister"] = function() { + return (_sqlite3_vfs_unregister = Module["_sqlite3_vfs_unregister"] = Module["asm"]["sqlite3_vfs_unregister"]).apply(null, arguments); +}; + + +var _sqlite3_malloc64 = Module["_sqlite3_malloc64"] = function() { + return (_sqlite3_malloc64 = Module["_sqlite3_malloc64"] = Module["asm"]["sqlite3_malloc64"]).apply(null, arguments); +}; + + +var _sqlite3_realloc = Module["_sqlite3_realloc"] = function() { + return (_sqlite3_realloc = Module["_sqlite3_realloc"] = Module["asm"]["sqlite3_realloc"]).apply(null, arguments); +}; + + +var _sqlite3_realloc64 = Module["_sqlite3_realloc64"] = function() { + return (_sqlite3_realloc64 = Module["_sqlite3_realloc64"] = Module["asm"]["sqlite3_realloc64"]).apply(null, arguments); +}; + + +var _sqlite3_value_text = Module["_sqlite3_value_text"] = function() { + return (_sqlite3_value_text = Module["_sqlite3_value_text"] = Module["asm"]["sqlite3_value_text"]).apply(null, arguments); +}; + + +var _sqlite3_randomness = Module["_sqlite3_randomness"] = function() { + return (_sqlite3_randomness = Module["_sqlite3_randomness"] = Module["asm"]["sqlite3_randomness"]).apply(null, arguments); +}; + + +var _sqlite3_stricmp = Module["_sqlite3_stricmp"] = function() { + return (_sqlite3_stricmp = Module["_sqlite3_stricmp"] = Module["asm"]["sqlite3_stricmp"]).apply(null, arguments); +}; + + +var _sqlite3_strnicmp = Module["_sqlite3_strnicmp"] = function() { + return (_sqlite3_strnicmp = Module["_sqlite3_strnicmp"] = Module["asm"]["sqlite3_strnicmp"]).apply(null, arguments); +}; + + +var _sqlite3_uri_parameter = Module["_sqlite3_uri_parameter"] = function() { + return (_sqlite3_uri_parameter = Module["_sqlite3_uri_parameter"] = Module["asm"]["sqlite3_uri_parameter"]).apply(null, arguments); +}; + + +var ___errno_location = Module["___errno_location"] = function() { + return (___errno_location = Module["___errno_location"] = Module["asm"]["__errno_location"]).apply(null, arguments); +}; + + +var _sqlite3_uri_boolean = Module["_sqlite3_uri_boolean"] = function() { + return (_sqlite3_uri_boolean = Module["_sqlite3_uri_boolean"] = Module["asm"]["sqlite3_uri_boolean"]).apply(null, arguments); +}; + + +var _sqlite3_serialize = Module["_sqlite3_serialize"] = function() { + return (_sqlite3_serialize = Module["_sqlite3_serialize"] = Module["asm"]["sqlite3_serialize"]).apply(null, arguments); +}; + + +var _sqlite3_prepare_v2 = Module["_sqlite3_prepare_v2"] = function() { + return (_sqlite3_prepare_v2 = Module["_sqlite3_prepare_v2"] = Module["asm"]["sqlite3_prepare_v2"]).apply(null, arguments); +}; + + +var _sqlite3_step = Module["_sqlite3_step"] = function() { + return (_sqlite3_step = Module["_sqlite3_step"] = Module["asm"]["sqlite3_step"]).apply(null, arguments); +}; + + +var _sqlite3_column_int64 = Module["_sqlite3_column_int64"] = function() { + return (_sqlite3_column_int64 = Module["_sqlite3_column_int64"] = Module["asm"]["sqlite3_column_int64"]).apply(null, arguments); +}; + + +var _sqlite3_column_int = Module["_sqlite3_column_int"] = function() { + return (_sqlite3_column_int = Module["_sqlite3_column_int"] = Module["asm"]["sqlite3_column_int"]).apply(null, arguments); +}; + + +var _sqlite3_finalize = Module["_sqlite3_finalize"] = function() { + return (_sqlite3_finalize = Module["_sqlite3_finalize"] = Module["asm"]["sqlite3_finalize"]).apply(null, arguments); +}; + + +var _sqlite3_file_control = Module["_sqlite3_file_control"] = function() { + return (_sqlite3_file_control = Module["_sqlite3_file_control"] = Module["asm"]["sqlite3_file_control"]).apply(null, arguments); +}; + + +var _sqlite3_reset = Module["_sqlite3_reset"] = function() { + return (_sqlite3_reset = Module["_sqlite3_reset"] = Module["asm"]["sqlite3_reset"]).apply(null, arguments); +}; + + +var _sqlite3_deserialize = Module["_sqlite3_deserialize"] = function() { + return (_sqlite3_deserialize = Module["_sqlite3_deserialize"] = Module["asm"]["sqlite3_deserialize"]).apply(null, arguments); +}; + + +var _sqlite3_clear_bindings = Module["_sqlite3_clear_bindings"] = function() { + return (_sqlite3_clear_bindings = Module["_sqlite3_clear_bindings"] = Module["asm"]["sqlite3_clear_bindings"]).apply(null, arguments); +}; + + +var _sqlite3_value_blob = Module["_sqlite3_value_blob"] = function() { + return (_sqlite3_value_blob = Module["_sqlite3_value_blob"] = Module["asm"]["sqlite3_value_blob"]).apply(null, arguments); +}; + + +var _sqlite3_value_bytes = Module["_sqlite3_value_bytes"] = function() { + return (_sqlite3_value_bytes = Module["_sqlite3_value_bytes"] = Module["asm"]["sqlite3_value_bytes"]).apply(null, arguments); +}; + + +var _sqlite3_value_double = Module["_sqlite3_value_double"] = function() { + return (_sqlite3_value_double = Module["_sqlite3_value_double"] = Module["asm"]["sqlite3_value_double"]).apply(null, arguments); +}; + + +var _sqlite3_value_int = Module["_sqlite3_value_int"] = function() { + return (_sqlite3_value_int = Module["_sqlite3_value_int"] = Module["asm"]["sqlite3_value_int"]).apply(null, arguments); +}; + + +var _sqlite3_value_int64 = Module["_sqlite3_value_int64"] = function() { + return (_sqlite3_value_int64 = Module["_sqlite3_value_int64"] = Module["asm"]["sqlite3_value_int64"]).apply(null, arguments); +}; + + +var _sqlite3_value_subtype = Module["_sqlite3_value_subtype"] = function() { + return (_sqlite3_value_subtype = Module["_sqlite3_value_subtype"] = Module["asm"]["sqlite3_value_subtype"]).apply(null, arguments); +}; + + +var _sqlite3_value_pointer = Module["_sqlite3_value_pointer"] = function() { + return (_sqlite3_value_pointer = Module["_sqlite3_value_pointer"] = Module["asm"]["sqlite3_value_pointer"]).apply(null, arguments); +}; + + +var _sqlite3_value_type = Module["_sqlite3_value_type"] = function() { + return (_sqlite3_value_type = Module["_sqlite3_value_type"] = Module["asm"]["sqlite3_value_type"]).apply(null, arguments); +}; + + +var _sqlite3_value_nochange = Module["_sqlite3_value_nochange"] = function() { + return (_sqlite3_value_nochange = Module["_sqlite3_value_nochange"] = Module["asm"]["sqlite3_value_nochange"]).apply(null, arguments); +}; + + +var _sqlite3_value_frombind = Module["_sqlite3_value_frombind"] = function() { + return (_sqlite3_value_frombind = Module["_sqlite3_value_frombind"] = Module["asm"]["sqlite3_value_frombind"]).apply(null, arguments); +}; + + +var _sqlite3_value_dup = Module["_sqlite3_value_dup"] = function() { + return (_sqlite3_value_dup = Module["_sqlite3_value_dup"] = Module["asm"]["sqlite3_value_dup"]).apply(null, arguments); +}; + + +var _sqlite3_value_free = Module["_sqlite3_value_free"] = function() { + return (_sqlite3_value_free = Module["_sqlite3_value_free"] = Module["asm"]["sqlite3_value_free"]).apply(null, arguments); +}; + + +var _sqlite3_result_blob = Module["_sqlite3_result_blob"] = function() { + return (_sqlite3_result_blob = Module["_sqlite3_result_blob"] = Module["asm"]["sqlite3_result_blob"]).apply(null, arguments); +}; + + +var _sqlite3_result_error_nomem = Module["_sqlite3_result_error_nomem"] = function() { + return (_sqlite3_result_error_nomem = Module["_sqlite3_result_error_nomem"] = Module["asm"]["sqlite3_result_error_nomem"]).apply(null, arguments); +}; + + +var _sqlite3_result_error_toobig = Module["_sqlite3_result_error_toobig"] = function() { + return (_sqlite3_result_error_toobig = Module["_sqlite3_result_error_toobig"] = Module["asm"]["sqlite3_result_error_toobig"]).apply(null, arguments); +}; + + +var _sqlite3_result_double = Module["_sqlite3_result_double"] = function() { + return (_sqlite3_result_double = Module["_sqlite3_result_double"] = Module["asm"]["sqlite3_result_double"]).apply(null, arguments); +}; + + +var _sqlite3_result_error = Module["_sqlite3_result_error"] = function() { + return (_sqlite3_result_error = Module["_sqlite3_result_error"] = Module["asm"]["sqlite3_result_error"]).apply(null, arguments); +}; + + +var _sqlite3_result_int = Module["_sqlite3_result_int"] = function() { + return (_sqlite3_result_int = Module["_sqlite3_result_int"] = Module["asm"]["sqlite3_result_int"]).apply(null, arguments); +}; + + +var _sqlite3_result_int64 = Module["_sqlite3_result_int64"] = function() { + return (_sqlite3_result_int64 = Module["_sqlite3_result_int64"] = Module["asm"]["sqlite3_result_int64"]).apply(null, arguments); +}; + + +var _sqlite3_result_null = Module["_sqlite3_result_null"] = function() { + return (_sqlite3_result_null = Module["_sqlite3_result_null"] = Module["asm"]["sqlite3_result_null"]).apply(null, arguments); +}; + + +var _sqlite3_result_pointer = Module["_sqlite3_result_pointer"] = function() { + return (_sqlite3_result_pointer = Module["_sqlite3_result_pointer"] = Module["asm"]["sqlite3_result_pointer"]).apply(null, arguments); +}; + + +var _sqlite3_result_subtype = Module["_sqlite3_result_subtype"] = function() { + return (_sqlite3_result_subtype = Module["_sqlite3_result_subtype"] = Module["asm"]["sqlite3_result_subtype"]).apply(null, arguments); +}; + + +var _sqlite3_result_text = Module["_sqlite3_result_text"] = function() { + return (_sqlite3_result_text = Module["_sqlite3_result_text"] = Module["asm"]["sqlite3_result_text"]).apply(null, arguments); +}; + + +var _sqlite3_result_zeroblob = Module["_sqlite3_result_zeroblob"] = function() { + return (_sqlite3_result_zeroblob = Module["_sqlite3_result_zeroblob"] = Module["asm"]["sqlite3_result_zeroblob"]).apply(null, arguments); +}; + + +var _sqlite3_result_zeroblob64 = Module["_sqlite3_result_zeroblob64"] = function() { + return (_sqlite3_result_zeroblob64 = Module["_sqlite3_result_zeroblob64"] = Module["asm"]["sqlite3_result_zeroblob64"]).apply(null, arguments); +}; + + +var _sqlite3_result_error_code = Module["_sqlite3_result_error_code"] = function() { + return (_sqlite3_result_error_code = Module["_sqlite3_result_error_code"] = Module["asm"]["sqlite3_result_error_code"]).apply(null, arguments); +}; + + +var _sqlite3_user_data = Module["_sqlite3_user_data"] = function() { + return (_sqlite3_user_data = Module["_sqlite3_user_data"] = Module["asm"]["sqlite3_user_data"]).apply(null, arguments); +}; + + +var _sqlite3_context_db_handle = Module["_sqlite3_context_db_handle"] = function() { + return (_sqlite3_context_db_handle = Module["_sqlite3_context_db_handle"] = Module["asm"]["sqlite3_context_db_handle"]).apply(null, arguments); +}; + + +var _sqlite3_vtab_nochange = Module["_sqlite3_vtab_nochange"] = function() { + return (_sqlite3_vtab_nochange = Module["_sqlite3_vtab_nochange"] = Module["asm"]["sqlite3_vtab_nochange"]).apply(null, arguments); +}; + + +var _sqlite3_vtab_in_first = Module["_sqlite3_vtab_in_first"] = function() { + return (_sqlite3_vtab_in_first = Module["_sqlite3_vtab_in_first"] = Module["asm"]["sqlite3_vtab_in_first"]).apply(null, arguments); +}; + + +var _sqlite3_vtab_in_next = Module["_sqlite3_vtab_in_next"] = function() { + return (_sqlite3_vtab_in_next = Module["_sqlite3_vtab_in_next"] = Module["asm"]["sqlite3_vtab_in_next"]).apply(null, arguments); +}; + + +var _sqlite3_aggregate_context = Module["_sqlite3_aggregate_context"] = function() { + return (_sqlite3_aggregate_context = Module["_sqlite3_aggregate_context"] = Module["asm"]["sqlite3_aggregate_context"]).apply(null, arguments); +}; + + +var _sqlite3_get_auxdata = Module["_sqlite3_get_auxdata"] = function() { + return (_sqlite3_get_auxdata = Module["_sqlite3_get_auxdata"] = Module["asm"]["sqlite3_get_auxdata"]).apply(null, arguments); +}; + + +var _sqlite3_set_auxdata = Module["_sqlite3_set_auxdata"] = function() { + return (_sqlite3_set_auxdata = Module["_sqlite3_set_auxdata"] = Module["asm"]["sqlite3_set_auxdata"]).apply(null, arguments); +}; + + +var _sqlite3_column_count = Module["_sqlite3_column_count"] = function() { + return (_sqlite3_column_count = Module["_sqlite3_column_count"] = Module["asm"]["sqlite3_column_count"]).apply(null, arguments); +}; + + +var _sqlite3_data_count = Module["_sqlite3_data_count"] = function() { + return (_sqlite3_data_count = Module["_sqlite3_data_count"] = Module["asm"]["sqlite3_data_count"]).apply(null, arguments); +}; + + +var _sqlite3_column_blob = Module["_sqlite3_column_blob"] = function() { + return (_sqlite3_column_blob = Module["_sqlite3_column_blob"] = Module["asm"]["sqlite3_column_blob"]).apply(null, arguments); +}; + + +var _sqlite3_column_bytes = Module["_sqlite3_column_bytes"] = function() { + return (_sqlite3_column_bytes = Module["_sqlite3_column_bytes"] = Module["asm"]["sqlite3_column_bytes"]).apply(null, arguments); +}; + + +var _sqlite3_column_double = Module["_sqlite3_column_double"] = function() { + return (_sqlite3_column_double = Module["_sqlite3_column_double"] = Module["asm"]["sqlite3_column_double"]).apply(null, arguments); +}; + + +var _sqlite3_column_text = Module["_sqlite3_column_text"] = function() { + return (_sqlite3_column_text = Module["_sqlite3_column_text"] = Module["asm"]["sqlite3_column_text"]).apply(null, arguments); +}; + + +var _sqlite3_column_value = Module["_sqlite3_column_value"] = function() { + return (_sqlite3_column_value = Module["_sqlite3_column_value"] = Module["asm"]["sqlite3_column_value"]).apply(null, arguments); +}; + + +var _sqlite3_column_type = Module["_sqlite3_column_type"] = function() { + return (_sqlite3_column_type = Module["_sqlite3_column_type"] = Module["asm"]["sqlite3_column_type"]).apply(null, arguments); +}; + + +var _sqlite3_column_name = Module["_sqlite3_column_name"] = function() { + return (_sqlite3_column_name = Module["_sqlite3_column_name"] = Module["asm"]["sqlite3_column_name"]).apply(null, arguments); +}; + + +var _sqlite3_bind_blob = Module["_sqlite3_bind_blob"] = function() { + return (_sqlite3_bind_blob = Module["_sqlite3_bind_blob"] = Module["asm"]["sqlite3_bind_blob"]).apply(null, arguments); +}; + + +var _sqlite3_bind_double = Module["_sqlite3_bind_double"] = function() { + return (_sqlite3_bind_double = Module["_sqlite3_bind_double"] = Module["asm"]["sqlite3_bind_double"]).apply(null, arguments); +}; + + +var _sqlite3_bind_int = Module["_sqlite3_bind_int"] = function() { + return (_sqlite3_bind_int = Module["_sqlite3_bind_int"] = Module["asm"]["sqlite3_bind_int"]).apply(null, arguments); +}; + + +var _sqlite3_bind_int64 = Module["_sqlite3_bind_int64"] = function() { + return (_sqlite3_bind_int64 = Module["_sqlite3_bind_int64"] = Module["asm"]["sqlite3_bind_int64"]).apply(null, arguments); +}; + + +var _sqlite3_bind_null = Module["_sqlite3_bind_null"] = function() { + return (_sqlite3_bind_null = Module["_sqlite3_bind_null"] = Module["asm"]["sqlite3_bind_null"]).apply(null, arguments); +}; + + +var _sqlite3_bind_pointer = Module["_sqlite3_bind_pointer"] = function() { + return (_sqlite3_bind_pointer = Module["_sqlite3_bind_pointer"] = Module["asm"]["sqlite3_bind_pointer"]).apply(null, arguments); +}; + + +var _sqlite3_bind_text = Module["_sqlite3_bind_text"] = function() { + return (_sqlite3_bind_text = Module["_sqlite3_bind_text"] = Module["asm"]["sqlite3_bind_text"]).apply(null, arguments); +}; + + +var _sqlite3_bind_parameter_count = Module["_sqlite3_bind_parameter_count"] = function() { + return (_sqlite3_bind_parameter_count = Module["_sqlite3_bind_parameter_count"] = Module["asm"]["sqlite3_bind_parameter_count"]).apply(null, arguments); +}; + + +var _sqlite3_bind_parameter_index = Module["_sqlite3_bind_parameter_index"] = function() { + return (_sqlite3_bind_parameter_index = Module["_sqlite3_bind_parameter_index"] = Module["asm"]["sqlite3_bind_parameter_index"]).apply(null, arguments); +}; + + +var _sqlite3_db_handle = Module["_sqlite3_db_handle"] = function() { + return (_sqlite3_db_handle = Module["_sqlite3_db_handle"] = Module["asm"]["sqlite3_db_handle"]).apply(null, arguments); +}; + + +var _sqlite3_stmt_readonly = Module["_sqlite3_stmt_readonly"] = function() { + return (_sqlite3_stmt_readonly = Module["_sqlite3_stmt_readonly"] = Module["asm"]["sqlite3_stmt_readonly"]).apply(null, arguments); +}; + + +var _sqlite3_stmt_isexplain = Module["_sqlite3_stmt_isexplain"] = function() { + return (_sqlite3_stmt_isexplain = Module["_sqlite3_stmt_isexplain"] = Module["asm"]["sqlite3_stmt_isexplain"]).apply(null, arguments); +}; + + +var _sqlite3_stmt_status = Module["_sqlite3_stmt_status"] = function() { + return (_sqlite3_stmt_status = Module["_sqlite3_stmt_status"] = Module["asm"]["sqlite3_stmt_status"]).apply(null, arguments); +}; + + +var _sqlite3_sql = Module["_sqlite3_sql"] = function() { + return (_sqlite3_sql = Module["_sqlite3_sql"] = Module["asm"]["sqlite3_sql"]).apply(null, arguments); +}; + + +var _sqlite3_expanded_sql = Module["_sqlite3_expanded_sql"] = function() { + return (_sqlite3_expanded_sql = Module["_sqlite3_expanded_sql"] = Module["asm"]["sqlite3_expanded_sql"]).apply(null, arguments); +}; + + +var _sqlite3_preupdate_old = Module["_sqlite3_preupdate_old"] = function() { + return (_sqlite3_preupdate_old = Module["_sqlite3_preupdate_old"] = Module["asm"]["sqlite3_preupdate_old"]).apply(null, arguments); +}; + + +var _sqlite3_preupdate_count = Module["_sqlite3_preupdate_count"] = function() { + return (_sqlite3_preupdate_count = Module["_sqlite3_preupdate_count"] = Module["asm"]["sqlite3_preupdate_count"]).apply(null, arguments); +}; + + +var _sqlite3_preupdate_depth = Module["_sqlite3_preupdate_depth"] = function() { + return (_sqlite3_preupdate_depth = Module["_sqlite3_preupdate_depth"] = Module["asm"]["sqlite3_preupdate_depth"]).apply(null, arguments); +}; + + +var _sqlite3_preupdate_blobwrite = Module["_sqlite3_preupdate_blobwrite"] = function() { + return (_sqlite3_preupdate_blobwrite = Module["_sqlite3_preupdate_blobwrite"] = Module["asm"]["sqlite3_preupdate_blobwrite"]).apply(null, arguments); +}; + + +var _sqlite3_preupdate_new = Module["_sqlite3_preupdate_new"] = function() { + return (_sqlite3_preupdate_new = Module["_sqlite3_preupdate_new"] = Module["asm"]["sqlite3_preupdate_new"]).apply(null, arguments); +}; + + +var _sqlite3_value_numeric_type = Module["_sqlite3_value_numeric_type"] = function() { + return (_sqlite3_value_numeric_type = Module["_sqlite3_value_numeric_type"] = Module["asm"]["sqlite3_value_numeric_type"]).apply(null, arguments); +}; + + +var _sqlite3_errmsg = Module["_sqlite3_errmsg"] = function() { + return (_sqlite3_errmsg = Module["_sqlite3_errmsg"] = Module["asm"]["sqlite3_errmsg"]).apply(null, arguments); +}; + + +var _sqlite3_set_authorizer = Module["_sqlite3_set_authorizer"] = function() { + return (_sqlite3_set_authorizer = Module["_sqlite3_set_authorizer"] = Module["asm"]["sqlite3_set_authorizer"]).apply(null, arguments); +}; + + +var _sqlite3_strglob = Module["_sqlite3_strglob"] = function() { + return (_sqlite3_strglob = Module["_sqlite3_strglob"] = Module["asm"]["sqlite3_strglob"]).apply(null, arguments); +}; + + +var _sqlite3_strlike = Module["_sqlite3_strlike"] = function() { + return (_sqlite3_strlike = Module["_sqlite3_strlike"] = Module["asm"]["sqlite3_strlike"]).apply(null, arguments); +}; + + +var _sqlite3_exec = Module["_sqlite3_exec"] = function() { + return (_sqlite3_exec = Module["_sqlite3_exec"] = Module["asm"]["sqlite3_exec"]).apply(null, arguments); +}; + + +var _sqlite3_auto_extension = Module["_sqlite3_auto_extension"] = function() { + return (_sqlite3_auto_extension = Module["_sqlite3_auto_extension"] = Module["asm"]["sqlite3_auto_extension"]).apply(null, arguments); +}; + + +var _sqlite3_cancel_auto_extension = Module["_sqlite3_cancel_auto_extension"] = function() { + return (_sqlite3_cancel_auto_extension = Module["_sqlite3_cancel_auto_extension"] = Module["asm"]["sqlite3_cancel_auto_extension"]).apply(null, arguments); +}; + + +var _sqlite3_reset_auto_extension = Module["_sqlite3_reset_auto_extension"] = function() { + return (_sqlite3_reset_auto_extension = Module["_sqlite3_reset_auto_extension"] = Module["asm"]["sqlite3_reset_auto_extension"]).apply(null, arguments); +}; + + +var _sqlite3_prepare_v3 = Module["_sqlite3_prepare_v3"] = function() { + return (_sqlite3_prepare_v3 = Module["_sqlite3_prepare_v3"] = Module["asm"]["sqlite3_prepare_v3"]).apply(null, arguments); +}; + + +var _sqlite3_create_module = Module["_sqlite3_create_module"] = function() { + return (_sqlite3_create_module = Module["_sqlite3_create_module"] = Module["asm"]["sqlite3_create_module"]).apply(null, arguments); +}; + + +var _sqlite3_create_module_v2 = Module["_sqlite3_create_module_v2"] = function() { + return (_sqlite3_create_module_v2 = Module["_sqlite3_create_module_v2"] = Module["asm"]["sqlite3_create_module_v2"]).apply(null, arguments); +}; + + +var _sqlite3_drop_modules = Module["_sqlite3_drop_modules"] = function() { + return (_sqlite3_drop_modules = Module["_sqlite3_drop_modules"] = Module["asm"]["sqlite3_drop_modules"]).apply(null, arguments); +}; + + +var _sqlite3_declare_vtab = Module["_sqlite3_declare_vtab"] = function() { + return (_sqlite3_declare_vtab = Module["_sqlite3_declare_vtab"] = Module["asm"]["sqlite3_declare_vtab"]).apply(null, arguments); +}; + + +var _sqlite3_vtab_on_conflict = Module["_sqlite3_vtab_on_conflict"] = function() { + return (_sqlite3_vtab_on_conflict = Module["_sqlite3_vtab_on_conflict"] = Module["asm"]["sqlite3_vtab_on_conflict"]).apply(null, arguments); +}; + + +var _sqlite3_vtab_collation = Module["_sqlite3_vtab_collation"] = function() { + return (_sqlite3_vtab_collation = Module["_sqlite3_vtab_collation"] = Module["asm"]["sqlite3_vtab_collation"]).apply(null, arguments); +}; + + +var _sqlite3_vtab_in = Module["_sqlite3_vtab_in"] = function() { + return (_sqlite3_vtab_in = Module["_sqlite3_vtab_in"] = Module["asm"]["sqlite3_vtab_in"]).apply(null, arguments); +}; + + +var _sqlite3_vtab_rhs_value = Module["_sqlite3_vtab_rhs_value"] = function() { + return (_sqlite3_vtab_rhs_value = Module["_sqlite3_vtab_rhs_value"] = Module["asm"]["sqlite3_vtab_rhs_value"]).apply(null, arguments); +}; + + +var _sqlite3_vtab_distinct = Module["_sqlite3_vtab_distinct"] = function() { + return (_sqlite3_vtab_distinct = Module["_sqlite3_vtab_distinct"] = Module["asm"]["sqlite3_vtab_distinct"]).apply(null, arguments); +}; + + +var _sqlite3_keyword_name = Module["_sqlite3_keyword_name"] = function() { + return (_sqlite3_keyword_name = Module["_sqlite3_keyword_name"] = Module["asm"]["sqlite3_keyword_name"]).apply(null, arguments); +}; + + +var _sqlite3_keyword_count = Module["_sqlite3_keyword_count"] = function() { + return (_sqlite3_keyword_count = Module["_sqlite3_keyword_count"] = Module["asm"]["sqlite3_keyword_count"]).apply(null, arguments); +}; + + +var _sqlite3_keyword_check = Module["_sqlite3_keyword_check"] = function() { + return (_sqlite3_keyword_check = Module["_sqlite3_keyword_check"] = Module["asm"]["sqlite3_keyword_check"]).apply(null, arguments); +}; + + +var _sqlite3_complete = Module["_sqlite3_complete"] = function() { + return (_sqlite3_complete = Module["_sqlite3_complete"] = Module["asm"]["sqlite3_complete"]).apply(null, arguments); +}; + + +var _sqlite3_libversion = Module["_sqlite3_libversion"] = function() { + return (_sqlite3_libversion = Module["_sqlite3_libversion"] = Module["asm"]["sqlite3_libversion"]).apply(null, arguments); +}; + + +var _sqlite3_libversion_number = Module["_sqlite3_libversion_number"] = function() { + return (_sqlite3_libversion_number = Module["_sqlite3_libversion_number"] = Module["asm"]["sqlite3_libversion_number"]).apply(null, arguments); +}; + + +var _sqlite3_shutdown = Module["_sqlite3_shutdown"] = function() { + return (_sqlite3_shutdown = Module["_sqlite3_shutdown"] = Module["asm"]["sqlite3_shutdown"]).apply(null, arguments); +}; + + +var _sqlite3_last_insert_rowid = Module["_sqlite3_last_insert_rowid"] = function() { + return (_sqlite3_last_insert_rowid = Module["_sqlite3_last_insert_rowid"] = Module["asm"]["sqlite3_last_insert_rowid"]).apply(null, arguments); +}; + + +var _sqlite3_set_last_insert_rowid = Module["_sqlite3_set_last_insert_rowid"] = function() { + return (_sqlite3_set_last_insert_rowid = Module["_sqlite3_set_last_insert_rowid"] = Module["asm"]["sqlite3_set_last_insert_rowid"]).apply(null, arguments); +}; + + +var _sqlite3_changes64 = Module["_sqlite3_changes64"] = function() { + return (_sqlite3_changes64 = Module["_sqlite3_changes64"] = Module["asm"]["sqlite3_changes64"]).apply(null, arguments); +}; + + +var _sqlite3_changes = Module["_sqlite3_changes"] = function() { + return (_sqlite3_changes = Module["_sqlite3_changes"] = Module["asm"]["sqlite3_changes"]).apply(null, arguments); +}; + + +var _sqlite3_total_changes64 = Module["_sqlite3_total_changes64"] = function() { + return (_sqlite3_total_changes64 = Module["_sqlite3_total_changes64"] = Module["asm"]["sqlite3_total_changes64"]).apply(null, arguments); +}; + + +var _sqlite3_total_changes = Module["_sqlite3_total_changes"] = function() { + return (_sqlite3_total_changes = Module["_sqlite3_total_changes"] = Module["asm"]["sqlite3_total_changes"]).apply(null, arguments); +}; + + +var _sqlite3_txn_state = Module["_sqlite3_txn_state"] = function() { + return (_sqlite3_txn_state = Module["_sqlite3_txn_state"] = Module["asm"]["sqlite3_txn_state"]).apply(null, arguments); +}; + + +var _sqlite3_close_v2 = Module["_sqlite3_close_v2"] = function() { + return (_sqlite3_close_v2 = Module["_sqlite3_close_v2"] = Module["asm"]["sqlite3_close_v2"]).apply(null, arguments); +}; + + +var _sqlite3_busy_handler = Module["_sqlite3_busy_handler"] = function() { + return (_sqlite3_busy_handler = Module["_sqlite3_busy_handler"] = Module["asm"]["sqlite3_busy_handler"]).apply(null, arguments); +}; + + +var _sqlite3_progress_handler = Module["_sqlite3_progress_handler"] = function() { + return (_sqlite3_progress_handler = Module["_sqlite3_progress_handler"] = Module["asm"]["sqlite3_progress_handler"]).apply(null, arguments); +}; + + +var _sqlite3_busy_timeout = Module["_sqlite3_busy_timeout"] = function() { + return (_sqlite3_busy_timeout = Module["_sqlite3_busy_timeout"] = Module["asm"]["sqlite3_busy_timeout"]).apply(null, arguments); +}; + + +var _sqlite3_create_function = Module["_sqlite3_create_function"] = function() { + return (_sqlite3_create_function = Module["_sqlite3_create_function"] = Module["asm"]["sqlite3_create_function"]).apply(null, arguments); +}; + + +var _sqlite3_create_function_v2 = Module["_sqlite3_create_function_v2"] = function() { + return (_sqlite3_create_function_v2 = Module["_sqlite3_create_function_v2"] = Module["asm"]["sqlite3_create_function_v2"]).apply(null, arguments); +}; + + +var _sqlite3_create_window_function = Module["_sqlite3_create_window_function"] = function() { + return (_sqlite3_create_window_function = Module["_sqlite3_create_window_function"] = Module["asm"]["sqlite3_create_window_function"]).apply(null, arguments); +}; + + +var _sqlite3_overload_function = Module["_sqlite3_overload_function"] = function() { + return (_sqlite3_overload_function = Module["_sqlite3_overload_function"] = Module["asm"]["sqlite3_overload_function"]).apply(null, arguments); +}; + + +var _sqlite3_trace_v2 = Module["_sqlite3_trace_v2"] = function() { + return (_sqlite3_trace_v2 = Module["_sqlite3_trace_v2"] = Module["asm"]["sqlite3_trace_v2"]).apply(null, arguments); +}; + + +var _sqlite3_commit_hook = Module["_sqlite3_commit_hook"] = function() { + return (_sqlite3_commit_hook = Module["_sqlite3_commit_hook"] = Module["asm"]["sqlite3_commit_hook"]).apply(null, arguments); +}; + + +var _sqlite3_update_hook = Module["_sqlite3_update_hook"] = function() { + return (_sqlite3_update_hook = Module["_sqlite3_update_hook"] = Module["asm"]["sqlite3_update_hook"]).apply(null, arguments); +}; + + +var _sqlite3_rollback_hook = Module["_sqlite3_rollback_hook"] = function() { + return (_sqlite3_rollback_hook = Module["_sqlite3_rollback_hook"] = Module["asm"]["sqlite3_rollback_hook"]).apply(null, arguments); +}; + + +var _sqlite3_preupdate_hook = Module["_sqlite3_preupdate_hook"] = function() { + return (_sqlite3_preupdate_hook = Module["_sqlite3_preupdate_hook"] = Module["asm"]["sqlite3_preupdate_hook"]).apply(null, arguments); +}; + + +var _sqlite3_error_offset = Module["_sqlite3_error_offset"] = function() { + return (_sqlite3_error_offset = Module["_sqlite3_error_offset"] = Module["asm"]["sqlite3_error_offset"]).apply(null, arguments); +}; + + +var _sqlite3_errcode = Module["_sqlite3_errcode"] = function() { + return (_sqlite3_errcode = Module["_sqlite3_errcode"] = Module["asm"]["sqlite3_errcode"]).apply(null, arguments); +}; + + +var _sqlite3_extended_errcode = Module["_sqlite3_extended_errcode"] = function() { + return (_sqlite3_extended_errcode = Module["_sqlite3_extended_errcode"] = Module["asm"]["sqlite3_extended_errcode"]).apply(null, arguments); +}; + + +var _sqlite3_errstr = Module["_sqlite3_errstr"] = function() { + return (_sqlite3_errstr = Module["_sqlite3_errstr"] = Module["asm"]["sqlite3_errstr"]).apply(null, arguments); +}; + + +var _sqlite3_limit = Module["_sqlite3_limit"] = function() { + return (_sqlite3_limit = Module["_sqlite3_limit"] = Module["asm"]["sqlite3_limit"]).apply(null, arguments); +}; + + +var _sqlite3_open = Module["_sqlite3_open"] = function() { + return (_sqlite3_open = Module["_sqlite3_open"] = Module["asm"]["sqlite3_open"]).apply(null, arguments); +}; + + +var _sqlite3_open_v2 = Module["_sqlite3_open_v2"] = function() { + return (_sqlite3_open_v2 = Module["_sqlite3_open_v2"] = Module["asm"]["sqlite3_open_v2"]).apply(null, arguments); +}; + + +var _sqlite3_create_collation = Module["_sqlite3_create_collation"] = function() { + return (_sqlite3_create_collation = Module["_sqlite3_create_collation"] = Module["asm"]["sqlite3_create_collation"]).apply(null, arguments); +}; + + +var _sqlite3_create_collation_v2 = Module["_sqlite3_create_collation_v2"] = function() { + return (_sqlite3_create_collation_v2 = Module["_sqlite3_create_collation_v2"] = Module["asm"]["sqlite3_create_collation_v2"]).apply(null, arguments); +}; + + +var _sqlite3_collation_needed = Module["_sqlite3_collation_needed"] = function() { + return (_sqlite3_collation_needed = Module["_sqlite3_collation_needed"] = Module["asm"]["sqlite3_collation_needed"]).apply(null, arguments); +}; + + +var _sqlite3_table_column_metadata = Module["_sqlite3_table_column_metadata"] = function() { + return (_sqlite3_table_column_metadata = Module["_sqlite3_table_column_metadata"] = Module["asm"]["sqlite3_table_column_metadata"]).apply(null, arguments); +}; + + +var _sqlite3_extended_result_codes = Module["_sqlite3_extended_result_codes"] = function() { + return (_sqlite3_extended_result_codes = Module["_sqlite3_extended_result_codes"] = Module["asm"]["sqlite3_extended_result_codes"]).apply(null, arguments); +}; + + +var _sqlite3_uri_key = Module["_sqlite3_uri_key"] = function() { + return (_sqlite3_uri_key = Module["_sqlite3_uri_key"] = Module["asm"]["sqlite3_uri_key"]).apply(null, arguments); +}; + + +var _sqlite3_uri_int64 = Module["_sqlite3_uri_int64"] = function() { + return (_sqlite3_uri_int64 = Module["_sqlite3_uri_int64"] = Module["asm"]["sqlite3_uri_int64"]).apply(null, arguments); +}; + + +var _sqlite3_db_name = Module["_sqlite3_db_name"] = function() { + return (_sqlite3_db_name = Module["_sqlite3_db_name"] = Module["asm"]["sqlite3_db_name"]).apply(null, arguments); +}; + + +var _sqlite3_db_filename = Module["_sqlite3_db_filename"] = function() { + return (_sqlite3_db_filename = Module["_sqlite3_db_filename"] = Module["asm"]["sqlite3_db_filename"]).apply(null, arguments); +}; + + +var _sqlite3_compileoption_used = Module["_sqlite3_compileoption_used"] = function() { + return (_sqlite3_compileoption_used = Module["_sqlite3_compileoption_used"] = Module["asm"]["sqlite3_compileoption_used"]).apply(null, arguments); +}; + + +var _sqlite3_compileoption_get = Module["_sqlite3_compileoption_get"] = function() { + return (_sqlite3_compileoption_get = Module["_sqlite3_compileoption_get"] = Module["asm"]["sqlite3_compileoption_get"]).apply(null, arguments); +}; + + +var _sqlite3session_diff = Module["_sqlite3session_diff"] = function() { + return (_sqlite3session_diff = Module["_sqlite3session_diff"] = Module["asm"]["sqlite3session_diff"]).apply(null, arguments); +}; + + +var _sqlite3session_attach = Module["_sqlite3session_attach"] = function() { + return (_sqlite3session_attach = Module["_sqlite3session_attach"] = Module["asm"]["sqlite3session_attach"]).apply(null, arguments); +}; + + +var _sqlite3session_create = Module["_sqlite3session_create"] = function() { + return (_sqlite3session_create = Module["_sqlite3session_create"] = Module["asm"]["sqlite3session_create"]).apply(null, arguments); +}; + + +var _sqlite3session_delete = Module["_sqlite3session_delete"] = function() { + return (_sqlite3session_delete = Module["_sqlite3session_delete"] = Module["asm"]["sqlite3session_delete"]).apply(null, arguments); +}; + + +var _sqlite3session_table_filter = Module["_sqlite3session_table_filter"] = function() { + return (_sqlite3session_table_filter = Module["_sqlite3session_table_filter"] = Module["asm"]["sqlite3session_table_filter"]).apply(null, arguments); +}; + + +var _sqlite3session_changeset = Module["_sqlite3session_changeset"] = function() { + return (_sqlite3session_changeset = Module["_sqlite3session_changeset"] = Module["asm"]["sqlite3session_changeset"]).apply(null, arguments); +}; + + +var _sqlite3session_changeset_strm = Module["_sqlite3session_changeset_strm"] = function() { + return (_sqlite3session_changeset_strm = Module["_sqlite3session_changeset_strm"] = Module["asm"]["sqlite3session_changeset_strm"]).apply(null, arguments); +}; + + +var _sqlite3session_patchset_strm = Module["_sqlite3session_patchset_strm"] = function() { + return (_sqlite3session_patchset_strm = Module["_sqlite3session_patchset_strm"] = Module["asm"]["sqlite3session_patchset_strm"]).apply(null, arguments); +}; + + +var _sqlite3session_patchset = Module["_sqlite3session_patchset"] = function() { + return (_sqlite3session_patchset = Module["_sqlite3session_patchset"] = Module["asm"]["sqlite3session_patchset"]).apply(null, arguments); +}; + + +var _sqlite3session_enable = Module["_sqlite3session_enable"] = function() { + return (_sqlite3session_enable = Module["_sqlite3session_enable"] = Module["asm"]["sqlite3session_enable"]).apply(null, arguments); +}; + + +var _sqlite3session_indirect = Module["_sqlite3session_indirect"] = function() { + return (_sqlite3session_indirect = Module["_sqlite3session_indirect"] = Module["asm"]["sqlite3session_indirect"]).apply(null, arguments); +}; + + +var _sqlite3session_isempty = Module["_sqlite3session_isempty"] = function() { + return (_sqlite3session_isempty = Module["_sqlite3session_isempty"] = Module["asm"]["sqlite3session_isempty"]).apply(null, arguments); +}; + + +var _sqlite3session_memory_used = Module["_sqlite3session_memory_used"] = function() { + return (_sqlite3session_memory_used = Module["_sqlite3session_memory_used"] = Module["asm"]["sqlite3session_memory_used"]).apply(null, arguments); +}; + + +var _sqlite3session_object_config = Module["_sqlite3session_object_config"] = function() { + return (_sqlite3session_object_config = Module["_sqlite3session_object_config"] = Module["asm"]["sqlite3session_object_config"]).apply(null, arguments); +}; + + +var _sqlite3session_changeset_size = Module["_sqlite3session_changeset_size"] = function() { + return (_sqlite3session_changeset_size = Module["_sqlite3session_changeset_size"] = Module["asm"]["sqlite3session_changeset_size"]).apply(null, arguments); +}; + + +var _sqlite3changeset_start = Module["_sqlite3changeset_start"] = function() { + return (_sqlite3changeset_start = Module["_sqlite3changeset_start"] = Module["asm"]["sqlite3changeset_start"]).apply(null, arguments); +}; + + +var _sqlite3changeset_start_v2 = Module["_sqlite3changeset_start_v2"] = function() { + return (_sqlite3changeset_start_v2 = Module["_sqlite3changeset_start_v2"] = Module["asm"]["sqlite3changeset_start_v2"]).apply(null, arguments); +}; + + +var _sqlite3changeset_start_strm = Module["_sqlite3changeset_start_strm"] = function() { + return (_sqlite3changeset_start_strm = Module["_sqlite3changeset_start_strm"] = Module["asm"]["sqlite3changeset_start_strm"]).apply(null, arguments); +}; + + +var _sqlite3changeset_start_v2_strm = Module["_sqlite3changeset_start_v2_strm"] = function() { + return (_sqlite3changeset_start_v2_strm = Module["_sqlite3changeset_start_v2_strm"] = Module["asm"]["sqlite3changeset_start_v2_strm"]).apply(null, arguments); +}; + + +var _sqlite3changeset_next = Module["_sqlite3changeset_next"] = function() { + return (_sqlite3changeset_next = Module["_sqlite3changeset_next"] = Module["asm"]["sqlite3changeset_next"]).apply(null, arguments); +}; + + +var _sqlite3changeset_op = Module["_sqlite3changeset_op"] = function() { + return (_sqlite3changeset_op = Module["_sqlite3changeset_op"] = Module["asm"]["sqlite3changeset_op"]).apply(null, arguments); +}; + + +var _sqlite3changeset_pk = Module["_sqlite3changeset_pk"] = function() { + return (_sqlite3changeset_pk = Module["_sqlite3changeset_pk"] = Module["asm"]["sqlite3changeset_pk"]).apply(null, arguments); +}; + + +var _sqlite3changeset_old = Module["_sqlite3changeset_old"] = function() { + return (_sqlite3changeset_old = Module["_sqlite3changeset_old"] = Module["asm"]["sqlite3changeset_old"]).apply(null, arguments); +}; + + +var _sqlite3changeset_new = Module["_sqlite3changeset_new"] = function() { + return (_sqlite3changeset_new = Module["_sqlite3changeset_new"] = Module["asm"]["sqlite3changeset_new"]).apply(null, arguments); +}; + + +var _sqlite3changeset_conflict = Module["_sqlite3changeset_conflict"] = function() { + return (_sqlite3changeset_conflict = Module["_sqlite3changeset_conflict"] = Module["asm"]["sqlite3changeset_conflict"]).apply(null, arguments); +}; + + +var _sqlite3changeset_fk_conflicts = Module["_sqlite3changeset_fk_conflicts"] = function() { + return (_sqlite3changeset_fk_conflicts = Module["_sqlite3changeset_fk_conflicts"] = Module["asm"]["sqlite3changeset_fk_conflicts"]).apply(null, arguments); +}; + + +var _sqlite3changeset_finalize = Module["_sqlite3changeset_finalize"] = function() { + return (_sqlite3changeset_finalize = Module["_sqlite3changeset_finalize"] = Module["asm"]["sqlite3changeset_finalize"]).apply(null, arguments); +}; + + +var _sqlite3changeset_invert = Module["_sqlite3changeset_invert"] = function() { + return (_sqlite3changeset_invert = Module["_sqlite3changeset_invert"] = Module["asm"]["sqlite3changeset_invert"]).apply(null, arguments); +}; + + +var _sqlite3changeset_invert_strm = Module["_sqlite3changeset_invert_strm"] = function() { + return (_sqlite3changeset_invert_strm = Module["_sqlite3changeset_invert_strm"] = Module["asm"]["sqlite3changeset_invert_strm"]).apply(null, arguments); +}; + + +var _sqlite3changeset_apply_v2 = Module["_sqlite3changeset_apply_v2"] = function() { + return (_sqlite3changeset_apply_v2 = Module["_sqlite3changeset_apply_v2"] = Module["asm"]["sqlite3changeset_apply_v2"]).apply(null, arguments); +}; + + +var _sqlite3changeset_apply = Module["_sqlite3changeset_apply"] = function() { + return (_sqlite3changeset_apply = Module["_sqlite3changeset_apply"] = Module["asm"]["sqlite3changeset_apply"]).apply(null, arguments); +}; + + +var _sqlite3changeset_apply_v2_strm = Module["_sqlite3changeset_apply_v2_strm"] = function() { + return (_sqlite3changeset_apply_v2_strm = Module["_sqlite3changeset_apply_v2_strm"] = Module["asm"]["sqlite3changeset_apply_v2_strm"]).apply(null, arguments); +}; + + +var _sqlite3changeset_apply_strm = Module["_sqlite3changeset_apply_strm"] = function() { + return (_sqlite3changeset_apply_strm = Module["_sqlite3changeset_apply_strm"] = Module["asm"]["sqlite3changeset_apply_strm"]).apply(null, arguments); +}; + + +var _sqlite3changegroup_new = Module["_sqlite3changegroup_new"] = function() { + return (_sqlite3changegroup_new = Module["_sqlite3changegroup_new"] = Module["asm"]["sqlite3changegroup_new"]).apply(null, arguments); +}; + + +var _sqlite3changegroup_add = Module["_sqlite3changegroup_add"] = function() { + return (_sqlite3changegroup_add = Module["_sqlite3changegroup_add"] = Module["asm"]["sqlite3changegroup_add"]).apply(null, arguments); +}; + + +var _sqlite3changegroup_output = Module["_sqlite3changegroup_output"] = function() { + return (_sqlite3changegroup_output = Module["_sqlite3changegroup_output"] = Module["asm"]["sqlite3changegroup_output"]).apply(null, arguments); +}; + + +var _sqlite3changegroup_add_strm = Module["_sqlite3changegroup_add_strm"] = function() { + return (_sqlite3changegroup_add_strm = Module["_sqlite3changegroup_add_strm"] = Module["asm"]["sqlite3changegroup_add_strm"]).apply(null, arguments); +}; + + +var _sqlite3changegroup_output_strm = Module["_sqlite3changegroup_output_strm"] = function() { + return (_sqlite3changegroup_output_strm = Module["_sqlite3changegroup_output_strm"] = Module["asm"]["sqlite3changegroup_output_strm"]).apply(null, arguments); +}; + + +var _sqlite3changegroup_delete = Module["_sqlite3changegroup_delete"] = function() { + return (_sqlite3changegroup_delete = Module["_sqlite3changegroup_delete"] = Module["asm"]["sqlite3changegroup_delete"]).apply(null, arguments); +}; + + +var _sqlite3changeset_concat = Module["_sqlite3changeset_concat"] = function() { + return (_sqlite3changeset_concat = Module["_sqlite3changeset_concat"] = Module["asm"]["sqlite3changeset_concat"]).apply(null, arguments); +}; + + +var _sqlite3changeset_concat_strm = Module["_sqlite3changeset_concat_strm"] = function() { + return (_sqlite3changeset_concat_strm = Module["_sqlite3changeset_concat_strm"] = Module["asm"]["sqlite3changeset_concat_strm"]).apply(null, arguments); +}; + + +var _sqlite3session_config = Module["_sqlite3session_config"] = function() { + return (_sqlite3session_config = Module["_sqlite3session_config"] = Module["asm"]["sqlite3session_config"]).apply(null, arguments); +}; + + +var _sqlite3_sourceid = Module["_sqlite3_sourceid"] = function() { + return (_sqlite3_sourceid = Module["_sqlite3_sourceid"] = Module["asm"]["sqlite3_sourceid"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_pstack_ptr = Module["_sqlite3_wasm_pstack_ptr"] = function() { + return (_sqlite3_wasm_pstack_ptr = Module["_sqlite3_wasm_pstack_ptr"] = Module["asm"]["sqlite3_wasm_pstack_ptr"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_pstack_restore = Module["_sqlite3_wasm_pstack_restore"] = function() { + return (_sqlite3_wasm_pstack_restore = Module["_sqlite3_wasm_pstack_restore"] = Module["asm"]["sqlite3_wasm_pstack_restore"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_pstack_alloc = Module["_sqlite3_wasm_pstack_alloc"] = function() { + return (_sqlite3_wasm_pstack_alloc = Module["_sqlite3_wasm_pstack_alloc"] = Module["asm"]["sqlite3_wasm_pstack_alloc"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_pstack_remaining = Module["_sqlite3_wasm_pstack_remaining"] = function() { + return (_sqlite3_wasm_pstack_remaining = Module["_sqlite3_wasm_pstack_remaining"] = Module["asm"]["sqlite3_wasm_pstack_remaining"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_pstack_quota = Module["_sqlite3_wasm_pstack_quota"] = function() { + return (_sqlite3_wasm_pstack_quota = Module["_sqlite3_wasm_pstack_quota"] = Module["asm"]["sqlite3_wasm_pstack_quota"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_db_error = Module["_sqlite3_wasm_db_error"] = function() { + return (_sqlite3_wasm_db_error = Module["_sqlite3_wasm_db_error"] = Module["asm"]["sqlite3_wasm_db_error"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_test_struct = Module["_sqlite3_wasm_test_struct"] = function() { + return (_sqlite3_wasm_test_struct = Module["_sqlite3_wasm_test_struct"] = Module["asm"]["sqlite3_wasm_test_struct"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_enum_json = Module["_sqlite3_wasm_enum_json"] = function() { + return (_sqlite3_wasm_enum_json = Module["_sqlite3_wasm_enum_json"] = Module["asm"]["sqlite3_wasm_enum_json"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_vfs_unlink = Module["_sqlite3_wasm_vfs_unlink"] = function() { + return (_sqlite3_wasm_vfs_unlink = Module["_sqlite3_wasm_vfs_unlink"] = Module["asm"]["sqlite3_wasm_vfs_unlink"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_db_vfs = Module["_sqlite3_wasm_db_vfs"] = function() { + return (_sqlite3_wasm_db_vfs = Module["_sqlite3_wasm_db_vfs"] = Module["asm"]["sqlite3_wasm_db_vfs"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_db_reset = Module["_sqlite3_wasm_db_reset"] = function() { + return (_sqlite3_wasm_db_reset = Module["_sqlite3_wasm_db_reset"] = Module["asm"]["sqlite3_wasm_db_reset"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_db_export_chunked = Module["_sqlite3_wasm_db_export_chunked"] = function() { + return (_sqlite3_wasm_db_export_chunked = Module["_sqlite3_wasm_db_export_chunked"] = Module["asm"]["sqlite3_wasm_db_export_chunked"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_db_serialize = Module["_sqlite3_wasm_db_serialize"] = function() { + return (_sqlite3_wasm_db_serialize = Module["_sqlite3_wasm_db_serialize"] = Module["asm"]["sqlite3_wasm_db_serialize"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_vfs_create_file = Module["_sqlite3_wasm_vfs_create_file"] = function() { + return (_sqlite3_wasm_vfs_create_file = Module["_sqlite3_wasm_vfs_create_file"] = Module["asm"]["sqlite3_wasm_vfs_create_file"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_kvvfsMakeKeyOnPstack = Module["_sqlite3_wasm_kvvfsMakeKeyOnPstack"] = function() { + return (_sqlite3_wasm_kvvfsMakeKeyOnPstack = Module["_sqlite3_wasm_kvvfsMakeKeyOnPstack"] = Module["asm"]["sqlite3_wasm_kvvfsMakeKeyOnPstack"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_kvvfs_methods = Module["_sqlite3_wasm_kvvfs_methods"] = function() { + return (_sqlite3_wasm_kvvfs_methods = Module["_sqlite3_wasm_kvvfs_methods"] = Module["asm"]["sqlite3_wasm_kvvfs_methods"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_vtab_config = Module["_sqlite3_wasm_vtab_config"] = function() { + return (_sqlite3_wasm_vtab_config = Module["_sqlite3_wasm_vtab_config"] = Module["asm"]["sqlite3_wasm_vtab_config"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_db_config_ip = Module["_sqlite3_wasm_db_config_ip"] = function() { + return (_sqlite3_wasm_db_config_ip = Module["_sqlite3_wasm_db_config_ip"] = Module["asm"]["sqlite3_wasm_db_config_ip"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_db_config_pii = Module["_sqlite3_wasm_db_config_pii"] = function() { + return (_sqlite3_wasm_db_config_pii = Module["_sqlite3_wasm_db_config_pii"] = Module["asm"]["sqlite3_wasm_db_config_pii"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_db_config_s = Module["_sqlite3_wasm_db_config_s"] = function() { + return (_sqlite3_wasm_db_config_s = Module["_sqlite3_wasm_db_config_s"] = Module["asm"]["sqlite3_wasm_db_config_s"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_config_i = Module["_sqlite3_wasm_config_i"] = function() { + return (_sqlite3_wasm_config_i = Module["_sqlite3_wasm_config_i"] = Module["asm"]["sqlite3_wasm_config_i"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_config_ii = Module["_sqlite3_wasm_config_ii"] = function() { + return (_sqlite3_wasm_config_ii = Module["_sqlite3_wasm_config_ii"] = Module["asm"]["sqlite3_wasm_config_ii"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_config_j = Module["_sqlite3_wasm_config_j"] = function() { + return (_sqlite3_wasm_config_j = Module["_sqlite3_wasm_config_j"] = Module["asm"]["sqlite3_wasm_config_j"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_init_wasmfs = Module["_sqlite3_wasm_init_wasmfs"] = function() { + return (_sqlite3_wasm_init_wasmfs = Module["_sqlite3_wasm_init_wasmfs"] = Module["asm"]["sqlite3_wasm_init_wasmfs"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_test_intptr = Module["_sqlite3_wasm_test_intptr"] = function() { + return (_sqlite3_wasm_test_intptr = Module["_sqlite3_wasm_test_intptr"] = Module["asm"]["sqlite3_wasm_test_intptr"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_test_voidptr = Module["_sqlite3_wasm_test_voidptr"] = function() { + return (_sqlite3_wasm_test_voidptr = Module["_sqlite3_wasm_test_voidptr"] = Module["asm"]["sqlite3_wasm_test_voidptr"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_test_int64_max = Module["_sqlite3_wasm_test_int64_max"] = function() { + return (_sqlite3_wasm_test_int64_max = Module["_sqlite3_wasm_test_int64_max"] = Module["asm"]["sqlite3_wasm_test_int64_max"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_test_int64_min = Module["_sqlite3_wasm_test_int64_min"] = function() { + return (_sqlite3_wasm_test_int64_min = Module["_sqlite3_wasm_test_int64_min"] = Module["asm"]["sqlite3_wasm_test_int64_min"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_test_int64_times2 = Module["_sqlite3_wasm_test_int64_times2"] = function() { + return (_sqlite3_wasm_test_int64_times2 = Module["_sqlite3_wasm_test_int64_times2"] = Module["asm"]["sqlite3_wasm_test_int64_times2"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_test_int64_minmax = Module["_sqlite3_wasm_test_int64_minmax"] = function() { + return (_sqlite3_wasm_test_int64_minmax = Module["_sqlite3_wasm_test_int64_minmax"] = Module["asm"]["sqlite3_wasm_test_int64_minmax"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_test_int64ptr = Module["_sqlite3_wasm_test_int64ptr"] = function() { + return (_sqlite3_wasm_test_int64ptr = Module["_sqlite3_wasm_test_int64ptr"] = Module["asm"]["sqlite3_wasm_test_int64ptr"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_test_stack_overflow = Module["_sqlite3_wasm_test_stack_overflow"] = function() { + return (_sqlite3_wasm_test_stack_overflow = Module["_sqlite3_wasm_test_stack_overflow"] = Module["asm"]["sqlite3_wasm_test_stack_overflow"]).apply(null, arguments); +}; + + +var _sqlite3_wasm_test_str_hello = Module["_sqlite3_wasm_test_str_hello"] = function() { + return (_sqlite3_wasm_test_str_hello = Module["_sqlite3_wasm_test_str_hello"] = Module["asm"]["sqlite3_wasm_test_str_hello"]).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 _realloc = Module["_realloc"] = function() { + return (_realloc = Module["_realloc"] = Module["asm"]["realloc"]).apply(null, arguments); +}; + + +var stackSave = Module["stackSave"] = function() { + return (stackSave = Module["stackSave"] = Module["asm"]["stackSave"]).apply(null, arguments); +}; + + +var stackRestore = Module["stackRestore"] = function() { + return (stackRestore = Module["stackRestore"] = Module["asm"]["stackRestore"]).apply(null, arguments); +}; + + +var stackAlloc = Module["stackAlloc"] = function() { + return (stackAlloc = Module["stackAlloc"] = Module["asm"]["stackAlloc"]).apply(null, arguments); +}; + + + + + + + +Module["wasmMemory"] = wasmMemory; + + +var calledRun; + +dependenciesFulfilled = function runCaller() { + + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; +}; + + +function run(args) { + args = args || arguments_; + + if (runDependencies > 0) { + return; + } + + preRun(); + + + if (runDependencies > 0) { + return; + } + + function doRun() { + + + if (calledRun) return; + calledRun = true; + Module['calledRun'] = true; + + if (ABORT) return; + + initRuntime(); + + readyPromiseResolve(Module); + if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized'](); + + postRun(); + } + + if (Module['setStatus']) { + Module['setStatus']('Running...'); + setTimeout(function() { + setTimeout(function() { + Module['setStatus'](''); + }, 1); + doRun(); + }, 1); + } else + { + doRun(); + } +} + +if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } +} + +run(); + + + + + +if(!Module.postRun) Module.postRun = []; +Module.postRun.push(function(Module){ + 'use strict'; + + + + + + + + + + + +'use strict'; +globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap( + apiConfig = (globalThis.sqlite3ApiConfig || sqlite3ApiBootstrap.defaultConfig) +){ + if(sqlite3ApiBootstrap.sqlite3){ + console.warn("sqlite3ApiBootstrap() called multiple times.", + "Config and external initializers are ignored on calls after the first."); + return sqlite3ApiBootstrap.sqlite3; + } + const config = Object.assign(Object.create(null),{ + exports: undefined, + memory: undefined, + bigIntEnabled: (()=>{ + if('undefined'!==typeof Module){ + + return !!Module.HEAPU64; + } + return !!globalThis.BigInt64Array; + })(), + debug: console.debug.bind(console), + warn: console.warn.bind(console), + error: console.error.bind(console), + log: console.log.bind(console), + wasmfsOpfsDir: '/opfs', + + useStdAlloc: false + }, apiConfig || {}); + + Object.assign(config, { + allocExportName: config.useStdAlloc ? 'malloc' : 'sqlite3_malloc', + deallocExportName: config.useStdAlloc ? 'free' : 'sqlite3_free', + reallocExportName: config.useStdAlloc ? 'realloc' : 'sqlite3_realloc' + }, config); + + [ + + + 'exports', 'memory', 'wasmfsOpfsDir' + ].forEach((k)=>{ + if('function' === typeof config[k]){ + config[k] = config[k](); + } + }); + config.wasmOpfsDir = + false; + + + const capi = Object.create(null); + + const wasm = Object.create(null); + + + const __rcStr = (rc)=>{ + return (capi.sqlite3_js_rc_str && capi.sqlite3_js_rc_str(rc)) + || ("Unknown result code #"+rc); + }; + + + const __isInt = (n)=>'number'===typeof n && n===(n | 0); + + + class SQLite3Error extends Error { + + constructor(...args){ + let rc; + if(args.length){ + if(__isInt(args[0])){ + rc = args[0]; + if(1===args.length){ + super(__rcStr(args[0])); + }else{ + const rcStr = __rcStr(rc); + if('object'===typeof args[1]){ + super(rcStr,args[1]); + }else{ + args[0] = rcStr+':'; + super(args.join(' ')); + } + } + }else{ + if(2===args.length && 'object'===typeof args[1]){ + super(...args); + }else{ + super(args.join(' ')); + } + } + } + this.resultCode = rc || capi.SQLITE_ERROR; + this.name = 'SQLite3Error'; + } + }; + + + SQLite3Error.toss = (...args)=>{ + throw new SQLite3Error(...args); + }; + const toss3 = SQLite3Error.toss; + + if(config.wasmfsOpfsDir && !/^\/[^/]+$/.test(config.wasmfsOpfsDir)){ + toss3("config.wasmfsOpfsDir must be falsy or in the form '/dir-name'."); + } + + + const isInt32 = (n)=>{ + return ('bigint'!==typeof n ) + && !!(n===(n|0) && n<=2147483647 && n>=-2147483648); + }; + + const bigIntFits64 = function f(b){ + if(!f._max){ + f._max = BigInt("0x7fffffffffffffff"); + f._min = ~f._max; + } + return b >= f._min && b <= f._max; + }; + + + const bigIntFits32 = (b)=>(b >= (-0x7fffffffn - 1n) && b <= 0x7fffffffn); + + + const bigIntFitsDouble = function f(b){ + if(!f._min){ + f._min = Number.MIN_SAFE_INTEGER; + f._max = Number.MAX_SAFE_INTEGER; + } + return b >= f._min && b <= f._max; + }; + + + const isTypedArray = (v)=>{ + return (v && v.constructor && isInt32(v.constructor.BYTES_PER_ELEMENT)) ? v : false; + }; + + + + const __SAB = ('undefined'===typeof SharedArrayBuffer) + ? function(){} : SharedArrayBuffer; + + const isSharedTypedArray = (aTypedArray)=>(aTypedArray.buffer instanceof __SAB); + + + const typedArrayPart = (aTypedArray, begin, end)=>{ + return isSharedTypedArray(aTypedArray) + ? aTypedArray.slice(begin, end) + : aTypedArray.subarray(begin, end); + }; + + + const isBindableTypedArray = (v)=>{ + return v && (v instanceof Uint8Array + || v instanceof Int8Array + || v instanceof ArrayBuffer); + }; + + + const isSQLableTypedArray = (v)=>{ + return v && (v instanceof Uint8Array + || v instanceof Int8Array + || v instanceof ArrayBuffer); + }; + + + const affirmBindableTypedArray = (v)=>{ + return isBindableTypedArray(v) + || toss3("Value is not of a supported TypedArray type."); + }; + + const utf8Decoder = new TextDecoder('utf-8'); + + + const typedArrayToString = function(typedArray, begin, end){ + return utf8Decoder.decode(typedArrayPart(typedArray, begin,end)); + }; + + + const flexibleString = function(v){ + if(isSQLableTypedArray(v)){ + return typedArrayToString( + (v instanceof ArrayBuffer) ? new Uint8Array(v) : v + ); + } + else if(Array.isArray(v)) return v.join(""); + else if(wasm.isPtr(v)) v = wasm.cstrToJs(v); + return v; + }; + + + class WasmAllocError extends Error { + + constructor(...args){ + if(2===args.length && 'object'===typeof args[1]){ + super(...args); + }else if(args.length){ + super(args.join(' ')); + }else{ + super("Allocation failed."); + } + this.resultCode = capi.SQLITE_NOMEM; + this.name = 'WasmAllocError'; + } + }; + + WasmAllocError.toss = (...args)=>{ + throw new WasmAllocError(...args); + }; + + Object.assign(capi, { + + sqlite3_bind_blob: undefined, + + + sqlite3_bind_text: undefined, + + + sqlite3_create_function_v2: ( + pDb, funcName, nArg, eTextRep, pApp, + xFunc, xStep, xFinal, xDestroy + )=>{}, + + sqlite3_create_function: ( + pDb, funcName, nArg, eTextRep, pApp, + xFunc, xStep, xFinal + )=>{}, + + sqlite3_create_window_function: ( + pDb, funcName, nArg, eTextRep, pApp, + xStep, xFinal, xValue, xInverse, xDestroy + )=>{}, + + sqlite3_prepare_v3: (dbPtr, sql, sqlByteLen, prepFlags, + stmtPtrPtr, strPtrPtr)=>{}, + + + sqlite3_prepare_v2: (dbPtr, sql, sqlByteLen, + stmtPtrPtr,strPtrPtr)=>{}, + + + sqlite3_exec: (pDb, sql, callback, pVoid, pErrMsg)=>{}, + + + sqlite3_randomness: (n, outPtr)=>{}, + }); + + + const util = { + affirmBindableTypedArray, flexibleString, + bigIntFits32, bigIntFits64, bigIntFitsDouble, + isBindableTypedArray, + isInt32, isSQLableTypedArray, isTypedArray, + typedArrayToString, + isUIThread: ()=>(globalThis.window===globalThis && !!globalThis.document), + + isSharedTypedArray, + toss: function(...args){throw new Error(args.join(' '))}, + toss3, + typedArrayPart + }; + + Object.assign(wasm, { + + ptrSizeof: config.wasmPtrSizeof || 4, + + ptrIR: config.wasmPtrIR || "i32", + + bigIntEnabled: !!config.bigIntEnabled, + + exports: config.exports + || toss3("Missing API config.exports (WASM module exports)."), + + + memory: config.memory || config.exports['memory'] + || toss3("API config object requires a WebAssembly.Memory object", + "in either config.exports.memory (exported)", + "or config.memory (imported)."), + + + alloc: undefined, + + + realloc: undefined, + + + dealloc: undefined + + + }); + + + wasm.allocFromTypedArray = function(srcTypedArray){ + if(srcTypedArray instanceof ArrayBuffer){ + srcTypedArray = new Uint8Array(srcTypedArray); + } + affirmBindableTypedArray(srcTypedArray); + const pRet = wasm.alloc(srcTypedArray.byteLength || 1); + wasm.heapForSize(srcTypedArray.constructor).set( + srcTypedArray.byteLength ? srcTypedArray : [0], pRet + ); + return pRet; + }; + + { + + const keyAlloc = config.allocExportName, + keyDealloc = config.deallocExportName, + keyRealloc = config.reallocExportName; + for(const key of [keyAlloc, keyDealloc, keyRealloc]){ + const f = wasm.exports[key]; + if(!(f instanceof Function)) toss3("Missing required exports[",key,"] function."); + } + + wasm.alloc = function f(n){ + return f.impl(n) || WasmAllocError.toss("Failed to allocate",n," bytes."); + }; + wasm.alloc.impl = wasm.exports[keyAlloc]; + wasm.realloc = function f(m,n){ + const m2 = f.impl(m,n); + return n ? (m2 || WasmAllocError.toss("Failed to reallocate",n," bytes.")) : 0; + }; + wasm.realloc.impl = wasm.exports[keyRealloc]; + wasm.dealloc = wasm.exports[keyDealloc]; + } + + + wasm.compileOptionUsed = function f(optName){ + if(!arguments.length){ + if(f._result) return f._result; + else if(!f._opt){ + f._rx = /^([^=]+)=(.+)/; + f._rxInt = /^-?\d+$/; + f._opt = function(opt, rv){ + const m = f._rx.exec(opt); + rv[0] = (m ? m[1] : opt); + rv[1] = m ? (f._rxInt.test(m[2]) ? +m[2] : m[2]) : true; + }; + } + const rc = {}, ov = [0,0]; + let i = 0, k; + while((k = capi.sqlite3_compileoption_get(i++))){ + f._opt(k,ov); + rc[ov[0]] = ov[1]; + } + return f._result = rc; + }else if(Array.isArray(optName)){ + const rc = {}; + optName.forEach((v)=>{ + rc[v] = capi.sqlite3_compileoption_used(v); + }); + return rc; + }else if('object' === typeof optName){ + Object.keys(optName).forEach((k)=> { + optName[k] = capi.sqlite3_compileoption_used(k); + }); + return optName; + } + return ( + 'string'===typeof optName + ) ? !!capi.sqlite3_compileoption_used(optName) : false; + }; + + + wasm.pstack = Object.assign(Object.create(null),{ + + restore: wasm.exports.sqlite3_wasm_pstack_restore, + + alloc: function(n){ + if('string'===typeof n && !(n = wasm.sizeofIR(n))){ + WasmAllocError.toss("Invalid value for pstack.alloc(",arguments[0],")"); + } + return wasm.exports.sqlite3_wasm_pstack_alloc(n) + || WasmAllocError.toss("Could not allocate",n, + "bytes from the pstack."); + }, + + allocChunks: function(n,sz){ + if('string'===typeof sz && !(sz = wasm.sizeofIR(sz))){ + WasmAllocError.toss("Invalid size value for allocChunks(",arguments[1],")"); + } + const mem = wasm.pstack.alloc(n * sz); + const rc = []; + let i = 0, offset = 0; + for(; i < n; ++i, offset += sz) rc.push(mem + offset); + return rc; + }, + + allocPtr: (n=1,safePtrSize=true)=>{ + return 1===n + ? wasm.pstack.alloc(safePtrSize ? 8 : wasm.ptrSizeof) + : wasm.pstack.allocChunks(n, safePtrSize ? 8 : wasm.ptrSizeof); + } + }); + Object.defineProperties(wasm.pstack, { + + pointer: { + configurable: false, iterable: true, writeable: false, + get: wasm.exports.sqlite3_wasm_pstack_ptr + + + + }, + + quota: { + configurable: false, iterable: true, writeable: false, + get: wasm.exports.sqlite3_wasm_pstack_quota + }, + + remaining: { + configurable: false, iterable: true, writeable: false, + get: wasm.exports.sqlite3_wasm_pstack_remaining + } + }); + + capi.sqlite3_randomness = (...args)=>{ + if(1===args.length && util.isTypedArray(args[0]) + && 1===args[0].BYTES_PER_ELEMENT){ + const ta = args[0]; + if(0===ta.byteLength){ + wasm.exports.sqlite3_randomness(0,0); + return ta; + } + const stack = wasm.pstack.pointer; + try { + let n = ta.byteLength, offset = 0; + const r = wasm.exports.sqlite3_randomness; + const heap = wasm.heap8u(); + const nAlloc = n < 512 ? n : 512; + const ptr = wasm.pstack.alloc(nAlloc); + do{ + const j = (n>nAlloc ? nAlloc : n); + r(j, ptr); + ta.set(typedArrayPart(heap, ptr, ptr+j), offset); + n -= j; + offset += j; + } while(n > 0); + }catch(e){ + console.error("Highly unexpected (and ignored!) "+ + "exception in sqlite3_randomness():",e); + }finally{ + wasm.pstack.restore(stack); + } + return ta; + } + wasm.exports.sqlite3_randomness(...args); + }; + + + let __wasmfsOpfsDir = undefined; + + capi.sqlite3_wasmfs_opfs_dir = function(){ + if(undefined !== __wasmfsOpfsDir) return __wasmfsOpfsDir; + + const pdir = config.wasmfsOpfsDir; + console.error("sqlite3_wasmfs_opfs_dir() can no longer work due "+ + "to incompatible WASMFS changes. It will be removed."); + if(!pdir + || !globalThis.FileSystemHandle + || !globalThis.FileSystemDirectoryHandle + || !globalThis.FileSystemFileHandle){ + return __wasmfsOpfsDir = ""; + } + try{ + if(pdir && 0===wasm.xCallWrapped( + 'sqlite3_wasm_init_wasmfs', 'i32', ['string'], pdir + )){ + return __wasmfsOpfsDir = pdir; + }else{ + return __wasmfsOpfsDir = ""; + } + }catch(e){ + + return __wasmfsOpfsDir = ""; + } + }; + + + capi.sqlite3_wasmfs_filename_is_persistent = function(name){ + const p = capi.sqlite3_wasmfs_opfs_dir(); + return (p && name) ? name.startsWith(p+'/') : false; + }; + + + if(false && 0===wasm.exports.sqlite3_vfs_find(0)){ + + wasm.exports.sqlite3_initialize(); + } + + + capi.sqlite3_js_db_uses_vfs = function(pDb,vfsName,dbName=0){ + try{ + const pK = capi.sqlite3_vfs_find(vfsName); + if(!pK) return false; + else if(!pDb){ + return pK===capi.sqlite3_vfs_find(0) ? pK : false; + }else{ + return pK===capi.sqlite3_js_db_vfs(pDb,dbName) ? pK : false; + } + }catch(e){ + + return false; + } + }; + + + capi.sqlite3_js_vfs_list = function(){ + const rc = []; + let pVfs = capi.sqlite3_vfs_find(0); + while(pVfs){ + const oVfs = new capi.sqlite3_vfs(pVfs); + rc.push(wasm.cstrToJs(oVfs.$zName)); + pVfs = oVfs.$pNext; + oVfs.dispose(); + } + return rc; + }; + + + capi.sqlite3_js_db_export = function(pDb, schema=0){ + pDb = wasm.xWrap.testConvertArg('sqlite3*', pDb); + if(!pDb) toss3('Invalid sqlite3* argument.'); + if(!wasm.bigIntEnabled) toss3('BigInt64 support is not enabled.'); + const scope = wasm.scopedAllocPush(); + let pOut; + try{ + const pSize = wasm.scopedAlloc(8 + wasm.ptrSizeof); + const ppOut = pSize + 8; + + const zSchema = schema + ? (wasm.isPtr(schema) ? schema : wasm.scopedAllocCString(''+schema)) + : 0; + let rc = wasm.exports.sqlite3_wasm_db_serialize( + pDb, zSchema, ppOut, pSize, 0 + ); + if(rc){ + toss3("Database serialization failed with code", + sqlite3.capi.sqlite3_js_rc_str(rc)); + } + pOut = wasm.peekPtr(ppOut); + const nOut = wasm.peek(pSize, 'i64'); + rc = nOut + ? wasm.heap8u().slice(pOut, pOut + Number(nOut)) + : new Uint8Array(); + return rc; + }finally{ + if(pOut) wasm.exports.sqlite3_free(pOut); + wasm.scopedAllocPop(scope); + } + }; + + + capi.sqlite3_js_db_vfs = + (dbPointer, dbName=0)=>wasm.sqlite3_wasm_db_vfs(dbPointer, dbName); + + + capi.sqlite3_js_aggregate_context = (pCtx, n)=>{ + return capi.sqlite3_aggregate_context(pCtx, n) + || (n ? WasmAllocError.toss("Cannot allocate",n, + "bytes for sqlite3_aggregate_context()") + : 0); + }; + + + capi.sqlite3_js_vfs_create_file = function(vfs, filename, data, dataLen){ + let pData; + if(data){ + if(wasm.isPtr(data)){ + pData = data; + }else if(data instanceof ArrayBuffer){ + data = new Uint8Array(data); + } + if(data instanceof Uint8Array){ + pData = wasm.allocFromTypedArray(data); + if(arguments.length<4 || !util.isInt32(dataLen) || dataLen<0){ + dataLen = data.byteLength; + } + }else{ + SQLite3Error.toss("Invalid 3rd argument type for sqlite3_js_vfs_create_file()."); + } + }else{ + pData = 0; + } + if(!util.isInt32(dataLen) || dataLen<0){ + wasm.dealloc(pData); + SQLite3Error.toss("Invalid 4th argument for sqlite3_js_vfs_create_file()."); + } + try{ + const rc = wasm.sqlite3_wasm_vfs_create_file(vfs, filename, pData, dataLen); + if(rc) SQLite3Error.toss("Creation of file failed with sqlite3 result code", + capi.sqlite3_js_rc_str(rc)); + }finally{ + wasm.dealloc(pData); + } + }; + + if( util.isUIThread() ){ + + + + const __kvvfsInfo = function(which){ + const rc = Object.create(null); + rc.prefix = 'kvvfs-'+which; + rc.stores = []; + if('session'===which || ""===which) rc.stores.push(globalThis.sessionStorage); + if('local'===which || ""===which) rc.stores.push(globalThis.localStorage); + return rc; + }; + + + capi.sqlite3_js_kvvfs_clear = function(which=""){ + let rc = 0; + const kvinfo = __kvvfsInfo(which); + kvinfo.stores.forEach((s)=>{ + const toRm = [] ; + let i; + for( i = 0; i < s.length; ++i ){ + const k = s.key(i); + if(k.startsWith(kvinfo.prefix)) toRm.push(k); + } + toRm.forEach((kk)=>s.removeItem(kk)); + rc += toRm.length; + }); + return rc; + }; + + + capi.sqlite3_js_kvvfs_size = function(which=""){ + let sz = 0; + const kvinfo = __kvvfsInfo(which); + kvinfo.stores.forEach((s)=>{ + let i; + for(i = 0; i < s.length; ++i){ + const k = s.key(i); + if(k.startsWith(kvinfo.prefix)){ + sz += k.length; + sz += s.getItem(k).length; + } + } + }); + return sz * 2 ; + }; + + } + + + capi.sqlite3_db_config = function(pDb, op, ...args){ + if(!this.s){ + this.s = wasm.xWrap('sqlite3_wasm_db_config_s','int', + ['sqlite3*', 'int', 'string:static'] + ); + this.pii = wasm.xWrap('sqlite3_wasm_db_config_pii', 'int', + ['sqlite3*', 'int', '*','int', 'int']); + this.ip = wasm.xWrap('sqlite3_wasm_db_config_ip','int', + ['sqlite3*', 'int', 'int','*']); + } + switch(op){ + case capi.SQLITE_DBCONFIG_ENABLE_FKEY: + case capi.SQLITE_DBCONFIG_ENABLE_TRIGGER: + case capi.SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: + case capi.SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: + case capi.SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: + case capi.SQLITE_DBCONFIG_ENABLE_QPSG: + case capi.SQLITE_DBCONFIG_TRIGGER_EQP: + case capi.SQLITE_DBCONFIG_RESET_DATABASE: + case capi.SQLITE_DBCONFIG_DEFENSIVE: + case capi.SQLITE_DBCONFIG_WRITABLE_SCHEMA: + case capi.SQLITE_DBCONFIG_LEGACY_ALTER_TABLE: + case capi.SQLITE_DBCONFIG_DQS_DML: + case capi.SQLITE_DBCONFIG_DQS_DDL: + case capi.SQLITE_DBCONFIG_ENABLE_VIEW: + case capi.SQLITE_DBCONFIG_LEGACY_FILE_FORMAT: + case capi.SQLITE_DBCONFIG_TRUSTED_SCHEMA: + case capi.SQLITE_DBCONFIG_STMT_SCANSTATUS: + case capi.SQLITE_DBCONFIG_REVERSE_SCANORDER: + return this.ip(pDb, op, args[0], args[1] || 0); + case capi.SQLITE_DBCONFIG_LOOKASIDE: + return this.pii(pDb, op, args[0], args[1], args[2]); + case capi.SQLITE_DBCONFIG_MAINDBNAME: + return this.s(pDb, op, args[0]); + default: + return capi.SQLITE_MISUSE; + } + }.bind(Object.create(null)); + + + capi.sqlite3_value_to_js = function(pVal,throwIfCannotConvert=true){ + let arg; + const valType = capi.sqlite3_value_type(pVal); + switch(valType){ + case capi.SQLITE_INTEGER: + if(wasm.bigIntEnabled){ + arg = capi.sqlite3_value_int64(pVal); + if(util.bigIntFitsDouble(arg)) arg = Number(arg); + } + else arg = capi.sqlite3_value_double(pVal); + break; + case capi.SQLITE_FLOAT: + arg = capi.sqlite3_value_double(pVal); + break; + case capi.SQLITE_TEXT: + arg = capi.sqlite3_value_text(pVal); + break; + case capi.SQLITE_BLOB:{ + const n = capi.sqlite3_value_bytes(pVal); + const pBlob = capi.sqlite3_value_blob(pVal); + if(n && !pBlob) sqlite3.WasmAllocError.toss( + "Cannot allocate memory for blob argument of",n,"byte(s)" + ); + arg = n ? wasm.heap8u().slice(pBlob, pBlob + Number(n)) : null; + break; + } + case capi.SQLITE_NULL: + arg = null; break; + default: + if(throwIfCannotConvert){ + toss3(capi.SQLITE_MISMATCH, + "Unhandled sqlite3_value_type():",valType); + } + arg = undefined; + } + return arg; + }; + + + capi.sqlite3_values_to_js = function(argc,pArgv,throwIfCannotConvert=true){ + let i; + const tgt = []; + for(i = 0; i < argc; ++i){ + + tgt.push(capi.sqlite3_value_to_js( + wasm.peekPtr(pArgv + (wasm.ptrSizeof * i)) + )); + } + return tgt; + }; + + + capi.sqlite3_result_error_js = function(pCtx,e){ + if(e instanceof WasmAllocError){ + capi.sqlite3_result_error_nomem(pCtx); + }else{ + ; + capi.sqlite3_result_error(pCtx, ''+e, -1); + } + }; + + + capi.sqlite3_result_js = function(pCtx,val){ + if(val instanceof Error){ + capi.sqlite3_result_error_js(pCtx, val); + return; + } + try{ + switch(typeof val) { + case 'undefined': + + break; + case 'boolean': + capi.sqlite3_result_int(pCtx, val ? 1 : 0); + break; + case 'bigint': + if(util.bigIntFits32(val)){ + capi.sqlite3_result_int(pCtx, Number(val)); + }else if(util.bigIntFitsDouble(val)){ + capi.sqlite3_result_double(pCtx, Number(val)); + }else if(wasm.bigIntEnabled){ + if(util.bigIntFits64(val)) capi.sqlite3_result_int64(pCtx, val); + else toss3("BigInt value",val.toString(),"is too BigInt for int64."); + }else{ + toss3("BigInt value",val.toString(),"is too BigInt."); + } + break; + case 'number': { + let f; + if(util.isInt32(val)){ + f = capi.sqlite3_result_int; + }else if(wasm.bigIntEnabled + && Number.isInteger(val) + && util.bigIntFits64(BigInt(val))){ + f = capi.sqlite3_result_int64; + }else{ + f = capi.sqlite3_result_double; + } + f(pCtx, val); + break; + } + case 'string': { + const [p, n] = wasm.allocCString(val,true); + capi.sqlite3_result_text(pCtx, p, n, capi.SQLITE_WASM_DEALLOC); + break; + } + case 'object': + if(null===val) { + capi.sqlite3_result_null(pCtx); + break; + }else if(util.isBindableTypedArray(val)){ + const pBlob = wasm.allocFromTypedArray(val); + capi.sqlite3_result_blob( + pCtx, pBlob, val.byteLength, + capi.SQLITE_WASM_DEALLOC + ); + break; + } + + default: + toss3("Don't not how to handle this UDF result value:",(typeof val), val); + } + }catch(e){ + capi.sqlite3_result_error_js(pCtx, e); + } + }; + + + capi.sqlite3_column_js = function(pStmt, iCol, throwIfCannotConvert=true){ + const v = capi.sqlite3_column_value(pStmt, iCol); + return (0===v) ? undefined : capi.sqlite3_value_to_js(v, throwIfCannotConvert); + }; + + + const __newOldValue = function(pObj, iCol, impl){ + impl = capi[impl]; + if(!this.ptr) this.ptr = wasm.allocPtr(); + else wasm.pokePtr(this.ptr, 0); + const rc = impl(pObj, iCol, this.ptr); + if(rc) return SQLite3Error.toss(rc,arguments[2]+"() failed with code "+rc); + const pv = wasm.peekPtr(this.ptr); + return pv ? capi.sqlite3_value_to_js( pv, true ) : undefined; + }.bind(Object.create(null)); + + + capi.sqlite3_preupdate_new_js = + (pDb, iCol)=>__newOldValue(pDb, iCol, 'sqlite3_preupdate_new'); + + + capi.sqlite3_preupdate_old_js = + (pDb, iCol)=>__newOldValue(pDb, iCol, 'sqlite3_preupdate_old'); + + + capi.sqlite3changeset_new_js = + (pChangesetIter, iCol) => __newOldValue(pChangesetIter, iCol, + 'sqlite3changeset_new'); + + + capi.sqlite3changeset_old_js = + (pChangesetIter, iCol)=>__newOldValue(pChangesetIter, iCol, + 'sqlite3changeset_old'); + + + const sqlite3 = { + WasmAllocError: WasmAllocError, + SQLite3Error: SQLite3Error, + capi, + util, + wasm, + config, + + version: Object.create(null), + + + client: undefined, + + + asyncPostInit: async function(){ + let lip = sqlite3ApiBootstrap.initializersAsync; + delete sqlite3ApiBootstrap.initializersAsync; + if(!lip || !lip.length) return Promise.resolve(sqlite3); + lip = lip.map((f)=>{ + const p = (f instanceof Promise) ? f : f(sqlite3); + return p.catch((e)=>{ + console.error("an async sqlite3 initializer failed:",e); + throw e; + }); + }); + const postInit = ()=>{ + if(!sqlite3.__isUnderTest){ + + delete sqlite3.util; + + delete sqlite3.StructBinder; + } + return sqlite3; + }; + if(1){ + + let p = lip.shift(); + while(lip.length) p = p.then(lip.shift()); + return p.then(postInit); + }else{ + + return Promise.all(lip).then(postInit); + } + }, + + scriptInfo: undefined + }; + try{ + sqlite3ApiBootstrap.initializers.forEach((f)=>{ + f(sqlite3); + }); + }catch(e){ + + console.error("sqlite3 bootstrap initializer threw:",e); + throw e; + } + delete sqlite3ApiBootstrap.initializers; + sqlite3ApiBootstrap.sqlite3 = sqlite3; + return sqlite3; +}; + +globalThis.sqlite3ApiBootstrap.initializers = []; + +globalThis.sqlite3ApiBootstrap.initializersAsync = []; + +globalThis.sqlite3ApiBootstrap.defaultConfig = Object.create(null); + +globalThis.sqlite3ApiBootstrap.sqlite3 = undefined; + + + + +globalThis.WhWasmUtilInstaller = function(target){ + 'use strict'; + if(undefined===target.bigIntEnabled){ + target.bigIntEnabled = !!self['BigInt64Array']; + } + + + const toss = (...args)=>{throw new Error(args.join(' '))}; + + if(!target.exports){ + Object.defineProperty(target, 'exports', { + enumerable: true, configurable: true, + get: ()=>(target.instance && target.instance.exports) + }); + } + + + + + + const ptrIR = target.pointerIR || 'i32'; + const ptrSizeof = target.ptrSizeof = + ('i32'===ptrIR ? 4 + : ('i64'===ptrIR + ? 8 : toss("Unhandled ptrSizeof:",ptrIR))); + + const cache = Object.create(null); + + cache.heapSize = 0; + + cache.memory = null; + + cache.freeFuncIndexes = []; + + cache.scopedAlloc = []; + + cache.utf8Decoder = new TextDecoder(); + cache.utf8Encoder = new TextEncoder('utf-8'); + + + target.sizeofIR = (n)=>{ + switch(n){ + case 'i8': return 1; + case 'i16': return 2; + case 'i32': case 'f32': case 'float': return 4; + case 'i64': case 'f64': case 'double': return 8; + case '*': return ptrSizeof; + default: + return (''+n).endsWith('*') ? ptrSizeof : undefined; + } + }; + + + const heapWrappers = function(){ + if(!cache.memory){ + cache.memory = (target.memory instanceof WebAssembly.Memory) + ? target.memory : target.exports.memory; + }else if(cache.heapSize === cache.memory.buffer.byteLength){ + return cache; + } + + const b = cache.memory.buffer; + cache.HEAP8 = new Int8Array(b); cache.HEAP8U = new Uint8Array(b); + cache.HEAP16 = new Int16Array(b); cache.HEAP16U = new Uint16Array(b); + cache.HEAP32 = new Int32Array(b); cache.HEAP32U = new Uint32Array(b); + if(target.bigIntEnabled){ + cache.HEAP64 = new BigInt64Array(b); cache.HEAP64U = new BigUint64Array(b); + } + cache.HEAP32F = new Float32Array(b); cache.HEAP64F = new Float64Array(b); + cache.heapSize = b.byteLength; + return cache; + }; + + + target.heap8 = ()=>heapWrappers().HEAP8; + + + target.heap8u = ()=>heapWrappers().HEAP8U; + + + target.heap16 = ()=>heapWrappers().HEAP16; + + + target.heap16u = ()=>heapWrappers().HEAP16U; + + + target.heap32 = ()=>heapWrappers().HEAP32; + + + target.heap32u = ()=>heapWrappers().HEAP32U; + + + target.heapForSize = function(n,unsigned = true){ + let ctor; + const c = (cache.memory && cache.heapSize === cache.memory.buffer.byteLength) + ? cache : heapWrappers(); + switch(n){ + case Int8Array: return c.HEAP8; case Uint8Array: return c.HEAP8U; + case Int16Array: return c.HEAP16; case Uint16Array: return c.HEAP16U; + case Int32Array: return c.HEAP32; case Uint32Array: return c.HEAP32U; + case 8: return unsigned ? c.HEAP8U : c.HEAP8; + case 16: return unsigned ? c.HEAP16U : c.HEAP16; + case 32: return unsigned ? c.HEAP32U : c.HEAP32; + case 64: + if(c.HEAP64) return unsigned ? c.HEAP64U : c.HEAP64; + break; + default: + if(target.bigIntEnabled){ + if(n===self['BigUint64Array']) return c.HEAP64U; + else if(n===self['BigInt64Array']) return c.HEAP64; + break; + } + } + toss("Invalid heapForSize() size: expecting 8, 16, 32,", + "or (if BigInt is enabled) 64."); + }; + + + target.functionTable = function(){ + return target.exports.__indirect_function_table; + + }; + + + target.functionEntry = function(fptr){ + const ft = target.functionTable(); + return fptr < ft.length ? ft.get(fptr) : undefined; + }; + + + target.jsFuncToWasm = function f(func, sig){ + + if(!f._){ + f._ = { + + sigTypes: Object.assign(Object.create(null),{ + i: 'i32', p: 'i32', P: 'i32', s: 'i32', + j: 'i64', f: 'f32', d: 'f64' + }), + + typeCodes: Object.assign(Object.create(null),{ + f64: 0x7c, f32: 0x7d, i64: 0x7e, i32: 0x7f + }), + + uleb128Encode: function(tgt, method, n){ + if(n<128) tgt[method](n); + else tgt[method]( (n % 128) | 128, n>>7); + }, + + rxJSig: /^(\w)\((\w*)\)$/, + + sigParams: function(sig){ + const m = f._.rxJSig.exec(sig); + return m ? m[2] : sig.substr(1); + }, + + letterType: (x)=>f._.sigTypes[x] || toss("Invalid signature letter:",x), + + + + pushSigType: (dest, letter)=>dest.push(f._.typeCodes[f._.letterType(letter)]) + }; + } + if('string'===typeof func){ + const x = sig; + sig = func; + func = x; + } + const sigParams = f._.sigParams(sig); + const wasmCode = [0x01, 0x60]; + f._.uleb128Encode(wasmCode, 'push', sigParams.length); + for(const x of sigParams) f._.pushSigType(wasmCode, x); + if('v'===sig[0]) wasmCode.push(0); + else{ + wasmCode.push(1); + f._.pushSigType(wasmCode, sig[0]); + } + f._.uleb128Encode(wasmCode, 'unshift', wasmCode.length); + wasmCode.unshift( + 0x00, 0x61, 0x73, 0x6d, + 0x01, 0x00, 0x00, 0x00, + 0x01 + ); + wasmCode.push( + 0x02, 0x07, + + 0x01, 0x01, 0x65, 0x01, 0x66, 0x00, 0x00, + 0x07, 0x05, + + 0x01, 0x01, 0x66, 0x00, 0x00 + ); + return (new WebAssembly.Instance( + new WebAssembly.Module(new Uint8Array(wasmCode)), { + e: { f: func } + })).exports['f']; + }; + + + const __installFunction = function f(func, sig, scoped){ + if(scoped && !cache.scopedAlloc.length){ + toss("No scopedAllocPush() scope is active."); + } + if('string'===typeof func){ + const x = sig; + sig = func; + func = x; + } + if('string'!==typeof sig || !(func instanceof Function)){ + toss("Invalid arguments: expecting (function,signature) "+ + "or (signature,function)."); + } + const ft = target.functionTable(); + const oldLen = ft.length; + let ptr; + while(cache.freeFuncIndexes.length){ + ptr = cache.freeFuncIndexes.pop(); + if(ft.get(ptr)){ + ptr = null; + continue; + }else{ + break; + } + } + if(!ptr){ + ptr = oldLen; + ft.grow(1); + } + try{ + + ft.set(ptr, func); + if(scoped){ + cache.scopedAlloc[cache.scopedAlloc.length-1].push(ptr); + } + return ptr; + }catch(e){ + if(!(e instanceof TypeError)){ + if(ptr===oldLen) cache.freeFuncIndexes.push(oldLen); + throw e; + } + } + + try { + const fptr = target.jsFuncToWasm(func, sig); + ft.set(ptr, fptr); + if(scoped){ + cache.scopedAlloc[cache.scopedAlloc.length-1].push(ptr); + } + }catch(e){ + if(ptr===oldLen) cache.freeFuncIndexes.push(oldLen); + throw e; + } + return ptr; + }; + + + target.installFunction = (func, sig)=>__installFunction(func, sig, false); + + + target.scopedInstallFunction = (func, sig)=>__installFunction(func, sig, true); + + + target.uninstallFunction = function(ptr){ + if(!ptr && 0!==ptr) return undefined; + const fi = cache.freeFuncIndexes; + const ft = target.functionTable(); + fi.push(ptr); + const rc = ft.get(ptr); + ft.set(ptr, null); + return rc; + }; + + + target.peek = function f(ptr, type='i8'){ + if(type.endsWith('*')) type = ptrIR; + const c = (cache.memory && cache.heapSize === cache.memory.buffer.byteLength) + ? cache : heapWrappers(); + const list = Array.isArray(ptr) ? [] : undefined; + let rc; + do{ + if(list) ptr = arguments[0].shift(); + switch(type){ + case 'i1': + case 'i8': rc = c.HEAP8[ptr>>0]; break; + case 'i16': rc = c.HEAP16[ptr>>1]; break; + case 'i32': rc = c.HEAP32[ptr>>2]; break; + case 'float': case 'f32': rc = c.HEAP32F[ptr>>2]; break; + case 'double': case 'f64': rc = Number(c.HEAP64F[ptr>>3]); break; + case 'i64': + if(target.bigIntEnabled){ + rc = BigInt(c.HEAP64[ptr>>3]); + break; + } + + default: + toss('Invalid type for peek():',type); + } + if(list) list.push(rc); + }while(list && arguments[0].length); + return list || rc; + }; + + + target.poke = function(ptr, value, type='i8'){ + if (type.endsWith('*')) type = ptrIR; + const c = (cache.memory && cache.heapSize === cache.memory.buffer.byteLength) + ? cache : heapWrappers(); + for(const p of (Array.isArray(ptr) ? ptr : [ptr])){ + switch (type) { + case 'i1': + case 'i8': c.HEAP8[p>>0] = value; continue; + case 'i16': c.HEAP16[p>>1] = value; continue; + case 'i32': c.HEAP32[p>>2] = value; continue; + case 'float': case 'f32': c.HEAP32F[p>>2] = value; continue; + case 'double': case 'f64': c.HEAP64F[p>>3] = value; continue; + case 'i64': + if(c.HEAP64){ + c.HEAP64[p>>3] = BigInt(value); + continue; + } + + default: + toss('Invalid type for poke(): ' + type); + } + } + return this; + }; + + + target.peekPtr = (...ptr)=>target.peek( (1===ptr.length ? ptr[0] : ptr), ptrIR ); + + + target.pokePtr = (ptr, value=0)=>target.poke(ptr, value, ptrIR); + + + target.peek8 = (...ptr)=>target.peek( (1===ptr.length ? ptr[0] : ptr), 'i8' ); + + target.poke8 = (ptr, value)=>target.poke(ptr, value, 'i8'); + + target.peek16 = (...ptr)=>target.peek( (1===ptr.length ? ptr[0] : ptr), 'i16' ); + + target.poke16 = (ptr, value)=>target.poke(ptr, value, 'i16'); + + target.peek32 = (...ptr)=>target.peek( (1===ptr.length ? ptr[0] : ptr), 'i32' ); + + target.poke32 = (ptr, value)=>target.poke(ptr, value, 'i32'); + + target.peek64 = (...ptr)=>target.peek( (1===ptr.length ? ptr[0] : ptr), 'i64' ); + + target.poke64 = (ptr, value)=>target.poke(ptr, value, 'i64'); + + target.peek32f = (...ptr)=>target.peek( (1===ptr.length ? ptr[0] : ptr), 'f32' ); + + target.poke32f = (ptr, value)=>target.poke(ptr, value, 'f32'); + + target.peek64f = (...ptr)=>target.peek( (1===ptr.length ? ptr[0] : ptr), 'f64' ); + + target.poke64f = (ptr, value)=>target.poke(ptr, value, 'f64'); + + + target.getMemValue = target.peek; + + target.getPtrValue = target.peekPtr; + + target.setMemValue = target.poke; + + target.setPtrValue = target.pokePtr; + + + target.isPtr32 = (ptr)=>('number'===typeof ptr && (ptr===(ptr|0)) && ptr>=0); + + + target.isPtr = target.isPtr32; + + + target.cstrlen = function(ptr){ + if(!ptr || !target.isPtr(ptr)) return null; + const h = heapWrappers().HEAP8U; + let pos = ptr; + for( ; h[pos] !== 0; ++pos ){} + return pos - ptr; + }; + + + const __SAB = ('undefined'===typeof SharedArrayBuffer) + ? function(){} : SharedArrayBuffer; + const __utf8Decode = function(arrayBuffer, begin, end){ + return cache.utf8Decoder.decode( + (arrayBuffer.buffer instanceof __SAB) + ? arrayBuffer.slice(begin, end) + : arrayBuffer.subarray(begin, end) + ); + }; + + + target.cstrToJs = function(ptr){ + const n = target.cstrlen(ptr); + return n ? __utf8Decode(heapWrappers().HEAP8U, ptr, ptr+n) : (null===n ? n : ""); + }; + + + target.jstrlen = function(str){ + + if('string'!==typeof str) return null; + const n = str.length; + let len = 0; + for(let i = 0; i < n; ++i){ + let u = str.charCodeAt(i); + if(u>=0xd800 && u<=0xdfff){ + u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF); + } + if(u<=0x7f) ++len; + else if(u<=0x7ff) len += 2; + else if(u<=0xffff) len += 3; + else len += 4; + } + return len; + }; + + + target.jstrcpy = function(jstr, tgt, offset = 0, maxBytes = -1, addNul = true){ + + if(!tgt || (!(tgt instanceof Int8Array) && !(tgt instanceof Uint8Array))){ + toss("jstrcpy() target must be an Int8Array or Uint8Array."); + } + if(maxBytes<0) maxBytes = tgt.length - offset; + if(!(maxBytes>0) || !(offset>=0)) return 0; + let i = 0, max = jstr.length; + const begin = offset, end = offset + maxBytes - (addNul ? 1 : 0); + for(; i < max && offset < end; ++i){ + let u = jstr.charCodeAt(i); + if(u>=0xd800 && u<=0xdfff){ + u = 0x10000 + ((u & 0x3FF) << 10) | (jstr.charCodeAt(++i) & 0x3FF); + } + if(u<=0x7f){ + if(offset >= end) break; + tgt[offset++] = u; + }else if(u<=0x7ff){ + if(offset + 1 >= end) break; + tgt[offset++] = 0xC0 | (u >> 6); + tgt[offset++] = 0x80 | (u & 0x3f); + }else if(u<=0xffff){ + if(offset + 2 >= end) break; + tgt[offset++] = 0xe0 | (u >> 12); + tgt[offset++] = 0x80 | ((u >> 6) & 0x3f); + tgt[offset++] = 0x80 | (u & 0x3f); + }else{ + if(offset + 3 >= end) break; + tgt[offset++] = 0xf0 | (u >> 18); + tgt[offset++] = 0x80 | ((u >> 12) & 0x3f); + tgt[offset++] = 0x80 | ((u >> 6) & 0x3f); + tgt[offset++] = 0x80 | (u & 0x3f); + } + } + if(addNul) tgt[offset++] = 0; + return offset - begin; + }; + + + target.cstrncpy = function(tgtPtr, srcPtr, n){ + if(!tgtPtr || !srcPtr) toss("cstrncpy() does not accept NULL strings."); + if(n<0) n = target.cstrlen(strPtr)+1; + else if(!(n>0)) return 0; + const heap = target.heap8u(); + let i = 0, ch; + for(; i < n && (ch = heap[srcPtr+i]); ++i){ + heap[tgtPtr+i] = ch; + } + if(i{ + return cache.utf8Encoder.encode(addNul ? (str+"\0") : str); + + + + + + + + + + + + + + + + + + + + + + + + + + }; + + const __affirmAlloc = (obj,funcName)=>{ + if(!(obj.alloc instanceof Function) || + !(obj.dealloc instanceof Function)){ + toss("Object is missing alloc() and/or dealloc() function(s)", + "required by",funcName+"()."); + } + }; + + const __allocCStr = function(jstr, returnWithLength, allocator, funcName){ + __affirmAlloc(target, funcName); + if('string'!==typeof jstr) return null; + if(0){ + const n = target.jstrlen(jstr), + ptr = allocator(n+1); + target.jstrcpy(jstr, target.heap8u(), ptr, n+1, true); + return returnWithLength ? [ptr, n] : ptr; + }else{ + const u = cache.utf8Encoder.encode(jstr), + ptr = allocator(u.length+1), + heap = heapWrappers().HEAP8U; + heap.set(u, ptr); + heap[ptr + u.length] = 0; + return returnWithLength ? [ptr, u.length] : ptr; + } + }; + + + target.allocCString = + (jstr, returnWithLength=false)=>__allocCStr(jstr, returnWithLength, + target.alloc, 'allocCString()'); + + + target.scopedAllocPush = function(){ + __affirmAlloc(target, 'scopedAllocPush'); + const a = []; + cache.scopedAlloc.push(a); + return a; + }; + + + target.scopedAllocPop = function(state){ + __affirmAlloc(target, 'scopedAllocPop'); + const n = arguments.length + ? cache.scopedAlloc.indexOf(state) + : cache.scopedAlloc.length-1; + if(n<0) toss("Invalid state object for scopedAllocPop()."); + if(0===arguments.length) state = cache.scopedAlloc[n]; + cache.scopedAlloc.splice(n,1); + for(let p; (p = state.pop()); ){ + if(target.functionEntry(p)){ + + target.uninstallFunction(p); + } + else target.dealloc(p); + } + }; + + + target.scopedAlloc = function(n){ + if(!cache.scopedAlloc.length){ + toss("No scopedAllocPush() scope is active."); + } + const p = target.alloc(n); + cache.scopedAlloc[cache.scopedAlloc.length-1].push(p); + return p; + }; + + Object.defineProperty(target.scopedAlloc, 'level', { + configurable: false, enumerable: false, + get: ()=>cache.scopedAlloc.length, + set: ()=>toss("The 'active' property is read-only.") + }); + + + target.scopedAllocCString = + (jstr, returnWithLength=false)=>__allocCStr(jstr, returnWithLength, + target.scopedAlloc, 'scopedAllocCString()'); + + + const __allocMainArgv = function(isScoped, list){ + const pList = target[ + isScoped ? 'scopedAlloc' : 'alloc' + ]((list.length + 1) * target.ptrSizeof); + let i = 0; + list.forEach((e)=>{ + target.pokePtr(pList + (target.ptrSizeof * i++), + target[ + isScoped ? 'scopedAllocCString' : 'allocCString' + ](""+e)); + }); + target.pokePtr(pList + (target.ptrSizeof * i), 0); + return pList; + }; + + + target.scopedAllocMainArgv = (list)=>__allocMainArgv(true, list); + + + target.allocMainArgv = (list)=>__allocMainArgv(false, list); + + + target.cArgvToJs = (argc, pArgv)=>{ + const list = []; + for(let i = 0; i < argc; ++i){ + const arg = target.peekPtr(pArgv + (target.ptrSizeof * i)); + list.push( arg ? target.cstrToJs(arg) : null ); + } + return list; + }; + + + target.scopedAllocCall = function(func){ + target.scopedAllocPush(); + try{ return func() } finally{ target.scopedAllocPop() } + }; + + + const __allocPtr = function(howMany, safePtrSize, method){ + __affirmAlloc(target, method); + const pIr = safePtrSize ? 'i64' : ptrIR; + let m = target[method](howMany * (safePtrSize ? 8 : ptrSizeof)); + target.poke(m, 0, pIr) + if(1===howMany){ + return m; + } + const a = [m]; + for(let i = 1; i < howMany; ++i){ + m += (safePtrSize ? 8 : ptrSizeof); + a[i] = m; + target.poke(m, 0, pIr); + } + return a; + }; + + + target.allocPtr = + (howMany=1, safePtrSize=true)=>__allocPtr(howMany, safePtrSize, 'alloc'); + + + target.scopedAllocPtr = + (howMany=1, safePtrSize=true)=>__allocPtr(howMany, safePtrSize, 'scopedAlloc'); + + + target.xGet = function(name){ + return target.exports[name] || toss("Cannot find exported symbol:",name); + }; + + const __argcMismatch = + (f,n)=>toss(f+"() requires",n,"argument(s)."); + + + target.xCall = function(fname, ...args){ + const f = target.xGet(fname); + if(!(f instanceof Function)) toss("Exported symbol",fname,"is not a function."); + if(f.length!==args.length) __argcMismatch(fname,f.length) + ; + return (2===arguments.length && Array.isArray(arguments[1])) + ? f.apply(null, arguments[1]) + : f.apply(null, args); + }; + + + cache.xWrap = Object.create(null); + cache.xWrap.convert = Object.create(null); + + cache.xWrap.convert.arg = new Map; + + cache.xWrap.convert.result = new Map; + const xArg = cache.xWrap.convert.arg, xResult = cache.xWrap.convert.result; + + if(target.bigIntEnabled){ + xArg.set('i64', (i)=>BigInt(i)); + } + const __xArgPtr = 'i32' === ptrIR + ? ((i)=>(i | 0)) : ((i)=>(BigInt(i) | BigInt(0))); + xArg.set('i32', __xArgPtr ) + .set('i16', (i)=>((i | 0) & 0xFFFF)) + .set('i8', (i)=>((i | 0) & 0xFF)) + .set('f32', (i)=>Number(i).valueOf()) + .set('float', xArg.get('f32')) + .set('f64', xArg.get('f32')) + .set('double', xArg.get('f64')) + .set('int', xArg.get('i32')) + .set('null', (i)=>i) + .set(null, xArg.get('null')) + .set('**', __xArgPtr) + .set('*', __xArgPtr); + xResult.set('*', __xArgPtr) + .set('pointer', __xArgPtr) + .set('number', (v)=>Number(v)) + .set('void', (v)=>undefined) + .set('null', (v)=>v) + .set(null, xResult.get('null')); + + { + const copyToResult = ['i8', 'i16', 'i32', 'int', + 'f32', 'float', 'f64', 'double']; + if(target.bigIntEnabled) copyToResult.push('i64'); + const adaptPtr = xArg.get(ptrIR); + for(const t of copyToResult){ + xArg.set(t+'*', adaptPtr); + xResult.set(t+'*', adaptPtr); + xResult.set(t, (xArg.get(t) || toss("Missing arg converter:",t))); + } + } + + + const __xArgString = function(v){ + if('string'===typeof v) return target.scopedAllocCString(v); + return v ? __xArgPtr(v) : null; + }; + xArg.set('string', __xArgString) + .set('utf8', __xArgString) + .set('pointer', __xArgString); + + + xResult.set('string', (i)=>target.cstrToJs(i)) + .set('utf8', xResult.get('string')) + .set('string:dealloc', (i)=>{ + try { return i ? target.cstrToJs(i) : null } + finally{ target.dealloc(i) } + }) + .set('utf8:dealloc', xResult.get('string:dealloc')) + .set('json', (i)=>JSON.parse(target.cstrToJs(i))) + .set('json:dealloc', (i)=>{ + try{ return i ? JSON.parse(target.cstrToJs(i)) : null } + finally{ target.dealloc(i) } + }); + + + const AbstractArgAdapter = class { + constructor(opt){ + this.name = opt.name || 'unnamed adapter'; + } + + convertArg(v,argv,argIndex){ + toss("AbstractArgAdapter must be subclassed."); + } + }; + + + xArg.FuncPtrAdapter = class FuncPtrAdapter extends AbstractArgAdapter { + constructor(opt) { + super(opt); + if(xArg.FuncPtrAdapter.warnOnUse){ + console.warn('xArg.FuncPtrAdapter is an internal-only API', + 'and is not intended to be invoked from', + 'client-level code. Invoked with:',opt); + } + this.signature = opt.signature; + if(opt.contextKey instanceof Function){ + this.contextKey = opt.contextKey; + if(!opt.bindScope) opt.bindScope = 'context'; + } + this.bindScope = opt.bindScope + || toss("FuncPtrAdapter options requires a bindScope (explicit or implied)."); + if(FuncPtrAdapter.bindScopes.indexOf(opt.bindScope)<0){ + toss("Invalid options.bindScope ("+opt.bindMod+") for FuncPtrAdapter. "+ + "Expecting one of: ("+FuncPtrAdapter.bindScopes.join(', ')+')'); + } + this.isTransient = 'transient'===this.bindScope; + this.isContext = 'context'===this.bindScope; + this.isPermanent = 'permanent'===this.bindScope; + this.singleton = ('singleton'===this.bindScope) ? [] : undefined; + + this.callProxy = (opt.callProxy instanceof Function) + ? opt.callProxy : undefined; + } + + + static warnOnUse = false; + + + static debugFuncInstall = false; + + + static debugOut = console.debug.bind(console); + + static bindScopes = [ + 'transient', 'context', 'singleton', 'permanent' + ]; + + + contextKey(argv,argIndex){ + return this; + } + + + contextMap(key){ + const cm = (this.__cmap || (this.__cmap = new Map)); + let rc = cm.get(key); + if(undefined===rc) cm.set(key, (rc = [])); + return rc; + } + + + convertArg(v,argv,argIndex){ + + let pair = this.singleton; + if(!pair && this.isContext){ + pair = this.contextMap(this.contextKey(argv,argIndex)); + } + if(pair && pair[0]===v) return pair[1]; + if(v instanceof Function){ + + if(this.callProxy) v = this.callProxy(v); + const fp = __installFunction(v, this.signature, this.isTransient); + if(FuncPtrAdapter.debugFuncInstall){ + FuncPtrAdapter.debugOut("FuncPtrAdapter installed", this, + this.contextKey(argv,argIndex), '@'+fp, v); + } + if(pair){ + + if(pair[1]){ + if(FuncPtrAdapter.debugFuncInstall){ + FuncPtrAdapter.debugOut("FuncPtrAdapter uninstalling", this, + this.contextKey(argv,argIndex), '@'+pair[1], v); + } + try{target.uninstallFunction(pair[1])} + catch(e){} + } + pair[0] = v; + pair[1] = fp; + } + return fp; + }else if(target.isPtr(v) || null===v || undefined===v){ + if(pair && pair[1] && pair[1]!==v){ + + if(FuncPtrAdapter.debugFuncInstall){ + FuncPtrAdapter.debugOut("FuncPtrAdapter uninstalling", this, + this.contextKey(argv,argIndex), '@'+pair[1], v); + } + try{target.uninstallFunction(pair[1])} + catch(e){} + pair[0] = pair[1] = (v | 0); + } + return v || 0; + }else{ + throw new TypeError("Invalid FuncPtrAdapter argument type. "+ + "Expecting a function pointer or a "+ + (this.name ? this.name+' ' : '')+ + "function matching signature "+ + this.signature+"."); + } + } + }; + + const __xArgAdapterCheck = + (t)=>xArg.get(t) || toss("Argument adapter not found:",t); + + const __xResultAdapterCheck = + (t)=>xResult.get(t) || toss("Result adapter not found:",t); + + cache.xWrap.convertArg = (t,...args)=>__xArgAdapterCheck(t)(...args); + cache.xWrap.convertArgNoCheck = (t,...args)=>xArg.get(t)(...args); + + cache.xWrap.convertResult = + (t,v)=>(null===t ? v : (t ? __xResultAdapterCheck(t)(v) : undefined)); + cache.xWrap.convertResultNoCheck = + (t,v)=>(null===t ? v : (t ? xResult.get(t)(v) : undefined)); + + + target.xWrap = function(fArg, resultType, ...argTypes){ + if(3===arguments.length && Array.isArray(arguments[2])){ + argTypes = arguments[2]; + } + if(target.isPtr(fArg)){ + fArg = target.functionEntry(fArg) + || toss("Function pointer not found in WASM function table."); + } + const fIsFunc = (fArg instanceof Function); + const xf = fIsFunc ? fArg : target.xGet(fArg); + if(fIsFunc) fArg = xf.name || 'unnamed function'; + if(argTypes.length!==xf.length) __argcMismatch(fArg, xf.length); + if((null===resultType) && 0===xf.length){ + + return xf; + } + ; + if(undefined!==resultType && null!==resultType) __xResultAdapterCheck(resultType); + for(const t of argTypes){ + if(t instanceof AbstractArgAdapter) xArg.set(t, (...args)=>t.convertArg(...args)); + else __xArgAdapterCheck(t); + } + const cxw = cache.xWrap; + if(0===xf.length){ + + return (...args)=>(args.length + ? __argcMismatch(fArg, xf.length) + : cxw.convertResult(resultType, xf.call(null))); + } + return function(...args){ + if(args.length!==xf.length) __argcMismatch(fArg, xf.length); + const scope = target.scopedAllocPush(); + try{ + + for(const i in args) args[i] = cxw.convertArgNoCheck( + argTypes[i], args[i], args, i + ); + return cxw.convertResultNoCheck(resultType, xf.apply(null,args)); + }finally{ + target.scopedAllocPop(scope); + } + }; + }; + + + const __xAdapter = function(func, argc, typeName, adapter, modeName, xcvPart){ + if('string'===typeof typeName){ + if(1===argc) return xcvPart.get(typeName); + else if(2===argc){ + if(!adapter){ + delete xcvPart.get(typeName); + return func; + }else if(!(adapter instanceof Function)){ + toss(modeName,"requires a function argument."); + } + xcvPart.set(typeName, adapter); + return func; + } + } + toss("Invalid arguments to",modeName); + }; + + + target.xWrap.resultAdapter = function f(typeName, adapter){ + return __xAdapter(f, arguments.length, typeName, adapter, + 'resultAdapter()', xResult); + }; + + + target.xWrap.argAdapter = function f(typeName, adapter){ + return __xAdapter(f, arguments.length, typeName, adapter, + 'argAdapter()', xArg); + }; + + target.xWrap.FuncPtrAdapter = xArg.FuncPtrAdapter; + + + target.xCallWrapped = function(fArg, resultType, argTypes, ...args){ + if(Array.isArray(arguments[3])) args = arguments[3]; + return target.xWrap(fArg, resultType, argTypes||[]).apply(null, args||[]); + }; + + + target.xWrap.testConvertArg = cache.xWrap.convertArg; + + + target.xWrap.testConvertResult = cache.xWrap.convertResult; + + return target; +}; + + +globalThis.WhWasmUtilInstaller.yawl = function(config){ + const wfetch = ()=>fetch(config.uri, {credentials: 'same-origin'}); + const wui = this; + const finalThen = function(arg){ + + if(config.wasmUtilTarget){ + const toss = (...args)=>{throw new Error(args.join(' '))}; + const tgt = config.wasmUtilTarget; + tgt.module = arg.module; + tgt.instance = arg.instance; + + if(!tgt.instance.exports.memory){ + + tgt.memory = (config.imports && config.imports.env + && config.imports.env.memory) + || toss("Missing 'memory' object!"); + } + if(!tgt.alloc && arg.instance.exports.malloc){ + const exports = arg.instance.exports; + tgt.alloc = function(n){ + return exports.malloc(n) || toss("Allocation of",n,"bytes failed."); + }; + tgt.dealloc = function(m){exports.free(m)}; + } + wui(tgt); + } + if(config.onload) config.onload(arg,config); + return arg ; + }; + const loadWasm = WebAssembly.instantiateStreaming + ? function loadWasmStreaming(){ + return WebAssembly.instantiateStreaming(wfetch(), config.imports||{}) + .then(finalThen); + } + : function loadWasmOldSchool(){ + return wfetch() + .then(response => response.arrayBuffer()) + .then(bytes => WebAssembly.instantiate(bytes, config.imports||{})) + .then(finalThen); + }; + return loadWasm; +}.bind(globalThis.WhWasmUtilInstaller); + + + +'use strict'; +globalThis.Jaccwabyt = function StructBinderFactory(config){ + + + + const toss = (...args)=>{throw new Error(args.join(' '))}; + + + if(!(config.heap instanceof WebAssembly.Memory) + && !(config.heap instanceof Function)){ + toss("config.heap must be WebAssembly.Memory instance or a function."); + } + ['alloc','dealloc'].forEach(function(k){ + (config[k] instanceof Function) || + toss("Config option '"+k+"' must be a function."); + }); + const SBF = StructBinderFactory; + const heap = (config.heap instanceof Function) + ? config.heap : (()=>new Uint8Array(config.heap.buffer)), + alloc = config.alloc, + dealloc = config.dealloc, + log = config.log || console.log.bind(console), + memberPrefix = (config.memberPrefix || ""), + memberSuffix = (config.memberSuffix || ""), + bigIntEnabled = (undefined===config.bigIntEnabled + ? !!self['BigInt64Array'] : !!config.bigIntEnabled), + BigInt = self['BigInt'], + BigInt64Array = self['BigInt64Array'], + + ptrSizeof = config.ptrSizeof || 4, + ptrIR = config.ptrIR || 'i32' + ; + + if(!SBF.debugFlags){ + SBF.__makeDebugFlags = function(deriveFrom=null){ + + if(deriveFrom && deriveFrom.__flags) deriveFrom = deriveFrom.__flags; + const f = function f(flags){ + if(0===arguments.length){ + return f.__flags; + } + if(flags<0){ + delete f.__flags.getter; delete f.__flags.setter; + delete f.__flags.alloc; delete f.__flags.dealloc; + }else{ + f.__flags.getter = 0!==(0x01 & flags); + f.__flags.setter = 0!==(0x02 & flags); + f.__flags.alloc = 0!==(0x04 & flags); + f.__flags.dealloc = 0!==(0x08 & flags); + } + return f._flags; + }; + Object.defineProperty(f,'__flags', { + iterable: false, writable: false, + value: Object.create(deriveFrom) + }); + if(!deriveFrom) f(0); + return f; + }; + SBF.debugFlags = SBF.__makeDebugFlags(); + } + + const isLittleEndian = (function() { + const buffer = new ArrayBuffer(2); + new DataView(buffer).setInt16(0, 256, true ); + + return new Int16Array(buffer)[0] === 256; + })(); + + + + const isFuncSig = (s)=>'('===s[1]; + + const isPtrSig = (s)=>'p'===s || 'P'===s; + const isAutoPtrSig = (s)=>'P'===s ; + const sigLetter = (s)=>isFuncSig(s) ? 'p' : s[0]; + + const sigIR = function(s){ + switch(sigLetter(s)){ + case 'c': case 'C': return 'i8'; + case 'i': return 'i32'; + case 'p': case 'P': case 's': return ptrIR; + case 'j': return 'i64'; + case 'f': return 'float'; + case 'd': return 'double'; + } + toss("Unhandled signature IR:",s); + }; + + const affirmBigIntArray = BigInt64Array + ? ()=>true : ()=>toss('BigInt64Array is not available.'); + + const sigDVGetter = function(s){ + switch(sigLetter(s)) { + case 'p': case 'P': case 's': { + switch(ptrSizeof){ + case 4: return 'getInt32'; + case 8: return affirmBigIntArray() && 'getBigInt64'; + } + break; + } + case 'i': return 'getInt32'; + case 'c': return 'getInt8'; + case 'C': return 'getUint8'; + case 'j': return affirmBigIntArray() && 'getBigInt64'; + case 'f': return 'getFloat32'; + case 'd': return 'getFloat64'; + } + toss("Unhandled DataView getter for signature:",s); + }; + + const sigDVSetter = function(s){ + switch(sigLetter(s)){ + case 'p': case 'P': case 's': { + switch(ptrSizeof){ + case 4: return 'setInt32'; + case 8: return affirmBigIntArray() && 'setBigInt64'; + } + break; + } + case 'i': return 'setInt32'; + case 'c': return 'setInt8'; + case 'C': return 'setUint8'; + case 'j': return affirmBigIntArray() && 'setBigInt64'; + case 'f': return 'setFloat32'; + case 'd': return 'setFloat64'; + } + toss("Unhandled DataView setter for signature:",s); + }; + + const sigDVSetWrapper = function(s){ + switch(sigLetter(s)) { + case 'i': case 'f': case 'c': case 'C': case 'd': return Number; + case 'j': return affirmBigIntArray() && BigInt; + case 'p': case 'P': case 's': + switch(ptrSizeof){ + case 4: return Number; + case 8: return affirmBigIntArray() && BigInt; + } + break; + } + toss("Unhandled DataView set wrapper for signature:",s); + }; + + + const sPropName = (s,k)=>s+'::'+k; + + const __propThrowOnSet = function(structName,propName){ + return ()=>toss(sPropName(structName,propName),"is read-only."); + }; + + + const __instancePointerMap = new WeakMap(); + + + const xPtrPropName = '(pointer-is-external)'; + + + const __freeStruct = function(ctor, obj, m){ + if(!m) m = __instancePointerMap.get(obj); + if(m) { + __instancePointerMap.delete(obj); + if(Array.isArray(obj.ondispose)){ + let x; + while((x = obj.ondispose.shift())){ + try{ + if(x instanceof Function) x.call(obj); + else if(x instanceof StructType) x.dispose(); + else if('number' === typeof x) dealloc(x); + + + }catch(e){ + console.warn("ondispose() for",ctor.structName,'@', + m,'threw. NOT propagating it.',e); + } + } + }else if(obj.ondispose instanceof Function){ + try{obj.ondispose()} + catch(e){ + + console.warn("ondispose() for",ctor.structName,'@', + m,'threw. NOT propagating it.',e); + } + } + delete obj.ondispose; + if(ctor.debugFlags.__flags.dealloc){ + log("debug.dealloc:",(obj[xPtrPropName]?"EXTERNAL":""), + ctor.structName,"instance:", + ctor.structInfo.sizeof,"bytes @"+m); + } + if(!obj[xPtrPropName]) dealloc(m); + } + }; + + + const rop = (v)=>{return {configurable: false, writable: false, + iterable: false, value: v}}; + + + const __allocStruct = function(ctor, obj, m){ + let fill = !m; + if(m) Object.defineProperty(obj, xPtrPropName, rop(m)); + else{ + m = alloc(ctor.structInfo.sizeof); + if(!m) toss("Allocation of",ctor.structName,"structure failed."); + } + try { + if(ctor.debugFlags.__flags.alloc){ + log("debug.alloc:",(fill?"":"EXTERNAL"), + ctor.structName,"instance:", + ctor.structInfo.sizeof,"bytes @"+m); + } + if(fill) heap().fill(0, m, m + ctor.structInfo.sizeof); + __instancePointerMap.set(obj, m); + }catch(e){ + __freeStruct(ctor, obj, m); + throw e; + } + }; + + const __memoryDump = function(){ + const p = this.pointer; + return p + ? new Uint8Array(heap().slice(p, p+this.structInfo.sizeof)) + : null; + }; + + const __memberKey = (k)=>memberPrefix + k + memberSuffix; + const __memberKeyProp = rop(__memberKey); + + + const __lookupMember = function(structInfo, memberName, tossIfNotFound=true){ + let m = structInfo.members[memberName]; + if(!m && (memberPrefix || memberSuffix)){ + + for(const v of Object.values(structInfo.members)){ + if(v.key===memberName){ m = v; break; } + } + if(!m && tossIfNotFound){ + toss(sPropName(structInfo.name,memberName),'is not a mapped struct member.'); + } + } + return m; + }; + + + const __memberSignature = function f(obj,memberName,emscriptenFormat=false){ + if(!f._) f._ = (x)=>x.replace(/[^vipPsjrdcC]/g,"").replace(/[pPscC]/g,'i'); + const m = __lookupMember(obj.structInfo, memberName, true); + return emscriptenFormat ? f._(m.signature) : m.signature; + }; + + const __ptrPropDescriptor = { + configurable: false, enumerable: false, + get: function(){return __instancePointerMap.get(this)}, + set: ()=>toss("Cannot assign the 'pointer' property of a struct.") + + + + }; + + + const __structMemberKeys = rop(function(){ + const a = []; + for(const k of Object.keys(this.structInfo.members)){ + a.push(this.memberKey(k)); + } + return a; + }); + + const __utf8Decoder = new TextDecoder('utf-8'); + const __utf8Encoder = new TextEncoder(); + + const __SAB = ('undefined'===typeof SharedArrayBuffer) + ? function(){} : SharedArrayBuffer; + const __utf8Decode = function(arrayBuffer, begin, end){ + return __utf8Decoder.decode( + (arrayBuffer.buffer instanceof __SAB) + ? arrayBuffer.slice(begin, end) + : arrayBuffer.subarray(begin, end) + ); + }; + + const __memberIsString = function(obj,memberName, tossIfNotFound=false){ + const m = __lookupMember(obj.structInfo, memberName, tossIfNotFound); + return (m && 1===m.signature.length && 's'===m.signature[0]) ? m : false; + }; + + + const __affirmCStringSignature = function(member){ + if('s'===member.signature) return; + toss("Invalid member type signature for C-string value:", + JSON.stringify(member)); + }; + + + const __memberToJsString = function f(obj,memberName){ + const m = __lookupMember(obj.structInfo, memberName, true); + __affirmCStringSignature(m); + const addr = obj[m.key]; + + if(!addr) return null; + let pos = addr; + const mem = heap(); + for( ; mem[pos]!==0; ++pos ) { + + }; + + return (addr===pos) ? "" : __utf8Decode(mem, addr, pos); + }; + + + const __addOnDispose = function(obj, ...v){ + if(obj.ondispose){ + if(!Array.isArray(obj.ondispose)){ + obj.ondispose = [obj.ondispose]; + } + }else{ + obj.ondispose = []; + } + obj.ondispose.push(...v); + }; + + + const __allocCString = function(str){ + const u = __utf8Encoder.encode(str); + const mem = alloc(u.length+1); + if(!mem) toss("Allocation error while duplicating string:",str); + const h = heap(); + + + h.set(u, mem); + h[mem + u.length] = 0; + + return mem; + }; + + + const __setMemberCString = function(obj, memberName, str){ + const m = __lookupMember(obj.structInfo, memberName, true); + __affirmCStringSignature(m); + + const mem = __allocCString(str); + obj[m.key] = mem; + __addOnDispose(obj, mem); + return obj; + }; + + + const StructType = function ctor(structName, structInfo){ + if(arguments[2]!==rop){ + toss("Do not call the StructType constructor", + "from client-level code."); + } + Object.defineProperties(this,{ + + structName: rop(structName), + structInfo: rop(structInfo) + }); + }; + + + StructType.prototype = Object.create(null, { + dispose: rop(function(){__freeStruct(this.constructor, this)}), + lookupMember: rop(function(memberName, tossIfNotFound=true){ + return __lookupMember(this.structInfo, memberName, tossIfNotFound); + }), + memberToJsString: rop(function(memberName){ + return __memberToJsString(this, memberName); + }), + memberIsString: rop(function(memberName, tossIfNotFound=true){ + return __memberIsString(this, memberName, tossIfNotFound); + }), + memberKey: __memberKeyProp, + memberKeys: __structMemberKeys, + memberSignature: rop(function(memberName, emscriptenFormat=false){ + return __memberSignature(this, memberName, emscriptenFormat); + }), + memoryDump: rop(__memoryDump), + pointer: __ptrPropDescriptor, + setMemberCString: rop(function(memberName, str){ + return __setMemberCString(this, memberName, str); + }) + }); + + Object.assign(StructType.prototype,{ + addOnDispose: function(...v){ + __addOnDispose(this,...v); + return this; + } + }); + + + Object.defineProperties(StructType, { + allocCString: rop(__allocCString), + isA: rop((v)=>v instanceof StructType), + hasExternalPointer: rop((v)=>(v instanceof StructType) && !!v[xPtrPropName]), + memberKey: __memberKeyProp + }); + + const isNumericValue = (v)=>Number.isFinite(v) || (v instanceof (BigInt || Number)); + + + const makeMemberWrapper = function f(ctor,name, descr){ + if(!f._){ + + f._ = {getters: {}, setters: {}, sw:{}}; + const a = ['i','c','C','p','P','s','f','d','v()']; + if(bigIntEnabled) a.push('j'); + a.forEach(function(v){ + + f._.getters[v] = sigDVGetter(v) ; + f._.setters[v] = sigDVSetter(v) ; + f._.sw[v] = sigDVSetWrapper(v) ; + }); + const rxSig1 = /^[ipPsjfdcC]$/, + rxSig2 = /^[vipPsjfdcC]\([ipPsjfdcC]*\)$/; + f.sigCheck = function(obj, name, key,sig){ + if(Object.prototype.hasOwnProperty.call(obj, key)){ + toss(obj.structName,'already has a property named',key+'.'); + } + rxSig1.test(sig) || rxSig2.test(sig) + || toss("Malformed signature for", + sPropName(obj.structName,name)+":",sig); + }; + } + const key = ctor.memberKey(name); + f.sigCheck(ctor.prototype, name, key, descr.signature); + descr.key = key; + descr.name = name; + const sigGlyph = sigLetter(descr.signature); + const xPropName = sPropName(ctor.prototype.structName,key); + const dbg = ctor.prototype.debugFlags.__flags; + + const prop = Object.create(null); + prop.configurable = false; + prop.enumerable = false; + prop.get = function(){ + if(dbg.getter){ + log("debug.getter:",f._.getters[sigGlyph],"for", sigIR(sigGlyph), + xPropName,'@', this.pointer,'+',descr.offset,'sz',descr.sizeof); + } + let rc = ( + new DataView(heap().buffer, this.pointer + descr.offset, descr.sizeof) + )[f._.getters[sigGlyph]](0, isLittleEndian); + if(dbg.getter) log("debug.getter:",xPropName,"result =",rc); + return rc; + }; + if(descr.readOnly){ + prop.set = __propThrowOnSet(ctor.prototype.structName,key); + }else{ + prop.set = function(v){ + if(dbg.setter){ + log("debug.setter:",f._.setters[sigGlyph],"for", sigIR(sigGlyph), + xPropName,'@', this.pointer,'+',descr.offset,'sz',descr.sizeof, v); + } + if(!this.pointer){ + toss("Cannot set struct property on disposed instance."); + } + if(null===v) v = 0; + else while(!isNumericValue(v)){ + if(isAutoPtrSig(descr.signature) && (v instanceof StructType)){ + + v = v.pointer || 0; + if(dbg.setter) log("debug.setter:",xPropName,"resolved to",v); + break; + } + toss("Invalid value for pointer-type",xPropName+'.'); + } + ( + new DataView(heap().buffer, this.pointer + descr.offset, descr.sizeof) + )[f._.setters[sigGlyph]](0, f._.sw[sigGlyph](v), isLittleEndian); + }; + } + Object.defineProperty(ctor.prototype, key, prop); + }; + + + const StructBinder = function StructBinder(structName, structInfo){ + if(1===arguments.length){ + structInfo = structName; + structName = structInfo.name; + }else if(!structInfo.name){ + structInfo.name = structName; + } + if(!structName) toss("Struct name is required."); + let lastMember = false; + Object.keys(structInfo.members).forEach((k)=>{ + + const m = structInfo.members[k]; + if(!m.sizeof) toss(structName,"member",k,"is missing sizeof."); + else if(m.sizeof===1){ + (m.signature === 'c' || m.signature === 'C') || + toss("Unexpected sizeof==1 member", + sPropName(structInfo.name,k), + "with signature",m.signature); + }else{ + + + if(0!==(m.sizeof%4)){ + console.warn("Invalid struct member description =",m,"from",structInfo); + toss(structName,"member",k,"sizeof is not aligned. sizeof="+m.sizeof); + } + if(0!==(m.offset%4)){ + console.warn("Invalid struct member description =",m,"from",structInfo); + toss(structName,"member",k,"offset is not aligned. offset="+m.offset); + } + } + if(!lastMember || lastMember.offset < m.offset) lastMember = m; + }); + if(!lastMember) toss("No member property descriptions found."); + else if(structInfo.sizeof < lastMember.offset+lastMember.sizeof){ + toss("Invalid struct config:",structName, + "max member offset ("+lastMember.offset+") ", + "extends past end of struct (sizeof="+structInfo.sizeof+")."); + } + const debugFlags = rop(SBF.__makeDebugFlags(StructBinder.debugFlags)); + + const StructCtor = function StructCtor(externalMemory){ + if(!(this instanceof StructCtor)){ + toss("The",structName,"constructor may only be called via 'new'."); + }else if(arguments.length){ + if(externalMemory!==(externalMemory|0) || externalMemory<=0){ + toss("Invalid pointer value for",structName,"constructor."); + } + __allocStruct(StructCtor, this, externalMemory); + }else{ + __allocStruct(StructCtor, this); + } + }; + Object.defineProperties(StructCtor,{ + debugFlags: debugFlags, + isA: rop((v)=>v instanceof StructCtor), + memberKey: __memberKeyProp, + memberKeys: __structMemberKeys, + methodInfoForKey: rop(function(mKey){ + }), + structInfo: rop(structInfo), + structName: rop(structName) + }); + StructCtor.prototype = new StructType(structName, structInfo, rop); + Object.defineProperties(StructCtor.prototype,{ + debugFlags: debugFlags, + constructor: rop(StructCtor) + + }); + Object.keys(structInfo.members).forEach( + (name)=>makeMemberWrapper(StructCtor, name, structInfo.members[name]) + ); + return StructCtor; + }; + StructBinder.StructType = StructType; + StructBinder.config = config; + StructBinder.allocCString = __allocCString; + if(!StructBinder.debugFlags){ + StructBinder.debugFlags = SBF.__makeDebugFlags(SBF.debugFlags); + } + return StructBinder; +}; + + + +globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ + 'use strict'; + const toss = (...args)=>{throw new Error(args.join(' '))}; + const toss3 = sqlite3.SQLite3Error.toss; + const capi = sqlite3.capi, wasm = sqlite3.wasm, util = sqlite3.util; + globalThis.WhWasmUtilInstaller(wasm); + delete globalThis.WhWasmUtilInstaller; + + if(0){ + + + const dealloc = wasm.exports[sqlite3.config.deallocExportName]; + const nFunc = wasm.functionTable().length; + let i; + for(i = 0; i < nFunc; ++i){ + const e = wasm.functionEntry(i); + if(dealloc === e){ + capi.SQLITE_WASM_DEALLOC = i; + break; + } + } + if(dealloc !== wasm.functionEntry(capi.SQLITE_WASM_DEALLOC)){ + toss("Internal error: cannot find function pointer for SQLITE_WASM_DEALLOC."); + } + } + + + wasm.bindingSignatures = [ + + ["sqlite3_aggregate_context","void*", "sqlite3_context*", "int"], + + + ["sqlite3_bind_double","int", "sqlite3_stmt*", "int", "f64"], + ["sqlite3_bind_int","int", "sqlite3_stmt*", "int", "int"], + ["sqlite3_bind_null",undefined, "sqlite3_stmt*", "int"], + ["sqlite3_bind_parameter_count", "int", "sqlite3_stmt*"], + ["sqlite3_bind_parameter_index","int", "sqlite3_stmt*", "string"], + ["sqlite3_bind_pointer", "int", + "sqlite3_stmt*", "int", "*", "string:static", "*"], + ["sqlite3_busy_handler","int", [ + "sqlite3*", + new wasm.xWrap.FuncPtrAdapter({ + signature: 'i(pi)', + contextKey: (argv,argIndex)=>argv[0] + }), + "*" + ]], + ["sqlite3_busy_timeout","int", "sqlite3*", "int"], + + + ["sqlite3_changes", "int", "sqlite3*"], + ["sqlite3_clear_bindings","int", "sqlite3_stmt*"], + ["sqlite3_collation_needed", "int", "sqlite3*", "*", "*"], + ["sqlite3_column_blob","*", "sqlite3_stmt*", "int"], + ["sqlite3_column_bytes","int", "sqlite3_stmt*", "int"], + ["sqlite3_column_count", "int", "sqlite3_stmt*"], + ["sqlite3_column_double","f64", "sqlite3_stmt*", "int"], + ["sqlite3_column_int","int", "sqlite3_stmt*", "int"], + ["sqlite3_column_name","string", "sqlite3_stmt*", "int"], + ["sqlite3_column_text","string", "sqlite3_stmt*", "int"], + ["sqlite3_column_type","int", "sqlite3_stmt*", "int"], + ["sqlite3_column_value","sqlite3_value*", "sqlite3_stmt*", "int"], + ["sqlite3_commit_hook", "void*", [ + "sqlite3*", + new wasm.xWrap.FuncPtrAdapter({ + name: 'sqlite3_commit_hook', + signature: 'i(p)', + contextKey: (argv)=>argv[0] + }), + '*' + ]], + ["sqlite3_compileoption_get", "string", "int"], + ["sqlite3_compileoption_used", "int", "string"], + ["sqlite3_complete", "int", "string:flexible"], + ["sqlite3_context_db_handle", "sqlite3*", "sqlite3_context*"], + + + + ["sqlite3_data_count", "int", "sqlite3_stmt*"], + ["sqlite3_db_filename", "string", "sqlite3*", "string"], + ["sqlite3_db_handle", "sqlite3*", "sqlite3_stmt*"], + ["sqlite3_db_name", "string", "sqlite3*", "int"], + ["sqlite3_db_status", "int", "sqlite3*", "int", "*", "*", "int"], + ["sqlite3_errcode", "int", "sqlite3*"], + ["sqlite3_errmsg", "string", "sqlite3*"], + ["sqlite3_error_offset", "int", "sqlite3*"], + ["sqlite3_errstr", "string", "int"], + ["sqlite3_exec", "int", [ + "sqlite3*", "string:flexible", + new wasm.xWrap.FuncPtrAdapter({ + signature: 'i(pipp)', + bindScope: 'transient', + callProxy: (callback)=>{ + let aNames; + return (pVoid, nCols, pColVals, pColNames)=>{ + try { + const aVals = wasm.cArgvToJs(nCols, pColVals); + if(!aNames) aNames = wasm.cArgvToJs(nCols, pColNames); + return callback(aVals, aNames) | 0; + }catch(e){ + + return e.resultCode || capi.SQLITE_ERROR; + } + } + } + }), + "*", "**" + ]], + ["sqlite3_expanded_sql", "string", "sqlite3_stmt*"], + ["sqlite3_extended_errcode", "int", "sqlite3*"], + ["sqlite3_extended_result_codes", "int", "sqlite3*", "int"], + ["sqlite3_file_control", "int", "sqlite3*", "string", "int", "*"], + ["sqlite3_finalize", "int", "sqlite3_stmt*"], + ["sqlite3_free", undefined,"*"], + ["sqlite3_get_auxdata", "*", "sqlite3_context*", "int"], + ["sqlite3_initialize", undefined], + + ["sqlite3_keyword_count", "int"], + ["sqlite3_keyword_name", "int", ["int", "**", "*"]], + ["sqlite3_keyword_check", "int", ["string", "int"]], + ["sqlite3_libversion", "string"], + ["sqlite3_libversion_number", "int"], + ["sqlite3_limit", "int", ["sqlite3*", "int", "int"]], + ["sqlite3_malloc", "*","int"], + ["sqlite3_open", "int", "string", "*"], + ["sqlite3_open_v2", "int", "string", "*", "int", "string"], + + + ["sqlite3_progress_handler", undefined, [ + "sqlite3*", "int", new wasm.xWrap.FuncPtrAdapter({ + name: 'xProgressHandler', + signature: 'i(p)', + bindScope: 'context', + contextKey: (argv,argIndex)=>argv[0] + }), "*" + ]], + ["sqlite3_realloc", "*","*","int"], + ["sqlite3_reset", "int", "sqlite3_stmt*"], + + ["sqlite3_result_blob", undefined, "sqlite3_context*", "*", "int", "*"], + ["sqlite3_result_double", undefined, "sqlite3_context*", "f64"], + ["sqlite3_result_error", undefined, "sqlite3_context*", "string", "int"], + ["sqlite3_result_error_code", undefined, "sqlite3_context*", "int"], + ["sqlite3_result_error_nomem", undefined, "sqlite3_context*"], + ["sqlite3_result_error_toobig", undefined, "sqlite3_context*"], + ["sqlite3_result_int", undefined, "sqlite3_context*", "int"], + ["sqlite3_result_null", undefined, "sqlite3_context*"], + ["sqlite3_result_pointer", undefined, + "sqlite3_context*", "*", "string:static", "*"], + ["sqlite3_result_subtype", undefined, "sqlite3_value*", "int"], + ["sqlite3_result_text", undefined, "sqlite3_context*", "string", "int", "*"], + ["sqlite3_result_zeroblob", undefined, "sqlite3_context*", "int"], + ["sqlite3_rollback_hook", "void*", [ + "sqlite3*", + new wasm.xWrap.FuncPtrAdapter({ + name: 'sqlite3_rollback_hook', + signature: 'v(p)', + contextKey: (argv)=>argv[0] + }), + '*' + ]], + ["sqlite3_set_authorizer", "int", [ + "sqlite3*", + new wasm.xWrap.FuncPtrAdapter({ + name: "sqlite3_set_authorizer::xAuth", + signature: "i(pi"+"ssss)", + contextKey: (argv, argIndex)=>argv[0], + callProxy: (callback)=>{ + return (pV, iCode, s0, s1, s2, s3)=>{ + try{ + s0 = s0 && wasm.cstrToJs(s0); s1 = s1 && wasm.cstrToJs(s1); + s2 = s2 && wasm.cstrToJs(s2); s3 = s3 && wasm.cstrToJs(s3); + return callback(pV, iCode, s0, s1, s2, s3) || 0; + }catch(e){ + return e.resultCode || capi.SQLITE_ERROR; + } + } + } + }), + "*" + ]], + ["sqlite3_set_auxdata", undefined, [ + "sqlite3_context*", "int", "*", + new wasm.xWrap.FuncPtrAdapter({ + name: 'xDestroyAuxData', + signature: 'v(*)', + contextKey: (argv, argIndex)=>argv[0] + }) + ]], + ["sqlite3_shutdown", undefined], + ["sqlite3_sourceid", "string"], + ["sqlite3_sql", "string", "sqlite3_stmt*"], + ["sqlite3_status", "int", "int", "*", "*", "int"], + ["sqlite3_step", "int", "sqlite3_stmt*"], + ["sqlite3_stmt_isexplain", "int", ["sqlite3_stmt*"]], + ["sqlite3_stmt_readonly", "int", ["sqlite3_stmt*"]], + ["sqlite3_stmt_status", "int", "sqlite3_stmt*", "int", "int"], + ["sqlite3_strglob", "int", "string","string"], + ["sqlite3_stricmp", "int", "string", "string"], + ["sqlite3_strlike", "int", "string", "string","int"], + ["sqlite3_strnicmp", "int", "string", "string", "int"], + ["sqlite3_table_column_metadata", "int", + "sqlite3*", "string", "string", "string", + "**", "**", "*", "*", "*"], + ["sqlite3_total_changes", "int", "sqlite3*"], + ["sqlite3_trace_v2", "int", [ + "sqlite3*", "int", + new wasm.xWrap.FuncPtrAdapter({ + name: 'sqlite3_trace_v2::callback', + signature: 'i(ippp)', + contextKey: (argv,argIndex)=>argv[0] + }), + "*" + ]], + ["sqlite3_txn_state", "int", ["sqlite3*","string"]], + + ["sqlite3_uri_boolean", "int", "sqlite3_filename", "string", "int"], + ["sqlite3_uri_key", "string", "sqlite3_filename", "int"], + ["sqlite3_uri_parameter", "string", "sqlite3_filename", "string"], + ["sqlite3_user_data","void*", "sqlite3_context*"], + ["sqlite3_value_blob", "*", "sqlite3_value*"], + ["sqlite3_value_bytes","int", "sqlite3_value*"], + ["sqlite3_value_double","f64", "sqlite3_value*"], + ["sqlite3_value_dup", "sqlite3_value*", "sqlite3_value*"], + ["sqlite3_value_free", undefined, "sqlite3_value*"], + ["sqlite3_value_frombind", "int", "sqlite3_value*"], + ["sqlite3_value_int","int", "sqlite3_value*"], + ["sqlite3_value_nochange", "int", "sqlite3_value*"], + ["sqlite3_value_numeric_type", "int", "sqlite3_value*"], + ["sqlite3_value_pointer", "*", "sqlite3_value*", "string:static"], + ["sqlite3_value_subtype", "int", "sqlite3_value*"], + ["sqlite3_value_text", "string", "sqlite3_value*"], + ["sqlite3_value_type", "int", "sqlite3_value*"], + ["sqlite3_vfs_find", "*", "string"], + ["sqlite3_vfs_register", "int", "sqlite3_vfs*", "int"], + ["sqlite3_vfs_unregister", "int", "sqlite3_vfs*"] + ]; + + if(false && wasm.compileOptionUsed('SQLITE_ENABLE_NORMALIZE')){ + + wasm.bindingSignatures.push(["sqlite3_normalized_sql", "string", "sqlite3_stmt*"]); + } + + if(wasm.exports.sqlite3_activate_see instanceof Function){ + wasm.bindingSignatures.push( + ["sqlite3_key", "int", "sqlite3*", "string", "int"], + ["sqlite3_key_v2","int","sqlite3*","string","*","int"], + ["sqlite3_rekey", "int", "sqlite3*", "string", "int"], + ["sqlite3_rekey_v2", "int", "sqlite3*", "string", "*", "int"], + ["sqlite3_activate_see", undefined, "string"] + ); + } + + wasm.bindingSignatures.int64 = [ + ["sqlite3_bind_int64","int", ["sqlite3_stmt*", "int", "i64"]], + ["sqlite3_changes64","i64", ["sqlite3*"]], + ["sqlite3_column_int64","i64", ["sqlite3_stmt*", "int"]], + ["sqlite3_create_module", "int", + ["sqlite3*","string","sqlite3_module*","*"]], + ["sqlite3_create_module_v2", "int", + ["sqlite3*","string","sqlite3_module*","*","*"]], + ["sqlite3_declare_vtab", "int", ["sqlite3*", "string:flexible"]], + ["sqlite3_deserialize", "int", "sqlite3*", "string", "*", "i64", "i64", "int"] + , + ["sqlite3_drop_modules", "int", ["sqlite3*", "**"]], + ["sqlite3_last_insert_rowid", "i64", ["sqlite3*"]], + ["sqlite3_malloc64", "*","i64"], + ["sqlite3_msize", "i64", "*"], + ["sqlite3_overload_function", "int", ["sqlite3*","string","int"]], + ["sqlite3_preupdate_blobwrite", "int", "sqlite3*"], + ["sqlite3_preupdate_count", "int", "sqlite3*"], + ["sqlite3_preupdate_depth", "int", "sqlite3*"], + ["sqlite3_preupdate_hook", "*", [ + "sqlite3*", + new wasm.xWrap.FuncPtrAdapter({ + name: 'sqlite3_preupdate_hook', + signature: "v(ppippjj)", + contextKey: (argv)=>argv[0], + callProxy: (callback)=>{ + return (p,db,op,zDb,zTbl,iKey1,iKey2)=>{ + callback(p, db, op, wasm.cstrToJs(zDb), wasm.cstrToJs(zTbl), + iKey1, iKey2); + }; + } + }), + "*" + ]], + ["sqlite3_preupdate_new", "int", ["sqlite3*", "int", "**"]], + ["sqlite3_preupdate_old", "int", ["sqlite3*", "int", "**"]], + ["sqlite3_realloc64", "*","*", "i64"], + ["sqlite3_result_int64", undefined, "*", "i64"], + ["sqlite3_result_zeroblob64", "int", "*", "i64"], + ["sqlite3_serialize","*", "sqlite3*", "string", "*", "int"], + ["sqlite3_set_last_insert_rowid", undefined, ["sqlite3*", "i64"]], + ["sqlite3_status64", "int", "int", "*", "*", "int"], + ["sqlite3_total_changes64", "i64", ["sqlite3*"]], + ["sqlite3_update_hook", "*", [ + "sqlite3*", + new wasm.xWrap.FuncPtrAdapter({ + name: 'sqlite3_update_hook', + signature: "v(iippj)", + contextKey: (argv)=>argv[0], + callProxy: (callback)=>{ + return (p,op,z0,z1,rowid)=>{ + callback(p, op, wasm.cstrToJs(z0), wasm.cstrToJs(z1), rowid); + }; + } + }), + "*" + ]], + ["sqlite3_uri_int64", "i64", ["sqlite3_filename", "string", "i64"]], + ["sqlite3_value_int64","i64", "sqlite3_value*"], + ["sqlite3_vtab_collation","string","sqlite3_index_info*","int"], + ["sqlite3_vtab_distinct","int", "sqlite3_index_info*"], + ["sqlite3_vtab_in","int", "sqlite3_index_info*", "int", "int"], + ["sqlite3_vtab_in_first", "int", "sqlite3_value*", "**"], + ["sqlite3_vtab_in_next", "int", "sqlite3_value*", "**"], + + ["sqlite3_vtab_nochange","int", "sqlite3_context*"], + ["sqlite3_vtab_on_conflict","int", "sqlite3*"], + ["sqlite3_vtab_rhs_value","int", "sqlite3_index_info*", "int", "**"] + ]; + + + if(wasm.bigIntEnabled && !!wasm.exports.sqlite3changegroup_add){ + + + const __ipsProxy = { + signature: 'i(ps)', + callProxy:(callback)=>{ + return (p,s)=>{ + try{return callback(p, wasm.cstrToJs(s)) | 0} + catch(e){return e.resultCode || capi.SQLITE_ERROR} + } + } + }; + + wasm.bindingSignatures.int64.push(...[ + ['sqlite3changegroup_add', 'int', ['sqlite3_changegroup*', 'int', 'void*']], + ['sqlite3changegroup_add_strm', 'int', [ + 'sqlite3_changegroup*', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xInput', signature: 'i(ppp)', bindScope: 'transient' + }), + 'void*' + ]], + ['sqlite3changegroup_delete', undefined, ['sqlite3_changegroup*']], + ['sqlite3changegroup_new', 'int', ['**']], + ['sqlite3changegroup_output', 'int', ['sqlite3_changegroup*', 'int*', '**']], + ['sqlite3changegroup_output_strm', 'int', [ + 'sqlite3_changegroup*', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xOutput', signature: 'i(ppi)', bindScope: 'transient' + }), + 'void*' + ]], + ['sqlite3changeset_apply', 'int', [ + 'sqlite3*', 'int', 'void*', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xFilter', bindScope: 'transient', ...__ipsProxy + }), + new wasm.xWrap.FuncPtrAdapter({ + name: 'xConflict', signature: 'i(pip)', bindScope: 'transient' + }), + 'void*' + ]], + ['sqlite3changeset_apply_strm', 'int', [ + 'sqlite3*', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xInput', signature: 'i(ppp)', bindScope: 'transient' + }), + 'void*', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xFilter', bindScope: 'transient', ...__ipsProxy + }), + new wasm.xWrap.FuncPtrAdapter({ + name: 'xConflict', signature: 'i(pip)', bindScope: 'transient' + }), + 'void*' + ]], + ['sqlite3changeset_apply_v2', 'int', [ + 'sqlite3*', 'int', 'void*', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xFilter', bindScope: 'transient', ...__ipsProxy + }), + new wasm.xWrap.FuncPtrAdapter({ + name: 'xConflict', signature: 'i(pip)', bindScope: 'transient' + }), + 'void*', '**', 'int*', 'int' + + ]], + ['sqlite3changeset_apply_v2_strm', 'int', [ + 'sqlite3*', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xInput', signature: 'i(ppp)', bindScope: 'transient' + }), + 'void*', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xFilter', bindScope: 'transient', ...__ipsProxy + }), + new wasm.xWrap.FuncPtrAdapter({ + name: 'xConflict', signature: 'i(pip)', bindScope: 'transient' + }), + 'void*', '**', 'int*', 'int' + ]], + ['sqlite3changeset_concat', 'int', ['int','void*', 'int', 'void*', 'int*', '**']], + ['sqlite3changeset_concat_strm', 'int', [ + new wasm.xWrap.FuncPtrAdapter({ + name: 'xInputA', signature: 'i(ppp)', bindScope: 'transient' + }), + 'void*', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xInputB', signature: 'i(ppp)', bindScope: 'transient' + }), + 'void*', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xOutput', signature: 'i(ppi)', bindScope: 'transient' + }), + 'void*' + ]], + ['sqlite3changeset_conflict', 'int', ['sqlite3_changeset_iter*', 'int', '**']], + ['sqlite3changeset_finalize', 'int', ['sqlite3_changeset_iter*']], + ['sqlite3changeset_fk_conflicts', 'int', ['sqlite3_changeset_iter*', 'int*']], + ['sqlite3changeset_invert', 'int', ['int', 'void*', 'int*', '**']], + ['sqlite3changeset_invert_strm', 'int', [ + new wasm.xWrap.FuncPtrAdapter({ + name: 'xInput', signature: 'i(ppp)', bindScope: 'transient' + }), + 'void*', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xOutput', signature: 'i(ppi)', bindScope: 'transient' + }), + 'void*' + ]], + ['sqlite3changeset_new', 'int', ['sqlite3_changeset_iter*', 'int', '**']], + ['sqlite3changeset_next', 'int', ['sqlite3_changeset_iter*']], + ['sqlite3changeset_old', 'int', ['sqlite3_changeset_iter*', 'int', '**']], + ['sqlite3changeset_op', 'int', [ + 'sqlite3_changeset_iter*', '**', 'int*', 'int*','int*' + ]], + ['sqlite3changeset_pk', 'int', ['sqlite3_changeset_iter*', '**', 'int*']], + ['sqlite3changeset_start', 'int', ['**', 'int', '*']], + ['sqlite3changeset_start_strm', 'int', [ + '**', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xInput', signature: 'i(ppp)', bindScope: 'transient' + }), + 'void*' + ]], + ['sqlite3changeset_start_v2', 'int', ['**', 'int', '*', 'int']], + ['sqlite3changeset_start_v2_strm', 'int', [ + '**', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xInput', signature: 'i(ppp)', bindScope: 'transient' + }), + 'void*', 'int' + ]], + ['sqlite3session_attach', 'int', ['sqlite3_session*', 'string']], + ['sqlite3session_changeset', 'int', ['sqlite3_session*', 'int*', '**']], + ['sqlite3session_changeset_size', 'i64', ['sqlite3_session*']], + ['sqlite3session_changeset_strm', 'int', [ + 'sqlite3_session*', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xOutput', signature: 'i(ppp)', bindScope: 'transient' + }), + 'void*' + ]], + ['sqlite3session_config', 'int', ['int', 'void*']], + ['sqlite3session_create', 'int', ['sqlite3*', 'string', '**']], + + ['sqlite3session_diff', 'int', ['sqlite3_session*', 'string', 'string', '**']], + ['sqlite3session_enable', 'int', ['sqlite3_session*', 'int']], + ['sqlite3session_indirect', 'int', ['sqlite3_session*', 'int']], + ['sqlite3session_isempty', 'int', ['sqlite3_session*']], + ['sqlite3session_memory_used', 'i64', ['sqlite3_session*']], + ['sqlite3session_object_config', 'int', ['sqlite3_session*', 'int', 'void*']], + ['sqlite3session_patchset', 'int', ['sqlite3_session*', '*', '**']], + ['sqlite3session_patchset_strm', 'int', [ + 'sqlite3_session*', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xOutput', signature: 'i(ppp)', bindScope: 'transient' + }), + 'void*' + ]], + ['sqlite3session_table_filter', undefined, [ + 'sqlite3_session*', + new wasm.xWrap.FuncPtrAdapter({ + name: 'xFilter', ...__ipsProxy, + contextKey: (argv,argIndex)=>argv[0] + }), + '*' + ]] + ]); + } + + + wasm.bindingSignatures.wasm = [ + ["sqlite3_wasm_db_reset", "int", "sqlite3*"], + ["sqlite3_wasm_db_vfs", "sqlite3_vfs*", "sqlite3*","string"], + ["sqlite3_wasm_vfs_create_file", "int", + "sqlite3_vfs*","string","*", "int"], + ["sqlite3_wasm_vfs_unlink", "int", "sqlite3_vfs*","string"] + ]; + + + sqlite3.StructBinder = globalThis.Jaccwabyt({ + heap: 0 ? wasm.memory : wasm.heap8u, + alloc: wasm.alloc, + dealloc: wasm.dealloc, + bigIntEnabled: wasm.bigIntEnabled, + memberPrefix: '$' + }); + delete globalThis.Jaccwabyt; + + { + + + const __xString = wasm.xWrap.argAdapter('string'); + wasm.xWrap.argAdapter( + 'string:flexible', (v)=>__xString(util.flexibleString(v)) + ); + + + wasm.xWrap.argAdapter( + 'string:static', + function(v){ + if(wasm.isPtr(v)) return v; + v = ''+v; + let rc = this[v]; + return rc || (this[v] = wasm.allocCString(v)); + }.bind(Object.create(null)) + ); + + + const __xArgPtr = wasm.xWrap.argAdapter('*'); + const nilType = function(){}; + wasm.xWrap.argAdapter('sqlite3_filename', __xArgPtr) + ('sqlite3_context*', __xArgPtr) + ('sqlite3_value*', __xArgPtr) + ('void*', __xArgPtr) + ('sqlite3_changegroup*', __xArgPtr) + ('sqlite3_changeset_iter*', __xArgPtr) + + ('sqlite3_session*', __xArgPtr) + ('sqlite3_stmt*', (v)=> + __xArgPtr((v instanceof (sqlite3?.oo1?.Stmt || nilType)) + ? v.pointer : v)) + ('sqlite3*', (v)=> + __xArgPtr((v instanceof (sqlite3?.oo1?.DB || nilType)) + ? v.pointer : v)) + ('sqlite3_index_info*', (v)=> + __xArgPtr((v instanceof (capi.sqlite3_index_info || nilType)) + ? v.pointer : v)) + ('sqlite3_module*', (v)=> + __xArgPtr((v instanceof (capi.sqlite3_module || nilType)) + ? v.pointer : v)) + + ('sqlite3_vfs*', (v)=>{ + if('string'===typeof v){ + + return capi.sqlite3_vfs_find(v) + || sqlite3.SQLite3Error.toss( + capi.SQLITE_NOTFOUND, + "Unknown sqlite3_vfs name:", v + ); + } + return __xArgPtr((v instanceof (capi.sqlite3_vfs || nilType)) + ? v.pointer : v); + }); + + const __xRcPtr = wasm.xWrap.resultAdapter('*'); + wasm.xWrap.resultAdapter('sqlite3*', __xRcPtr) + ('sqlite3_context*', __xRcPtr) + ('sqlite3_stmt*', __xRcPtr) + ('sqlite3_value*', __xRcPtr) + ('sqlite3_vfs*', __xRcPtr) + ('void*', __xRcPtr); + + + for(const e of wasm.bindingSignatures){ + capi[e[0]] = wasm.xWrap.apply(null, e); + } + for(const e of wasm.bindingSignatures.wasm){ + wasm[e[0]] = wasm.xWrap.apply(null, e); + } + + + const fI64Disabled = function(fname){ + return ()=>toss(fname+"() is unavailable due to lack", + "of BigInt support in this build."); + }; + for(const e of wasm.bindingSignatures.int64){ + capi[e[0]] = wasm.bigIntEnabled + ? wasm.xWrap.apply(null, e) + : fI64Disabled(e[0]); + } + + + delete wasm.bindingSignatures; + + if(wasm.exports.sqlite3_wasm_db_error){ + const __db_err = wasm.xWrap( + 'sqlite3_wasm_db_error', 'int', 'sqlite3*', 'int', 'string' + ); + + util.sqlite3_wasm_db_error = function(pDb, resultCode, message){ + if(resultCode instanceof sqlite3.WasmAllocError){ + resultCode = capi.SQLITE_NOMEM; + message = 0 ; + }else if(resultCode instanceof Error){ + message = message || ''+resultCode; + resultCode = (resultCode.resultCode || capi.SQLITE_ERROR); + } + return pDb ? __db_err(pDb, resultCode, message) : resultCode; + }; + }else{ + util.sqlite3_wasm_db_error = function(pDb,errCode,msg){ + console.warn("sqlite3_wasm_db_error() is not exported.",arguments); + return errCode; + }; + } + } + + { + const cJson = wasm.xCall('sqlite3_wasm_enum_json'); + if(!cJson){ + toss("Maintenance required: increase sqlite3_wasm_enum_json()'s", + "static buffer size!"); + } + + wasm.ctype = JSON.parse(wasm.cstrToJs(cJson)); + + const defineGroups = ['access', 'authorizer', + 'blobFinalizers', 'changeset', + 'config', 'dataTypes', + 'dbConfig', 'dbStatus', + 'encodings', 'fcntl', 'flock', 'ioCap', + 'limits', 'openFlags', + 'prepareFlags', 'resultCodes', + 'sqlite3Status', + 'stmtStatus', 'syncFlags', + 'trace', 'txnState', 'udfFlags', + 'version' ]; + if(wasm.bigIntEnabled){ + defineGroups.push('serialize', 'session', 'vtab'); + } + for(const t of defineGroups){ + for(const e of Object.entries(wasm.ctype[t])){ + + + capi[e[0]] = e[1]; + } + } + if(!wasm.functionEntry(capi.SQLITE_WASM_DEALLOC)){ + toss("Internal error: cannot resolve exported function", + "entry SQLITE_WASM_DEALLOC (=="+capi.SQLITE_WASM_DEALLOC+")."); + } + const __rcMap = Object.create(null); + for(const t of ['resultCodes']){ + for(const e of Object.entries(wasm.ctype[t])){ + __rcMap[e[1]] = e[0]; + } + } + + capi.sqlite3_js_rc_str = (rc)=>__rcMap[rc]; + + const notThese = Object.assign(Object.create(null),{ + + WasmTestStruct: true, + + sqlite3_kvvfs_methods: !util.isUIThread(), + + sqlite3_index_info: !wasm.bigIntEnabled, + sqlite3_index_constraint: !wasm.bigIntEnabled, + sqlite3_index_orderby: !wasm.bigIntEnabled, + sqlite3_index_constraint_usage: !wasm.bigIntEnabled + }); + for(const s of wasm.ctype.structs){ + if(!notThese[s.name]){ + capi[s.name] = sqlite3.StructBinder(s); + } + } + if(capi.sqlite3_index_info){ + + for(const k of ['sqlite3_index_constraint', + 'sqlite3_index_orderby', + 'sqlite3_index_constraint_usage']){ + capi.sqlite3_index_info[k] = capi[k]; + delete capi[k]; + } + capi.sqlite3_vtab_config = wasm.xWrap( + 'sqlite3_wasm_vtab_config','int',[ + 'sqlite3*', 'int', 'int'] + ); + } + } + + + const __dbArgcMismatch = (pDb,f,n)=>{ + return sqlite3.util.sqlite3_wasm_db_error(pDb, capi.SQLITE_MISUSE, + f+"() requires "+n+" argument"+ + (1===n?"":'s')+"."); + }; + + + const __errEncoding = (pDb)=>{ + return util.sqlite3_wasm_db_error( + pDb, capi.SQLITE_FORMAT, "SQLITE_UTF8 is the only supported encoding." + ); + }; + + + const __argPDb = (pDb)=>wasm.xWrap.argAdapter('sqlite3*')(pDb); + const __argStr = (str)=>wasm.isPtr(str) ? wasm.cstrToJs(str) : str; + const __dbCleanupMap = function( + pDb, mode + ){ + pDb = __argPDb(pDb); + let m = this.dbMap.get(pDb); + if(!mode){ + this.dbMap.delete(pDb); + return m; + }else if(!m && mode>0){ + this.dbMap.set(pDb, (m = Object.create(null))); + } + return m; + }.bind(Object.assign(Object.create(null),{ + dbMap: new Map + })); + + __dbCleanupMap.addCollation = function(pDb, name){ + const m = __dbCleanupMap(pDb, 1); + if(!m.collation) m.collation = new Set; + m.collation.add(__argStr(name).toLowerCase()); + }; + + __dbCleanupMap._addUDF = function(pDb, name, arity, map){ + + name = __argStr(name).toLowerCase(); + let u = map.get(name); + if(!u) map.set(name, (u = new Set)); + u.add((arity<0) ? -1 : arity); + }; + + __dbCleanupMap.addFunction = function(pDb, name, arity){ + const m = __dbCleanupMap(pDb, 1); + if(!m.udf) m.udf = new Map; + this._addUDF(pDb, name, arity, m.udf); + }; + + __dbCleanupMap.addWindowFunc = function(pDb, name, arity){ + const m = __dbCleanupMap(pDb, 1); + if(!m.wudf) m.wudf = new Map; + this._addUDF(pDb, name, arity, m.wudf); + }; + + + __dbCleanupMap.cleanup = function(pDb){ + pDb = __argPDb(pDb); + + + const closeArgs = [pDb]; + for(const name of [ + 'sqlite3_busy_handler', + 'sqlite3_commit_hook', + 'sqlite3_preupdate_hook', + 'sqlite3_progress_handler', + 'sqlite3_rollback_hook', + 'sqlite3_set_authorizer', + 'sqlite3_trace_v2', + 'sqlite3_update_hook' + ]) { + const x = wasm.exports[name]; + closeArgs.length = x.length + ; + try{ capi[name](...closeArgs) } + catch(e){ + console.warn("close-time call of",name+"(",closeArgs,") threw:",e); + } + } + const m = __dbCleanupMap(pDb, 0); + if(!m) return; + if(m.collation){ + for(const name of m.collation){ + try{ + capi.sqlite3_create_collation_v2( + pDb, name, capi.SQLITE_UTF8, 0, 0, 0 + ); + }catch(e){ + + } + } + delete m.collation; + } + let i; + for(i = 0; i < 2; ++i){ + const fmap = i ? m.wudf : m.udf; + if(!fmap) continue; + const func = i + ? capi.sqlite3_create_window_function + : capi.sqlite3_create_function_v2; + for(const e of fmap){ + const name = e[0], arities = e[1]; + const fargs = [pDb, name, 0, capi.SQLITE_UTF8, 0, 0, 0, 0, 0]; + if(i) fargs.push(0); + for(const arity of arities){ + try{ fargs[2] = arity; func.apply(null, fargs); } + catch(e){} + } + arities.clear(); + } + fmap.clear(); + } + delete m.udf; + delete m.wudf; + }; + + { + const __sqlite3CloseV2 = wasm.xWrap("sqlite3_close_v2", "int", "sqlite3*"); + capi.sqlite3_close_v2 = function(pDb){ + if(1!==arguments.length) return __dbArgcMismatch(pDb, 'sqlite3_close_v2', 1); + if(pDb){ + try{__dbCleanupMap.cleanup(pDb)} catch(e){} + } + return __sqlite3CloseV2(pDb); + }; + } + + if(capi.sqlite3session_table_filter){ + const __sqlite3SessionDelete = wasm.xWrap( + 'sqlite3session_delete', undefined, ['sqlite3_session*'] + ); + capi.sqlite3session_delete = function(pSession){ + if(1!==arguments.length){ + return __dbArgcMismatch(pDb, 'sqlite3session_delete', 1); + + } + else if(pSession){ + + capi.sqlite3session_table_filter(pSession, 0, 0); + } + __sqlite3SessionDelete(pSession); + }; + } + + { + + const contextKey = (argv,argIndex)=>{ + return 'argv['+argIndex+']:'+argv[0]+ + ':'+wasm.cstrToJs(argv[1]).toLowerCase() + }; + const __sqlite3CreateCollationV2 = wasm.xWrap( + 'sqlite3_create_collation_v2', 'int', [ + 'sqlite3*', 'string', 'int', '*', + new wasm.xWrap.FuncPtrAdapter({ + + name: 'xCompare', signature: 'i(pipip)', contextKey + }), + new wasm.xWrap.FuncPtrAdapter({ + + name: 'xDestroy', signature: 'v(p)', contextKey + }) + ] + ); + + + capi.sqlite3_create_collation_v2 = function(pDb,zName,eTextRep,pArg,xCompare,xDestroy){ + if(6!==arguments.length) return __dbArgcMismatch(pDb, 'sqlite3_create_collation_v2', 6); + else if( 0 === (eTextRep & 0xf) ){ + eTextRep |= capi.SQLITE_UTF8; + }else if( capi.SQLITE_UTF8 !== (eTextRep & 0xf) ){ + return __errEncoding(pDb); + } + try{ + const rc = __sqlite3CreateCollationV2(pDb, zName, eTextRep, pArg, xCompare, xDestroy); + if(0===rc && xCompare instanceof Function){ + __dbCleanupMap.addCollation(pDb, zName); + } + return rc; + }catch(e){ + return util.sqlite3_wasm_db_error(pDb, e); + } + }; + + capi.sqlite3_create_collation = (pDb,zName,eTextRep,pArg,xCompare)=>{ + return (5===arguments.length) + ? capi.sqlite3_create_collation_v2(pDb,zName,eTextRep,pArg,xCompare,0) + : __dbArgcMismatch(pDb, 'sqlite3_create_collation', 5); + }; + + } + + { + + const contextKey = function(argv,argIndex){ + return ( + argv[0] + +':'+(argv[2] < 0 ? -1 : argv[2]) + +':'+argIndex + +':'+wasm.cstrToJs(argv[1]).toLowerCase() + ) + }; + + + const __cfProxy = Object.assign(Object.create(null), { + xInverseAndStep: { + signature:'v(pip)', contextKey, + callProxy: (callback)=>{ + return (pCtx, argc, pArgv)=>{ + try{ callback(pCtx, ...capi.sqlite3_values_to_js(argc, pArgv)) } + catch(e){ capi.sqlite3_result_error_js(pCtx, e) } + }; + } + }, + xFinalAndValue: { + signature:'v(p)', contextKey, + callProxy: (callback)=>{ + return (pCtx)=>{ + try{ capi.sqlite3_result_js(pCtx, callback(pCtx)) } + catch(e){ capi.sqlite3_result_error_js(pCtx, e) } + }; + } + }, + xFunc: { + signature:'v(pip)', contextKey, + callProxy: (callback)=>{ + return (pCtx, argc, pArgv)=>{ + try{ + capi.sqlite3_result_js( + pCtx, + callback(pCtx, ...capi.sqlite3_values_to_js(argc, pArgv)) + ); + }catch(e){ + + capi.sqlite3_result_error_js(pCtx, e); + } + }; + } + }, + xDestroy: { + signature:'v(p)', contextKey, + + callProxy: (callback)=>{ + return (pVoid)=>{ + try{ callback(pVoid) } + catch(e){ console.error("UDF xDestroy method threw:",e) } + }; + } + } + }); + + const __sqlite3CreateFunction = wasm.xWrap( + "sqlite3_create_function_v2", "int", [ + "sqlite3*", "string", "int", + "int", "*", + new wasm.xWrap.FuncPtrAdapter({name: 'xFunc', ...__cfProxy.xFunc}), + new wasm.xWrap.FuncPtrAdapter({name: 'xStep', ...__cfProxy.xInverseAndStep}), + new wasm.xWrap.FuncPtrAdapter({name: 'xFinal', ...__cfProxy.xFinalAndValue}), + new wasm.xWrap.FuncPtrAdapter({name: 'xDestroy', ...__cfProxy.xDestroy}) + ] + ); + + const __sqlite3CreateWindowFunction = wasm.xWrap( + "sqlite3_create_window_function", "int", [ + "sqlite3*", "string", "int", + "int", "*", + new wasm.xWrap.FuncPtrAdapter({name: 'xStep', ...__cfProxy.xInverseAndStep}), + new wasm.xWrap.FuncPtrAdapter({name: 'xFinal', ...__cfProxy.xFinalAndValue}), + new wasm.xWrap.FuncPtrAdapter({name: 'xValue', ...__cfProxy.xFinalAndValue}), + new wasm.xWrap.FuncPtrAdapter({name: 'xInverse', ...__cfProxy.xInverseAndStep}), + new wasm.xWrap.FuncPtrAdapter({name: 'xDestroy', ...__cfProxy.xDestroy}) + ] + ); + + + capi.sqlite3_create_function_v2 = function f( + pDb, funcName, nArg, eTextRep, pApp, + xFunc, + xStep, + xFinal, + xDestroy + ){ + if( f.length!==arguments.length ){ + return __dbArgcMismatch(pDb,"sqlite3_create_function_v2",f.length); + }else if( 0 === (eTextRep & 0xf) ){ + eTextRep |= capi.SQLITE_UTF8; + }else if( capi.SQLITE_UTF8 !== (eTextRep & 0xf) ){ + return __errEncoding(pDb); + } + try{ + const rc = __sqlite3CreateFunction(pDb, funcName, nArg, eTextRep, + pApp, xFunc, xStep, xFinal, xDestroy); + if(0===rc && (xFunc instanceof Function + || xStep instanceof Function + || xFinal instanceof Function + || xDestroy instanceof Function)){ + __dbCleanupMap.addFunction(pDb, funcName, nArg); + } + return rc; + }catch(e){ + console.error("sqlite3_create_function_v2() setup threw:",e); + return util.sqlite3_wasm_db_error(pDb, e, "Creation of UDF threw: "+e); + } + }; + + + capi.sqlite3_create_function = function f( + pDb, funcName, nArg, eTextRep, pApp, + xFunc, xStep, xFinal + ){ + return (f.length===arguments.length) + ? capi.sqlite3_create_function_v2(pDb, funcName, nArg, eTextRep, + pApp, xFunc, xStep, xFinal, 0) + : __dbArgcMismatch(pDb,"sqlite3_create_function",f.length); + }; + + + capi.sqlite3_create_window_function = function f( + pDb, funcName, nArg, eTextRep, pApp, + xStep, + xFinal, + xValue, + xInverse, + xDestroy + ){ + if( f.length!==arguments.length ){ + return __dbArgcMismatch(pDb,"sqlite3_create_window_function",f.length); + }else if( 0 === (eTextRep & 0xf) ){ + eTextRep |= capi.SQLITE_UTF8; + }else if( capi.SQLITE_UTF8 !== (eTextRep & 0xf) ){ + return __errEncoding(pDb); + } + try{ + const rc = __sqlite3CreateWindowFunction(pDb, funcName, nArg, eTextRep, + pApp, xStep, xFinal, xValue, + xInverse, xDestroy); + if(0===rc && (xStep instanceof Function + || xFinal instanceof Function + || xValue instanceof Function + || xInverse instanceof Function + || xDestroy instanceof Function)){ + __dbCleanupMap.addWindowFunc(pDb, funcName, nArg); + } + return rc; + }catch(e){ + console.error("sqlite3_create_window_function() setup threw:",e); + return util.sqlite3_wasm_db_error(pDb, e, "Creation of UDF threw: "+e); + } + }; + + capi.sqlite3_create_function_v2.udfSetResult = + capi.sqlite3_create_function.udfSetResult = + capi.sqlite3_create_window_function.udfSetResult = capi.sqlite3_result_js; + + + capi.sqlite3_create_function_v2.udfConvertArgs = + capi.sqlite3_create_function.udfConvertArgs = + capi.sqlite3_create_window_function.udfConvertArgs = capi.sqlite3_values_to_js; + + + capi.sqlite3_create_function_v2.udfSetError = + capi.sqlite3_create_function.udfSetError = + capi.sqlite3_create_window_function.udfSetError = capi.sqlite3_result_error_js; + + }; + + { + + + const __flexiString = (v,n)=>{ + if('string'===typeof v){ + n = -1; + }else if(util.isSQLableTypedArray(v)){ + n = v.byteLength; + v = util.typedArrayToString( + (v instanceof ArrayBuffer) ? new Uint8Array(v) : v + ); + }else if(Array.isArray(v)){ + v = v.join(""); + n = -1; + } + return [v, n]; + }; + + + const __prepare = { + + basic: wasm.xWrap('sqlite3_prepare_v3', + "int", ["sqlite3*", "string", + "int", + "int", "**", + "**"]), + + full: wasm.xWrap('sqlite3_prepare_v3', + "int", ["sqlite3*", "*", "int", "int", + "**", "**"]) + }; + + + capi.sqlite3_prepare_v3 = function f(pDb, sql, sqlLen, prepFlags, ppStmt, pzTail){ + if(f.length!==arguments.length){ + return __dbArgcMismatch(pDb,"sqlite3_prepare_v3",f.length); + } + const [xSql, xSqlLen] = __flexiString(sql, sqlLen); + switch(typeof xSql){ + case 'string': return __prepare.basic(pDb, xSql, xSqlLen, prepFlags, ppStmt, null); + case 'number': return __prepare.full(pDb, xSql, xSqlLen, prepFlags, ppStmt, pzTail); + default: + return util.sqlite3_wasm_db_error( + pDb, capi.SQLITE_MISUSE, + "Invalid SQL argument type for sqlite3_prepare_v2/v3()." + ); + } + }; + + + capi.sqlite3_prepare_v2 = function f(pDb, sql, sqlLen, ppStmt, pzTail){ + return (f.length===arguments.length) + ? capi.sqlite3_prepare_v3(pDb, sql, sqlLen, 0, ppStmt, pzTail) + : __dbArgcMismatch(pDb,"sqlite3_prepare_v2",f.length); + }; + + } + + { + const __bindText = wasm.xWrap("sqlite3_bind_text", "int", [ + "sqlite3_stmt*", "int", "string", "int", "*" + ]); + const __bindBlob = wasm.xWrap("sqlite3_bind_blob", "int", [ + "sqlite3_stmt*", "int", "*", "int", "*" + ]); + + + capi.sqlite3_bind_text = function f(pStmt, iCol, text, nText, xDestroy){ + if(f.length!==arguments.length){ + return __dbArgcMismatch(capi.sqlite3_db_handle(pStmt), + "sqlite3_bind_text", f.length); + }else if(wasm.isPtr(text) || null===text){ + return __bindText(pStmt, iCol, text, nText, xDestroy); + }else if(text instanceof ArrayBuffer){ + text = new Uint8Array(text); + }else if(Array.isArray(pMem)){ + text = pMem.join(''); + } + let p, n; + try{ + if(util.isSQLableTypedArray(text)){ + p = wasm.allocFromTypedArray(text); + n = text.byteLength; + }else if('string'===typeof text){ + [p, n] = wasm.allocCString(text); + }else{ + return util.sqlite3_wasm_db_error( + capi.sqlite3_db_handle(pStmt), capi.SQLITE_MISUSE, + "Invalid 3rd argument type for sqlite3_bind_text()." + ); + } + return __bindText(pStmt, iCol, p, n, capi.SQLITE_WASM_DEALLOC); + }catch(e){ + wasm.dealloc(p); + return util.sqlite3_wasm_db_error( + capi.sqlite3_db_handle(pStmt), e + ); + } + }; + + + capi.sqlite3_bind_blob = function f(pStmt, iCol, pMem, nMem, xDestroy){ + if(f.length!==arguments.length){ + return __dbArgcMismatch(capi.sqlite3_db_handle(pStmt), + "sqlite3_bind_blob", f.length); + }else if(wasm.isPtr(pMem) || null===pMem){ + return __bindBlob(pStmt, iCol, pMem, nMem, xDestroy); + }else if(pMem instanceof ArrayBuffer){ + pMem = new Uint8Array(pMem); + }else if(Array.isArray(pMem)){ + pMem = pMem.join(''); + } + let p, n; + try{ + if(util.isBindableTypedArray(pMem)){ + p = wasm.allocFromTypedArray(pMem); + n = nMem>=0 ? nMem : pMem.byteLength; + }else if('string'===typeof pMem){ + [p, n] = wasm.allocCString(pMem); + }else{ + return util.sqlite3_wasm_db_error( + capi.sqlite3_db_handle(pStmt), capi.SQLITE_MISUSE, + "Invalid 3rd argument type for sqlite3_bind_blob()." + ); + } + return __bindBlob(pStmt, iCol, p, n, capi.SQLITE_WASM_DEALLOC); + }catch(e){ + wasm.dealloc(p); + return util.sqlite3_wasm_db_error( + capi.sqlite3_db_handle(pStmt), e + ); + } + }; + + } + + { + + capi.sqlite3_config = function(op, ...args){ + if(arguments.length<2) return capi.SQLITE_MISUSE; + switch(op){ + case capi.SQLITE_CONFIG_COVERING_INDEX_SCAN: + case capi.SQLITE_CONFIG_MEMSTATUS: + case capi.SQLITE_CONFIG_SMALL_MALLOC: + case capi.SQLITE_CONFIG_SORTERREF_SIZE: + case capi.SQLITE_CONFIG_STMTJRNL_SPILL: + case capi.SQLITE_CONFIG_URI: + return wasm.exports.sqlite3_wasm_config_i(op, args[0]); + case capi.SQLITE_CONFIG_LOOKASIDE: + return wasm.exports.sqlite3_wasm_config_ii(op, args[0], args[1]); + case capi.SQLITE_CONFIG_MEMDB_MAXSIZE: + return wasm.exports.sqlite3_wasm_config_j(op, args[0]); + case capi.SQLITE_CONFIG_GETMALLOC: + case capi.SQLITE_CONFIG_GETMUTEX: + case capi.SQLITE_CONFIG_GETPCACHE2: + case capi.SQLITE_CONFIG_GETPCACHE: + case capi.SQLITE_CONFIG_HEAP: + case capi.SQLITE_CONFIG_LOG: + case capi.SQLITE_CONFIG_MALLOC: + case capi.SQLITE_CONFIG_MMAP_SIZE: + case capi.SQLITE_CONFIG_MULTITHREAD: + case capi.SQLITE_CONFIG_MUTEX: + case capi.SQLITE_CONFIG_PAGECACHE: + case capi.SQLITE_CONFIG_PCACHE2: + case capi.SQLITE_CONFIG_PCACHE: + case capi.SQLITE_CONFIG_PCACHE_HDRSZ: + case capi.SQLITE_CONFIG_PMASZ: + case capi.SQLITE_CONFIG_SERIALIZED: + case capi.SQLITE_CONFIG_SINGLETHREAD: + case capi.SQLITE_CONFIG_SQLLOG: + case capi.SQLITE_CONFIG_WIN32_HEAPSIZE: + default: + return capi.SQLITE_NOTFOUND; + } + }; + } + + { + const __autoExtFptr = new Set; + + capi.sqlite3_auto_extension = function(fPtr){ + if( fPtr instanceof Function ){ + fPtr = wasm.installFunction('i(ppp)', fPtr); + }else if( 1!==arguments.length || !wasm.isPtr(fPtr) ){ + return capi.SQLITE_MISUSE; + } + const rc = wasm.exports.sqlite3_auto_extension(fPtr); + if( fPtr!==arguments[0] ){ + if(0===rc) __autoExtFptr.add(fPtr); + else wasm.uninstallFunction(fPtr); + } + return rc; + }; + + capi.sqlite3_cancel_auto_extension = function(fPtr){ + ; + if(!fPtr || 1!==arguments.length || !wasm.isPtr(fPtr)) return 0; + return wasm.exports.sqlite3_cancel_auto_extension(fPtr); + + }; + + capi.sqlite3_reset_auto_extension = function(){ + wasm.exports.sqlite3_reset_auto_extension(); + for(const fp of __autoExtFptr) wasm.uninstallFunction(fp); + __autoExtFptr.clear(); + }; + } + + const pKvvfs = capi.sqlite3_vfs_find("kvvfs"); + if( pKvvfs ){ + if(util.isUIThread()){ + const kvvfsMethods = new capi.sqlite3_kvvfs_methods( + wasm.exports.sqlite3_wasm_kvvfs_methods() + ); + delete capi.sqlite3_kvvfs_methods; + + const kvvfsMakeKey = wasm.exports.sqlite3_wasm_kvvfsMakeKeyOnPstack, + pstack = wasm.pstack; + + const kvvfsStorage = (zClass)=> + ((115===wasm.peek(zClass)) + ? sessionStorage : localStorage); + + + const kvvfsImpls = { + xRead: (zClass, zKey, zBuf, nBuf)=>{ + const stack = pstack.pointer, + astack = wasm.scopedAllocPush(); + try { + const zXKey = kvvfsMakeKey(zClass,zKey); + if(!zXKey) return -3; + const jKey = wasm.cstrToJs(zXKey); + const jV = kvvfsStorage(zClass).getItem(jKey); + if(!jV) return -1; + const nV = jV.length ; + if(nBuf<=0) return nV; + else if(1===nBuf){ + wasm.poke(zBuf, 0); + return nV; + } + const zV = wasm.scopedAllocCString(jV); + if(nBuf > nV + 1) nBuf = nV + 1; + wasm.heap8u().copyWithin(zBuf, zV, zV + nBuf - 1); + wasm.poke(zBuf + nBuf - 1, 0); + return nBuf - 1; + }catch(e){ + console.error("kvstorageRead()",e); + return -2; + }finally{ + pstack.restore(stack); + wasm.scopedAllocPop(astack); + } + }, + xWrite: (zClass, zKey, zData)=>{ + const stack = pstack.pointer; + try { + const zXKey = kvvfsMakeKey(zClass,zKey); + if(!zXKey) return 1; + const jKey = wasm.cstrToJs(zXKey); + kvvfsStorage(zClass).setItem(jKey, wasm.cstrToJs(zData)); + return 0; + }catch(e){ + console.error("kvstorageWrite()",e); + return capi.SQLITE_IOERR; + }finally{ + pstack.restore(stack); + } + }, + xDelete: (zClass, zKey)=>{ + const stack = pstack.pointer; + try { + const zXKey = kvvfsMakeKey(zClass,zKey); + if(!zXKey) return 1; + kvvfsStorage(zClass).removeItem(wasm.cstrToJs(zXKey)); + return 0; + }catch(e){ + console.error("kvstorageDelete()",e); + return capi.SQLITE_IOERR; + }finally{ + pstack.restore(stack); + } + } + }; + for(const k of Object.keys(kvvfsImpls)){ + kvvfsMethods[kvvfsMethods.memberKey(k)] = + wasm.installFunction( + kvvfsMethods.memberSignature(k), + kvvfsImpls[k] + ); + } + }else{ + + capi.sqlite3_vfs_unregister(pKvvfs); + } + } + + wasm.xWrap.FuncPtrAdapter.warnOnUse = true; +}); + + +globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ + sqlite3.version = {"libVersion": "3.42.0", "libVersionNumber": 3042000, "sourceId": "2023-05-16 12:36:15 831d0fb2836b71c9bc51067c49fee4b8f18047814f2ff22d817d25195cf350b0","downloadVersion": 3420000}; +}); + + + +globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ + const toss = (...args)=>{throw new Error(args.join(' '))}; + const toss3 = (...args)=>{throw new sqlite3.SQLite3Error(...args)}; + + const capi = sqlite3.capi, wasm = sqlite3.wasm, util = sqlite3.util; + + + + const __ptrMap = new WeakMap(); + + const __stmtMap = new WeakMap(); + + + const getOwnOption = (opts, p, dflt)=>{ + const d = Object.getOwnPropertyDescriptor(opts,p); + return d ? d.value : dflt; + }; + + + const checkSqlite3Rc = function(dbPtr, sqliteResultCode){ + if(sqliteResultCode){ + if(dbPtr instanceof DB) dbPtr = dbPtr.pointer; + toss3( + "sqlite3 result code",sqliteResultCode+":", + (dbPtr + ? capi.sqlite3_errmsg(dbPtr) + : capi.sqlite3_errstr(sqliteResultCode)) + ); + } + return arguments[0]; + }; + + + const __dbTraceToConsole = + wasm.installFunction('i(ippp)', function(t,c,p,x){ + if(capi.SQLITE_TRACE_STMT===t){ + + console.log("SQL TRACE #"+(++this.counter)+' via sqlite3@'+c+':', + wasm.cstrToJs(x)); + } + }.bind({counter: 0})); + + + const __vfsPostOpenSql = Object.create(null); + + + const dbCtorHelper = function ctor(...args){ + if(!ctor._name2vfs){ + + ctor._name2vfs = Object.create(null); + const isWorkerThread = ('function'===typeof importScripts) + ? (n)=>toss3("The VFS for",n,"is only available in the main window thread.") + : false; + ctor._name2vfs[':localStorage:'] = { + vfs: 'kvvfs', filename: isWorkerThread || (()=>'local') + }; + ctor._name2vfs[':sessionStorage:'] = { + vfs: 'kvvfs', filename: isWorkerThread || (()=>'session') + }; + } + const opt = ctor.normalizeArgs(...args); + let fn = opt.filename, vfsName = opt.vfs, flagsStr = opt.flags; + if(('string'!==typeof fn && 'number'!==typeof fn) + || 'string'!==typeof flagsStr + || (vfsName && ('string'!==typeof vfsName && 'number'!==typeof vfsName))){ + sqlite3.config.error("Invalid DB ctor args",opt,arguments); + toss3("Invalid arguments for DB constructor."); + } + let fnJs = ('number'===typeof fn) ? wasm.cstrToJs(fn) : fn; + const vfsCheck = ctor._name2vfs[fnJs]; + if(vfsCheck){ + vfsName = vfsCheck.vfs; + fn = fnJs = vfsCheck.filename(fnJs); + } + let pDb, oflags = 0; + if( flagsStr.indexOf('c')>=0 ){ + oflags |= capi.SQLITE_OPEN_CREATE | capi.SQLITE_OPEN_READWRITE; + } + if( flagsStr.indexOf('w')>=0 ) oflags |= capi.SQLITE_OPEN_READWRITE; + if( 0===oflags ) oflags |= capi.SQLITE_OPEN_READONLY; + oflags |= capi.SQLITE_OPEN_EXRESCODE; + const stack = wasm.pstack.pointer; + try { + const pPtr = wasm.pstack.allocPtr() ; + let rc = capi.sqlite3_open_v2(fn, pPtr, oflags, vfsName || 0); + pDb = wasm.peekPtr(pPtr); + checkSqlite3Rc(pDb, rc); + capi.sqlite3_extended_result_codes(pDb, 1); + if(flagsStr.indexOf('t')>=0){ + capi.sqlite3_trace_v2(pDb, capi.SQLITE_TRACE_STMT, + __dbTraceToConsole, pDb); + } + }catch( e ){ + if( pDb ) capi.sqlite3_close_v2(pDb); + throw e; + }finally{ + wasm.pstack.restore(stack); + } + this.filename = fnJs; + __ptrMap.set(this, pDb); + __stmtMap.set(this, Object.create(null)); + try{ + + const pVfs = capi.sqlite3_js_db_vfs(pDb); + if(!pVfs) toss3("Internal error: cannot get VFS for new db handle."); + const postInitSql = __vfsPostOpenSql[pVfs]; + if(postInitSql instanceof Function){ + postInitSql(this, sqlite3); + }else if(postInitSql){ + checkSqlite3Rc( + pDb, capi.sqlite3_exec(pDb, postInitSql, 0, 0, 0) + ); + } + }catch(e){ + this.close(); + throw e; + } + }; + + + dbCtorHelper.setVfsPostOpenSql = function(pVfs, sql){ + __vfsPostOpenSql[pVfs] = sql; + }; + + + dbCtorHelper.normalizeArgs = function(filename=':memory:',flags = 'c',vfs = null){ + const arg = {}; + if(1===arguments.length && arguments[0] && 'object'===typeof arguments[0]){ + Object.assign(arg, arguments[0]); + if(undefined===arg.flags) arg.flags = 'c'; + if(undefined===arg.vfs) arg.vfs = null; + if(undefined===arg.filename) arg.filename = ':memory:'; + }else{ + arg.filename = filename; + arg.flags = flags; + arg.vfs = vfs; + } + return arg; + }; + + const DB = function(...args){ + dbCtorHelper.apply(this, args); + }; + DB.dbCtorHelper = dbCtorHelper; + + + const BindTypes = { + null: 1, + number: 2, + string: 3, + boolean: 4, + blob: 5 + }; + BindTypes['undefined'] == BindTypes.null; + if(wasm.bigIntEnabled){ + BindTypes.bigint = BindTypes.number; + } + + + const Stmt = function(){ + if(BindTypes!==arguments[2]){ + toss3(capi.SQLITE_MISUSE, "Do not call the Stmt constructor directly. Use DB.prepare()."); + } + this.db = arguments[0]; + __ptrMap.set(this, arguments[1]); + this.columnCount = capi.sqlite3_column_count(this.pointer); + this.parameterCount = capi.sqlite3_bind_parameter_count(this.pointer); + }; + + + const affirmDbOpen = function(db){ + if(!db.pointer) toss3("DB has been closed."); + return db; + }; + + + const affirmColIndex = function(stmt,ndx){ + if((ndx !== (ndx|0)) || ndx<0 || ndx>=stmt.columnCount){ + toss3("Column index",ndx,"is out of range."); + } + return stmt; + }; + + + const parseExecArgs = function(db, args){ + const out = Object.create(null); + out.opt = Object.create(null); + switch(args.length){ + case 1: + if('string'===typeof args[0] || util.isSQLableTypedArray(args[0])){ + out.sql = args[0]; + }else if(Array.isArray(args[0])){ + out.sql = args[0]; + }else if(args[0] && 'object'===typeof args[0]){ + out.opt = args[0]; + out.sql = out.opt.sql; + } + break; + case 2: + out.sql = args[0]; + out.opt = args[1]; + break; + default: toss3("Invalid argument count for exec()."); + }; + out.sql = util.flexibleString(out.sql); + if('string'!==typeof out.sql){ + toss3("Missing SQL argument or unsupported SQL value type."); + } + const opt = out.opt; + switch(opt.returnValue){ + case 'resultRows': + if(!opt.resultRows) opt.resultRows = []; + out.returnVal = ()=>opt.resultRows; + break; + case 'saveSql': + if(!opt.saveSql) opt.saveSql = []; + out.returnVal = ()=>opt.saveSql; + break; + case undefined: + case 'this': + out.returnVal = ()=>db; + break; + default: + toss3("Invalid returnValue value:",opt.returnValue); + } + if(!opt.callback && !opt.returnValue && undefined!==opt.rowMode){ + if(!opt.resultRows) opt.resultRows = []; + out.returnVal = ()=>opt.resultRows; + } + if(opt.callback || opt.resultRows){ + switch((undefined===opt.rowMode) + ? 'array' : opt.rowMode) { + case 'object': out.cbArg = (stmt)=>stmt.get(Object.create(null)); break; + case 'array': out.cbArg = (stmt)=>stmt.get([]); break; + case 'stmt': + if(Array.isArray(opt.resultRows)){ + toss3("exec(): invalid rowMode for a resultRows array: must", + "be one of 'array', 'object',", + "a result column number, or column name reference."); + } + out.cbArg = (stmt)=>stmt; + break; + default: + if(util.isInt32(opt.rowMode)){ + out.cbArg = (stmt)=>stmt.get(opt.rowMode); + break; + }else if('string'===typeof opt.rowMode + && opt.rowMode.length>1 + && '$'===opt.rowMode[0]){ + + const $colName = opt.rowMode.substr(1); + out.cbArg = (stmt)=>{ + const rc = stmt.get(Object.create(null))[$colName]; + return (undefined===rc) + ? toss3(capi.SQLITE_NOTFOUND, + "exec(): unknown result column:",$colName) + : rc; + }; + break; + } + toss3("Invalid rowMode:",opt.rowMode); + } + } + return out; + }; + + + const __selectFirstRow = (db, sql, bind, ...getArgs)=>{ + const stmt = db.prepare(sql); + try { + return stmt.bind(bind).step() ? stmt.get(...getArgs) : undefined; + }finally{ + stmt.finalize(); + } + }; + + + const __selectAll = + (db, sql, bind, rowMode)=>db.exec({ + sql, bind, rowMode, returnValue: 'resultRows' + }); + + + DB.checkRc = (db,resultCode)=>checkSqlite3Rc(db,resultCode); + + DB.prototype = { + + isOpen: function(){ + return !!this.pointer; + }, + + affirmOpen: function(){ + return affirmDbOpen(this); + }, + + close: function(){ + if(this.pointer){ + if(this.onclose && (this.onclose.before instanceof Function)){ + try{this.onclose.before(this)} + catch(e){} + } + const pDb = this.pointer; + Object.keys(__stmtMap.get(this)).forEach((k,s)=>{ + if(s && s.pointer) s.finalize(); + }); + __ptrMap.delete(this); + __stmtMap.delete(this); + capi.sqlite3_close_v2(pDb); + if(this.onclose && (this.onclose.after instanceof Function)){ + try{this.onclose.after(this)} + catch(e){} + } + delete this.filename; + } + }, + + changes: function(total=false,sixtyFour=false){ + const p = affirmDbOpen(this).pointer; + if(total){ + return sixtyFour + ? capi.sqlite3_total_changes64(p) + : capi.sqlite3_total_changes(p); + }else{ + return sixtyFour + ? capi.sqlite3_changes64(p) + : capi.sqlite3_changes(p); + } + }, + + dbFilename: function(dbName='main'){ + return capi.sqlite3_db_filename(affirmDbOpen(this).pointer, dbName); + }, + + dbName: function(dbNumber=0){ + return capi.sqlite3_db_name(affirmDbOpen(this).pointer, dbNumber); + }, + + dbVfsName: function(dbName=0){ + let rc; + const pVfs = capi.sqlite3_js_db_vfs( + affirmDbOpen(this).pointer, dbName + ); + if(pVfs){ + const v = new capi.sqlite3_vfs(pVfs); + try{ rc = wasm.cstrToJs(v.$zName) } + finally { v.dispose() } + } + return rc; + }, + + prepare: function(sql){ + affirmDbOpen(this); + const stack = wasm.pstack.pointer; + let ppStmt, pStmt; + try{ + ppStmt = wasm.pstack.alloc(8); + DB.checkRc(this, capi.sqlite3_prepare_v2(this.pointer, sql, -1, ppStmt, null)); + pStmt = wasm.peekPtr(ppStmt); + } + finally { + wasm.pstack.restore(stack); + } + if(!pStmt) toss3("Cannot prepare empty SQL."); + const stmt = new Stmt(this, pStmt, BindTypes); + __stmtMap.get(this)[pStmt] = stmt; + return stmt; + }, + + exec: function(){ + affirmDbOpen(this); + const arg = parseExecArgs(this, arguments); + if(!arg.sql){ + return toss3("exec() requires an SQL string."); + } + const opt = arg.opt; + const callback = opt.callback; + const resultRows = + Array.isArray(opt.resultRows) ? opt.resultRows : undefined; + let stmt; + let bind = opt.bind; + let evalFirstResult = !!( + arg.cbArg || opt.columnNames || resultRows + ) ; + const stack = wasm.scopedAllocPush(); + const saveSql = Array.isArray(opt.saveSql) ? opt.saveSql : undefined; + try{ + const isTA = util.isSQLableTypedArray(arg.sql) + ; + + let sqlByteLen = isTA ? arg.sql.byteLength : wasm.jstrlen(arg.sql); + const ppStmt = wasm.scopedAlloc( + + (2 * wasm.ptrSizeof) + (sqlByteLen + 1) + ); + const pzTail = ppStmt + wasm.ptrSizeof ; + let pSql = pzTail + wasm.ptrSizeof; + const pSqlEnd = pSql + sqlByteLen; + if(isTA) wasm.heap8().set(arg.sql, pSql); + else wasm.jstrcpy(arg.sql, wasm.heap8(), pSql, sqlByteLen, false); + wasm.poke(pSql + sqlByteLen, 0); + while(pSql && wasm.peek(pSql, 'i8') + ){ + wasm.pokePtr([ppStmt, pzTail], 0); + DB.checkRc(this, capi.sqlite3_prepare_v3( + this.pointer, pSql, sqlByteLen, 0, ppStmt, pzTail + )); + const pStmt = wasm.peekPtr(ppStmt); + pSql = wasm.peekPtr(pzTail); + sqlByteLen = pSqlEnd - pSql; + if(!pStmt) continue; + if(saveSql) saveSql.push(capi.sqlite3_sql(pStmt).trim()); + stmt = new Stmt(this, pStmt, BindTypes); + if(bind && stmt.parameterCount){ + stmt.bind(bind); + bind = null; + } + if(evalFirstResult && stmt.columnCount){ + + evalFirstResult = false; + if(Array.isArray(opt.columnNames)){ + stmt.getColumnNames(opt.columnNames); + } + if(arg.cbArg || resultRows){ + for(; stmt.step(); stmt._isLocked = false){ + stmt._isLocked = true; + const row = arg.cbArg(stmt); + if(resultRows) resultRows.push(row); + if(callback && false === callback.call(opt, row, stmt)){ + break; + } + } + stmt._isLocked = false; + } + }else{ + stmt.step(); + } + stmt.finalize(); + stmt = null; + } + }finally{ + if(stmt){ + delete stmt._isLocked; + stmt.finalize(); + } + wasm.scopedAllocPop(stack); + } + return arg.returnVal(); + }, + + + createFunction: function f(name, xFunc, opt){ + const isFunc = (f)=>(f instanceof Function); + switch(arguments.length){ + case 1: + opt = name; + name = opt.name; + xFunc = opt.xFunc || 0; + break; + case 2: + if(!isFunc(xFunc)){ + opt = xFunc; + xFunc = opt.xFunc || 0; + } + break; + case 3: + break; + default: break; + } + if(!opt) opt = {}; + if('string' !== typeof name){ + toss3("Invalid arguments: missing function name."); + } + let xStep = opt.xStep || 0; + let xFinal = opt.xFinal || 0; + const xValue = opt.xValue || 0; + const xInverse = opt.xInverse || 0; + let isWindow = undefined; + if(isFunc(xFunc)){ + isWindow = false; + if(isFunc(xStep) || isFunc(xFinal)){ + toss3("Ambiguous arguments: scalar or aggregate?"); + } + xStep = xFinal = null; + }else if(isFunc(xStep)){ + if(!isFunc(xFinal)){ + toss3("Missing xFinal() callback for aggregate or window UDF."); + } + xFunc = null; + }else if(isFunc(xFinal)){ + toss3("Missing xStep() callback for aggregate or window UDF."); + }else{ + toss3("Missing function-type properties."); + } + if(false === isWindow){ + if(isFunc(xValue) || isFunc(xInverse)){ + toss3("xValue and xInverse are not permitted for non-window UDFs."); + } + }else if(isFunc(xValue)){ + if(!isFunc(xInverse)){ + toss3("xInverse must be provided if xValue is."); + } + isWindow = true; + }else if(isFunc(xInverse)){ + toss3("xValue must be provided if xInverse is."); + } + const pApp = opt.pApp; + if(undefined!==pApp && + null!==pApp && + (('number'!==typeof pApp) || !util.isInt32(pApp))){ + toss3("Invalid value for pApp property. Must be a legal WASM pointer value."); + } + const xDestroy = opt.xDestroy || 0; + if(xDestroy && !isFunc(xDestroy)){ + toss3("xDestroy property must be a function."); + } + let fFlags = 0 ; + if(getOwnOption(opt, 'deterministic')) fFlags |= capi.SQLITE_DETERMINISTIC; + if(getOwnOption(opt, 'directOnly')) fFlags |= capi.SQLITE_DIRECTONLY; + if(getOwnOption(opt, 'innocuous')) fFlags |= capi.SQLITE_INNOCUOUS; + name = name.toLowerCase(); + const xArity = xFunc || xStep; + const arity = getOwnOption(opt, 'arity'); + const arityArg = ('number'===typeof arity + ? arity + : (xArity.length ? xArity.length-1 : 0)); + let rc; + if( isWindow ){ + rc = capi.sqlite3_create_window_function( + this.pointer, name, arityArg, + capi.SQLITE_UTF8 | fFlags, pApp || 0, + xStep, xFinal, xValue, xInverse, xDestroy); + }else{ + rc = capi.sqlite3_create_function_v2( + this.pointer, name, arityArg, + capi.SQLITE_UTF8 | fFlags, pApp || 0, + xFunc, xStep, xFinal, xDestroy); + } + DB.checkRc(this, rc); + return this; + }, + + selectValue: function(sql,bind,asType){ + return __selectFirstRow(this, sql, bind, 0, asType); + }, + + + selectValues: function(sql,bind,asType){ + const stmt = this.prepare(sql), rc = []; + try { + stmt.bind(bind); + while(stmt.step()) rc.push(stmt.get(0,asType)); + }finally{ + stmt.finalize(); + } + return rc; + }, + + + selectArray: function(sql,bind){ + return __selectFirstRow(this, sql, bind, []); + }, + + + selectObject: function(sql,bind){ + return __selectFirstRow(this, sql, bind, {}); + }, + + + selectArrays: function(sql,bind){ + return __selectAll(this, sql, bind, 'array'); + }, + + + selectObjects: function(sql,bind){ + return __selectAll(this, sql, bind, 'object'); + }, + + + openStatementCount: function(){ + return this.pointer ? Object.keys(__stmtMap.get(this)).length : 0; + }, + + + transaction: function(callback){ + let opener = 'BEGIN'; + if(arguments.length>1){ + if(/[^a-zA-Z]/.test(arguments[0])){ + toss3(capi.SQLITE_MISUSE, "Invalid argument for BEGIN qualifier."); + } + opener += ' '+arguments[0]; + callback = arguments[1]; + } + affirmDbOpen(this).exec(opener); + try { + const rc = callback(this); + this.exec("COMMIT"); + return rc; + }catch(e){ + this.exec("ROLLBACK"); + throw e; + } + }, + + + savepoint: function(callback){ + affirmDbOpen(this).exec("SAVEPOINT oo1"); + try { + const rc = callback(this); + this.exec("RELEASE oo1"); + return rc; + }catch(e){ + this.exec("ROLLBACK to SAVEPOINT oo1; RELEASE SAVEPOINT oo1"); + throw e; + } + }, + + + checkRc: function(resultCode){ + return DB.checkRc(this, resultCode); + } + }; + + + + const affirmStmtOpen = function(stmt){ + if(!stmt.pointer) toss3("Stmt has been closed."); + return stmt; + }; + + + const isSupportedBindType = function(v){ + let t = BindTypes[(null===v||undefined===v) ? 'null' : typeof v]; + switch(t){ + case BindTypes.boolean: + case BindTypes.null: + case BindTypes.number: + case BindTypes.string: + return t; + case BindTypes.bigint: + if(wasm.bigIntEnabled) return t; + + default: + return util.isBindableTypedArray(v) ? BindTypes.blob : undefined; + } + }; + + + const affirmSupportedBindType = function(v){ + + return isSupportedBindType(v) || toss3("Unsupported bind() argument type:",typeof v); + }; + + + const affirmParamIndex = function(stmt,key){ + const n = ('number'===typeof key) + ? key : capi.sqlite3_bind_parameter_index(stmt.pointer, key); + if(0===n || !util.isInt32(n)){ + toss3("Invalid bind() parameter name: "+key); + } + else if(n<1 || n>stmt.parameterCount) toss3("Bind index",key,"is out of range."); + return n; + }; + + + const affirmUnlocked = function(stmt,currentOpName){ + if(stmt._isLocked){ + toss3("Operation is illegal when statement is locked:",currentOpName); + } + return stmt; + }; + + + const bindOne = function f(stmt,ndx,bindType,val){ + affirmUnlocked(affirmStmtOpen(stmt), 'bind()'); + if(!f._){ + f._tooBigInt = (v)=>toss3( + "BigInt value is too big to store without precision loss:", v + ); + + f._ = { + string: function(stmt, ndx, val, asBlob){ + const [pStr, n] = wasm.allocCString(val, true); + const f = asBlob ? capi.sqlite3_bind_blob : capi.sqlite3_bind_text; + return f(stmt.pointer, ndx, pStr, n, capi.SQLITE_WASM_DEALLOC); + } + }; + } + affirmSupportedBindType(val); + ndx = affirmParamIndex(stmt,ndx); + let rc = 0; + switch((null===val || undefined===val) ? BindTypes.null : bindType){ + case BindTypes.null: + rc = capi.sqlite3_bind_null(stmt.pointer, ndx); + break; + case BindTypes.string: + rc = f._.string(stmt, ndx, val, false); + break; + case BindTypes.number: { + let m; + if(util.isInt32(val)) m = capi.sqlite3_bind_int; + else if('bigint'===typeof val){ + if(!util.bigIntFits64(val)){ + f._tooBigInt(val); + }else if(wasm.bigIntEnabled){ + m = capi.sqlite3_bind_int64; + }else if(util.bigIntFitsDouble(val)){ + val = Number(val); + m = capi.sqlite3_bind_double; + }else{ + f._tooBigInt(val); + } + }else{ + val = Number(val); + if(wasm.bigIntEnabled && Number.isInteger(val)){ + m = capi.sqlite3_bind_int64; + }else{ + m = capi.sqlite3_bind_double; + } + } + rc = m(stmt.pointer, ndx, val); + break; + } + case BindTypes.boolean: + rc = capi.sqlite3_bind_int(stmt.pointer, ndx, val ? 1 : 0); + break; + case BindTypes.blob: { + if('string'===typeof val){ + rc = f._.string(stmt, ndx, val, true); + break; + }else if(val instanceof ArrayBuffer){ + val = new Uint8Array(val); + }else if(!util.isBindableTypedArray(val)){ + toss3("Binding a value as a blob requires", + "that it be a string, Uint8Array, Int8Array, or ArrayBuffer."); + } + const pBlob = wasm.alloc(val.byteLength || 1); + wasm.heap8().set(val.byteLength ? val : [0], pBlob) + rc = capi.sqlite3_bind_blob(stmt.pointer, ndx, pBlob, val.byteLength, + capi.SQLITE_WASM_DEALLOC); + break; + } + default: + sqlite3.config.warn("Unsupported bind() argument type:",val); + toss3("Unsupported bind() argument type: "+(typeof val)); + } + if(rc) DB.checkRc(stmt.db.pointer, rc); + stmt._mayGet = false; + return stmt; + }; + + Stmt.prototype = { + + finalize: function(){ + if(this.pointer){ + affirmUnlocked(this,'finalize()'); + delete __stmtMap.get(this.db)[this.pointer]; + capi.sqlite3_finalize(this.pointer); + __ptrMap.delete(this); + delete this._mayGet; + delete this.columnCount; + delete this.parameterCount; + delete this.db; + delete this._isLocked; + } + }, + + clearBindings: function(){ + affirmUnlocked(affirmStmtOpen(this), 'clearBindings()') + capi.sqlite3_clear_bindings(this.pointer); + this._mayGet = false; + return this; + }, + + reset: function(alsoClearBinds){ + affirmUnlocked(this,'reset()'); + if(alsoClearBinds) this.clearBindings(); + capi.sqlite3_reset(affirmStmtOpen(this).pointer); + this._mayGet = false; + return this; + }, + + bind: function(){ + affirmStmtOpen(this); + let ndx, arg; + switch(arguments.length){ + case 1: ndx = 1; arg = arguments[0]; break; + case 2: ndx = arguments[0]; arg = arguments[1]; break; + default: toss3("Invalid bind() arguments."); + } + if(undefined===arg){ + + return this; + }else if(!this.parameterCount){ + toss3("This statement has no bindable parameters."); + } + this._mayGet = false; + if(null===arg){ + + return bindOne(this, ndx, BindTypes.null, arg); + } + else if(Array.isArray(arg)){ + + if(1!==arguments.length){ + toss3("When binding an array, an index argument is not permitted."); + } + arg.forEach((v,i)=>bindOne(this, i+1, affirmSupportedBindType(v), v)); + return this; + }else if(arg instanceof ArrayBuffer){ + arg = new Uint8Array(arg); + } + if('object'===typeof arg + && !util.isBindableTypedArray(arg)){ + + if(1!==arguments.length){ + toss3("When binding an object, an index argument is not permitted."); + } + Object.keys(arg) + .forEach(k=>bindOne(this, k, + affirmSupportedBindType(arg[k]), + arg[k])); + return this; + }else{ + return bindOne(this, ndx, affirmSupportedBindType(arg), arg); + } + toss3("Should not reach this point."); + }, + + bindAsBlob: function(ndx,arg){ + affirmStmtOpen(this); + if(1===arguments.length){ + arg = ndx; + ndx = 1; + } + const t = affirmSupportedBindType(arg); + if(BindTypes.string !== t && BindTypes.blob !== t + && BindTypes.null !== t){ + toss3("Invalid value type for bindAsBlob()"); + } + return bindOne(this, ndx, BindTypes.blob, arg); + }, + + step: function(){ + affirmUnlocked(this, 'step()'); + const rc = capi.sqlite3_step(affirmStmtOpen(this).pointer); + switch(rc){ + case capi.SQLITE_DONE: return this._mayGet = false; + case capi.SQLITE_ROW: return this._mayGet = true; + default: + this._mayGet = false; + sqlite3.config.warn("sqlite3_step() rc=",rc, + capi.sqlite3_js_rc_str(rc), + "SQL =", capi.sqlite3_sql(this.pointer)); + DB.checkRc(this.db.pointer, rc); + } + }, + + stepReset: function(){ + this.step(); + return this.reset(); + }, + + stepFinalize: function(){ + const rc = this.step(); + this.finalize(); + return rc; + }, + + get: function(ndx,asType){ + if(!affirmStmtOpen(this)._mayGet){ + toss3("Stmt.step() has not (recently) returned true."); + } + if(Array.isArray(ndx)){ + let i = 0; + while(i=Number.MIN_SAFE_INTEGER && rc<=Number.MAX_SAFE_INTEGER){ + + return Number(rc).valueOf(); + } + return rc; + }else{ + const rc = capi.sqlite3_column_double(this.pointer, ndx); + if(rc>Number.MAX_SAFE_INTEGER || rctoss3("The pointer property is read-only.") + } + Object.defineProperty(Stmt.prototype, 'pointer', prop); + Object.defineProperty(DB.prototype, 'pointer', prop); + } + + + sqlite3.oo1 = { + DB, + Stmt + }; + + if(util.isUIThread()){ + + sqlite3.oo1.JsStorageDb = function(storageName='session'){ + if('session'!==storageName && 'local'!==storageName){ + toss3("JsStorageDb db name must be one of 'session' or 'local'."); + } + dbCtorHelper.call(this, { + filename: storageName, + flags: 'c', + vfs: "kvvfs" + }); + }; + const jdb = sqlite3.oo1.JsStorageDb; + jdb.prototype = Object.create(DB.prototype); + + jdb.clearStorage = capi.sqlite3_js_kvvfs_clear; + + jdb.prototype.clearStorage = function(){ + return jdb.clearStorage(affirmDbOpen(this).filename); + }; + + jdb.storageSize = capi.sqlite3_js_kvvfs_size; + + jdb.prototype.storageSize = function(){ + return jdb.storageSize(affirmDbOpen(this).filename); + }; + } + +}); + + + + + + +globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ +sqlite3.initWorker1API = function(){ + 'use strict'; + const toss = (...args)=>{throw new Error(args.join(' '))}; + if(!(globalThis.WorkerGlobalScope instanceof Function)){ + toss("initWorker1API() must be run from a Worker thread."); + } + const self = this.self; + const sqlite3 = this.sqlite3 || toss("Missing this.sqlite3 object."); + const DB = sqlite3.oo1.DB; + + + const getDbId = function(db){ + let id = wState.idMap.get(db); + if(id) return id; + id = 'db#'+(++wState.idSeq)+'@'+db.pointer; + + wState.idMap.set(db, id); + return id; + }; + + + const wState = { + + dbList: [], + + idSeq: 0, + + idMap: new WeakMap, + + xfer: [], + open: function(opt){ + const db = new DB(opt); + this.dbs[getDbId(db)] = db; + if(this.dbList.indexOf(db)<0) this.dbList.push(db); + return db; + }, + close: function(db,alsoUnlink){ + if(db){ + delete this.dbs[getDbId(db)]; + const filename = db.filename; + const pVfs = sqlite3.wasm.sqlite3_wasm_db_vfs(db.pointer, 0); + db.close(); + const ddNdx = this.dbList.indexOf(db); + if(ddNdx>=0) this.dbList.splice(ddNdx, 1); + if(alsoUnlink && filename && pVfs){ + sqlite3.wasm.sqlite3_wasm_vfs_unlink(pVfs, filename); + } + } + }, + + post: function(msg,xferList){ + if(xferList && xferList.length){ + globalThis.postMessage( msg, Array.from(xferList) ); + xferList.length = 0; + }else{ + globalThis.postMessage(msg); + } + }, + + dbs: Object.create(null), + + getDb: function(id,require=true){ + return this.dbs[id] + || (require ? toss("Unknown (or closed) DB ID:",id) : undefined); + } + }; + + + const affirmDbOpen = function(db = wState.dbList[0]){ + return (db && db.pointer) ? db : toss("DB is not opened."); + }; + + + const getMsgDb = function(msgData,affirmExists=true){ + const db = wState.getDb(msgData.dbId,false) || wState.dbList[0]; + return affirmExists ? affirmDbOpen(db) : db; + }; + + const getDefaultDbId = function(){ + return wState.dbList[0] && getDbId(wState.dbList[0]); + }; + + const guessVfs = function(filename){ + const m = /^file:.+(vfs=(\w+))/.exec(filename); + return sqlite3.capi.sqlite3_vfs_find(m ? m[2] : 0); + }; + + const isSpecialDbFilename = (n)=>{ + return ""===n || ':'===n[0]; + }; + + + const wMsgHandler = { + open: function(ev){ + const oargs = Object.create(null), args = (ev.args || Object.create(null)); + if(args.simulateError){ + toss("Throwing because of simulateError flag."); + } + const rc = Object.create(null); + let byteArray, pVfs; + oargs.vfs = args.vfs; + if(isSpecialDbFilename(args.filename)){ + oargs.filename = args.filename || ""; + }else{ + oargs.filename = args.filename; + byteArray = args.byteArray; + if(byteArray) pVfs = guessVfs(args.filename); + } + if(pVfs){ + + let pMem; + try{ + pMem = sqlite3.wasm.allocFromTypedArray(byteArray); + const rc = sqlite3.wasm.sqlite3_wasm_vfs_create_file( + pVfs, oargs.filename, pMem, byteArray.byteLength + ); + if(rc) sqlite3.SQLite3Error.toss(rc); + }catch(e){ + throw new sqlite3.SQLite3Error( + e.name+' creating '+args.filename+": "+e.message, { + cause: e + } + ); + }finally{ + if(pMem) sqlite3.wasm.dealloc(pMem); + } + } + const db = wState.open(oargs); + rc.filename = db.filename; + rc.persistent = !!sqlite3.capi.sqlite3_js_db_uses_vfs(db.pointer, "opfs"); + rc.dbId = getDbId(db); + rc.vfs = db.dbVfsName(); + return rc; + }, + + close: function(ev){ + const db = getMsgDb(ev,false); + const response = { + filename: db && db.filename + }; + if(db){ + const doUnlink = ((ev.args && 'object'===typeof ev.args) + ? !!ev.args.unlink : false); + wState.close(db, doUnlink); + } + return response; + }, + + exec: function(ev){ + const rc = ( + 'string'===typeof ev.args + ) ? {sql: ev.args} : (ev.args || Object.create(null)); + if('stmt'===rc.rowMode){ + toss("Invalid rowMode for 'exec': stmt mode", + "does not work in the Worker API."); + }else if(!rc.sql){ + toss("'exec' requires input SQL."); + } + const db = getMsgDb(ev); + if(rc.callback || Array.isArray(rc.resultRows)){ + + db._blobXfer = wState.xfer; + } + const theCallback = rc.callback; + let rowNumber = 0; + const hadColNames = !!rc.columnNames; + if('string' === typeof theCallback){ + if(!hadColNames) rc.columnNames = []; + + rc.callback = function(row,stmt){ + wState.post({ + type: theCallback, + columnNames: rc.columnNames, + rowNumber: ++rowNumber, + row: row + }, wState.xfer); + } + } + try { + db.exec(rc); + if(rc.callback instanceof Function){ + rc.callback = theCallback; + + wState.post({ + type: theCallback, + columnNames: rc.columnNames, + rowNumber: null , + row: undefined + }); + } + }finally{ + delete db._blobXfer; + if(rc.callback) rc.callback = theCallback; + } + return rc; + }, + + 'config-get': function(){ + const rc = Object.create(null), src = sqlite3.config; + [ + 'bigIntEnabled' + ].forEach(function(k){ + if(Object.getOwnPropertyDescriptor(src, k)) rc[k] = src[k]; + }); + rc.version = sqlite3.version; + rc.vfsList = sqlite3.capi.sqlite3_js_vfs_list(); + rc.opfsEnabled = !!sqlite3.opfs; + return rc; + }, + + + export: function(ev){ + const db = getMsgDb(ev); + const response = { + byteArray: sqlite3.capi.sqlite3_js_db_export(db.pointer), + filename: db.filename, + mimetype: 'application/x-sqlite3' + }; + wState.xfer.push(response.byteArray.buffer); + return response; + }, + + toss: function(ev){ + toss("Testing worker exception"); + }, + + 'opfs-tree': async function(ev){ + if(!sqlite3.opfs) toss("OPFS support is unavailable."); + const response = await sqlite3.opfs.treeList(); + return response; + } + }; + + globalThis.onmessage = async function(ev){ + ev = ev.data; + let result, dbId = ev.dbId, evType = ev.type; + const arrivalTime = performance.now(); + try { + if(wMsgHandler.hasOwnProperty(evType) && + wMsgHandler[evType] instanceof Function){ + result = await wMsgHandler[evType](ev); + }else{ + toss("Unknown db worker message type:",ev.type); + } + }catch(err){ + evType = 'error'; + result = { + operation: ev.type, + message: err.message, + errorClass: err.name, + input: ev + }; + if(err.stack){ + result.stack = ('string'===typeof err.stack) + ? err.stack.split(/\n\s*/) : err.stack; + } + if(0) sqlite3.config.warn("Worker is propagating an exception to main thread.", + "Reporting it _here_ for the stack trace:",err,result); + } + if(!dbId){ + dbId = result.dbId + || getDefaultDbId(); + } + + + wState.post({ + type: evType, + dbId: dbId, + messageId: ev.messageId, + workerReceivedTime: arrivalTime, + workerRespondTime: performance.now(), + departureTime: ev.departureTime, + + + + + + + result: result + }, wState.xfer); + }; + globalThis.postMessage({type:'sqlite3-api',result:'worker1-ready'}); +}.bind({self, sqlite3}); +}); + + + + + +'use strict'; +globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ + const wasm = sqlite3.wasm, capi = sqlite3.capi, toss = sqlite3.util.toss3; + const vfs = Object.create(null), vtab = Object.create(null); + + const StructBinder = sqlite3.StructBinder + ; + sqlite3.vfs = vfs; + sqlite3.vtab = vtab; + + const sii = capi.sqlite3_index_info; + + sii.prototype.nthConstraint = function(n, asPtr=false){ + if(n<0 || n>=this.$nConstraint) return false; + const ptr = this.$aConstraint + ( + sii.sqlite3_index_constraint.structInfo.sizeof * n + ); + return asPtr ? ptr : new sii.sqlite3_index_constraint(ptr); + }; + + + sii.prototype.nthConstraintUsage = function(n, asPtr=false){ + if(n<0 || n>=this.$nConstraint) return false; + const ptr = this.$aConstraintUsage + ( + sii.sqlite3_index_constraint_usage.structInfo.sizeof * n + ); + return asPtr ? ptr : new sii.sqlite3_index_constraint_usage(ptr); + }; + + + sii.prototype.nthOrderBy = function(n, asPtr=false){ + if(n<0 || n>=this.$nOrderBy) return false; + const ptr = this.$aOrderBy + ( + sii.sqlite3_index_orderby.structInfo.sizeof * n + ); + return asPtr ? ptr : new sii.sqlite3_index_orderby(ptr); + }; + + + const installMethod = function callee( + tgt, name, func, applyArgcCheck = callee.installMethodArgcCheck + ){ + if(!(tgt instanceof StructBinder.StructType)){ + toss("Usage error: target object is-not-a StructType."); + }else if(!(func instanceof Function) && !wasm.isPtr(func)){ + toss("Usage errror: expecting a Function or WASM pointer to one."); + } + if(1===arguments.length){ + return (n,f)=>callee(tgt, n, f, applyArgcCheck); + } + if(!callee.argcProxy){ + callee.argcProxy = function(tgt, funcName, func,sig){ + return function(...args){ + if(func.length!==arguments.length){ + toss("Argument mismatch for", + tgt.structInfo.name+"::"+funcName + +": Native signature is:",sig); + } + return func.apply(this, args); + } + }; + + callee.removeFuncList = function(){ + if(this.ondispose.__removeFuncList){ + this.ondispose.__removeFuncList.forEach( + (v,ndx)=>{ + if('number'===typeof v){ + try{wasm.uninstallFunction(v)} + catch(e){} + } + + } + ); + delete this.ondispose.__removeFuncList; + } + }; + } + const sigN = tgt.memberSignature(name); + if(sigN.length<2){ + toss("Member",name,"does not have a function pointer signature:",sigN); + } + const memKey = tgt.memberKey(name); + const fProxy = (applyArgcCheck && !wasm.isPtr(func)) + + ? callee.argcProxy(tgt, memKey, func, sigN) + : func; + if(wasm.isPtr(fProxy)){ + if(fProxy && !wasm.functionEntry(fProxy)){ + toss("Pointer",fProxy,"is not a WASM function table entry."); + } + tgt[memKey] = fProxy; + }else{ + const pFunc = wasm.installFunction(fProxy, tgt.memberSignature(name, true)); + tgt[memKey] = pFunc; + if(!tgt.ondispose || !tgt.ondispose.__removeFuncList){ + tgt.addOnDispose('ondispose.__removeFuncList handler', + callee.removeFuncList); + tgt.ondispose.__removeFuncList = []; + } + tgt.ondispose.__removeFuncList.push(memKey, pFunc); + } + return (n,f)=>callee(tgt, n, f, applyArgcCheck); + }; + installMethod.installMethodArgcCheck = false; + + + const installMethods = function( + structInstance, methods, applyArgcCheck = installMethod.installMethodArgcCheck + ){ + const seen = new Map ; + for(const k of Object.keys(methods)){ + const m = methods[k]; + const prior = seen.get(m); + if(prior){ + const mkey = structInstance.memberKey(k); + structInstance[mkey] = structInstance[structInstance.memberKey(prior)]; + }else{ + installMethod(structInstance, k, m, applyArgcCheck); + seen.set(m, k); + } + } + return structInstance; + }; + + + StructBinder.StructType.prototype.installMethod = function callee( + name, func, applyArgcCheck = installMethod.installMethodArgcCheck + ){ + return (arguments.length < 3 && name && 'object'===typeof name) + ? installMethods(this, ...arguments) + : installMethod(this, ...arguments); + }; + + + StructBinder.StructType.prototype.installMethods = function( + methods, applyArgcCheck = installMethod.installMethodArgcCheck + ){ + return installMethods(this, methods, applyArgcCheck); + }; + + + capi.sqlite3_vfs.prototype.registerVfs = function(asDefault=false){ + if(!(this instanceof sqlite3.capi.sqlite3_vfs)){ + toss("Expecting a sqlite3_vfs-type argument."); + } + const rc = capi.sqlite3_vfs_register(this, asDefault ? 1 : 0); + if(rc){ + toss("sqlite3_vfs_register(",this,") failed with rc",rc); + } + if(this.pointer !== capi.sqlite3_vfs_find(this.$zName)){ + toss("BUG: sqlite3_vfs_find(vfs.$zName) failed for just-installed VFS", + this); + } + return this; + }; + + + vfs.installVfs = function(opt){ + let count = 0; + const propList = ['io','vfs']; + for(const key of propList){ + const o = opt[key]; + if(o){ + ++count; + installMethods(o.struct, o.methods, !!o.applyArgcCheck); + if('vfs'===key){ + if(!o.struct.$zName && 'string'===typeof o.name){ + o.struct.addOnDispose( + o.struct.$zName = wasm.allocCString(o.name) + ); + } + o.struct.registerVfs(!!o.asDefault); + } + } + } + if(!count) toss("Misuse: installVfs() options object requires at least", + "one of:", propList); + return this; + }; + + + const __xWrapFactory = function(methodName,StructType){ + return function(ptr,removeMapping=false){ + if(0===arguments.length) ptr = new StructType; + if(ptr instanceof StructType){ + + this.set(ptr.pointer, ptr); + return ptr; + }else if(!wasm.isPtr(ptr)){ + sqlite3.SQLite3Error.toss("Invalid argument to",methodName+"()"); + } + let rc = this.get(ptr); + if(removeMapping) this.delete(ptr); + return rc; + }.bind(new Map); + }; + + + const StructPtrMapper = function(name, StructType){ + const __xWrap = __xWrapFactory(name,StructType); + + return Object.assign(Object.create(null),{ + + StructType, + + create: (ppOut)=>{ + const rc = __xWrap(); + wasm.pokePtr(ppOut, rc.pointer); + return rc; + }, + + get: (pCObj)=>__xWrap(pCObj), + + unget: (pCObj)=>__xWrap(pCObj,true), + + dispose: (pCObj)=>{ + const o = __xWrap(pCObj,true); + if(o) o.dispose(); + } + }); + }; + + + vtab.xVtab = StructPtrMapper('xVtab', capi.sqlite3_vtab); + + + vtab.xCursor = StructPtrMapper('xCursor', capi.sqlite3_vtab_cursor); + + + vtab.xIndexInfo = (pIdxInfo)=>new capi.sqlite3_index_info(pIdxInfo); + + + + + + vtab.xError = function f(methodName, err, defaultRc){ + if(f.errorReporter instanceof Function){ + try{f.errorReporter("sqlite3_module::"+methodName+"(): "+err.message);} + catch(e){} + } + let rc; + if(err instanceof sqlite3.WasmAllocError) rc = capi.SQLITE_NOMEM; + else if(arguments.length>2) rc = defaultRc; + else if(err instanceof sqlite3.SQLite3Error) rc = err.resultCode; + return rc || capi.SQLITE_ERROR; + }; + vtab.xError.errorReporter = 1 ? console.error.bind(console) : false; + + + + + + vtab.xRowid = (ppRowid64, value)=>wasm.poke(ppRowid64, value, 'i64'); + + + vtab.setupModule = function(opt){ + let createdMod = false; + const mod = (this instanceof capi.sqlite3_module) + ? this : (opt.struct || (createdMod = new capi.sqlite3_module())); + try{ + const methods = opt.methods || toss("Missing 'methods' object."); + for(const e of Object.entries({ + + + xConnect: 'xCreate', xDisconnect: 'xDestroy' + })){ + + const k = e[0], v = e[1]; + if(true === methods[k]) methods[k] = methods[v]; + else if(true === methods[v]) methods[v] = methods[k]; + } + if(opt.catchExceptions){ + const fwrap = function(methodName, func){ + if(['xConnect','xCreate'].indexOf(methodName) >= 0){ + return function(pDb, pAux, argc, argv, ppVtab, pzErr){ + try{return func(...arguments) || 0} + catch(e){ + if(!(e instanceof sqlite3.WasmAllocError)){ + wasm.dealloc(wasm.peekPtr(pzErr)); + wasm.pokePtr(pzErr, wasm.allocCString(e.message)); + } + return vtab.xError(methodName, e); + } + }; + }else{ + return function(...args){ + try{return func(...args) || 0} + catch(e){ + return vtab.xError(methodName, e); + } + }; + } + }; + const mnames = [ + 'xCreate', 'xConnect', 'xBestIndex', 'xDisconnect', + 'xDestroy', 'xOpen', 'xClose', 'xFilter', 'xNext', + 'xEof', 'xColumn', 'xRowid', 'xUpdate', + 'xBegin', 'xSync', 'xCommit', 'xRollback', + 'xFindFunction', 'xRename', 'xSavepoint', 'xRelease', + 'xRollbackTo', 'xShadowName' + ]; + const remethods = Object.create(null); + for(const k of mnames){ + const m = methods[k]; + if(!(m instanceof Function)) continue; + else if('xConnect'===k && methods.xCreate===m){ + remethods[k] = methods.xCreate; + }else if('xCreate'===k && methods.xConnect===m){ + remethods[k] = methods.xConnect; + }else{ + remethods[k] = fwrap(k, m); + } + } + installMethods(mod, remethods, false); + }else{ + + + installMethods( + mod, methods, !!opt.applyArgcCheck + ); + } + if(0===mod.$iVersion){ + let v; + if('number'===typeof opt.iVersion) v = opt.iVersion; + else if(mod.$xShadowName) v = 3; + else if(mod.$xSavePoint || mod.$xRelease || mod.$xRollbackTo) v = 2; + else v = 1; + mod.$iVersion = v; + } + }catch(e){ + if(createdMod) createdMod.dispose(); + throw e; + } + return mod; + }; + + + capi.sqlite3_module.prototype.setupModule = function(opt){ + return vtab.setupModule.call(this, opt); + }; +}); + + + +'use strict'; +globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ + +const installOpfsVfs = function callee(options){ + if(!globalThis.SharedArrayBuffer + || !globalThis.Atomics){ + return Promise.reject( + new Error("Cannot install OPFS: Missing SharedArrayBuffer and/or Atomics. "+ + "The server must emit the COOP/COEP response headers to enable those. "+ + "See https://sqlite.org/wasm/doc/trunk/persistence.md#coop-coep") + ); + }else if('undefined'===typeof WorkerGlobalScope){ + return Promise.reject( + new Error("The OPFS sqlite3_vfs cannot run in the main thread "+ + "because it requires Atomics.wait().") + ); + }else if(!globalThis.FileSystemHandle || + !globalThis.FileSystemDirectoryHandle || + !globalThis.FileSystemFileHandle || + !globalThis.FileSystemFileHandle.prototype.createSyncAccessHandle || + !navigator?.storage?.getDirectory){ + return Promise.reject( + new Error("Missing required OPFS APIs.") + ); + } + if(!options || 'object'!==typeof options){ + options = Object.create(null); + } + const urlParams = new URL(globalThis.location.href).searchParams; + if(undefined===options.verbose){ + options.verbose = urlParams.has('opfs-verbose') + ? (+urlParams.get('opfs-verbose') || 2) : 1; + } + if(undefined===options.sanityChecks){ + options.sanityChecks = urlParams.has('opfs-sanity-check'); + } + if(undefined===options.proxyUri){ + options.proxyUri = callee.defaultProxyUri; + } + + + + if('function' === typeof options.proxyUri){ + options.proxyUri = options.proxyUri(); + } + const thePromise = new Promise(function(promiseResolve_, promiseReject_){ + const loggers = { + 0:sqlite3.config.error, + 1:sqlite3.config.warn, + 2:sqlite3.config.log + }; + const logImpl = (level,...args)=>{ + if(options.verbose>level) loggers[level]("OPFS syncer:",...args); + }; + const log = (...args)=>logImpl(2, ...args); + const warn = (...args)=>logImpl(1, ...args); + const error = (...args)=>logImpl(0, ...args); + const toss = sqlite3.util.toss; + const capi = sqlite3.capi; + const wasm = sqlite3.wasm; + const sqlite3_vfs = capi.sqlite3_vfs; + const sqlite3_file = capi.sqlite3_file; + const sqlite3_io_methods = capi.sqlite3_io_methods; + + const opfsUtil = Object.create(null); + + + const thisThreadHasOPFS = ()=>{ + return globalThis.FileSystemHandle && + globalThis.FileSystemDirectoryHandle && + globalThis.FileSystemFileHandle && + globalThis.FileSystemFileHandle.prototype.createSyncAccessHandle && + navigator?.storage?.getDirectory; + }; + + + opfsUtil.metrics = { + dump: function(){ + let k, n = 0, t = 0, w = 0; + for(k in state.opIds){ + const m = metrics[k]; + n += m.count; + t += m.time; + w += m.wait; + m.avgTime = (m.count && m.time) ? (m.time / m.count) : 0; + m.avgWait = (m.count && m.wait) ? (m.wait / m.count) : 0; + } + sqlite3.config.log(globalThis.location.href, + "metrics for",globalThis.location.href,":",metrics, + "\nTotal of",n,"op(s) for",t, + "ms (incl. "+w+" ms of waiting on the async side)"); + sqlite3.config.log("Serialization metrics:",metrics.s11n); + W.postMessage({type:'opfs-async-metrics'}); + }, + reset: function(){ + let k; + const r = (m)=>(m.count = m.time = m.wait = 0); + for(k in state.opIds){ + r(metrics[k] = Object.create(null)); + } + let s = metrics.s11n = Object.create(null); + s = s.serialize = Object.create(null); + s.count = s.time = 0; + s = metrics.s11n.deserialize = Object.create(null); + s.count = s.time = 0; + } + }; + const opfsVfs = new sqlite3_vfs(); + const opfsIoMethods = new sqlite3_io_methods(); + let promiseWasRejected = undefined; + const promiseReject = (err)=>{ + promiseWasRejected = true; + opfsVfs.dispose(); + return promiseReject_(err); + }; + const promiseResolve = (value)=>{ + promiseWasRejected = false; + return promiseResolve_(value); + }; + const W = + new Worker(options.proxyUri); + setTimeout(()=>{ + + if(undefined===promiseWasRejected){ + promiseReject( + new Error("Timeout while waiting for OPFS async proxy worker.") + ); + } + }, 4000); + W._originalOnError = W.onerror ; + W.onerror = function(err){ + + + error("Error initializing OPFS asyncer:",err); + promiseReject(new Error("Loading OPFS async Worker failed for unknown reasons.")); + }; + const pDVfs = capi.sqlite3_vfs_find(null); + const dVfs = pDVfs + ? new sqlite3_vfs(pDVfs) + : null ; + opfsVfs.$iVersion = 2; + opfsVfs.$szOsFile = capi.sqlite3_file.structInfo.sizeof; + opfsVfs.$mxPathname = 1024; + opfsVfs.$zName = wasm.allocCString("opfs"); + + opfsVfs.$xDlOpen = opfsVfs.$xDlError = opfsVfs.$xDlSym = opfsVfs.$xDlClose = null; + opfsVfs.ondispose = [ + '$zName', opfsVfs.$zName, + 'cleanup default VFS wrapper', ()=>(dVfs ? dVfs.dispose() : null), + 'cleanup opfsIoMethods', ()=>opfsIoMethods.dispose() + ]; + + + const state = Object.create(null); + state.verbose = options.verbose; + state.littleEndian = (()=>{ + const buffer = new ArrayBuffer(2); + new DataView(buffer).setInt16(0, 256, true ); + + return new Int16Array(buffer)[0] === 256; + })(); + + state.asyncIdleWaitTime = 150; + + state.asyncS11nExceptions = 1; + + state.fileBufferSize = 1024 * 64; + state.sabS11nOffset = state.fileBufferSize; + + state.sabS11nSize = opfsVfs.$mxPathname * 2; + + state.sabIO = new SharedArrayBuffer( + state.fileBufferSize + + state.sabS11nSize + ); + state.opIds = Object.create(null); + const metrics = Object.create(null); + { + + let i = 0; + + state.opIds.whichOp = i++; + + state.opIds.rc = i++; + + state.opIds.xAccess = i++; + state.opIds.xClose = i++; + state.opIds.xDelete = i++; + state.opIds.xDeleteNoWait = i++; + state.opIds.xFileSize = i++; + state.opIds.xLock = i++; + state.opIds.xOpen = i++; + state.opIds.xRead = i++; + state.opIds.xSleep = i++; + state.opIds.xSync = i++; + state.opIds.xTruncate = i++; + state.opIds.xUnlock = i++; + state.opIds.xWrite = i++; + state.opIds.mkdir = i++; + state.opIds['opfs-async-metrics'] = i++; + state.opIds['opfs-async-shutdown'] = i++; + + state.opIds.retry = i++; + state.sabOP = new SharedArrayBuffer( + i * 4); + opfsUtil.metrics.reset(); + } + + state.sq3Codes = Object.create(null); + [ + 'SQLITE_ACCESS_EXISTS', + 'SQLITE_ACCESS_READWRITE', + 'SQLITE_BUSY', + 'SQLITE_ERROR', + 'SQLITE_IOERR', + 'SQLITE_IOERR_ACCESS', + 'SQLITE_IOERR_CLOSE', + 'SQLITE_IOERR_DELETE', + 'SQLITE_IOERR_FSYNC', + 'SQLITE_IOERR_LOCK', + 'SQLITE_IOERR_READ', + 'SQLITE_IOERR_SHORT_READ', + 'SQLITE_IOERR_TRUNCATE', + 'SQLITE_IOERR_UNLOCK', + 'SQLITE_IOERR_WRITE', + 'SQLITE_LOCK_EXCLUSIVE', + 'SQLITE_LOCK_NONE', + 'SQLITE_LOCK_PENDING', + 'SQLITE_LOCK_RESERVED', + 'SQLITE_LOCK_SHARED', + 'SQLITE_LOCKED', + 'SQLITE_MISUSE', + 'SQLITE_NOTFOUND', + 'SQLITE_OPEN_CREATE', + 'SQLITE_OPEN_DELETEONCLOSE', + 'SQLITE_OPEN_MAIN_DB', + 'SQLITE_OPEN_READONLY' + ].forEach((k)=>{ + if(undefined === (state.sq3Codes[k] = capi[k])){ + toss("Maintenance required: not found:",k); + } + }); + state.opfsFlags = Object.assign(Object.create(null),{ + + OPFS_UNLOCK_ASAP: 0x01, + + defaultUnlockAsap: false + }); + + + const opRun = (op,...args)=>{ + const opNdx = state.opIds[op] || toss("Invalid op ID:",op); + state.s11n.serialize(...args); + Atomics.store(state.sabOPView, state.opIds.rc, -1); + Atomics.store(state.sabOPView, state.opIds.whichOp, opNdx); + Atomics.notify(state.sabOPView, state.opIds.whichOp) + ; + const t = performance.now(); + Atomics.wait(state.sabOPView, state.opIds.rc, -1) + ; + const rc = Atomics.load(state.sabOPView, state.opIds.rc); + metrics[op].wait += performance.now() - t; + if(rc && state.asyncS11nExceptions){ + const err = state.s11n.deserialize(); + if(err) error(op+"() async error:",...err); + } + return rc; + }; + + + opfsUtil.debug = { + asyncShutdown: ()=>{ + warn("Shutting down OPFS async listener. The OPFS VFS will no longer work."); + opRun('opfs-async-shutdown'); + }, + asyncRestart: ()=>{ + warn("Attempting to restart OPFS VFS async listener. Might work, might not."); + W.postMessage({type: 'opfs-async-restart'}); + } + }; + + const initS11n = ()=>{ + + if(state.s11n) return state.s11n; + const textDecoder = new TextDecoder(), + textEncoder = new TextEncoder('utf-8'), + viewU8 = new Uint8Array(state.sabIO, state.sabS11nOffset, state.sabS11nSize), + viewDV = new DataView(state.sabIO, state.sabS11nOffset, state.sabS11nSize); + state.s11n = Object.create(null); + + const TypeIds = Object.create(null); + TypeIds.number = { id: 1, size: 8, getter: 'getFloat64', setter: 'setFloat64' }; + TypeIds.bigint = { id: 2, size: 8, getter: 'getBigInt64', setter: 'setBigInt64' }; + TypeIds.boolean = { id: 3, size: 4, getter: 'getInt32', setter: 'setInt32' }; + TypeIds.string = { id: 4 }; + + const getTypeId = (v)=>( + TypeIds[typeof v] + || toss("Maintenance required: this value type cannot be serialized.",v) + ); + const getTypeIdById = (tid)=>{ + switch(tid){ + case TypeIds.number.id: return TypeIds.number; + case TypeIds.bigint.id: return TypeIds.bigint; + case TypeIds.boolean.id: return TypeIds.boolean; + case TypeIds.string.id: return TypeIds.string; + default: toss("Invalid type ID:",tid); + } + }; + + + state.s11n.deserialize = function(clear=false){ + ++metrics.s11n.deserialize.count; + const t = performance.now(); + const argc = viewU8[0]; + const rc = argc ? [] : null; + if(argc){ + const typeIds = []; + let offset = 1, i, n, v; + for(i = 0; i < argc; ++i, ++offset){ + typeIds.push(getTypeIdById(viewU8[offset])); + } + for(i = 0; i < argc; ++i){ + const t = typeIds[i]; + if(t.getter){ + v = viewDV[t.getter](offset, state.littleEndian); + offset += t.size; + }else{ + n = viewDV.getInt32(offset, state.littleEndian); + offset += 4; + v = textDecoder.decode(viewU8.slice(offset, offset+n)); + offset += n; + } + rc.push(v); + } + } + if(clear) viewU8[0] = 0; + + metrics.s11n.deserialize.time += performance.now() - t; + return rc; + }; + + + state.s11n.serialize = function(...args){ + const t = performance.now(); + ++metrics.s11n.serialize.count; + if(args.length){ + + const typeIds = []; + let i = 0, offset = 1; + viewU8[0] = args.length & 0xff ; + for(; i < args.length; ++i, ++offset){ + + typeIds.push(getTypeId(args[i])); + viewU8[offset] = typeIds[i].id; + } + for(i = 0; i < args.length; ++i) { + + const t = typeIds[i]; + if(t.setter){ + viewDV[t.setter](offset, args[i], state.littleEndian); + offset += t.size; + }else{ + const s = textEncoder.encode(args[i]); + viewDV.setInt32(offset, s.byteLength, state.littleEndian); + offset += 4; + viewU8.set(s, offset); + offset += s.byteLength; + } + } + + }else{ + viewU8[0] = 0; + } + metrics.s11n.serialize.time += performance.now() - t; + }; + return state.s11n; + }; + + + const randomFilename = function f(len=16){ + if(!f._chars){ + f._chars = "abcdefghijklmnopqrstuvwxyz"+ + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"+ + "012346789"; + f._n = f._chars.length; + } + const a = []; + let i = 0; + for( ; i < len; ++i){ + const ndx = Math.random() * (f._n * 64) % f._n | 0; + a[i] = f._chars[ndx]; + } + return a.join(""); + + }; + + + const __openFiles = Object.create(null); + + const opTimer = Object.create(null); + opTimer.op = undefined; + opTimer.start = undefined; + const mTimeStart = (op)=>{ + opTimer.start = performance.now(); + opTimer.op = op; + ++metrics[op].count; + }; + const mTimeEnd = ()=>( + metrics[opTimer.op].time += performance.now() - opTimer.start + ); + + + const ioSyncWrappers = { + xCheckReservedLock: function(pFile,pOut){ + + const f = __openFiles[pFile]; + wasm.poke(pOut, f.lockType ? 1 : 0, 'i32'); + return 0; + }, + xClose: function(pFile){ + mTimeStart('xClose'); + let rc = 0; + const f = __openFiles[pFile]; + if(f){ + delete __openFiles[pFile]; + rc = opRun('xClose', pFile); + if(f.sq3File) f.sq3File.dispose(); + } + mTimeEnd(); + return rc; + }, + xDeviceCharacteristics: function(pFile){ + + return capi.SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN; + }, + xFileControl: function(pFile, opId, pArg){ + + return capi.SQLITE_NOTFOUND; + }, + xFileSize: function(pFile,pSz64){ + mTimeStart('xFileSize'); + let rc = opRun('xFileSize', pFile); + if(0==rc){ + try { + const sz = state.s11n.deserialize()[0]; + wasm.poke(pSz64, sz, 'i64'); + }catch(e){ + error("Unexpected error reading xFileSize() result:",e); + rc = state.sq3Codes.SQLITE_IOERR; + } + } + mTimeEnd(); + return rc; + }, + xLock: function(pFile,lockType){ + mTimeStart('xLock'); + const f = __openFiles[pFile]; + let rc = 0; + + if( !f.lockType ) { + rc = opRun('xLock', pFile, lockType); + if( 0===rc ) f.lockType = lockType; + }else{ + f.lockType = lockType; + } + mTimeEnd(); + return rc; + }, + xRead: function(pFile,pDest,n,offset64){ + mTimeStart('xRead'); + const f = __openFiles[pFile]; + let rc; + try { + rc = opRun('xRead',pFile, n, Number(offset64)); + if(0===rc || capi.SQLITE_IOERR_SHORT_READ===rc){ + + wasm.heap8u().set(f.sabView.subarray(0, n), pDest); + } + }catch(e){ + error("xRead(",arguments,") failed:",e,f); + rc = capi.SQLITE_IOERR_READ; + } + mTimeEnd(); + return rc; + }, + xSync: function(pFile,flags){ + mTimeStart('xSync'); + ++metrics.xSync.count; + const rc = opRun('xSync', pFile, flags); + mTimeEnd(); + return rc; + }, + xTruncate: function(pFile,sz64){ + mTimeStart('xTruncate'); + const rc = opRun('xTruncate', pFile, Number(sz64)); + mTimeEnd(); + return rc; + }, + xUnlock: function(pFile,lockType){ + mTimeStart('xUnlock'); + const f = __openFiles[pFile]; + let rc = 0; + if( capi.SQLITE_LOCK_NONE === lockType + && f.lockType ){ + rc = opRun('xUnlock', pFile, lockType); + } + if( 0===rc ) f.lockType = lockType; + mTimeEnd(); + return rc; + }, + xWrite: function(pFile,pSrc,n,offset64){ + mTimeStart('xWrite'); + const f = __openFiles[pFile]; + let rc; + try { + f.sabView.set(wasm.heap8u().subarray(pSrc, pSrc+n)); + rc = opRun('xWrite', pFile, n, Number(offset64)); + }catch(e){ + error("xWrite(",arguments,") failed:",e,f); + rc = capi.SQLITE_IOERR_WRITE; + } + mTimeEnd(); + return rc; + } + }; + + + const vfsSyncWrappers = { + xAccess: function(pVfs,zName,flags,pOut){ + mTimeStart('xAccess'); + const rc = opRun('xAccess', wasm.cstrToJs(zName)); + wasm.poke( pOut, (rc ? 0 : 1), 'i32' ); + mTimeEnd(); + return 0; + }, + xCurrentTime: function(pVfs,pOut){ + + wasm.poke(pOut, 2440587.5 + (new Date().getTime()/86400000), + 'double'); + return 0; + }, + xCurrentTimeInt64: function(pVfs,pOut){ + + wasm.poke(pOut, (2440587.5 * 86400000) + new Date().getTime(), + 'i64'); + return 0; + }, + xDelete: function(pVfs, zName, doSyncDir){ + mTimeStart('xDelete'); + opRun('xDelete', wasm.cstrToJs(zName), doSyncDir, false); + + mTimeEnd(); + return 0; + }, + xFullPathname: function(pVfs,zName,nOut,pOut){ + + const i = wasm.cstrncpy(pOut, zName, nOut); + return i!!v) : p; + }; + + + opfsUtil.getDirForFilename = async function f(absFilename, createDirs = false){ + const path = opfsUtil.getResolvedPath(absFilename, true); + const filename = path.pop(); + let dh = opfsUtil.rootDirectory; + for(const dirName of path){ + if(dirName){ + dh = await dh.getDirectoryHandle(dirName, {create: !!createDirs}); + } + } + return [dh, filename]; + }; + + + opfsUtil.mkdir = async function(absDirName){ + try { + await opfsUtil.getDirForFilename(absDirName+"/filepart", true); + return true; + }catch(e){ + + return false; + } + }; + + opfsUtil.entryExists = async function(fsEntryName){ + try { + const [dh, fn] = await opfsUtil.getDirForFilename(fsEntryName); + await dh.getFileHandle(fn); + return true; + }catch(e){ + return false; + } + }; + + + opfsUtil.randomFilename = randomFilename; + + + opfsUtil.registerVfs = (asDefault=false)=>{ + return wasm.exports.sqlite3_vfs_register( + opfsVfs.pointer, asDefault ? 1 : 0 + ); + }; + + + opfsUtil.treeList = async function(){ + const doDir = async function callee(dirHandle,tgt){ + tgt.name = dirHandle.name; + tgt.dirs = []; + tgt.files = []; + for await (const handle of dirHandle.values()){ + if('directory' === handle.kind){ + const subDir = Object.create(null); + tgt.dirs.push(subDir); + await callee(handle, subDir); + }else{ + tgt.files.push(handle.name); + } + } + }; + const root = Object.create(null); + await doDir(opfsUtil.rootDirectory, root); + return root; + }; + + + opfsUtil.rmfr = async function(){ + const dir = opfsUtil.rootDirectory, opt = {recurse: true}; + for await (const handle of dir.values()){ + dir.removeEntry(handle.name, opt); + } + }; + + + opfsUtil.unlink = async function(fsEntryName, recursive = false, + throwOnError = false){ + try { + const [hDir, filenamePart] = + await opfsUtil.getDirForFilename(fsEntryName, false); + await hDir.removeEntry(filenamePart, {recursive}); + return true; + }catch(e){ + if(throwOnError){ + throw new Error("unlink(",arguments[0],") failed: "+e.message,{ + cause: e + }); + } + return false; + } + }; + + + opfsUtil.traverse = async function(opt){ + const defaultOpt = { + recursive: true, + directory: opfsUtil.rootDirectory + }; + if('function'===typeof opt){ + opt = {callback:opt}; + } + opt = Object.assign(defaultOpt, opt||{}); + const doDir = async function callee(dirHandle, depth){ + for await (const handle of dirHandle.values()){ + if(false === opt.callback(handle, dirHandle, depth)) return false; + else if(opt.recursive && 'directory' === handle.kind){ + if(false === await callee(handle, depth + 1)) break; + } + } + }; + doDir(opt.directory, 0); + }; + + + + + + + + if(sqlite3.oo1){ + const OpfsDb = function(...args){ + const opt = sqlite3.oo1.DB.dbCtorHelper.normalizeArgs(...args); + opt.vfs = opfsVfs.$zName; + sqlite3.oo1.DB.dbCtorHelper.call(this, opt); + }; + OpfsDb.prototype = Object.create(sqlite3.oo1.DB.prototype); + sqlite3.oo1.OpfsDb = OpfsDb; + sqlite3.oo1.DB.dbCtorHelper.setVfsPostOpenSql( + opfsVfs.pointer, + function(oo1Db, sqlite3){ + + sqlite3.capi.sqlite3_busy_timeout(oo1Db, 10000); + sqlite3.capi.sqlite3_exec(oo1Db, [ + + "pragma journal_mode=persist;", + + "pragma cache_size=-16384;" + ], 0, 0, 0); + } + ); + } + + const sanityCheck = function(){ + const scope = wasm.scopedAllocPush(); + const sq3File = new sqlite3_file(); + try{ + const fid = sq3File.pointer; + const openFlags = capi.SQLITE_OPEN_CREATE + | capi.SQLITE_OPEN_READWRITE + + | capi.SQLITE_OPEN_MAIN_DB; + const pOut = wasm.scopedAlloc(8); + const dbFile = "/sanity/check/file"+randomFilename(8); + const zDbFile = wasm.scopedAllocCString(dbFile); + let rc; + state.s11n.serialize("This is ä string."); + rc = state.s11n.deserialize(); + log("deserialize() says:",rc); + if("This is ä string."!==rc[0]) toss("String d13n error."); + vfsSyncWrappers.xAccess(opfsVfs.pointer, zDbFile, 0, pOut); + rc = wasm.peek(pOut,'i32'); + log("xAccess(",dbFile,") exists ?=",rc); + rc = vfsSyncWrappers.xOpen(opfsVfs.pointer, zDbFile, + fid, openFlags, pOut); + log("open rc =",rc,"state.sabOPView[xOpen] =", + state.sabOPView[state.opIds.xOpen]); + if(0!==rc){ + error("open failed with code",rc); + return; + } + vfsSyncWrappers.xAccess(opfsVfs.pointer, zDbFile, 0, pOut); + rc = wasm.peek(pOut,'i32'); + if(!rc) toss("xAccess() failed to detect file."); + rc = ioSyncWrappers.xSync(sq3File.pointer, 0); + if(rc) toss('sync failed w/ rc',rc); + rc = ioSyncWrappers.xTruncate(sq3File.pointer, 1024); + if(rc) toss('truncate failed w/ rc',rc); + wasm.poke(pOut,0,'i64'); + rc = ioSyncWrappers.xFileSize(sq3File.pointer, pOut); + if(rc) toss('xFileSize failed w/ rc',rc); + log("xFileSize says:",wasm.peek(pOut, 'i64')); + rc = ioSyncWrappers.xWrite(sq3File.pointer, zDbFile, 10, 1); + if(rc) toss("xWrite() failed!"); + const readBuf = wasm.scopedAlloc(16); + rc = ioSyncWrappers.xRead(sq3File.pointer, readBuf, 6, 2); + wasm.poke(readBuf+6,0); + let jRead = wasm.cstrToJs(readBuf); + log("xRead() got:",jRead); + if("sanity"!==jRead) toss("Unexpected xRead() value."); + if(vfsSyncWrappers.xSleep){ + log("xSleep()ing before close()ing..."); + vfsSyncWrappers.xSleep(opfsVfs.pointer,2000); + log("waking up from xSleep()"); + } + rc = ioSyncWrappers.xClose(fid); + log("xClose rc =",rc,"sabOPView =",state.sabOPView); + log("Deleting file:",dbFile); + vfsSyncWrappers.xDelete(opfsVfs.pointer, zDbFile, 0x1234); + vfsSyncWrappers.xAccess(opfsVfs.pointer, zDbFile, 0, pOut); + rc = wasm.peek(pOut,'i32'); + if(rc) toss("Expecting 0 from xAccess(",dbFile,") after xDelete()."); + warn("End of OPFS sanity checks."); + }finally{ + sq3File.dispose(); + wasm.scopedAllocPop(scope); + } + }; + + W.onmessage = function({data}){ + + switch(data.type){ + case 'opfs-unavailable': + + promiseReject(new Error(data.payload.join(' '))); + break; + case 'opfs-async-loaded': + + W.postMessage({type: 'opfs-async-init',args: state}); + break; + case 'opfs-async-inited': { + + if(true===promiseWasRejected){ + break ; + } + try { + sqlite3.vfs.installVfs({ + io: {struct: opfsIoMethods, methods: ioSyncWrappers}, + vfs: {struct: opfsVfs, methods: vfsSyncWrappers} + }); + state.sabOPView = new Int32Array(state.sabOP); + state.sabFileBufView = new Uint8Array(state.sabIO, 0, state.fileBufferSize); + state.sabS11nView = new Uint8Array(state.sabIO, state.sabS11nOffset, state.sabS11nSize); + initS11n(); + if(options.sanityChecks){ + warn("Running sanity checks because of opfs-sanity-check URL arg..."); + sanityCheck(); + } + if(thisThreadHasOPFS()){ + navigator.storage.getDirectory().then((d)=>{ + W.onerror = W._originalOnError; + delete W._originalOnError; + sqlite3.opfs = opfsUtil; + opfsUtil.rootDirectory = d; + log("End of OPFS sqlite3_vfs setup.", opfsVfs); + promiseResolve(sqlite3); + }).catch(promiseReject); + }else{ + promiseResolve(sqlite3); + } + }catch(e){ + error(e); + promiseReject(e); + } + break; + } + default: { + const errMsg = ( + "Unexpected message from the OPFS async worker: " + + JSON.stringify(data) + ); + error(errMsg); + promiseReject(new Error(errMsg)); + break; + } + } + }; + }); + return thePromise; +}; +installOpfsVfs.defaultProxyUri = + "sqlite3-opfs-async-proxy.js"; +globalThis.sqlite3ApiBootstrap.initializersAsync.push(async (sqlite3)=>{ + try{ + let proxyJs = installOpfsVfs.defaultProxyUri; + if(sqlite3.scriptInfo.sqlite3Dir){ + installOpfsVfs.defaultProxyUri = + sqlite3.scriptInfo.sqlite3Dir + proxyJs; + + } + return installOpfsVfs().catch((e)=>{ + sqlite3.config.warn("Ignoring inability to install OPFS sqlite3_vfs:",e.message); + }); + }catch(e){ + sqlite3.config.error("installOpfsVfs() exception:",e); + throw e; + } +}); +}); + + + +'use strict'; +if('undefined' !== typeof Module){ + + const SABC = Object.assign( + Object.create(null), { + exports: Module['asm'], + memory: Module.wasmMemory + }, + globalThis.sqlite3ApiConfig || {} + ); + + + + globalThis.sqlite3ApiConfig = SABC; + let sqlite3; + try{ + sqlite3 = globalThis.sqlite3ApiBootstrap(); + }catch(e){ + console.error("sqlite3ApiBootstrap() error:",e); + throw e; + }finally{ + delete globalThis.sqlite3ApiBootstrap; + delete globalThis.sqlite3ApiConfig; + } + + Module.sqlite3 = sqlite3 ; +}else{ + console.warn("This is not running in an Emscripten module context, so", + "globalThis.sqlite3ApiBootstrap() is _not_ being called due to lack", + "of config info for the WASM environment.", + "It must be called manually."); +} + + + + +}); + + + + return sqlite3InitModule.ready +} +); +})(); +if (typeof exports === 'object' && typeof module === 'object') + module.exports = sqlite3InitModule; +else if (typeof define === 'function' && define['amd']) + define([], function() { return sqlite3InitModule; }); +else if (typeof exports === 'object') + exports["sqlite3InitModule"] = sqlite3InitModule; + + + +(function(){ + + const originalInit = + sqlite3InitModule; + if(!originalInit){ + throw new Error("Expecting globalThis.sqlite3InitModule to be defined by the Emscripten build."); + } + + const initModuleState = globalThis.sqlite3InitModuleState = Object.assign(Object.create(null),{ + moduleScript: globalThis?.document?.currentScript, + isWorker: ('undefined' !== typeof WorkerGlobalScope), + location: globalThis.location, + urlParams: globalThis?.location?.href + ? new URL(globalThis.location.href).searchParams + : new URLSearchParams() + }); + initModuleState.debugModule = + initModuleState.urlParams.has('sqlite3.debugModule') + ? (...args)=>console.warn('sqlite3.debugModule:',...args) + : ()=>{}; + + if(initModuleState.urlParams.has('sqlite3.dir')){ + initModuleState.sqlite3Dir = initModuleState.urlParams.get('sqlite3.dir') +'/'; + }else if(initModuleState.moduleScript){ + const li = initModuleState.moduleScript.src.split('/'); + li.pop(); + initModuleState.sqlite3Dir = li.join('/') + '/'; + } + + globalThis.sqlite3InitModule = function ff(...args){ + + return originalInit(...args).then((EmscriptenModule)=>{ + if('undefined'!==typeof WorkerGlobalScope && + (EmscriptenModule['ENVIRONMENT_IS_PTHREAD'] + || EmscriptenModule['_pthread_self'] + || 'function'===typeof threadAlert + || globalThis?.location?.pathname?.endsWith?.('.worker.js') + )){ + + return EmscriptenModule; + } + const s = EmscriptenModule.sqlite3; + s.scriptInfo = initModuleState; + + if(ff.__isUnderTest) s.__isUnderTest = true; + const f = s.asyncPostInit; + delete s.asyncPostInit; + return f(); + }).catch((e)=>{ + console.error("Exception loading sqlite3 module:",e); + throw e; + }); + }; + globalThis.sqlite3InitModule.ready = originalInit.ready; + + if(globalThis.sqlite3InitModuleState.moduleScript){ + const sim = globalThis.sqlite3InitModuleState; + let src = sim.moduleScript.src.split('/'); + src.pop(); + sim.scriptDir = src.join('/') + '/'; + } + initModuleState.debugModule('sqlite3InitModuleState =',initModuleState); + if(0){ + console.warn("Replaced sqlite3InitModule()"); + console.warn("globalThis.location.href =",globalThis.location.href); + if('undefined' !== typeof document){ + console.warn("document.currentScript.src =", + document?.currentScript?.src); + } + } + + + + + if (typeof exports === 'object' && typeof module === 'object'){ + module.exports = sqlite3InitModule; + }else if (typeof exports === 'object'){ + exports["sqlite3InitModule"] = sqlite3InitModule; + } + + return globalThis.sqlite3InitModule ; +})(); diff --git a/plugins/tiddlywiki/demo-alternate-store/engines/sqlite/files/sqlite3.wasm b/plugins/tiddlywiki/demo-alternate-store/engines/sqlite/files/sqlite3.wasm new file mode 100644 index 0000000000000000000000000000000000000000..ef87f7b51e221b3bf660d2a06bd31b2cfbc02ee3 GIT binary patch literal 879655 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

Xpi@#chDVHj8?h{+ds{k@lpn@l37-JD+Y<4C}N~ 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�{-jcf}PIx7O~p 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 + // Save a reference to the sqlite3 object + $tw.sqlite3 = sqlite3; + // Boot TiddlyWiki – the timeout appears to be needed to give boot.js a chance to run + setTimeout(function() { + $tw.boot.boot(); + },0); +}); + +$tw.Wiki = function(options) { + options = options || {}; + var self = this, + tiddlers = Object.create(null), // Hashmap of tiddlers + tiddlerTitles = null, // Array of tiddler titles + getTiddlerTitles = function() { + if(!tiddlerTitles) { + tiddlerTitles = Object.keys(tiddlers).sort(function(a,b) {return a.localeCompare(b);}); + } + return tiddlerTitles; + }, + pluginTiddlers = [], // Array of tiddlers containing registered plugins, ordered by priority + pluginInfo = Object.create(null), // Hashmap of parsed plugin content + shadowTiddlers = Object.create(null), // Hashmap by title of {source:, tiddler:} + shadowTiddlerTitles = null, + getShadowTiddlerTitles = function() { + if(!shadowTiddlerTitles) { + shadowTiddlerTitles = Object.keys(shadowTiddlers); + } + return shadowTiddlerTitles; + }, + enableIndexers = options.enableIndexers || null, + indexers = [], + indexersByName = Object.create(null); + //$tw.utils replacements + var eachObj = function(object,callback) { + var next,f,length; + if(object) { + if(Object.prototype.toString.call(object) == "[object Array]") { + for (f=0, length=object.length; f> 1; + cmp = value.localeCompare(array[mid]); + if(cmp > 0) { + low = mid + 1; + } else if(cmp < 0) { + high = mid - 1; + } else { + return array; + } + } + array.splice(low,0,value); + return array; + }, + parseJSONSafe = function(text,defaultJSON) { + try { + return JSON.parse(text); + } catch(e) { + if(typeof defaultJSON === "function") { + return defaultJSON(e); + } else { + return defaultJSON || {}; + } + } + }; + + this.addIndexer = function(indexer,name) { + // Bail if this indexer is not enabled + if(enableIndexers && enableIndexers.indexOf(name) === -1) { + return; + } + indexers.push(indexer); + indexersByName[name] = indexer; + indexer.init(); + }; + + this.getIndexer = function(name) { + return indexersByName[name] || null; + }; + + // Add a tiddler to the store + this.addTiddler = function(tiddler) { + if(!(tiddler instanceof $tw.Tiddler)) { + tiddler = new $tw.Tiddler(tiddler); + } + // Save the tiddler + if(tiddler) { + var title = tiddler.fields.title; + if(title) { + // Uncomment the following line for detailed logs of all tiddler writes + // console.log("Adding",title,tiddler) + // Record the old tiddler state + var updateDescriptor = { + old: { + tiddler: this.getTiddler(title), + shadow: this.isShadowTiddler(title), + exists: this.tiddlerExists(title) + } + } + // Save the new tiddler + tiddlers[title] = tiddler; + // Check we've got the title + tiddlerTitles = insertSortedArray(tiddlerTitles || [],title); + // Record the new tiddler state + updateDescriptor["new"] = { + tiddler: tiddler, + shadow: this.isShadowTiddler(title), + exists: this.tiddlerExists(title) + } + // Update indexes + this.clearCache(title); + this.clearGlobalCache(); + eachObj(indexers,function(indexer) { + indexer.update(updateDescriptor); + }); + // Queue a change event + this.enqueueTiddlerEvent(title); + } + } + }; + + // Delete a tiddler + this.deleteTiddler = function(title) { + // Uncomment the following line for detailed logs of all tiddler deletions + // console.log("Deleting",title) + if(hop(tiddlers,title)) { + // Record the old tiddler state + var updateDescriptor = { + old: { + tiddler: this.getTiddler(title), + shadow: this.isShadowTiddler(title), + exists: this.tiddlerExists(title) + } + } + // Delete the tiddler + delete tiddlers[title]; + // Delete it from the list of titles + if(tiddlerTitles) { + var index = tiddlerTitles.indexOf(title); + if(index !== -1) { + tiddlerTitles.splice(index,1); + } + } + // Record the new tiddler state + updateDescriptor["new"] = { + tiddler: this.getTiddler(title), + shadow: this.isShadowTiddler(title), + exists: this.tiddlerExists(title) + } + // Update indexes + this.clearCache(title); + this.clearGlobalCache(); + eachObj(indexers,function(indexer) { + indexer.update(updateDescriptor); + }); + // Queue a change event + this.enqueueTiddlerEvent(title,true); + } + }; + + // Get a tiddler from the store + this.getTiddler = function(title) { + if(title) { + var t = tiddlers[title]; + if(t !== undefined) { + return t; + } else { + var s = shadowTiddlers[title]; + if(s !== undefined) { + return s.tiddler; + } + } + } + return undefined; + }; + + // Get an array of all tiddler titles + this.allTitles = function() { + return getTiddlerTitles().slice(0); + }; + + // Iterate through all tiddler titles + this.each = function(callback) { + var titles = getTiddlerTitles(), + index,titlesLength,title; + for(index = 0, titlesLength = titles.length; index < titlesLength; index++) { + title = titles[index]; + callback(tiddlers[title],title); + } + }; + + // Get an array of all shadow tiddler titles + this.allShadowTitles = function() { + return getShadowTiddlerTitles().slice(0); + }; + + // Iterate through all shadow tiddler titles + this.eachShadow = function(callback) { + var titles = getShadowTiddlerTitles(), + index,titlesLength,title; + for(index = 0, titlesLength = titles.length; index < titlesLength; index++) { + title = titles[index]; + if(tiddlers[title]) { + callback(tiddlers[title],title); + } else { + var shadowInfo = shadowTiddlers[title]; + callback(shadowInfo.tiddler,title); + } + } + }; + + // Iterate through all tiddlers and then the shadows + this.eachTiddlerPlusShadows = function(callback) { + var index,titlesLength,title, + titles = getTiddlerTitles(); + for(index = 0, titlesLength = titles.length; index < titlesLength; index++) { + title = titles[index]; + callback(tiddlers[title],title); + } + titles = getShadowTiddlerTitles(); + for(index = 0, titlesLength = titles.length; index < titlesLength; index++) { + title = titles[index]; + if(!tiddlers[title]) { + var shadowInfo = shadowTiddlers[title]; + callback(shadowInfo.tiddler,title); + } + } + }; + + // Iterate through all the shadows and then the tiddlers + this.eachShadowPlusTiddlers = function(callback) { + var index,titlesLength,title, + titles = getShadowTiddlerTitles(); + for(index = 0, titlesLength = titles.length; index < titlesLength; index++) { + title = titles[index]; + if(tiddlers[title]) { + callback(tiddlers[title],title); + } else { + var shadowInfo = shadowTiddlers[title]; + callback(shadowInfo.tiddler,title); + } + } + titles = getTiddlerTitles(); + for(index = 0, titlesLength = titles.length; index < titlesLength; index++) { + title = titles[index]; + if(!shadowTiddlers[title]) { + callback(tiddlers[title],title); + } + } + }; + + this.tiddlerExists = function(title) { + return !!hop(tiddlers,title); + }; + + this.isShadowTiddler = function(title) { + return hop(shadowTiddlers,title); + }; + + this.getShadowSource = function(title) { + if(hop(shadowTiddlers,title)) { + return shadowTiddlers[title].source; + } + return null; + }; + + // Get an array of all the currently recognised plugin types + this.getPluginTypes = function() { + var types = []; + eachObj(pluginTiddlers,function(pluginTiddler) { + var pluginType = pluginTiddler.fields["plugin-type"]; + if(pluginType && types.indexOf(pluginType) === -1) { + types.push(pluginType); + } + }); + return types; + }; + + // Read plugin info for all plugins, or just an array of titles. Returns the number of plugins updated or deleted + this.readPluginInfo = function(titles) { + var results = { + modifiedPlugins: [], + deletedPlugins: [] + }; + eachObj(titles || getTiddlerTitles(),function(title) { + var tiddler = tiddlers[title]; + if(tiddler) { + if(tiddler.fields.type === "application/json" && tiddler.hasField("plugin-type") && tiddler.fields.text) { + pluginInfo[tiddler.fields.title] = parseJSONSafe(tiddler.fields.text); + results.modifiedPlugins.push(tiddler.fields.title); + } + } else { + if(pluginInfo[title]) { + delete pluginInfo[title]; + results.deletedPlugins.push(title); + } + } + }); + return results; + }; + + // Get plugin info for a plugin + this.getPluginInfo = function(title) { + return pluginInfo[title]; + }; + + // Register the plugin tiddlers of a particular type, or null/undefined for any type, optionally restricting registration to an array of tiddler titles. Return the array of titles affected + this.registerPluginTiddlers = function(pluginType,titles) { + var self = this, + registeredTitles = [], + checkTiddler = function(tiddler,title) { + if(tiddler && tiddler.fields.type === "application/json" && tiddler.fields["plugin-type"] && (!pluginType || tiddler.fields["plugin-type"] === pluginType)) { + var disablingTiddler = self.getTiddler("$:/config/Plugins/Disabled/" + title); + if(title === "$:/core" || !disablingTiddler || (disablingTiddler.fields.text || "").trim() !== "yes") { + self.unregisterPluginTiddlers(null,[title]); // Unregister the plugin if it's already registered + pluginTiddlers.push(tiddler); + registeredTitles.push(tiddler.fields.title); + } + } + }; + if(titles) { + eachObj(titles,function(title) { + checkTiddler(self.getTiddler(title),title); + }); + } else { + this.each(function(tiddler,title) { + checkTiddler(tiddler,title); + }); + } + return registeredTitles; + }; + + // Unregister the plugin tiddlers of a particular type, or null/undefined for any type, optionally restricting unregistering to an array of tiddler titles. Returns an array of the titles affected + this.unregisterPluginTiddlers = function(pluginType,titles) { + var self = this, + unregisteredTitles = []; + // Remove any previous registered plugins of this type + for(var t=pluginTiddlers.length-1; t>=0; t--) { + var tiddler = pluginTiddlers[t]; + if(tiddler.fields["plugin-type"] && (!pluginType || tiddler.fields["plugin-type"] === pluginType) && (!titles || titles.indexOf(tiddler.fields.title) !== -1)) { + unregisteredTitles.push(tiddler.fields.title); + pluginTiddlers.splice(t,1); + } + } + return unregisteredTitles; + }; + + // Unpack the currently registered plugins, creating shadow tiddlers for their constituent tiddlers + this.unpackPluginTiddlers = function() { + var self = this; + // Sort the plugin titles by the `plugin-priority` field + pluginTiddlers.sort(function(a,b) { + if("plugin-priority" in a.fields && "plugin-priority" in b.fields) { + return a.fields["plugin-priority"] - b.fields["plugin-priority"]; + } else if("plugin-priority" in a.fields) { + return -1; + } else if("plugin-priority" in b.fields) { + return +1; + } else if(a.fields.title < b.fields.title) { + return -1; + } else if(a.fields.title === b.fields.title) { + return 0; + } else { + return +1; + } + }); + // Now go through the plugins in ascending order and assign the shadows + shadowTiddlers = Object.create(null); + eachObj(pluginTiddlers,function(tiddler) { + // Extract the constituent tiddlers + if(hop(pluginInfo,tiddler.fields.title)) { + eachObj(pluginInfo[tiddler.fields.title].tiddlers,function(constituentTiddler,constituentTitle) { + // Save the tiddler object + if(constituentTitle) { + shadowTiddlers[constituentTitle] = { + source: tiddler.fields.title, + tiddler: new $tw.Tiddler(constituentTiddler,{title: constituentTitle}) + }; + } + }); + } + }); + shadowTiddlerTitles = null; + this.clearCache(null); + this.clearGlobalCache(); + eachObj(indexers,function(indexer) { + indexer.rebuild(); + }); + }; + + if(this.addIndexersToWiki) { + this.addIndexersToWiki(); + } +}; + +})(); +//# sourceURL=$:/plugins/tiddlywiki/demo-alternate-store/engines/sqlite/rawmarkup.js \ No newline at end of file