apiConfig = (globalThis.sqlite3ApiConfig || sqlite3ApiBootstrap.defaultConfig)

if(sqlite3ApiBootstrap.sqlite3){ /* already initialized */

(sqlite3ApiBootstrap.sqlite3.config || 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: !!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'

});

[

// If any of these config options are functions, replace them with

// the result of calling that function. They must not be async.

'exports', 'memory', 'functionTable', 'wasmfsOpfsDir'

].forEach((k)=>{

if('function' === typeof config[k]){

config[k] = config[k]();

}

});

/**

delete globalThis.sqlite3ApiConfig;

delete sqlite3ApiBootstrap.defaultConfig;

/**

const capi = Object.create(null);

/**

const wasm = Object.create(null);

/** Internal helper for SQLite3Error ctor. */

const __rcStr = (rc)=>{

return (capi.sqlite3_js_rc_str && capi.sqlite3_js_rc_str(rc))

|| ("Unknown result code #"+rc);

};

/** Internal helper for SQLite3Error ctor. */

const isInt32 = (n)=>

'number'===typeof n

&& n===(n | 0)

&& n<=2147483647 && n>=-2147483648;

/**

class SQLite3Error extends Error {

/**

constructor(...args){

let rc;

if(args.length){

if(isInt32(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 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;

};

/** Returns v if v appears to be a TypedArray, else false. */

const isTypedArray = (v)=>{

return (v && v.constructor && isInt32(v.constructor.BYTES_PER_ELEMENT)) ? v : false;

};

/**

const isBindableTypedArray = (v)=>

v && (v instanceof Uint8Array

|| v instanceof Int8Array

|| v instanceof ArrayBuffer);

/**

const isSQLableTypedArray = (v)=>

v && (v instanceof Uint8Array

|| v instanceof Int8Array

|| v instanceof ArrayBuffer);

/** Returns true if isBindableTypedArray(v) does, else throws with a message

const affirmBindableTypedArray = (v)=>

isBindableTypedArray(v)

|| toss3("Value is not of a supported TypedArray type.");

/**

const flexibleString = function(v){

if(isSQLableTypedArray(v)){

return wasm.typedArrayToString(

(v instanceof ArrayBuffer) ? new Uint8Array(v) : v,

0, v.length

);

}

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/*installed later*/,

/**

sqlite3_bind_text: undefined/*installed later*/,

/**

sqlite3_create_function_v2: (

pDb, funcName, nArg, eTextRep, pApp,

xFunc, xStep, xFinal, xDestroy

)=>{/*installed later*/},

/**

sqlite3_create_function: (

pDb, funcName, nArg, eTextRep, pApp,

xFunc, xStep, xFinal

)=>{/*installed later*/},

/**

sqlite3_create_window_function: (

pDb, funcName, nArg, eTextRep, pApp,

xStep, xFinal, xValue, xInverse, xDestroy

)=>{/*installed later*/},

/**

sqlite3_prepare_v3: (dbPtr, sql, sqlByteLen, prepFlags,

stmtPtrPtr, strPtrPtr)=>{}/*installed later*/,

/**

sqlite3_prepare_v2: (dbPtr, sql, sqlByteLen,

stmtPtrPtr,strPtrPtr)=>{}/*installed later*/,

/**

sqlite3_exec: (pDb, sql, callback, pVoid, pErrMsg)=>{}/*installed later*/,

/**

sqlite3_randomness: (n, outPtr)=>{/*installed later*/},

}/*capi*/);

/**

const util = {

affirmBindableTypedArray, flexibleString,

bigIntFits32, bigIntFits64, bigIntFitsDouble,

isBindableTypedArray,

isInt32, isSQLableTypedArray, isTypedArray,

isUIThread: ()=>(globalThis.window===globalThis && !!globalThis.document),

// is this true for ESM?: 'undefined'===typeof WorkerGlobalScope

toss: function(...args){throw new Error(args.join(' '))},

toss3,

typedArrayPart: wasm.typedArrayPart,

/**

affirmDbHeader: function(bytes){

if(bytes instanceof ArrayBuffer) bytes = new Uint8Array(bytes);

const header = "SQLite format 3";

if( header.length > bytes.byteLength ){

toss3("Input does not contain an SQLite3 database header.");

}

for(let i = 0; i < header.length; ++i){

if( header.charCodeAt(i) !== bytes[i] ){

toss3("Input does not contain an SQLite3 database header.");

}

}

},

/**

affirmIsDb: function(bytes){

if(bytes instanceof ArrayBuffer) bytes = new Uint8Array(bytes);

const n = bytes.byteLength;

if(n<512 || n%512!==0) {

toss3("Byte array size",n,"is invalid for an SQLite3 db.");

}

util.affirmDbHeader(bytes);

}

}/*util*/;

/**

Object.assign(wasm, {

/**

pointerIR: config.wasmPtrIR,

/**

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)."),

/**

functionTable: config.functionTable,

/**

alloc: undefined/*installed later*/,

/**

realloc: undefined/*installed later*/,

/**

dealloc: undefined/*installed later*/

/* Many more wasm-related APIs get installed later on. */

}/*wasm*/);

/**

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], Number(pRet))

/* Maintenance note: the order of alloc() and heapForSize() calls

return pRet;

};

{

// Set up allocators...

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(wasm.ptr.coerce(m)/*tag:64bit*/,n);

return n ? (m2 || WasmAllocError.toss("Failed to reallocate",n," bytes.")) : wasm.ptr.null;

};

wasm.realloc.impl = wasm.exports[keyRealloc];

wasm.dealloc = function f(m){

f.impl(wasm.ptr.coerce(m)/*tag:64bit*/);

};

wasm.dealloc.impl = 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 = Object.create(null), ov = [0,0];

let i = 0, k;

while((k = capi.sqlite3_compileoption_get(i++))){