@powersync/web 0.0.0-dev-20260414110516 → 0.0.0-dev-20260503073249

package/dist/worker/node_modules_pnpm_journeyapps_wa-sqlite_1_7_0_node_modules_journeyapps_wa-sqlite_src_examples-2fb422.umd.js

@@ -0,0 +1,3562 @@
+"use strict";
+(self["webpackChunksdk_web"] = self["webpackChunksdk_web"] || []).push([["node_modules_pnpm_journeyapps_wa-sqlite_1_7_0_node_modules_journeyapps_wa-sqlite_src_examples-2fb422"],{
+
+/***/ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/FacadeVFS.js"
+/*!******************************************************************************************************************!*\
+  !*** ../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/FacadeVFS.js ***!
+  \******************************************************************************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   FacadeVFS: () => (/* binding */ FacadeVFS)
+/* harmony export */ });
+/* harmony import */ var _VFS_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./VFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/VFS.js");
+// Copyright 2024 Roy T. Hashimoto. All Rights Reserved.
+
+
+const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+
+// Milliseconds since Julian epoch as a BigInt.
+// https://github.com/sqlite/sqlite/blob/e57527c14f7b7cfa6e32eeab5c549d50c4fa3674/src/os_unix.c#L6872-L6882
+const UNIX_EPOCH = 24405875n * 8640000n;
+
+// Convenience base class for a JavaScript VFS.
+// The raw xOpen, xRead, etc. function signatures receive only C primitives
+// which aren't easy to work with. This class provides corresponding calls
+// like jOpen, jRead, etc., which receive JavaScript-friendlier arguments
+// such as string, Uint8Array, and DataView.
+class FacadeVFS extends _VFS_js__WEBPACK_IMPORTED_MODULE_0__.Base {
+  /**
+   * @param {string} name 
+   * @param {object} module 
+   */
+  constructor(name, module) {
+    super(name, module);
+  }
+
+  /**
+   * Override to indicate which methods are asynchronous.
+   * @param {string} methodName 
+   * @returns {boolean}
+   */
+  hasAsyncMethod(methodName) {
+    // The input argument is a string like "xOpen", so convert to "jOpen".
+    // Then check if the method exists and is async.
+    const jMethodName = `j${methodName.slice(1)}`;
+    return this[jMethodName] instanceof AsyncFunction;
+  }
+  
+  /**
+   * Return the filename for a file id for use by mixins.
+   * @param {number} pFile 
+   * @returns {string}
+   */
+  getFilename(pFile) {
+    throw new Error('unimplemented');
+  }
+
+  /**
+   * @param {string?} filename 
+   * @param {number} pFile 
+   * @param {number} flags 
+   * @param {DataView} pOutFlags 
+   * @returns {number|Promise<number>}
+   */
+  jOpen(filename, pFile, flags, pOutFlags) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CANTOPEN;
+  }
+
+  /**
+   * @param {string} filename 
+   * @param {number} syncDir 
+   * @returns {number|Promise<number>}
+   */
+  jDelete(filename, syncDir) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {string} filename 
+   * @param {number} flags 
+   * @param {DataView} pResOut 
+   * @returns {number|Promise<number>}
+   */
+  jAccess(filename, flags, pResOut) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {string} filename 
+   * @param {Uint8Array} zOut 
+   * @returns {number|Promise<number>}
+   */
+  jFullPathname(filename, zOut) {
+    // Copy the filename to the output buffer.
+    const { read, written } = new TextEncoder().encodeInto(filename, zOut);
+    if (read < filename.length) return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
+    if (written >= zOut.length) return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
+    zOut[written] = 0;
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {Uint8Array} zBuf 
+   * @returns {number|Promise<number>}
+   */
+  jGetLastError(zBuf) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @returns {number|Promise<number>}
+   */
+  jClose(pFile) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset 
+   * @returns {number|Promise<number>}
+   */
+  jRead(pFile, pData, iOffset) {
+    pData.fill(0);
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_SHORT_READ;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset 
+   * @returns {number|Promise<number>}
+   */
+  jWrite(pFile, pData, iOffset) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_WRITE;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} size 
+   * @returns {number|Promise<number>}
+   */
+  jTruncate(pFile, size) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} flags 
+   * @returns {number|Promise<number>}
+   */
+  jSync(pFile, flags) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {DataView} pSize
+   * @returns {number|Promise<number>}
+   */
+  jFileSize(pFile, pSize) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number|Promise<number>}
+   */
+  jLock(pFile, lockType) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number|Promise<number>}
+   */
+  jUnlock(pFile, lockType) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {DataView} pResOut 
+   * @returns {number|Promise<number>}
+   */
+  jCheckReservedLock(pFile, pResOut) {
+    pResOut.setInt32(0, 0, true);
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile
+   * @param {number} op
+   * @param {DataView} pArg
+   * @returns {number|Promise<number>}
+   */
+  jFileControl(pFile, op, pArg) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTFOUND;
+  }
+
+  /**
+   * @param {number} pFile
+   * @returns {number|Promise<number>}
+   */
+  jSectorSize(pFile) {
+    return super.xSectorSize(pFile);
+  }
+
+  /**
+   * @param {number} pFile
+   * @returns {number|Promise<number>}
+   */
+  jDeviceCharacteristics(pFile) {
+    return 0;
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} pFile 
+   * @param {number} flags 
+   * @param {number} pOutFlags 
+   * @returns {number|Promise<number>}
+   */
+  xOpen(pVfs, zName, pFile, flags, pOutFlags) {
+    const filename = this.#decodeFilename(zName, flags);
+    const pOutFlagsView = this.#makeTypedDataView('Int32', pOutFlags);
+    this['log']?.('jOpen', filename, pFile, '0x' + flags.toString(16));
+    return this.jOpen(filename, pFile, flags, pOutFlagsView);
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} nByte 
+   * @param {number} pCharOut
+   * @returns {number|Promise<number>}
+   */
+  xRandomness(pVfs, nByte, pCharOut) {
+    const randomArray = new Uint8Array(nByte);
+    crypto.getRandomValues(randomArray);
+    // Copy randomArray to the WebAssembly memory
+    const buffer = pCharOut; // Pointer to memory in WebAssembly
+    this._module.HEAPU8.set(randomArray, buffer); // Copy randomArray into memory starting at buffer
+    return nByte;
+  }
+
+  /**
+   * Gets the current time as milliseconds since Unix epoch
+   * @param {number} pVfs pointer to the VFS
+   * @param {number} pTime pointer to write the time value
+   * @returns {number} SQLite error code
+   */
+  xCurrentTimeInt64(pVfs, pTime) {
+    // Create a DataView to write the current time
+    const timeView = this.#makeTypedDataView('BigInt64', pTime);
+  
+    const currentTime = BigInt(Date.now());
+    // Convert the current time to milliseconds since Unix epoch
+    const value = UNIX_EPOCH + currentTime;
+    
+    // Write the time value to the pointer location
+    timeView.setBigInt64(0, value, true);
+    
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} syncDir 
+   * @returns {number|Promise<number>}
+   */
+  xDelete(pVfs, zName, syncDir) {
+    const filename = this._module.UTF8ToString(zName);
+    this['log']?.('jDelete', filename, syncDir);
+    return this.jDelete(filename, syncDir);
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} flags 
+   * @param {number} pResOut 
+   * @returns {number|Promise<number>}
+   */
+  xAccess(pVfs, zName, flags, pResOut) {
+    const filename = this._module.UTF8ToString(zName);
+    const pResOutView = this.#makeTypedDataView('Int32', pResOut);
+    this['log']?.('jAccess', filename, flags);
+    return this.jAccess(filename, flags, pResOutView);
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} nOut 
+   * @param {number} zOut 
+   * @returns {number|Promise<number>}
+   */
+  xFullPathname(pVfs, zName, nOut, zOut) {
+    const filename = this._module.UTF8ToString(zName);
+    const zOutArray = this._module.HEAPU8.subarray(zOut, zOut + nOut);
+    this['log']?.('jFullPathname', filename, nOut);
+    return this.jFullPathname(filename, zOutArray);
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} nBuf 
+   * @param {number} zBuf 
+   * @returns {number|Promise<number>}
+   */
+  xGetLastError(pVfs, nBuf, zBuf) {
+    const zBufArray = this._module.HEAPU8.subarray(zBuf, zBuf + nBuf);
+    this['log']?.('jGetLastError', nBuf);
+    return this.jGetLastError(zBufArray);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @returns {number|Promise<number>}
+   */
+  xClose(pFile) {
+    this['log']?.('jClose', pFile);
+    return this.jClose(pFile);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} pData 
+   * @param {number} iAmt 
+   * @param {number} iOffsetLo 
+   * @param {number} iOffsetHi 
+   * @returns {number|Promise<number>}
+   */
+  xRead(pFile, pData, iAmt, iOffsetLo, iOffsetHi) {
+    const pDataArray = this.#makeDataArray(pData, iAmt);
+    const iOffset = delegalize(iOffsetLo, iOffsetHi);
+    this['log']?.('jRead', pFile, iAmt, iOffset);
+    return this.jRead(pFile, pDataArray, iOffset);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} pData 
+   * @param {number} iAmt 
+   * @param {number} iOffsetLo 
+   * @param {number} iOffsetHi 
+   * @returns {number|Promise<number>}
+   */
+  xWrite(pFile, pData, iAmt, iOffsetLo, iOffsetHi) {
+    const pDataArray = this.#makeDataArray(pData, iAmt);
+    const iOffset = delegalize(iOffsetLo, iOffsetHi);
+    this['log']?.('jWrite', pFile, pDataArray, iOffset);
+    return this.jWrite(pFile, pDataArray, iOffset);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} sizeLo 
+   * @param {number} sizeHi 
+   * @returns {number|Promise<number>}
+   */
+  xTruncate(pFile, sizeLo, sizeHi) {
+    const size = delegalize(sizeLo, sizeHi);
+    this['log']?.('jTruncate', pFile, size);
+    return this.jTruncate(pFile, size);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} flags 
+   * @returns {number|Promise<number>}
+   */
+  xSync(pFile, flags) {
+    this['log']?.('jSync', pFile, flags);
+    return this.jSync(pFile, flags);
+  }
+
+  /**
+   * 
+   * @param {number} pFile 
+   * @param {number} pSize 
+   * @returns {number|Promise<number>}
+   */
+  xFileSize(pFile, pSize) {
+    const pSizeView = this.#makeTypedDataView('BigInt64', pSize);
+    this['log']?.('jFileSize', pFile);
+    return this.jFileSize(pFile, pSizeView);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number|Promise<number>}
+   */
+  xLock(pFile, lockType) {
+    this['log']?.('jLock', pFile, lockType);
+    return this.jLock(pFile, lockType);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number|Promise<number>}
+   */
+  xUnlock(pFile, lockType) {
+    this['log']?.('jUnlock', pFile, lockType);
+    return this.jUnlock(pFile, lockType);
+  } 
+
+  /**
+   * @param {number} pFile 
+   * @param {number} pResOut 
+   * @returns {number|Promise<number>}
+   */
+  xCheckReservedLock(pFile, pResOut) {
+    const pResOutView = this.#makeTypedDataView('Int32', pResOut);
+    this['log']?.('jCheckReservedLock', pFile);
+    return this.jCheckReservedLock(pFile, pResOutView);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} op 
+   * @param {number} pArg 
+   * @returns {number|Promise<number>}
+   */
+  xFileControl(pFile, op, pArg) {
+    const pArgView = new DataView(
+      this._module.HEAPU8.buffer,
+      this._module.HEAPU8.byteOffset + pArg);
+    this['log']?.('jFileControl', pFile, op, pArgView);
+    return this.jFileControl(pFile, op, pArgView);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @returns {number|Promise<number>}
+   */
+  xSectorSize(pFile) {
+    this['log']?.('jSectorSize', pFile);
+    return this.jSectorSize(pFile);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @returns {number|Promise<number>}
+   */
+  xDeviceCharacteristics(pFile) {
+    this['log']?.('jDeviceCharacteristics', pFile);
+    return this.jDeviceCharacteristics(pFile);
+  }
+
+  /**
+   * Wrapped DataView for pointer arguments.
+   * Pointers to a single value are passed using a DataView-like class.
+   * This wrapper class prevents use of incorrect type or endianness, and
+   * reacquires the underlying buffer when the WebAssembly memory is resized.
+   * @param {'Int32'|'BigInt64'} type 
+   * @param {number} byteOffset 
+   * @returns {DataView}
+   */
+  #makeTypedDataView(type, byteOffset) {
+    // @ts-ignore
+    return new DataViewProxy(this._module, byteOffset, type);
+  }
+
+  /**
+   * Wrapped Uint8Array for buffer arguments.
+   * Memory blocks are passed as a Uint8Array-like class. This wrapper
+   * class reacquires the underlying buffer when the WebAssembly memory
+   * is resized.
+   * @param {number} byteOffset 
+   * @param {number} byteLength 
+   * @returns {Uint8Array}
+   */
+  #makeDataArray(byteOffset, byteLength) {
+    // @ts-ignore
+    return new Uint8ArrayProxy(this._module, byteOffset, byteLength);
+  }
+
+  #decodeFilename(zName, flags) {
+    if (flags & _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_URI) {
+      // The first null-terminated string is the URI path. Subsequent
+      // strings are query parameter keys and values.
+      // https://www.sqlite.org/c3ref/open.html#urifilenamesinsqlite3open
+      let pName = zName;
+      let state = 1;
+      const charCodes = [];
+      while (state) {
+        const charCode = this._module.HEAPU8[pName++];
+        if (charCode) {
+          charCodes.push(charCode);
+        } else {
+          if (!this._module.HEAPU8[pName]) state = null;
+          switch (state) {
+            case 1: // path
+              charCodes.push('?'.charCodeAt(0));
+              state = 2;
+              break;
+            case 2: // key
+              charCodes.push('='.charCodeAt(0));
+              state = 3;
+              break;
+            case 3: // value
+              charCodes.push('&'.charCodeAt(0));
+              state = 2;
+              break;
+          }
+        }
+      }
+      return  new TextDecoder().decode(new Uint8Array(charCodes));
+    }
+    return zName ? this._module.UTF8ToString(zName) : null;
+  }
+}
+
+// Emscripten "legalizes" 64-bit integer arguments by passing them as
+// two 32-bit signed integers.
+function delegalize(lo32, hi32) {
+  return (hi32 * 0x100000000) + lo32 + (lo32 < 0 ? 2**32 : 0);
+}
+
+// This class provides a Uint8Array-like interface for a WebAssembly memory
+// buffer. It is used to access memory blocks passed as arguments to
+// xRead, xWrite, etc. The class reacquires the underlying buffer when the
+// WebAssembly memory is resized, which can happen when the memory is
+// detached and resized by the WebAssembly module.
+//
+// Note that although this class implements the same methods as Uint8Array,
+// it is not a real Uint8Array and passing it to functions that expect
+// a Uint8Array may not work. Use subarray() to get a real Uint8Array
+// if needed.
+class Uint8ArrayProxy {
+  #module;
+
+  #_array = new Uint8Array()
+  get #array() {
+    if (this.#_array.buffer.byteLength === 0) {
+      // WebAssembly memory resize detached the buffer so re-create the
+      // array with the new buffer.
+      this.#_array = this.#module.HEAPU8.subarray(
+        this.byteOffset,
+        this.byteOffset + this.byteLength);
+    }
+    return this.#_array;
+  }
+
+  /**
+   * @param {*} module
+   * @param {number} byteOffset 
+   * @param {number} byteLength 
+   */
+  constructor(module, byteOffset, byteLength) {
+    this.#module = module;
+    this.byteOffset = byteOffset;
+    this.length = this.byteLength = byteLength;
+  }
+
+  get buffer() {
+    return this.#array.buffer;
+  }
+
+  at(index) {
+    return this.#array.at(index);
+  }
+  copyWithin(target, start, end) {
+    this.#array.copyWithin(target, start, end);
+  }
+  entries() {
+    return this.#array.entries();
+  }
+  every(predicate) {
+    return this.#array.every(predicate);
+  }
+  fill(value, start, end) {
+    this.#array.fill(value, start, end);
+  }
+  filter(predicate) {
+    return this.#array.filter(predicate);
+  }
+  find(predicate) {
+    return this.#array.find(predicate);
+  }
+  findIndex(predicate) {
+    return this.#array.findIndex(predicate);
+  }
+  findLast(predicate) {
+    return this.#array.findLast(predicate);
+  }
+  findLastIndex(predicate) {
+    return this.#array.findLastIndex(predicate);
+  }
+  forEach(callback) {
+    this.#array.forEach(callback);
+  }
+  includes(value, start) {
+    return this.#array.includes(value, start);
+  }
+  indexOf(value, start) {
+    return this.#array.indexOf(value, start);
+  }
+  join(separator) {
+    return this.#array.join(separator);
+  }
+  keys() {
+    return this.#array.keys();
+  }
+  lastIndexOf(value, start) {
+    return this.#array.lastIndexOf(value, start);
+  }
+  map(callback) {
+    return this.#array.map(callback);
+  }
+  reduce(callback, initialValue) {
+    return this.#array.reduce(callback, initialValue);
+  }
+  reduceRight(callback, initialValue) {
+    return this.#array.reduceRight(callback, initialValue);
+  }
+  reverse() {
+    this.#array.reverse();
+  }
+  set(array, offset) {
+    this.#array.set(array, offset);
+  }
+  slice(start, end) {
+    return this.#array.slice(start, end);
+  }
+  some(predicate) {
+    return this.#array.some(predicate);
+  }
+  sort(compareFn) {
+    this.#array.sort(compareFn);
+  }
+  subarray(begin, end) {
+    return this.#array.subarray(begin, end);
+  }
+  toLocaleString(locales, options) {
+    // @ts-ignore
+    return this.#array.toLocaleString(locales, options);
+  }
+  toReversed() {
+    return this.#array.toReversed();
+  }
+  toSorted(compareFn) {
+    return this.#array.toSorted(compareFn);
+  }
+  toString() {
+    return this.#array.toString();
+  }
+  values() {
+    return this.#array.values();
+  }
+  with(index, value) {
+    return this.#array.with(index, value);
+  }
+  [Symbol.iterator]() {
+    return this.#array[Symbol.iterator]();
+  }
+}
+
+// This class provides a DataView-like interface for a WebAssembly memory
+// buffer, restricted to either Int32 or BigInt64 types. It also reacquires
+// the underlying buffer when the WebAssembly memory is resized, which can
+// happen when the memory is detached and resized by the WebAssembly module.
+class DataViewProxy {
+  #module;
+  #type;
+
+  #_view = new DataView(new ArrayBuffer(0));
+  get #view() {
+    if (this.#_view.buffer.byteLength === 0) {
+      // WebAssembly memory resize detached the buffer so re-create the
+      // view with the new buffer.
+      this.#_view = new DataView(
+        this.#module.HEAPU8.buffer,
+        this.#module.HEAPU8.byteOffset + this.byteOffset);
+    }
+    return this.#_view;
+  }
+
+  /**
+   * @param {*} module
+   * @param {number} byteOffset 
+   * @param {'Int32'|'BigInt64'} type
+   */
+  constructor(module, byteOffset, type) {
+    this.#module = module;
+    this.byteOffset = byteOffset;
+    this.#type = type;
+  }
+
+  get buffer() {
+    return this.#view.buffer;
+  }
+  get byteLength() {
+    return this.#type === 'Int32' ? 4 : 8;
+  }
+
+  getInt32(byteOffset, littleEndian) {
+    if (this.#type !== 'Int32') {
+      throw new Error('invalid type');
+    }
+    if (!littleEndian) throw new Error('must be little endian');
+    return this.#view.getInt32(byteOffset, littleEndian);
+  }
+  setInt32(byteOffset, value, littleEndian) {
+    if (this.#type !== 'Int32') {
+      throw new Error('invalid type');
+    }
+    if (!littleEndian) throw new Error('must be little endian');
+    this.#view.setInt32(byteOffset, value, littleEndian);
+  }
+  getBigInt64(byteOffset, littleEndian) {
+    if (this.#type !== 'BigInt64') {
+      throw new Error('invalid type');
+    }
+    if (!littleEndian) throw new Error('must be little endian');
+    return this.#view.getBigInt64(byteOffset, littleEndian);
+  }
+  setBigInt64(byteOffset, value, littleEndian) {
+    if (this.#type !== 'BigInt64') {
+      throw new Error('invalid type');
+    }
+    if (!littleEndian) throw new Error('must be little endian');
+    this.#view.setBigInt64(byteOffset, value, littleEndian);
+  }
+}
+
+/***/ },
+
+/***/ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/VFS.js"
+/*!************************************************************************************************************!*\
+  !*** ../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/VFS.js ***!
+  \************************************************************************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Base: () => (/* binding */ Base),
+/* harmony export */   FILE_TYPE_MASK: () => (/* binding */ FILE_TYPE_MASK),
+/* harmony export */   SQLITE_ABORT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ABORT),
+/* harmony export */   SQLITE_ACCESS_EXISTS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ACCESS_EXISTS),
+/* harmony export */   SQLITE_ACCESS_READ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ACCESS_READ),
+/* harmony export */   SQLITE_ACCESS_READWRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ACCESS_READWRITE),
+/* harmony export */   SQLITE_ALTER_TABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ALTER_TABLE),
+/* harmony export */   SQLITE_ANALYZE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ANALYZE),
+/* harmony export */   SQLITE_ATTACH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ATTACH),
+/* harmony export */   SQLITE_AUTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_AUTH),
+/* harmony export */   SQLITE_BLOB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BLOB),
+/* harmony export */   SQLITE_BUSY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BUSY),
+/* harmony export */   SQLITE_CANTOPEN: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CANTOPEN),
+/* harmony export */   SQLITE_CONSTRAINT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT),
+/* harmony export */   SQLITE_CONSTRAINT_CHECK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_CHECK),
+/* harmony export */   SQLITE_CONSTRAINT_COMMITHOOK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_COMMITHOOK),
+/* harmony export */   SQLITE_CONSTRAINT_FOREIGNKEY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_FOREIGNKEY),
+/* harmony export */   SQLITE_CONSTRAINT_FUNCTION: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_FUNCTION),
+/* harmony export */   SQLITE_CONSTRAINT_NOTNULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_NOTNULL),
+/* harmony export */   SQLITE_CONSTRAINT_PINNED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_PINNED),
+/* harmony export */   SQLITE_CONSTRAINT_PRIMARYKEY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_PRIMARYKEY),
+/* harmony export */   SQLITE_CONSTRAINT_ROWID: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_ROWID),
+/* harmony export */   SQLITE_CONSTRAINT_TRIGGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_TRIGGER),
+/* harmony export */   SQLITE_CONSTRAINT_UNIQUE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_UNIQUE),
+/* harmony export */   SQLITE_CONSTRAINT_VTAB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_VTAB),
+/* harmony export */   SQLITE_COPY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_COPY),
+/* harmony export */   SQLITE_CORRUPT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CORRUPT),
+/* harmony export */   SQLITE_CREATE_INDEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_INDEX),
+/* harmony export */   SQLITE_CREATE_TABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TABLE),
+/* harmony export */   SQLITE_CREATE_TEMP_INDEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TEMP_INDEX),
+/* harmony export */   SQLITE_CREATE_TEMP_TABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TEMP_TABLE),
+/* harmony export */   SQLITE_CREATE_TEMP_TRIGGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TEMP_TRIGGER),
+/* harmony export */   SQLITE_CREATE_TEMP_VIEW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TEMP_VIEW),
+/* harmony export */   SQLITE_CREATE_TRIGGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TRIGGER),
+/* harmony export */   SQLITE_CREATE_VIEW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_VIEW),
+/* harmony export */   SQLITE_CREATE_VTABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_VTABLE),
+/* harmony export */   SQLITE_DELETE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DELETE),
+/* harmony export */   SQLITE_DENY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DENY),
+/* harmony export */   SQLITE_DETACH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DETACH),
+/* harmony export */   SQLITE_DETERMINISTIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DETERMINISTIC),
+/* harmony export */   SQLITE_DIRECTONLY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DIRECTONLY),
+/* harmony export */   SQLITE_DONE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DONE),
+/* harmony export */   SQLITE_DROP_INDEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_INDEX),
+/* harmony export */   SQLITE_DROP_TABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TABLE),
+/* harmony export */   SQLITE_DROP_TEMP_INDEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TEMP_INDEX),
+/* harmony export */   SQLITE_DROP_TEMP_TABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TEMP_TABLE),
+/* harmony export */   SQLITE_DROP_TEMP_TRIGGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TEMP_TRIGGER),
+/* harmony export */   SQLITE_DROP_TEMP_VIEW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TEMP_VIEW),
+/* harmony export */   SQLITE_DROP_TRIGGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TRIGGER),
+/* harmony export */   SQLITE_DROP_VIEW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_VIEW),
+/* harmony export */   SQLITE_DROP_VTABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_VTABLE),
+/* harmony export */   SQLITE_EMPTY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_EMPTY),
+/* harmony export */   SQLITE_ERROR: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ERROR),
+/* harmony export */   SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_BEGIN_ATOMIC_WRITE),
+/* harmony export */   SQLITE_FCNTL_BUSYHANDLER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_BUSYHANDLER),
+/* harmony export */   SQLITE_FCNTL_CHUNK_SIZE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_CHUNK_SIZE),
+/* harmony export */   SQLITE_FCNTL_CKPT_DONE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_CKPT_DONE),
+/* harmony export */   SQLITE_FCNTL_CKPT_START: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_CKPT_START),
+/* harmony export */   SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_COMMIT_ATOMIC_WRITE),
+/* harmony export */   SQLITE_FCNTL_COMMIT_PHASETWO: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_COMMIT_PHASETWO),
+/* harmony export */   SQLITE_FCNTL_DATA_VERSION: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_DATA_VERSION),
+/* harmony export */   SQLITE_FCNTL_FILE_POINTER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_FILE_POINTER),
+/* harmony export */   SQLITE_FCNTL_GET_LOCKPROXYFILE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_GET_LOCKPROXYFILE),
+/* harmony export */   SQLITE_FCNTL_HAS_MOVED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_HAS_MOVED),
+/* harmony export */   SQLITE_FCNTL_JOURNAL_POINTER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_JOURNAL_POINTER),
+/* harmony export */   SQLITE_FCNTL_LAST_ERRNO: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_LAST_ERRNO),
+/* harmony export */   SQLITE_FCNTL_LOCKSTATE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_LOCKSTATE),
+/* harmony export */   SQLITE_FCNTL_LOCK_TIMEOUT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_LOCK_TIMEOUT),
+/* harmony export */   SQLITE_FCNTL_MMAP_SIZE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_MMAP_SIZE),
+/* harmony export */   SQLITE_FCNTL_OVERWRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_OVERWRITE),
+/* harmony export */   SQLITE_FCNTL_PDB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_PDB),
+/* harmony export */   SQLITE_FCNTL_PERSIST_WAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_PERSIST_WAL),
+/* harmony export */   SQLITE_FCNTL_POWERSAFE_OVERWRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_POWERSAFE_OVERWRITE),
+/* harmony export */   SQLITE_FCNTL_PRAGMA: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_PRAGMA),
+/* harmony export */   SQLITE_FCNTL_RBU: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_RBU),
+/* harmony export */   SQLITE_FCNTL_RESERVE_BYTES: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_RESERVE_BYTES),
+/* harmony export */   SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE),
+/* harmony export */   SQLITE_FCNTL_SET_LOCKPROXYFILE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_SET_LOCKPROXYFILE),
+/* harmony export */   SQLITE_FCNTL_SIZE_HINT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_SIZE_HINT),
+/* harmony export */   SQLITE_FCNTL_SIZE_LIMIT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_SIZE_LIMIT),
+/* harmony export */   SQLITE_FCNTL_SYNC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_SYNC),
+/* harmony export */   SQLITE_FCNTL_SYNC_OMITTED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_SYNC_OMITTED),
+/* harmony export */   SQLITE_FCNTL_TEMPFILENAME: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_TEMPFILENAME),
+/* harmony export */   SQLITE_FCNTL_TRACE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_TRACE),
+/* harmony export */   SQLITE_FCNTL_VFSNAME: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_VFSNAME),
+/* harmony export */   SQLITE_FCNTL_VFS_POINTER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_VFS_POINTER),
+/* harmony export */   SQLITE_FCNTL_WAL_BLOCK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_WAL_BLOCK),
+/* harmony export */   SQLITE_FCNTL_WIN32_AV_RETRY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_WIN32_AV_RETRY),
+/* harmony export */   SQLITE_FCNTL_WIN32_GET_HANDLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_WIN32_GET_HANDLE),
+/* harmony export */   SQLITE_FCNTL_WIN32_SET_HANDLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_WIN32_SET_HANDLE),
+/* harmony export */   SQLITE_FCNTL_ZIPVFS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_ZIPVFS),
+/* harmony export */   SQLITE_FLOAT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FLOAT),
+/* harmony export */   SQLITE_FORMAT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FORMAT),
+/* harmony export */   SQLITE_FULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FULL),
+/* harmony export */   SQLITE_FUNCTION: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FUNCTION),
+/* harmony export */   SQLITE_IGNORE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IGNORE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_EQ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_EQ),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_FUNCTION: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_FUNCTION),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_GE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_GE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_GLOB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_GLOB),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_GT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_GT),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_IS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_IS),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_ISNOT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_ISNOT),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_ISNOTNULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_ISNOTNULL),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_ISNULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_ISNULL),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_LE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_LE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_LIKE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_LIKE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_LT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_LT),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_MATCH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_MATCH),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_NE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_NE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_REGEXP: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_REGEXP),
+/* harmony export */   SQLITE_INDEX_SCAN_UNIQUE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_SCAN_UNIQUE),
+/* harmony export */   SQLITE_INNOCUOUS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INNOCUOUS),
+/* harmony export */   SQLITE_INSERT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INSERT),
+/* harmony export */   SQLITE_INTEGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INTEGER),
+/* harmony export */   SQLITE_INTERNAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INTERNAL),
+/* harmony export */   SQLITE_INTERRUPT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INTERRUPT),
+/* harmony export */   SQLITE_IOCAP_ATOMIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC),
+/* harmony export */   SQLITE_IOCAP_ATOMIC16K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC16K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC1K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC1K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC2K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC2K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC32K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC32K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC4K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC4K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC512: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC512),
+/* harmony export */   SQLITE_IOCAP_ATOMIC64K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC64K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC8K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC8K),
+/* harmony export */   SQLITE_IOCAP_BATCH_ATOMIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_BATCH_ATOMIC),
+/* harmony export */   SQLITE_IOCAP_IMMUTABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_IMMUTABLE),
+/* harmony export */   SQLITE_IOCAP_POWERSAFE_OVERWRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_POWERSAFE_OVERWRITE),
+/* harmony export */   SQLITE_IOCAP_SAFE_APPEND: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_SAFE_APPEND),
+/* harmony export */   SQLITE_IOCAP_SEQUENTIAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_SEQUENTIAL),
+/* harmony export */   SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN),
+/* harmony export */   SQLITE_IOERR: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR),
+/* harmony export */   SQLITE_IOERR_ACCESS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_ACCESS),
+/* harmony export */   SQLITE_IOERR_BEGIN_ATOMIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_BEGIN_ATOMIC),
+/* harmony export */   SQLITE_IOERR_CHECKRESERVEDLOCK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_CHECKRESERVEDLOCK),
+/* harmony export */   SQLITE_IOERR_CLOSE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_CLOSE),
+/* harmony export */   SQLITE_IOERR_COMMIT_ATOMIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_COMMIT_ATOMIC),
+/* harmony export */   SQLITE_IOERR_DATA: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_DATA),
+/* harmony export */   SQLITE_IOERR_DELETE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_DELETE),
+/* harmony export */   SQLITE_IOERR_DELETE_NOENT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_DELETE_NOENT),
+/* harmony export */   SQLITE_IOERR_DIR_FSYNC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_DIR_FSYNC),
+/* harmony export */   SQLITE_IOERR_FSTAT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_FSTAT),
+/* harmony export */   SQLITE_IOERR_FSYNC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_FSYNC),
+/* harmony export */   SQLITE_IOERR_GETTEMPPATH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_GETTEMPPATH),
+/* harmony export */   SQLITE_IOERR_LOCK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_LOCK),
+/* harmony export */   SQLITE_IOERR_NOMEM: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_NOMEM),
+/* harmony export */   SQLITE_IOERR_RDLOCK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_RDLOCK),
+/* harmony export */   SQLITE_IOERR_READ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_READ),
+/* harmony export */   SQLITE_IOERR_ROLLBACK_ATOMIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_ROLLBACK_ATOMIC),
+/* harmony export */   SQLITE_IOERR_SEEK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_SEEK),
+/* harmony export */   SQLITE_IOERR_SHORT_READ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_SHORT_READ),
+/* harmony export */   SQLITE_IOERR_TRUNCATE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_TRUNCATE),
+/* harmony export */   SQLITE_IOERR_UNLOCK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_UNLOCK),
+/* harmony export */   SQLITE_IOERR_VNODE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_VNODE),
+/* harmony export */   SQLITE_IOERR_WRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_WRITE),
+/* harmony export */   SQLITE_LIMIT_ATTACHED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_ATTACHED),
+/* harmony export */   SQLITE_LIMIT_COLUMN: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_COLUMN),
+/* harmony export */   SQLITE_LIMIT_COMPOUND_SELECT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_COMPOUND_SELECT),
+/* harmony export */   SQLITE_LIMIT_EXPR_DEPTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_EXPR_DEPTH),
+/* harmony export */   SQLITE_LIMIT_FUNCTION_ARG: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_FUNCTION_ARG),
+/* harmony export */   SQLITE_LIMIT_LENGTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_LENGTH),
+/* harmony export */   SQLITE_LIMIT_LIKE_PATTERN_LENGTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_LIKE_PATTERN_LENGTH),
+/* harmony export */   SQLITE_LIMIT_SQL_LENGTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_SQL_LENGTH),
+/* harmony export */   SQLITE_LIMIT_TRIGGER_DEPTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_TRIGGER_DEPTH),
+/* harmony export */   SQLITE_LIMIT_VARIABLE_NUMBER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_VARIABLE_NUMBER),
+/* harmony export */   SQLITE_LIMIT_VDBE_OP: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_VDBE_OP),
+/* harmony export */   SQLITE_LIMIT_WORKER_THREADS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_WORKER_THREADS),
+/* harmony export */   SQLITE_LOCKED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCKED),
+/* harmony export */   SQLITE_LOCK_EXCLUSIVE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_EXCLUSIVE),
+/* harmony export */   SQLITE_LOCK_NONE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_NONE),
+/* harmony export */   SQLITE_LOCK_PENDING: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_PENDING),
+/* harmony export */   SQLITE_LOCK_RESERVED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_RESERVED),
+/* harmony export */   SQLITE_LOCK_SHARED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_SHARED),
+/* harmony export */   SQLITE_MISMATCH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISMATCH),
+/* harmony export */   SQLITE_MISUSE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISUSE),
+/* harmony export */   SQLITE_NOLFS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOLFS),
+/* harmony export */   SQLITE_NOMEM: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOMEM),
+/* harmony export */   SQLITE_NOTADB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTADB),
+/* harmony export */   SQLITE_NOTFOUND: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTFOUND),
+/* harmony export */   SQLITE_NOTICE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTICE),
+/* harmony export */   SQLITE_NULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NULL),
+/* harmony export */   SQLITE_OK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK),
+/* harmony export */   SQLITE_OPEN_AUTOPROXY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_AUTOPROXY),
+/* harmony export */   SQLITE_OPEN_CREATE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_CREATE),
+/* harmony export */   SQLITE_OPEN_DELETEONCLOSE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_DELETEONCLOSE),
+/* harmony export */   SQLITE_OPEN_EXCLUSIVE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_EXCLUSIVE),
+/* harmony export */   SQLITE_OPEN_FULLMUTEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_FULLMUTEX),
+/* harmony export */   SQLITE_OPEN_MAIN_DB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_MAIN_DB),
+/* harmony export */   SQLITE_OPEN_MAIN_JOURNAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_MAIN_JOURNAL),
+/* harmony export */   SQLITE_OPEN_MEMORY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_MEMORY),
+/* harmony export */   SQLITE_OPEN_NOFOLLOW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_NOFOLLOW),
+/* harmony export */   SQLITE_OPEN_NOMUTEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_NOMUTEX),
+/* harmony export */   SQLITE_OPEN_PRIVATECACHE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_PRIVATECACHE),
+/* harmony export */   SQLITE_OPEN_READONLY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_READONLY),
+/* harmony export */   SQLITE_OPEN_READWRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_READWRITE),
+/* harmony export */   SQLITE_OPEN_SHAREDCACHE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_SHAREDCACHE),
+/* harmony export */   SQLITE_OPEN_SUBJOURNAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_SUBJOURNAL),
+/* harmony export */   SQLITE_OPEN_SUPER_JOURNAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_SUPER_JOURNAL),
+/* harmony export */   SQLITE_OPEN_TEMP_DB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_TEMP_DB),
+/* harmony export */   SQLITE_OPEN_TEMP_JOURNAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_TEMP_JOURNAL),
+/* harmony export */   SQLITE_OPEN_TRANSIENT_DB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_TRANSIENT_DB),
+/* harmony export */   SQLITE_OPEN_URI: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_URI),
+/* harmony export */   SQLITE_OPEN_WAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_WAL),
+/* harmony export */   SQLITE_PERM: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PERM),
+/* harmony export */   SQLITE_PRAGMA: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PRAGMA),
+/* harmony export */   SQLITE_PREPARE_NORMALIZED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PREPARE_NORMALIZED),
+/* harmony export */   SQLITE_PREPARE_NO_VTAB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PREPARE_NO_VTAB),
+/* harmony export */   SQLITE_PREPARE_PERSISTENT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PREPARE_PERSISTENT),
+/* harmony export */   SQLITE_PROTOCOL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PROTOCOL),
+/* harmony export */   SQLITE_RANGE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_RANGE),
+/* harmony export */   SQLITE_READ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_READ),
+/* harmony export */   SQLITE_READONLY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_READONLY),
+/* harmony export */   SQLITE_RECURSIVE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_RECURSIVE),
+/* harmony export */   SQLITE_REINDEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_REINDEX),
+/* harmony export */   SQLITE_ROW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ROW),
+/* harmony export */   SQLITE_SAVEPOINT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SAVEPOINT),
+/* harmony export */   SQLITE_SCHEMA: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SCHEMA),
+/* harmony export */   SQLITE_SELECT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SELECT),
+/* harmony export */   SQLITE_STATIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_STATIC),
+/* harmony export */   SQLITE_SUBTYPE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SUBTYPE),
+/* harmony export */   SQLITE_SYNC_DATAONLY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SYNC_DATAONLY),
+/* harmony export */   SQLITE_SYNC_FULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SYNC_FULL),
+/* harmony export */   SQLITE_SYNC_NORMAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SYNC_NORMAL),
+/* harmony export */   SQLITE_TEXT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_TEXT),
+/* harmony export */   SQLITE_TOOBIG: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_TOOBIG),
+/* harmony export */   SQLITE_TRANSACTION: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_TRANSACTION),
+/* harmony export */   SQLITE_TRANSIENT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_TRANSIENT),
+/* harmony export */   SQLITE_UPDATE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_UPDATE),
+/* harmony export */   SQLITE_UTF16: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_UTF16),
+/* harmony export */   SQLITE_UTF16BE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_UTF16BE),
+/* harmony export */   SQLITE_UTF16LE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_UTF16LE),
+/* harmony export */   SQLITE_UTF8: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_UTF8),
+/* harmony export */   SQLITE_WARNING: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_WARNING)
+/* harmony export */ });
+/* harmony import */ var _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./sqlite-constants.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/sqlite-constants.js");
+// Copyright 2024 Roy T. Hashimoto. All Rights Reserved.
+
+
+
+const DEFAULT_SECTOR_SIZE = 512;
+
+// Base class for a VFS.
+class Base {
+  name;
+  mxPathname = 64;
+  _module;
+
+  /**
+   * @param {string} name 
+   * @param {object} module 
+   */
+  constructor(name, module) {
+    this.name = name;
+    this._module = module;
+  }
+
+  /**
+   * @returns {void|Promise<void>} 
+   */
+  close() {
+  }
+
+  /**
+   * @returns {boolean|Promise<boolean>}
+   */
+  isReady() {
+    return true;
+  }
+
+  /**
+   * Overload in subclasses to indicate which methods are asynchronous.
+   * @param {string} methodName 
+   * @returns {boolean}
+   */
+  hasAsyncMethod(methodName) {
+    return false;
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} pFile 
+   * @param {number} flags 
+   * @param {number} pOutFlags 
+   * @returns {number|Promise<number>}
+   */
+  xOpen(pVfs, zName, pFile, flags, pOutFlags) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CANTOPEN;
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} syncDir 
+   * @returns {number|Promise<number>}
+   */
+  xDelete(pVfs, zName, syncDir) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} flags 
+   * @param {number} pResOut 
+   * @returns {number|Promise<number>}
+   */
+  xAccess(pVfs, zName, flags, pResOut) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} nOut 
+   * @param {number} zOut 
+   * @returns {number|Promise<number>}
+   */
+  xFullPathname(pVfs, zName, nOut, zOut) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} nBuf 
+   * @param {number} zBuf 
+   * @returns {number|Promise<number>}
+   */
+  xGetLastError(pVfs, nBuf, zBuf) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @returns {number|Promise<number>}
+   */
+  xClose(pFile) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} pData 
+   * @param {number} iAmt 
+   * @param {number} iOffsetLo 
+   * @param {number} iOffsetHi 
+   * @returns {number|Promise<number>}
+   */
+  xRead(pFile, pData, iAmt, iOffsetLo, iOffsetHi) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} pData 
+   * @param {number} iAmt 
+   * @param {number} iOffsetLo 
+   * @param {number} iOffsetHi 
+   * @returns {number|Promise<number>}
+   */
+  xWrite(pFile, pData, iAmt, iOffsetLo, iOffsetHi) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} sizeLo 
+   * @param {number} sizeHi 
+   * @returns {number|Promise<number>}
+   */
+  xTruncate(pFile, sizeLo, sizeHi) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} flags 
+   * @returns {number|Promise<number>}
+   */
+  xSync(pFile, flags) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * 
+   * @param {number} pFile 
+   * @param {number} pSize 
+   * @returns {number|Promise<number>}
+   */
+  xFileSize(pFile, pSize) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number|Promise<number>}
+   */
+  xLock(pFile, lockType) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number|Promise<number>}
+   */
+  xUnlock(pFile, lockType) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  } 
+
+  /**
+   * @param {number} pFile 
+   * @param {number} pResOut 
+   * @returns {number|Promise<number>}
+   */
+  xCheckReservedLock(pFile, pResOut) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} op 
+   * @param {number} pArg 
+   * @returns {number|Promise<number>}
+   */
+  xFileControl(pFile, op, pArg) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTFOUND;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @returns {number|Promise<number>}
+   */
+  xSectorSize(pFile) {
+    return DEFAULT_SECTOR_SIZE;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @returns {number|Promise<number>}
+   */
+  xDeviceCharacteristics(pFile) {
+    return 0;
+  }
+}
+
+const FILE_TYPE_MASK = [
+  _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_MAIN_DB,
+  _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_MAIN_JOURNAL,
+  _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_TEMP_DB,
+  _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_TEMP_JOURNAL,
+  _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_TRANSIENT_DB,
+  _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_SUBJOURNAL,
+  _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_SUPER_JOURNAL,
+  _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_WAL
+].reduce((mask, element) => mask | element);
+
+/***/ },
+
+/***/ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/LazyLock.js"
+/*!**************************************************************************************************************************!*\
+  !*** ../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/LazyLock.js ***!
+  \**************************************************************************************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   LazyLock: () => (/* binding */ LazyLock)
+/* harmony export */ });
+/* harmony import */ var _Lock_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Lock.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/Lock.js");
+
+
+class LazyLock extends _Lock_js__WEBPACK_IMPORTED_MODULE_0__.Lock {
+  #channel;
+  #isBusy = false;
+  #hasReleaseRequest = false;
+
+  /**
+   * @param {string} name 
+   */
+  constructor(name) {
+    super(name);
+    this.#channel = new BroadcastChannel(name);
+    this.#channel.onmessage = (event) => {
+      if (this.#isBusy) {
+        // We're using the lock so postpone the release.
+        this.#hasReleaseRequest = true;
+      } else {
+        this.release();
+      }
+    }
+  }
+
+  close() {
+    super.close();
+    this.#channel.onmessage = null;
+    this.#channel.close();
+  }
+
+  /**
+   * @param {LockMode} mode 
+   * @param {number} timeout 
+   * @returns {Promise<boolean>}
+   */
+  async acquire(mode, timeout = -1) {
+    this.#isBusy = true;
+    try {
+      if (mode === this.mode) {
+        // We never had to release the lock.
+        return true;
+      }
+
+      if (this.mode) {
+        // Release the lock to acquire it in a different mode.
+        super.release();
+      } else {
+        // Poll for the lock. This isn't necessary but if it works it avoids
+        // the BroadcastChannel traffic.
+        if (await super.acquire(mode, 0)) {
+          return true;
+        }
+      }
+
+      // Request the lock.
+      const pResult = super.acquire(mode, timeout)
+      this.#channel.postMessage({});
+
+      return await pResult;
+    } catch (e) {
+      this.release();
+      throw e;
+    }
+  }
+
+  /**
+   * @param {LockMode} mode 
+   * @returns {boolean}
+   */
+  acquireIfHeld(mode) {
+    if (mode === this.mode) {
+      this.#isBusy = true;
+      return true;
+    }
+    return false;
+  }
+
+  release() {
+    super.release();
+    this.#isBusy = false;
+    this.#hasReleaseRequest = false;
+  }
+
+  releaseLazy() {
+    // Release the lock only if someone else wants it.
+    this.#isBusy = false;
+    if (this.#hasReleaseRequest) {
+      this.release();
+    }
+  }
+}
+
+/***/ },
+
+/***/ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/Lock.js"
+/*!**********************************************************************************************************************!*\
+  !*** ../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/Lock.js ***!
+  \**********************************************************************************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Lock: () => (/* binding */ Lock)
+/* harmony export */ });
+// This is a convenience wrapper for the Web Locks API.
+class Lock {
+  #name;
+  /** @type {LockMode?} */ #mode = null;
+  /** @type {Promise<Function|null>} */ #releaser = Promise.resolve(null);
+  #isAcquiring = false;
+
+  /**
+   * @param {string} name 
+   */
+  constructor(name) {
+    this.#name = name;
+  }
+
+  get name() { return this.#name; }
+  get mode() { return this.#mode; }
+
+  close() {
+    this.release();
+  }
+  
+  /**
+   * @param {'shared'|'exclusive'} mode 
+   * @param {number} timeout -1 for infinite, 0 for poll, >0 for milliseconds
+   * @return {Promise<boolean>} true if lock acquired, false on failed poll
+   */
+  async acquire(mode, timeout = -1) {
+    if (this.#isAcquiring) throw new Error('Lock is already being acquired');
+    this.#isAcquiring = true;
+    try {
+      if (this.#mode) {
+        throw new Error(`Lock ${this.#name} is already acquired`);
+      }
+
+      this.#releaser = new Promise((resolve, reject) => {
+        /** @type {LockOptions} */
+        const options = { mode, ifAvailable: timeout === 0 };
+        if (timeout > 0) {
+          options.signal = AbortSignal.timeout(timeout);
+        }
+
+        navigator.locks.request(this.#name, options, lock => {
+          if (lock === null) {
+            // Polling (with timeout = 0) did not acquire the lock.
+            return resolve(null);
+          }
+
+          // Lock acquired. The lock is released when this returned
+          // Promise is resolved.
+          this.#mode = mode;
+          return new Promise(releaser => {
+            resolve(releaser);
+          })
+        }).catch(e => {
+          return reject(e);
+        });
+      });
+
+      return this.#releaser.then(releaser => !!releaser)
+    } finally {
+      this.#isAcquiring = false;
+    }
+  }
+
+  release() {
+    this.#releaser.then(releaser => releaser?.(), () => {});
+    this.#mode = null;
+  }
+}
+
+
+/***/ },
+
+/***/ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js"
+/*!***********************************************************************************************************************************!*\
+  !*** ../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js ***!
+  \***********************************************************************************************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   OPFSWriteAheadVFS: () => (/* binding */ OPFSWriteAheadVFS)
+/* harmony export */ });
+/* harmony import */ var _FacadeVFS_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../FacadeVFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/FacadeVFS.js");
+/* harmony import */ var _VFS_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../VFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/VFS.js");
+/* harmony import */ var _LazyLock_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./LazyLock.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/LazyLock.js");
+/* harmony import */ var _WriteAhead_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./WriteAhead.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/WriteAhead.js");
+
+
+
+
+
+const LIBRARY_FILES_ROOT = '.wa-sqlite';
+const DEFAULT_TEMP_FILES = 6;
+
+const finalizationRegistry = new FinalizationRegistry((/** @type {() => void} */ f) => f());
+
+/**
+ * @typedef FileEntry
+ * @property {string} zName
+ * @property {number} flags
+ * @property {FileSystemSyncAccessHandle} [accessHandle]
+
+ * Main database file properties:
+ * @property {*} [retryResult]
+ * @property {FileSystemSyncAccessHandle[]} [waHandles]
+ * 
+ * @property {'reserved'|'exclusive'|null} [writeHint]
+ * @property {'normal'|'exclusive'} [lockingMode]
+ * @property {number} [lockState] SQLITE_LOCK_*
+ * @property {LazyLock} [readLock]
+ * @property {LazyLock} [writeLock]
+ * @property {'none'|'read'|'write'|'readwrite'} [useLazyLock]
+ * @property {number} [timeout]
+ * @property {0|1|2|3} [synchronous]
+ * @property {number?} [pageSize]
+ * @property {boolean} [overwrite]
+ * 
+ * @property {WriteAhead} [writeAhead]
+ */
+
+/**
+ * @typedef OPFSWriteAheadOptions
+ * @property {number} [nTmpFiles]
+ * @property {number} [autoCheckpoint]
+ * @property {number} [backstopInterval]
+ */
+
+class OPFSWriteAheadVFS extends _FacadeVFS_js__WEBPACK_IMPORTED_MODULE_0__.FacadeVFS {
+  lastError = null;
+  log = null;
+  
+  /** @type {Map<number, FileEntry>} */ mapIdToFile = new Map();
+  /** @type {Map<string, FileEntry>} */ mapPathToFile = new Map();
+
+  /** @type {Map<string, FileSystemSyncAccessHandle>} */ boundTempFiles = new Map();
+  /** @type {Set<FileSystemSyncAccessHandle>} */ unboundTempFiles = new Set();
+  /** @type {OPFSWriteAheadOptions} */ options = {
+    nTmpFiles: DEFAULT_TEMP_FILES
+  };
+
+  _ready;
+
+  static async create(name, module, options) {
+    const vfs = new OPFSWriteAheadVFS(name, module);
+    Object.assign(vfs.options, options);
+    await vfs.isReady();
+    return vfs;
+  }
+
+  constructor(name, module) {
+    super(name, module);
+    this._ready = (async () => {
+      // Ensure the library files root directory exists.
+      let dirHandle = await navigator.storage.getDirectory();
+      dirHandle = await dirHandle.getDirectoryHandle(LIBRARY_FILES_ROOT, { create: true });
+
+      // Clean up any stale session directories.
+      // @ts-ignore
+      for await (const name of dirHandle.keys()) {
+        if (name.startsWith('.session-')) {
+          // Acquire a lock on the session directory to ensure it is not in use.
+          await navigator.locks.request(name, { ifAvailable: true }, async lock => {
+            if (lock) {
+              // This directory is not in use.
+              try {
+                await dirHandle.removeEntry(name, { recursive: true });
+              } catch (e) {
+                // Ignore errors, will try again next time.
+              }
+            }
+          });
+        }
+      }
+
+      // Create our session directory.
+      const dirName = `.session-${Math.random().toString(16).slice(2)}`;
+      await new Promise(resolve => {
+        navigator.locks.request(dirName, () => {
+          // @ts-ignore
+          resolve();
+          return new Promise(release => {
+            // @ts-ignore
+            finalizationRegistry.register(this, release);
+          });
+        });
+      });
+      dirHandle = await dirHandle.getDirectoryHandle(dirName, { create: true });
+
+      // Create temporary files.
+      for (let i = 0; i < this.options.nTmpFiles; i++) {
+        const fileHandle= await dirHandle.getFileHandle(i.toString(), { create: true });
+        const accessHandle = await fileHandle.createSyncAccessHandle();
+        finalizationRegistry.register(this, () => accessHandle.close());
+        this.unboundTempFiles.add(accessHandle);
+      }
+    })();
+  }
+
+  isReady() {
+    return Promise.all([super.isReady(), this._ready]).then(() => true);
+  }
+
+ /**
+   * @param {string?} zName 
+   * @param {number} fileId 
+   * @param {number} flags 
+   * @param {DataView} pOutFlags 
+   * @returns {number}
+   */
+  jOpen(zName, fileId, flags, pOutFlags) {
+    try {
+      if (zName === null) {
+        // Generate a temporary filename. This will only be used as a
+        // key to map to a pre-opened temporary file access handle.
+        zName = Math.random().toString(16).slice(2);
+      }
+
+      const file = this.mapPathToFile.get(zName) ?? {
+        zName,
+        flags,
+        retryResult: null,
+      };
+      this.mapPathToFile.set(zName, file);
+
+      if (flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        // Open database and journal files with a retry operation.
+        if (file.retryResult === null) {
+          // This is the initial open attempt. Start the asynchronous task
+          // and return SQLITE_BUSY to force a retry.
+          this._module.retryOps.push(this.#retryOpen(zName, flags, fileId, pOutFlags));
+          return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_BUSY;
+        } else if (file.retryResult instanceof Error) {
+          const e = file.retryResult;
+          file.retryResult = null;
+          throw e;
+        }
+
+        // Initialize database file state.
+        file.accessHandle = file.retryResult.accessHandle;
+        file.waHandles = file.retryResult.waHandles;
+        file.writeAhead = file.retryResult.writeAhead;
+        file.retryResult = null;
+
+        file.lockState = _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_NONE;
+        file.lockingMode = 'normal';
+        file.readLock = new _LazyLock_js__WEBPACK_IMPORTED_MODULE_2__.LazyLock(`${zName}#read`);
+        file.writeLock = new _LazyLock_js__WEBPACK_IMPORTED_MODULE_2__.LazyLock(`${zName}#write`);
+        file.useLazyLock = 'readwrite';
+        file.timeout = -1;
+        file.synchronous = 1; // NORMAL
+        file.writeHint = null;
+        file.pageSize = null;
+        file.overwrite = false;
+      } else if (flags & (_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_WAL | _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_SUPER_JOURNAL)) {
+        throw new Error('WAL and super-journal files are not supported');
+      } else if (file.accessHandle) {
+        // This temporary file already has an access handle, which happens
+        // only for tests. Just use it as is.
+      } else {
+        // This is a temporary file. Use an unbound pre-opened accessHandle.
+        if (!(flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_CREATE)) throw new Error('file not found');
+        file.accessHandle = this.#openTemporaryFile(zName);
+      }
+
+      this.mapIdToFile.set(fileId, file);
+      pOutFlags.setInt32(0, flags, true);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      this.mapPathToFile.delete(zName);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_CANTOPEN;
+    }
+  }
+
+  /**
+   * @param {string} zName 
+   * @param {number} syncDir 
+   * @returns {number}
+   */
+  jDelete(zName, syncDir) {
+    try {
+      if (this.boundTempFiles.has(zName)) {
+        const file = this.mapPathToFile.get(zName);
+        this.#deleteTemporaryFile(file);
+      } else {
+        throw new Error(`unexpected file deletion: ${zName}`);
+      }
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_DELETE;
+    }
+  }
+
+  /**
+   * @param {string} zName 
+   * @param {number} flags 
+   * @param {DataView} pResOut 
+   * @returns {number}
+   */
+  jAccess(zName, flags, pResOut) {
+    try {
+      const file = this.mapPathToFile.get(zName);
+      pResOut.setInt32(0, file ? 1 : 0, true);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_ACCESS;
+    }
+  }
+
+  /**
+   * @param {number} fileId 
+   * @returns {number}
+   */
+  jClose(fileId) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+      if (file?.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        file.writeAhead.close();
+        file.accessHandle.close();
+        file.waHandles.forEach(handle => handle.close());
+        this.mapPathToFile.delete(file?.zName);
+
+        file.readLock.close();
+        file.writeLock.close();
+      } else if (file?.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_DELETEONCLOSE) {
+        this.#deleteTemporaryFile(file);
+      }
+
+      // Disassociate fileId from file entry.
+      this.mapIdToFile.delete(fileId);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_CLOSE;
+    }
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset
+   * @returns {number}
+   */
+  jRead(fileId, pData, iOffset) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+
+      let bytesRead = null;
+      if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        // Try reading from the write-ahead overlays first. A read on the
+        // database file is always a complete page, except when reading
+        // from the 100-byte header.
+        const pageOffset = iOffset < 100 ? iOffset : 0;
+        const page = file.writeAhead.read(iOffset - pageOffset);
+        if (page) {
+          const readData = page.subarray(pageOffset, pageOffset + pData.byteLength);
+          pData.set(readData);
+          bytesRead = readData.byteLength;
+        }
+      }
+
+      if (bytesRead === null) {
+        // Read directly from the OPFS file.
+
+        // On Chrome (at least), passing pData to accessHandle.read() is
+        // an error because pData is a Proxy of a Uint8Array. Calling
+        // subarray() produces a real Uint8Array and that works.
+        bytesRead = file.accessHandle.read(pData.subarray(), { at: iOffset });
+      }
+
+      if (bytesRead < pData.byteLength) {
+        pData.fill(0, bytesRead);
+        return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_SHORT_READ;
+      }
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_READ;
+    }
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset
+   * @returns {number}
+   */
+  jWrite(fileId, pData, iOffset) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+      if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        // Write to the write-ahead overlay.
+        const isPageResize = file.overwrite && file.pageSize !== pData.byteLength;
+        file.writeAhead.write(iOffset, pData, {
+          dstPageSize: isPageResize ? file.pageSize : null
+        });
+        return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+      }
+
+      // On Chrome (at least), passing pData to accessHandle.write() is
+      // an error because pData is a Proxy of a Uint8Array. Calling
+      // subarray() produces a real Uint8Array and that works.
+      file.accessHandle.write(pData.subarray(), { at: iOffset });
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_WRITE;
+    }
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {number} iSize 
+   * @returns {number}
+   */
+  jTruncate(fileId, iSize) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+      if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        file.writeAhead.truncate(iSize);
+        return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+      }
+      file.accessHandle.truncate(iSize);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_TRUNCATE;
+    }
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {number} flags 
+   * @returns {number}
+   */
+  jSync(fileId, flags) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+      if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        const durability = file.synchronous > 1 ? 'strict' : 'relaxed';
+        file.writeAhead.sync({ durability });
+      } else {
+        // This is a temporary file so sync is not needed.
+        // Temporary journals are only used for rollback by the
+        // connection that created them, not for recovery.
+      }
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_FSYNC;
+    }
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {DataView} pSize64 
+   * @returns {number}
+   */
+  jFileSize(fileId, pSize64) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+
+      let size;
+      if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        size = file.writeAhead.getFileSize() || file.accessHandle.getSize();
+      } else {
+        size = file.accessHandle.getSize();
+      }
+      pSize64.setBigInt64(0, BigInt(size), true);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_FSTAT;
+    }
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number|Promise<number>}
+   */
+  jLock(pFile, lockType) {
+    try {
+      const file = this.mapIdToFile.get(pFile);
+      if (file.lockState === _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_NONE && lockType === _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_SHARED) {
+        // We do all our locking work in this transition.
+        if (file.retryResult === null) {
+          if (file.lockingMode === 'exclusive') {
+            // Exclusive locking mode is treated as a write, and the
+            // read lock is also acquired to block readers.
+            file.retryResult = {};
+            this._module.retryOps.push(this.#retryLockWrite(file));
+            return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_BUSY;
+          }
+
+          // With WAL, read and write transactions use separate locks. In
+          // each case if the required lock is already held then we can
+          // proceed synchronously. Otherwise we need to acquire state
+          // asynchronously and retry.
+          if (file.writeHint) {
+            // Write transaction.
+            if (!file.writeLock.acquireIfHeld('exclusive')) {
+              file.retryResult = {};
+              this._module.retryOps.push(this.#retryLockWrite(file));
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_BUSY;
+            } else {
+              file.writeAhead.isolateForWrite();
+            }
+          } else {
+            // Read transaction.
+            if (!file.readLock.acquireIfHeld('shared')) {
+              file.retryResult = {};
+              this._module.retryOps.push(this.#retryLockRead(file));
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_BUSY;
+            } else {
+              file.writeAhead.isolateForRead();
+            }
+          }
+        } else if (file.retryResult instanceof Error) {
+          const e = file.retryResult;
+          file.retryResult = null;
+          throw e;
+        }
+
+        // We have acquired the needed locks, either synchronously or
+        // via retry.
+        file.retryResult = null;
+      } else if (lockType >= _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_RESERVED && !file.writeLock.mode) {
+        // This is a write transaction but we don't already have the write
+        // lock. This happens when the write hint was not used, which this
+        // VFS treats as an error.
+        throw new Error('Write transaction cannot use BEGIN DEFERRED');
+      }
+      file.lockState = lockType;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      if (e.name === 'TimeoutError') {
+        return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_BUSY;
+      }
+
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_LOCK;
+    }
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number}
+   */
+  jUnlock(pFile, lockType) {
+    try {
+      const file = this.mapIdToFile.get(pFile);
+
+      // If retryResult is non-null, an asynchronous lock operation is in
+      // progress. In that case, don't change any locks.
+      if (!file.retryResult && lockType === _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_NONE) {
+        // In this VFS, this is the only unlock transition that matters.
+        // Exit write-ahead isolation.
+        file.writeAhead.rejoin();
+
+        // Release any locks.
+        switch (file.useLazyLock) {
+          case 'none':
+            file.writeLock.release();
+            file.readLock.release();
+            break;
+          case 'read':
+            file.writeLock.release();
+            file.readLock.releaseLazy();
+            break;
+          case 'write':
+            file.writeLock.releaseLazy();
+            file.readLock.release();
+            break;
+          case 'readwrite':
+            file.writeLock.releaseLazy();
+            file.readLock.releaseLazy();
+            break;
+        }
+
+        // Reset state for the next transaction.
+        file.writeHint = null;
+      }
+      file.lockState = lockType;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_UNLOCK;
+    }
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {DataView} pResOut 
+   * @returns {number}
+   */
+  jCheckReservedLock(pFile, pResOut) {
+    // A hot journal cannot exist so this method should never be called.
+    console.assert(false, 'unexpected');
+    pResOut.setInt32(0, 0, true);
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile
+   * @param {number} op
+   * @param {DataView} pArg
+   * @returns {number}
+   */
+  jFileControl(pFile, op, pArg) {
+    try {
+      const file = this.mapIdToFile.get(pFile);
+      switch (op) {
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_PRAGMA:
+          const key = this._module.UTF8ToString(pArg.getUint32(4, true));
+          const valueAddress = pArg.getUint32(8, true);
+          const value = valueAddress ? this._module.UTF8ToString(valueAddress) : null;
+          this.log?.(`PRAGMA ${key} ${value}`);
+          switch (key.toLowerCase()) {
+            case 'experimental_pragma_20251114':
+              // After entering the SHARED locking state on the next
+              // transaction, SQLite intends to immediately transition to
+              // RESERVED if value is '1', or EXCLUSIVE if value is '2'.
+              switch (value) {
+                case '1':
+                  file.writeHint = 'reserved';
+                  break;
+                case '2':
+                  file.writeHint = 'exclusive';
+                  break;
+                default:
+                  throw new Error(`unexpected write hint value: ${value}`);
+              }
+              break;
+            case 'backstop_interval':
+              if (value !== null) {
+                const millis = parseInt(value);
+                file.writeAhead.setBackstopInterval(millis);
+              } else {
+                // Return current interval.
+                const s = file.writeAhead.options.backstopInterval.toString();
+                const ptr = this._module._sqlite3_malloc64(s.length + 1);
+                this._module.stringToUTF8(s, ptr, s.length + 1);
+                pArg.setUint32(0, ptr, true);
+              }
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+            case 'busy_timeout':
+              // Override SQLite's handling of busy timeouts with our
+              // blocking lock timeouts.
+              if (value !== null) {
+                file.timeout = parseInt(value);
+              } else {
+                // Return current timeout.
+                const s = file.timeout.toString();
+                const ptr = this._module._sqlite3_malloc64(s.length + 1);
+                this._module.stringToUTF8(s, ptr, s.length + 1);
+                pArg.setUint32(0, ptr, true);
+              }
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+            case 'journal_size_limit':
+              if (value !== null) {
+                const nPages = parseInt(value);
+                file.writeAhead.options.journalSizeLimit = nPages;
+              }
+              break;
+            case 'locking_mode':
+              // Track SQLite locking mode. Exclusive mode requires a
+              // write lock.
+              switch (value?.toLowerCase()) {
+                case 'normal':
+                  file.lockingMode = 'normal';
+                  break;
+                case 'exclusive':
+                  file.lockingMode = 'exclusive';
+                  break;
+              }
+              break;
+            case 'page_size':
+              if (value !== null) {
+                // Valid page sizes are 1 (which maps to 65536) or powers of
+                // two from 512 to 32768.
+                const n = parseInt(value);
+                if (n === 1 || (n >= 512 && n <= 32768 && (n & (n - 1)) === 0)) {
+                  file.pageSize = n === 1 ? 65536 : n;
+                }
+              }
+              break;
+            case 'synchronous':
+              // Track SQLite synchronous mode. Write-ahead transactions
+              // trade durability for performance on values 1 (NORMAL) or
+              // lower.
+              if (value !== null) {
+                switch (value.toLowerCase()) {
+                  case 'off':
+                  case '0':
+                    file.synchronous = 0;
+                    break;
+                  case 'normal':
+                  case '1':
+                    file.synchronous = 1;
+                    break;
+                  case 'full':
+                  case '2':
+                    file.synchronous = 2;
+                    break;
+                  case 'extra':
+                  case '3':
+                    file.synchronous = 3;
+                    break;
+                  default:
+                    throw new Error(`unexpected synchronous value: ${value}`);
+                }
+              }
+              break;
+            case 'vfs_trace':
+              // This is a trace feature for debugging only.
+              if (value !== null) {
+                this.log = parseInt(value) !== 0 ? console.debug : null;
+                file.writeAhead.log = this.log;
+              }
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+            case 'wal_autocheckpoint':
+              // A setting greater than zero enables automatic checkpoints
+              // with this connection (enabled by default).
+              if (value !== null) {
+                file.writeAhead.options.autoCheckpoint = parseInt(value);
+              }
+              break;
+            case 'wal_checkpoint':
+              const checkpointMode = (value ?? 'passive').toLowerCase();
+              switch (checkpointMode) {
+                case 'passive':
+                  this._module.pendingOps.push(this.#pendingCheckpoint(file, checkpointMode));
+                  break;
+                case 'full':
+                case 'restart':
+                case 'truncate':
+                  if (file.writeAhead.isTransactionPending()) {
+                    throw new Error('invalid while a transaction is in progress');
+                  }
+                  this._module.pendingOps.push(this.#pendingCheckpoint(file, checkpointMode));
+                  break;
+                case 'noop':
+                  break;
+                default:
+                  throw new Error(`unexpected wal_checkpoint mode: ${value}`);
+              }
+
+              // Return the approximate number of pages in the WAL before
+              // checkpointing. SQLite returns different information, but
+              // that is not feasible from a VFS.
+              {
+                const s = file.writeAhead.getWriteAheadSize().toString();
+                const ptr = this._module._sqlite3_malloc64(s.length + 1);
+                this._module.stringToUTF8(s, ptr, s.length + 1);
+                pArg.setUint32(0, ptr, true);
+              }
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+            case 'lazy_lock':
+              // Lazy locks don't actually release their Web Lock until
+              // they receive a message requesting it. Typically a setting
+              // of 'readwrite' (default) or 'read' is best.
+              if (value !== null) {
+                const useLazyLock = value.toLowerCase();
+                switch (useLazyLock) {
+                  case 'read':
+                  case 'write':
+                  case 'readwrite':
+                  case 'none':
+                    file.useLazyLock = useLazyLock;
+                    break;
+                  default:
+                    throw new Error(`unexpected value for lazy_lock: ${value}`);
+                }
+              }
+              {
+                const s = file.useLazyLock;
+                const ptr = this._module._sqlite3_malloc64(s.length + 1);
+                this._module.stringToUTF8(s, ptr, s.length + 1);
+                pArg.setUint32(0, ptr, true);
+              }
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+          }
+          break;
+
+        // Support SQLite batch atomic write transactions.
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_BEGIN_ATOMIC_WRITE:
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_COMMIT_ATOMIC_WRITE:
+          if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+            return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+          }
+          break;
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE:
+          if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+            file.writeAhead.rollback();
+            return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+          }
+          break;
+
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_SYNC:
+          if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+            file.writeAhead.commit();
+          }
+          break;
+
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_OVERWRITE:
+          file.overwrite = true;
+          break;
+      }
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR;
+    }
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_NOTFOUND;
+  }
+
+  /**
+   * @param {number} pFile
+   * @returns {number}
+   */
+  jDeviceCharacteristics(pFile) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
+      | _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOCAP_BATCH_ATOMIC;
+  }
+
+  /**
+   * @param {Uint8Array} zBuf 
+   * @returns {number}
+   */
+  jGetLastError(zBuf) {
+    if (this.lastError) {
+      console.error(this.lastError);
+      const outputArray = zBuf.subarray(0, zBuf.byteLength - 1);
+      const { written } = new TextEncoder().encodeInto(this.lastError.message, outputArray);
+      zBuf[written] = 0;
+    }
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK
+  }
+
+  /**
+   * @param {string} zName 
+   * @returns {FileSystemSyncAccessHandle}
+   */
+  #openTemporaryFile(zName) {
+    if (this.unboundTempFiles.size === 0) {
+      throw new Error('no temporary files available');
+    }
+
+    // Bind an access handle from the temporary pool.
+    const accessHandle = this.unboundTempFiles.values().next().value;
+    this.unboundTempFiles.delete(accessHandle);
+    this.boundTempFiles.set(zName, accessHandle);
+    return accessHandle;
+  }
+
+  /**
+   * @param {FileEntry} file 
+   */
+  #deleteTemporaryFile(file) {
+    file.accessHandle.truncate(0);
+
+    // Temporary files are not actually deleted, just returned to the pool.
+    this.mapPathToFile.delete(file.zName);
+    this.unboundTempFiles.add(file.accessHandle);
+    this.boundTempFiles.delete(file.zName);
+  }
+
+  /**
+   * @param {string} dbName 
+   * @param {number} i 
+   * @returns {string}
+   */
+  #getWriteAheadNameFromDbName(dbName, i) {
+    // Our WAL file is not compatible with SQLite WAL, so use a distinct name.
+    return `${dbName}-wa${i}`;
+  }
+
+  /**
+   * Asynchronous PRAGMA operation to checkpoint the write-ahead log.
+   * @param {FileEntry} file 
+   * @param {'passive'|'full'|'restart'|'truncate'} mode 
+   */
+  async #pendingCheckpoint(file, mode) {
+    const onFinally = [];
+    try {
+      if (mode !== 'passive' && file.lockState === _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_NONE) {
+        await file.writeLock.acquire('exclusive');
+        onFinally.push(() => file.writeLock.release());
+
+        file.writeAhead.isolateForWrite();
+        onFinally.push(() => file.writeAhead.rejoin());
+      }
+      
+      await file.writeAhead.checkpoint({ isPassive: mode === 'passive' });
+    } catch (e) {
+      if (e.name === 'AbortError') {
+        e.code = _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_BUSY;
+      }
+      throw e;
+    } finally {
+      while (onFinally.length) {
+        onFinally.pop()();
+      }
+    }
+  }
+
+  /**
+   * @param {FileEntry} file 
+   */
+  async #retryLockRead(file) {
+    const onError = [];
+    try {
+      await file.readLock.acquire('shared', file.timeout);
+      onError.push(() => file.readLock.release());
+
+      file.writeAhead.isolateForRead();
+      file.retryResult = {};
+    } catch (e) {
+      while (onError.length) {
+        onError.pop()();
+      }
+      file.retryResult = e;
+    }
+  }
+
+  /**
+   * @param {FileEntry} file 
+   */
+  async #retryLockWrite(file) {
+    const onError = [];
+    try {
+      // Exclusive locking mode requires both read and write locks.
+      // Otherwise, only the write lock is needed.
+      if (file.lockingMode === 'exclusive') {
+        await file.readLock.acquire('exclusive', file.timeout);
+        onError.push(() => file.readLock.release());
+      }
+
+      await file.writeLock.acquire('exclusive', file.timeout);
+      onError.push(() => file.writeLock.release());
+
+      file.writeAhead.isolateForWrite();
+      file.retryResult = {};
+    } catch (e) {
+      while (onError.length) {
+        onError.pop()();
+      }
+      file.retryResult = e;
+    }
+  }
+
+  /**
+   * Handle asynchronous jOpen() tasks.
+   * @param {string} zName 
+   * @param {number} flags 
+   * @param {number} fileId 
+   * @param {DataView} pOutFlags 
+   * @returns {Promise<void>}
+   */
+  async #retryOpen(zName, flags, fileId, pOutFlags) {
+    /** @type {(() => void)[]} */ const onError = [];
+    const file = this.mapPathToFile.get(zName);
+    try {
+      await navigator.locks.request(`${zName}#ckpt`, async lock => {
+        // Parse the path components.
+        const directoryNames = zName.split('/').filter(d => d);
+        const dbName = directoryNames.pop();
+
+        // Get the OPFS directory handle.
+        let dirHandle = await navigator.storage.getDirectory();
+        const create = !!(flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_CREATE);
+        for (const directoryName of directoryNames) {
+          dirHandle = await dirHandle.getDirectoryHandle(directoryName, { create });
+        }
+
+        const isNewDatabase = create && await (async function() {
+          try {
+            await dirHandle.getFileHandle(dbName);
+            return false;
+          } catch (e) {
+            if (e.name === 'NotFoundError') {
+              return true;
+            }
+            throw e;
+          }
+        })();
+
+        // Convenience function for opening access handles.
+        async function openFile(
+          /** @type {string} */ filename,
+          /** @type {FileSystemGetFileOptions} */ options) {
+          const fileHandle = await dirHandle.getFileHandle(filename, options);
+          // @ts-ignore
+          const accessHandle = await fileHandle.createSyncAccessHandle({
+            mode: 'readwrite-unsafe'
+          });
+          onError.push(() => {
+            accessHandle.close();
+            if (isNewDatabase) {
+              dirHandle.removeEntry(filename);
+            }
+          });
+          return accessHandle;
+        }
+
+        // Open the main database OPFS file.
+        const accessHandle = await openFile(dbName, { create });
+
+        // Open WAL files.
+        const waHandles = await Promise.all([0, 1].map(async i => {
+          const waName = this.#getWriteAheadNameFromDbName(dbName, i);
+          const waHandle = await openFile(waName, { create: true });
+          if (isNewDatabase) {
+            waHandle.truncate(0);
+          }
+          return waHandle;
+        }));
+
+        // Create the write-ahead manager.
+        const writeAhead = new _WriteAhead_js__WEBPACK_IMPORTED_MODULE_3__.WriteAhead(zName, accessHandle, waHandles);
+        await writeAhead.ready();
+
+        file.retryResult = { accessHandle, waHandles, writeAhead };
+      });
+    } catch (e) {
+      while (onError.length) {
+        onError.pop()();
+      }
+      file.retryResult = e;
+    }
+  }
+}
+
+
+/***/ },
+
+/***/ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/WriteAhead.js"
+/*!****************************************************************************************************************************!*\
+  !*** ../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/WriteAhead.js ***!
+  \****************************************************************************************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   WriteAhead: () => (/* binding */ WriteAhead)
+/* harmony export */ });
+/* harmony import */ var _Lock_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Lock.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/Lock.js");
+
+
+const DEFAULT_JOURNAL_SIZE_LIMIT = 1000;
+const DEFAULT_BACKSTOP_INTERVAL = 30_000;
+
+const MAGIC = 0x377f0684;
+const FILE_HEADER_SIZE = 32;
+const FRAME_HEADER_SIZE = 32;
+const FRAME_TYPE_PAGE = 0;
+const FRAME_TYPE_COMMIT = 1;
+const FRAME_TYPE_END = 2;
+
+/**
+ * @typedef PageEntry
+ * @property {number} waOffset location in WAL file
+ * @property {number} waSalt1 WAL2 file identifier
+ * @property {number} pageSize
+ * @property {Uint8Array} [pageData]
+ */
+
+/**
+ * @typedef Transaction
+ * @property {number} id
+ * @property {Map<number, PageEntry>} pages address to page data mapping
+ * @property {number} dbFileSize
+ * @property {number} [newPageSize]
+ * @property {number} waSalt1 WAL2 file identifier
+ * @property {number} waOffsetEnd
+ */
+
+/**
+ * @typedef WriteAheadOptions
+ * @property {number} [autoCheckpoint]
+ * @property {number} [backstopInterval]
+ * @property {number} [journalSizeLimit]
+ */
+
+class WriteAhead {
+
+  log = null;
+  /** @type {WriteAheadOptions} */ options = {
+    autoCheckpoint: 1,
+    backstopInterval: DEFAULT_BACKSTOP_INTERVAL,
+    journalSizeLimit: DEFAULT_JOURNAL_SIZE_LIMIT,
+  };
+
+  #zName;
+  #dbHandle;
+
+  /** @type {FileSystemSyncAccessHandle[]} */ #waHandles;
+  /** @type {FileSystemSyncAccessHandle} */ #activeHandle;
+  /** @type {{nextTxId: number, salt1: number, salt2: number}} */ #activeHeader;
+  /** @type {number} */ #activeOffset;
+  /** @type {number} */ #txId = 0;
+  /** @type {Transaction} */ #txInProgress = null;
+
+  #dbFileSize = 0;
+
+  /** @type {Promise<any>} */ #ready;
+  /** @type {'read'|'write'} */ #isolationState = null;
+
+  /** @type {Lock} */ #txIdLock = null;
+
+  /** @type {Map<number, PageEntry>} */ #waOverlay = new Map();
+  /** @type {Map<number, Transaction>} */ #mapIdToTx = new Map();
+  /** @type {Map<number, Transaction>} */ #mapIdToPendingTx = new Map();
+  #approxPageCount = 0;
+
+  /** @type {BroadcastChannel} */ #broadcastChannel;
+
+  /** @type {number} */ #backstopTimer;
+  /** @type {number} */ #backstopTimestamp = 0;
+
+  #abortController = new AbortController();
+
+  /**
+   * @param {string} zName
+   * @param {FileSystemSyncAccessHandle} dbHandle
+   * @param {FileSystemSyncAccessHandle[]} waHandles
+   * @param {WriteAheadOptions} options
+   */
+  constructor(zName, dbHandle, waHandles, options = {}) {
+    this.#zName = zName;
+    this.#dbHandle = dbHandle;
+    this.#waHandles = waHandles;
+    this.options = Object.assign(this.options, options);
+
+    // All the asynchronous initialization is done here.
+    this.#ready = (async () => {
+      // Set our advertised txId to zero until we know the proper value.
+      await this.#updateTxIdLock();
+
+      // Listen for transactions and checkpoints from other connections.
+      this.#broadcastChannel = new BroadcastChannel(`${zName}#wa`);
+      this.#broadcastChannel.onmessage = (event) => {
+        this.#handleMessage(event);
+      };
+
+      // Read headers from both WAL files and use the one with the
+      // lower nextTxId. If neither header is valid, create a new header.
+      const fileHeader = this.#waHandles
+        .map(handle => this.#readFileHeader(handle))
+        .filter(h => h)
+        .sort((a, b) => a.nextTxId - b.nextTxId)[0]
+        ?? this.#writeFileHeader(Math.floor(Math.random() * 0xffffffff));
+
+      this.#activeHeader = fileHeader;
+      this.#activeHandle = this.#waHandles[fileHeader.salt1 & 1];
+      this.#activeOffset = FILE_HEADER_SIZE;
+      this.#txId = fileHeader.nextTxId - 1;
+
+      // Load all the transactions from the WAL.
+      for (const tx of this.#readAllTx()) {
+        this.#activateTx(tx);
+      }
+      this.#updateTxIdLock(); // doesn't need await
+
+      // Schedule backstop. The backstop is a guard against a crash in
+      // another context between persisting a transaction and broadcasting
+      // it.
+      this.#backstopTimestamp = performance.now();
+      this.#backstop();
+    })();
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  ready() {
+    return this.#ready;
+  }
+
+  close() {
+    this.#abortController.abort();
+
+    // Stop asynchronous maintenance.
+    this.#broadcastChannel.onmessage = null;
+    clearTimeout(this.#backstopTimer);
+
+    this.#txIdLock?.release();
+    this.#broadcastChannel.close();
+  }
+
+  /**
+   * Freeze our view of the database.
+   * The view includes the transactions received so far but is not
+   * guaranteed to be completely up to date. Unfreeze the view with rejoin().
+   */
+  isolateForRead() {
+    if (this.#isolationState !== null) {
+      throw new Error('Already in isolated state');
+    }
+    this.#isolationState = 'read';
+
+    // Disable backstop during isolation.
+    clearTimeout(this.#backstopTimer);
+    this.#backstopTimer = null;
+  }
+
+  /**
+   * Freeze our view of the database for writing.
+   * The view includes all transactions. Unfreeze the view with rejoin().
+   */
+  isolateForWrite() {
+    if (this.#isolationState !== null) {
+      throw new Error('Already in isolated state');
+    }
+    this.#isolationState = 'write';
+
+    // Disable backstop during isolation.
+    clearTimeout(this.#backstopTimer);
+    this.#backstopTimer = null;
+
+    // A writer needs all previous transactions assimilated.
+    this.#advanceTxId({ readToCurrent: true });
+  }
+
+  rejoin() {
+    if (this.#isolationState === 'read') {
+      // Catch up on new transactions that arrived while isolated.
+      this.#advanceTxId({ autoCheckpoint: true });
+    }
+    this.#isolationState = null;
+
+    // Resume backstop after isolation.
+    this.#backstop();
+  }
+
+  /**
+   * @param {number} offset
+   * @return {Uint8Array?}
+   */
+  read(offset) {
+    // First look for the page in any write transaction in progress.
+    // If the page is not found in the transaction overlay, look in the
+    // write-ahead overlay.
+    const pageEntry = this.#txInProgress?.pages.get(offset) ?? this.#waOverlay.get(offset);
+    if (pageEntry) {
+      if (pageEntry.pageData) {
+        // Page data is cached.
+        this.log?.(`%cread page at ${offset} from WAL ${pageEntry.waSalt1 & 1}:${pageEntry.waOffset} (cached)`, 'background-color: gold;');
+        return pageEntry.pageData;
+      }
+
+      // Read the page from the WAL file.
+      this.log?.(`%cread page at ${offset} from WAL ${pageEntry.waSalt1 & 1}:${pageEntry.waOffset}`, 'background-color: gold;');
+      return this.#fetchPage(pageEntry);
+    }
+    return null;
+  }
+
+  /**
+   * @param {number} offset
+   * @param {Uint8Array} data
+   * @param {{dstPageSize: number?}} options
+   */
+  write(offset, data, options) {
+    if (this.#isolationState !== 'write') {
+      throw new Error('Not in write isolated state');
+    }
+
+    if (!this.#txInProgress) {
+      // There is no active transaction so we need to create one. But
+      // first check whether to move to the other WAL file.
+      const nPageThreshold = this.options.journalSizeLimit > 0 ?
+        this.options.journalSizeLimit :
+        DEFAULT_JOURNAL_SIZE_LIMIT;
+      if (this.#approxPageCount >= nPageThreshold && this.#isInactiveFileEmpty()) {
+        this.log?.(`%cchange WAL file at ${this.#approxPageCount} pages`, 'background-color: lightskyblue;');
+        this.#swapActiveFile();
+      }
+
+      this.#beginTx();
+      if (options.dstPageSize !== data.byteLength) {
+        // This is a VACUUM to a new page size. The incoming writes are at
+        // the old page size, but we want to write to the WAL with the new
+        // size.
+        this.#txInProgress.newPageSize = options.dstPageSize;
+      }
+    }
+
+    if (this.#txInProgress.newPageSize) {
+      // The incoming data is not a single page because the page size
+      // is changing. The two cases are when the new page size is
+      // smaller or larger than the old page size.
+      const frameSize = FRAME_HEADER_SIZE + this.#txInProgress.newPageSize;
+      if (data.byteLength > this.#txInProgress.newPageSize) {
+        // New page size is smaller. Write multiple pages of the new
+        // page size.
+        for (let i = 0; i < data.byteLength; i += this.#txInProgress.newPageSize) {
+          const pageData = data.slice(i, i + this.#txInProgress.newPageSize);
+          const waOffset = this.#writePage(offset + i, pageData);
+          this.log?.(`%cwrite page at ${offset + i} to WAL ${this.#activeHeader.salt1 & 1}:${waOffset}`, 'background-color: lightskyblue;');
+        }
+      } else {
+        // New page size is larger. Save the page data to the WAL file
+        // so it can be read back and rewritten as frames with the new
+        // page size.
+        const pageOffset = offset % this.#txInProgress.newPageSize;
+        const waOffset = this.#activeOffset +
+          (offset - pageOffset) / this.#txInProgress.newPageSize * frameSize +
+          FRAME_HEADER_SIZE +
+          pageOffset;
+        this.#activeHandle.write(data.subarray(), { at: waOffset });
+        this.log?.(`%cwrite page at ${offset} to WAL ${this.#activeHeader.salt1 & 1}:${waOffset}`, 'background-color: lightskyblue;');
+      }
+    } else {
+      // This is the normal case without a page size change.
+      const waOffset = this.#writePage(offset, data.slice());
+      this.log?.(`%cwrite page at ${offset} to WAL ${this.#activeHeader.salt1 & 1}:${waOffset}`, 'background-color: lightskyblue;');
+    }
+  }
+
+  /**
+   * @param {number} newSize
+   */
+  truncate(newSize) {
+    // Ignore truncation that happens outside of a transaction. That
+    // only happens (e.g. post-VACUUM) to ensure the file size matches
+    // the database header.
+    if (this.#txInProgress) {
+      // Remove any pages past the truncation point.
+      for (const offset of this.#txInProgress.pages.keys()) {
+        if (offset >= newSize) {
+          this.#txInProgress.pages.delete(offset);
+        }
+      }
+    }
+  }
+
+  getFileSize() {
+    return this.#txInProgress?.dbFileSize ?? this.#dbFileSize;
+  }
+
+  commit() {
+    const tx = this.#txInProgress;
+    if (tx.newPageSize && tx.pages.size === 0) {
+      // This transaction is a VACUUM with a page size increase. All
+      // the database pages have been written to the WAL file at their
+      // new size with blank frame headers. Read the page data back
+      // from the WAL file and rewrite as frames.
+      let pageCount = 1; // to be replaced on the first iteration
+      for (let i = 0; i < pageCount; i++) {
+        // Read the page data.
+        const pageData = new Uint8Array(tx.newPageSize);
+        const waOffset = this.#activeOffset +
+          i * (FRAME_HEADER_SIZE + tx.newPageSize) +
+          FRAME_HEADER_SIZE;
+        this.#activeHandle.read(pageData, { at: waOffset });
+
+        if (i === 0) {
+          // Get the actual page count from the file header.
+          const headerView = new DataView(pageData.buffer);
+          pageCount = headerView.getUint32(28);
+        }
+
+        // Write back as a frame.
+        this.#writePage(i * tx.newPageSize, pageData);
+      }
+    }
+
+    const page1 = this.#txInProgress.pages.get(0)?.pageData;
+    if (page1) {
+      const page1View = new DataView(page1.buffer, page1.byteOffset, page1.byteLength);
+      const pageCount = page1View.getUint32(28);
+      this.#txInProgress.dbFileSize = pageCount * page1.byteLength;
+    } else {
+      // The transaction doesn't include page 1, so this must be a
+      // non-batch-atomic rollback.
+      this.rollback();
+      return;
+    }
+
+    // Persist the final pending transaction page with the database size.
+    this.#commitTx();
+
+    // Incorporate the transaction locally.
+    this.#activateTx(tx);
+    this.#updateTxIdLock();
+
+    // Send the transaction to other connections.
+    const payload = { type: 'tx', tx };
+    this.#broadcastChannel.postMessage(payload);
+
+    this.#autoCheckpoint();
+    this.#backstopTimestamp = performance.now();
+  }
+
+  rollback() {
+    // Discard transaction pages.
+    this.#abortTx();
+  }
+
+  /**
+   * @param {{durability: 'strict'|'relaxed'}} options
+   */
+  sync(options) {
+    if (options.durability === 'strict') {
+      this.#flushActiveFile();
+    }
+  }
+
+  /**
+   * Move pages from write-ahead to main database file.
+   *
+   * @param {{isPassive: boolean}} options
+   */
+  async checkpoint(options = { isPassive: true }) {
+    // Passive checkpointing is abandoned if another connection is
+    // already checkpointing.
+    const lockOptions = {
+      ifAvailable: options.isPassive,
+    };
+
+    await navigator.locks.request(`${this.#zName}#ckpt`, lockOptions, async lock => {
+      if (!lock) return;
+      if (this.#abortController.signal.aborted) return;
+
+      let ckptId = this.#getActiveFileStartingTxId() - 1;
+      if (options.isPassive) {
+        if (!this.#mapIdToTx.has(ckptId)) {
+          // There are no transactions to checkpoint.
+          return;
+        }
+
+        // Scan the txId locks to find the oldest txId.
+        const busyTxId = (await this.#getTxIdLocks())
+          .reduce((min, value) => Math.min(min, value.maxTxId), this.#txId);
+
+        if (busyTxId < ckptId) {
+          // The inactive WAL file is still being used.
+          return;
+        }
+      } else {
+        // Wait for all connections to reach the current txId.
+        await this.#waitForTxIdLocks(value => value.maxTxId >= this.#txId);
+        ckptId = this.#txId;
+      }
+      this.log?.(`%ccheckpoint through txId ${ckptId}`, 'background-color: lightgreen;');
+
+      // Sync the WAL file. This ensures that if there is a crash after
+      // part of the WAL has been copied, the uncopied part will still be
+      // available afterwards.
+      this.#flushInactiveFile();
+      if (!options.isPassive) {
+        this.#flushActiveFile();
+      }
+
+      // Starting at ckptId and going backwards (higher to lower txId),
+      // write transaction pages to the main database file. Do not overwrite
+      // a page written by a more recent transaction.
+      const writtenOffsets = new Set();
+      let dbFileSize = this.#dbHandle.getSize();
+      for (let tx = this.#mapIdToTx.get(ckptId); tx; tx = this.#mapIdToTx.get(tx.id - 1)) {
+        if (tx.id === ckptId && dbFileSize !== tx.dbFileSize) {
+          // Set the file size from the latest transaction.
+          dbFileSize = tx.dbFileSize;
+          this.#dbHandle.truncate(dbFileSize);
+        }
+
+        for (const [offset, pageEntry] of tx.pages) {
+          if (offset < dbFileSize && !writtenOffsets.has(offset)) {
+            // Fetch the page data from the WAL file if not cached.
+            const pageData = pageEntry.pageData ?? this.#fetchPage(pageEntry);
+
+            // Write the page to the database file.
+            const nWritten = this.#dbHandle.write(pageData, { at: offset });
+            if (nWritten !== pageData.byteLength) {
+              throw new Error('Checkpoint write failed');
+            }
+            writtenOffsets.add(offset);
+            this.log?.(`%ccheckpoint wrote txId ${tx.id} page at ${offset} to database`, 'background-color: lightgreen;');
+          }
+        }
+
+        if (tx.newPageSize) {
+          // This transaction used a new page size to overwrite the entire
+          // database file so no older pages need to be written. This is
+          // not just an optimization; it prevents incorrectly writing
+          // older smaller pages at addresses that aren't multiples of
+          // the new page size.
+          break;
+        }
+      }
+
+      // Ensure that database writes are durable.
+      this.log?.(`%ccheckpoint flush database file`, 'background-color: lightgreen;');
+      this.#dbHandle.flush();
+
+      // Notify other connections and ourselves of the checkpoint.
+      this.#broadcastChannel.postMessage({
+        type: 'ckpt',
+        ckptId,
+      });
+      this.#handleCheckpoint(ckptId);
+
+      // Wait for all connections to update their overlay.
+      this.log?.(`%ccheckpoint waiting for connection updates`, 'background-color: lightgreen;');
+      await this.#waitForTxIdLocks(value => value.minTxId > ckptId);
+
+      // Truncate the inactive WAL file. This prevents new connections from
+      // unnecessarily reading checkpointed data, and allows writers to make
+      // it active when their conditions are met.
+      this.#truncateInactiveFile();
+      this.log?.(`%ccheckpoint complete`, 'background-color: lightgreen;');
+    });
+  }
+
+  /**
+   * Return the approximate number of write-ahead pages. This is the
+   * sum of the number of unique page indices for each transaction,
+   * so it can be fewer than the number of pages if any transaction
+   * contains multiple frames for the same page.
+   * @returns {number}
+   */
+  getWriteAheadSize() {
+    return this.#approxPageCount;
+  }
+
+  isTransactionPending() {
+    return !!this.#txInProgress;
+  }
+
+  setBackstopInterval(intervalMillis) {
+    this.options.backstopInterval = intervalMillis;
+    if (intervalMillis > 0 && this.#isolationState) {
+      this.#backstop();
+    }
+  }
+
+  /**
+   * Incorporate a transaction into our view of the database.
+   * @param {Transaction} tx
+   */
+  #activateTx(tx) {
+    // Transfer to the active collection of transactions.
+    this.#mapIdToTx.set(tx.id, tx);
+    this.#approxPageCount += tx.pages.size;
+
+    // Add transaction pages to the write-ahead overlay.
+    for (const [offset, pageEntry] of tx.pages) {
+      this.#waOverlay.set(offset, pageEntry);
+    }
+    this.#dbFileSize = tx.dbFileSize;
+  }
+
+  /**
+   * Advance the local view of the database. By default, advance to the
+   * last broadcast transaction. Optionally, also advance through any
+   * additional transactions in the WAL file to be fully current.
+   *
+   * @param {{readToCurrent?: boolean, autoCheckpoint?: boolean}} options
+   */
+  #advanceTxId(options = {}) {
+    let didAdvance = false;
+    while (this.#mapIdToPendingTx.size) {
+      // Fetch the next transaction in sequence. Usually this will come
+      // from pendingTx, but if it is missing then read it from the file.
+      const nextTxId = this.#txId + 1;
+      let tx;
+      if (this.#mapIdToPendingTx.has(nextTxId)) {
+        // This transaction arrived via message.
+        tx = this.#mapIdToPendingTx.get(nextTxId);
+        this.#mapIdToPendingTx.delete(tx.id);
+
+        // Move the WAL file offset past this transaction.
+        this.#skipTx(tx);
+      } else {
+        // Read the transaction from the WAL file.
+        tx = this.#readTx();
+      }
+
+      this.#activateTx(tx);
+      didAdvance = true;
+    }
+
+    if (options.readToCurrent) {
+      // Read all additional transactions from the WAL file.
+      for (const tx of this.#readAllTx()) {
+        this.#activateTx(tx);
+        didAdvance = true;
+      }
+    }
+
+    if (didAdvance) {
+      // Publish our new view txId.
+      this.#updateTxIdLock();
+
+      if (options.autoCheckpoint) {
+        this.#autoCheckpoint();
+      }
+    }
+
+    if (options.readToCurrent || didAdvance) {
+      // The WAL has been accessed, so reset the backstop.
+      // Calling #backstop() here is not necessary because if we are
+      // in an isolated state then rejoin() will schedule the next call,
+      // and if we are not in an isolated state then the next call
+      // should already be scheduled.
+      this.#backstopTimestamp = performance.now();
+    }
+  }
+
+  #autoCheckpoint() {
+    if (this.options.autoCheckpoint > 0) {
+      this.checkpoint({ isPassive: true });
+    }
+  }
+
+  /**
+   * After a checkpoint, remove checkpointed pages from write-ahead.
+   * The checkpoint may be been done locally or by another connection.
+   * @param {number} ckptId
+   */
+  #handleCheckpoint(ckptId) {
+    this.log?.(`%capply checkpoint through txId ${ckptId}`, 'background-color: lightgreen;');
+
+    // Loop backwards from ckptId.
+    for (let tx = this.#mapIdToTx.get(ckptId); tx; tx = this.#mapIdToTx.get(tx.id - 1)) {
+      // Remove pages from write-ahead overlay.
+      for (const [offset, pageEntry] of tx.pages.entries()) {
+        // Be sure not to remove a newer version of the page.
+        const overlayEntry = this.#waOverlay.get(offset);
+        if (overlayEntry === pageEntry) {
+          this.log?.(`%cremove txId ${tx.id} page at offset ${offset}`, 'background-color: lightgreen;');
+          this.#waOverlay.delete(offset);
+        }
+      }
+
+      // Remove transaction.
+      this.#mapIdToTx.delete(tx.id);
+      this.#approxPageCount -= tx.pages.size;
+    }
+    this.#updateTxIdLock();
+  }
+
+  /**
+   * @param {MessageEvent} event
+   */
+  #handleMessage(event) {
+    if (event.data.type === 'tx') {
+      // New transaction from another connection. Don't use it if we
+      // already have it.
+      /** @type {Transaction} */ const tx = event.data.tx;
+      if (tx.id > this.#txId) {
+        this.#mapIdToPendingTx.set(tx.id, tx);
+        if (this.#isolationState === null) {
+          // Not in an isolated state, so advance our view of the database.
+          this.#advanceTxId({ autoCheckpoint: true });
+        }
+      }
+    } else if (event.data.type === 'ckpt') {
+      // Checkpoint notification from another connection.
+      /** @type {number} */ const ckptId = event.data.ckptId;
+      this.#handleCheckpoint(ckptId);
+    }
+  }
+
+  /**
+   * Periodic check for recovering from lost transaction broadcasts.
+   */
+  #backstop() {
+    if (this.options.backstopInterval <= 0) {
+      // Backstop is disabled.
+      return;
+    }
+
+    if (this.#isolationState) {
+      throw new Error('Backstop was invoked in an isolated state');
+    }
+
+    const now = performance.now();
+    if (now >= this.#backstopTimestamp + this.options.backstopInterval) {
+      // The time since the last WAL access (read, write, or skip) has
+      // exceeded the backstop interval. Check for transactions in the
+      // write-ahead log that have not arrived via message.
+      const oldTxId = this.#txId;
+      this.#advanceTxId({ readToCurrent: true });
+      if (this.#txId > oldTxId) {
+        this.log?.(`%cbackstop txId ${oldTxId} -> ${this.#txId}`, 'background-color: lightyellow;');
+      }
+      this.#backstopTimestamp = performance.now();
+    }
+
+    // Schedule next backstop.
+    const delay = this.#backstopTimestamp + this.options.backstopInterval - performance.now();
+    clearTimeout(this.#backstopTimer);
+    this.#backstopTimer = self.setTimeout(() => {
+      this.#backstop();
+    }, delay);
+  }
+
+  /**
+   * Update the lock that publishes our current txId.
+   */
+  async #updateTxIdLock() {
+    // Our view of the database, i.e. the txId, is encoded into the name
+    // of a lock so other connections can see it. When our txId changes,
+    // we acquire a new lock and release the old one. We must not release
+    // the old lock until the new one is in place.
+    const oldLock = this.#txIdLock;
+    const newLockName = this.#encodeTxIdLockName();
+    if (oldLock?.name !== newLockName) {
+      this.#txIdLock = new _Lock_js__WEBPACK_IMPORTED_MODULE_0__.Lock(newLockName);
+      await this.#txIdLock.acquire('shared').then(() => {
+        // The new lock is acquired.
+        oldLock?.release();
+      });
+
+      if (this.log) {
+        const { minTxId, maxTxId } = this.#decodeTxIdLockName(newLockName);
+        this.log?.(`%ctxId to ${minTxId}:${maxTxId}`, 'background-color: pink;');
+      }
+    }
+  }
+
+  /**
+   * Get all txId locks for this database.
+   * @returns {Promise<{name: string, minTxId: number, maxTxId: number, encoded: string}[]>}
+   */
+  async #getTxIdLocks() {
+    const { held } = await navigator.locks.query();
+    return held
+      .map(lock => this.#decodeTxIdLockName(lock.name))
+      .filter(value => value !== null);
+  }
+
+  /**
+   * @returns {string}
+   */
+  #encodeTxIdLockName() {
+    // The maxTxId is our current view of the database. The minTxId is
+    // the lowest txId we get pages from the WAL for, which is the lowest
+    // key in mapIdToTx. If mapIdToTx is empty then we aren't reading
+    // from the WAL at all - in this case we arbitrarily set minTxId to
+    // invalid value maxTxId + 1.
+    //
+    // Use radix 36 to encode integer values to reduce the lock name length.
+    const maxTxId = this.#txId;
+    const minTxId = this.#mapIdToTx.keys().next().value ?? (maxTxId + 1);
+    return `${this.#zName}-txId<${minTxId.toString(36)}:${maxTxId.toString(36)}>`;
+  }
+
+  /**
+   * @param {string} lockName
+   * @returns {{name: string, minTxId: number, maxTxId: number, encoded: string}?}
+   */
+  #decodeTxIdLockName(lockName) {
+    const match = lockName.match(/^(.*)-txId<([0-9a-z]+):([0-9a-z]+)>$/);
+    if (match?.[1] === this.#zName) {
+      // This txId lock is for this database.
+      return {
+        name: match[1],
+        minTxId: parseInt(match[2], 36),
+        maxTxId: parseInt(match[3], 36),
+        encoded: lockName
+      };
+    }
+    return null;
+  }
+
+  /**
+   * Wait for all txId locks that fail the provided predicate.
+   * @param {(lock: {name: string, minTxId: number, maxTxId: number}) => boolean} predicate
+   */
+  async #waitForTxIdLocks(predicate) {
+    /** @type {string[]} */ let failingLockNames = [];
+    do {
+      // Wait for all connections that fail the predicate.
+      if (failingLockNames.length > 0) {
+        await Promise.all(
+          failingLockNames.map(name => navigator.locks.request(name, async () => {}))
+        );
+      }
+
+      // Refresh the list of failing locks.
+      failingLockNames = (await this.#getTxIdLocks())
+        .filter(value => !predicate(value))
+        .map(value => value.encoded);
+    } while (failingLockNames.length > 0);
+  }
+
+  /**
+   * @param {PageEntry} pageEntry
+   * @returns {Uint8Array}
+   */
+  #fetchPage(pageEntry) {
+    // Get the appropriate access handle based on salt parity.
+    const accessHandle = this.#waHandles[pageEntry.waSalt1 & 1];
+
+    // Read the page.
+    const pageData = new Uint8Array(pageEntry.pageSize);
+    const nBytesRead = accessHandle.read(pageData, { at: pageEntry.waOffset });
+
+    if (nBytesRead !== pageEntry.pageSize) {
+      throw new Error(`Short WAL read: expected ${pageEntry.pageSize} bytes, got ${nBytesRead}`);
+    }
+    return pageData;
+  }
+
+  *#readAllTx() {
+    while (true) {
+      const tx = this.#readTx();
+      if (!tx) break;
+      yield tx;
+    }
+  }
+
+  /**
+   * @returns {Transaction?}
+   */
+  #readTx() {
+    // Read the next complete transaction or return null.
+    /** @type {Transaction} */ const tx = {
+      id: 0, // placeholder
+      pages: new Map(),
+      dbFileSize: 0, // placeholder
+      waSalt1: 0, // placeholder
+      waOffsetEnd: 0, // placeholder
+    };
+
+    // The property this.#activeOffset is only advanced on a successful
+    // transition to the other WAL file or on reading a complete
+    // transaction. Use a local variable to track our progress.
+    let offset = this.#activeOffset;
+    while (true) {
+      const frame = this.#readFrame(offset);
+      if (!frame) return null;
+
+      if (frame.frameType === FRAME_TYPE_PAGE) {
+        tx.pages.set(
+          frame.pageOffset,
+          {
+            pageSize: frame.pageData.byteLength,
+            waOffset: offset + FRAME_HEADER_SIZE,
+            waSalt1: this.#activeHeader.salt1,
+          }
+        );
+      } else if (frame.frameType === FRAME_TYPE_COMMIT) {
+        // The transaction is complete. Update the instance state.
+        this.#txId += 1;
+        this.#activeOffset = offset + frame.byteLength;
+
+        // Finalize the transaction fields and return it.
+        tx.id = this.#txId;
+        tx.dbFileSize = frame.dbFileSize;
+        tx.waSalt1 = this.#activeHeader.salt1;
+        tx.newPageSize = (frame.flags & 1) ? tx.pages.get(0).pageSize : null;
+        tx.waOffsetEnd = this.#activeOffset;
+        return tx;
+      } else if (frame.frameType === FRAME_TYPE_END) {
+        // No more transactions on the current WAL file. Switch to the
+        // other file.
+        this.#followFileChange(frame.fileHeader);
+        offset = this.#activeOffset;
+        continue;
+      }
+
+      offset += frame.byteLength;
+    }
+  }
+
+  /**
+   * This method is called when transaction(s) have been received by other
+   * means than readTx(), e.g. via BroadcastChannel.
+   *
+   * @param {Transaction} tx
+   */
+  #skipTx(tx) {
+    if (tx.waSalt1 !== this.#activeHeader.salt1) {
+      // This transaction is on the other WAL file.
+      if (!this.#followFileChange(null)) {
+        throw new Error('invalid WAL file');
+      }
+    }
+
+    this.#txId = tx.id;
+    this.#activeOffset = tx.waOffsetEnd;
+  }
+
+  /**
+   * @param {{overwrite?: boolean}} options
+   * @returns {Transaction}
+   */
+  #beginTx(options = {}) {
+    this.#txInProgress = {
+      id: this.#txId + 1,
+      pages: new Map(),
+      dbFileSize: this.#dbFileSize,
+      waSalt1: this.#activeHeader.salt1,
+      waOffsetEnd: this.#activeOffset,
+    };
+    return this.#txInProgress;
+  }
+
+  /**
+   * Write a page frame to the WAL file.
+   *
+   * @param {number} pageOffset
+   * @param {Uint8Array} pageData
+   */
+  #writePage(pageOffset, pageData) {
+    const headerView = new DataView(new ArrayBuffer(FRAME_HEADER_SIZE));
+    headerView.setUint8(0, FRAME_TYPE_PAGE);
+    headerView.setUint16(2, pageData.byteLength === 65536 ? 1 : pageData.byteLength);
+    headerView.setBigUint64(8, BigInt(pageOffset));
+    headerView.setUint32(16, this.#activeHeader.salt1);
+    headerView.setUint32(20, this.#activeHeader.salt2);
+
+    const checksum = new Checksum();
+    checksum.update(new Uint8Array(headerView.buffer, 0, FRAME_HEADER_SIZE - 8));
+    checksum.update(pageData);
+    headerView.setUint32(24, checksum.s0);
+    headerView.setUint32(28, checksum.s1);
+
+    const bytesWritten =
+      this.#activeHandle.write(headerView, { at: this.#txInProgress.waOffsetEnd }) +
+      this.#activeHandle.write(pageData, {
+        at: this.#txInProgress.waOffsetEnd + FRAME_HEADER_SIZE,
+      });
+    if (bytesWritten !== headerView.byteLength + pageData.byteLength) {
+      throw new Error('write failed');
+    }
+
+    // Cache page 1 as a performance optimization and to exercise the
+    // cache code path.
+    const pageEntry = {
+      pageSize: pageData.byteLength,
+      waOffset: this.#txInProgress.waOffsetEnd + FRAME_HEADER_SIZE,
+      waSalt1: this.#activeHeader.salt1,
+      pageData: pageOffset === 0 ? pageData : undefined
+    };
+    this.#txInProgress.pages.set(pageOffset, pageEntry);
+    this.#txInProgress.waOffsetEnd += bytesWritten;
+
+    return pageEntry.waOffset;
+  }
+
+  /**
+   * @returns {Transaction}
+   */
+  #commitTx() {
+    // Write a commit frame - which is a special frame header with no
+    // body - to the WAL file.
+    const headerView = new DataView(new ArrayBuffer(FRAME_HEADER_SIZE));
+    headerView.setUint8(0, FRAME_TYPE_COMMIT);
+    headerView.setUint8(1, this.#txInProgress.newPageSize ? 1 : 0);
+    headerView.setBigUint64(8, BigInt(this.#txInProgress.dbFileSize));
+    headerView.setUint32(16, this.#activeHeader.salt1);
+    headerView.setUint32(20, this.#activeHeader.salt2);
+
+    const checksum = new Checksum();
+    checksum.update(new Uint8Array(headerView.buffer, 0, FRAME_HEADER_SIZE - 8));
+    headerView.setUint32(24, checksum.s0);
+    headerView.setUint32(28, checksum.s1);
+
+    const bytesWritten = this.#activeHandle.write(headerView, {
+      at: this.#txInProgress.waOffsetEnd,
+    });
+    if (bytesWritten !== headerView.byteLength) {
+      throw new Error('write failed');
+    }
+    this.#txInProgress.waOffsetEnd += bytesWritten;
+
+    const tx = this.#txInProgress;
+    this.#txInProgress = null;
+    this.#activeOffset = tx.waOffsetEnd;
+    this.#txId = tx.id;
+    return tx;
+  }
+
+  #abortTx() {
+    this.#txInProgress = null;
+    this.#activeHandle.truncate(this.#activeOffset);
+  }
+
+  /**
+   * Switch the active WAL file prior to writing the next transaction.
+   */
+  #swapActiveFile() {
+    // Write an end frame to terminate the currently active WAL file.
+    const frameView = new DataView(new ArrayBuffer(FRAME_HEADER_SIZE));
+    frameView.setUint8(0, FRAME_TYPE_END);
+    frameView.setUint32(16, this.#activeHeader.salt1);
+    frameView.setUint32(20, this.#activeHeader.salt2);
+
+    const checksum = new Checksum();
+    checksum.update(new Uint8Array(frameView.buffer, 0, FRAME_HEADER_SIZE - 8));
+    frameView.setUint32(24, checksum.s0);
+    frameView.setUint32(28, checksum.s1);
+
+    const bytesWritten = this.#activeHandle.write(frameView, { at: this.#activeOffset });
+    if (bytesWritten !== frameView.byteLength) {
+      throw new Error('write failed');
+    }
+
+    // Initialize the other WAL file and make it active.
+    this.#activeHeader = this.#writeFileHeader();
+    this.#activeHandle = this.#getInactiveHandle();
+    this.#activeOffset = FILE_HEADER_SIZE;
+  }
+
+  #getActiveFileStartingTxId() {
+    return this.#activeHeader.nextTxId;
+  }
+
+  #flushActiveFile() {
+    this.#activeHandle.flush();
+  }
+
+  #flushInactiveFile() {
+    const accessHandle = this.#getInactiveHandle();
+    accessHandle.flush();
+  }
+
+  #isInactiveFileEmpty() {
+    if (this.#mapIdToTx.has(this.#activeHeader.nextTxId - 1)) {
+      // At least one transaction on the inactive file has not been
+      // checkpointed.
+      return false;
+    }
+
+    const inactiveHandle = this.#getInactiveHandle();
+    if (inactiveHandle.getSize() < FILE_HEADER_SIZE) {
+      // The inactive file is smaller than the minimum size for a valid
+      // WAL file.
+      return true;
+    }
+
+    // This test is sufficient by itself but the previous tests are
+    // less expensive.
+    return this.#readFileHeader(inactiveHandle) === null;
+  }
+
+  #truncateInactiveFile() {
+    const accessHandle = this.#getInactiveHandle();
+    accessHandle.truncate(0);
+  }
+
+  /**
+   * This method is called after reading an end frame to switch to the
+   * other WAL file.
+   * @param {{nextTxId: number, salt1: number, salt2: number}?} fileHeader
+   */
+  #followFileChange(fileHeader) {
+    // As an optimization, the file header can be passed as an argument
+    // if it has already been read and validated. Otherwise that is
+    // done here.
+    const accessHandle = this.#getInactiveHandle();
+    if (!fileHeader) {
+      fileHeader = this.#readFileHeader(accessHandle);
+      if (fileHeader?.salt1 !== ((this.#activeHeader.salt1 + 1) >>> 0)) return null;
+    }
+
+    this.#activeHandle = accessHandle;
+    this.#activeHeader = fileHeader;
+    this.#activeOffset = FILE_HEADER_SIZE;
+    return fileHeader;
+  }
+
+  #getInactiveHandle() {
+    return this.#activeHandle !== this.#waHandles[0] ?
+      this.#waHandles[0] :
+      this.#waHandles[1];
+  }
+
+  /**
+   * @param {FileSystemSyncAccessHandle} accessHandle
+   */
+  #readFileHeader(accessHandle) {
+    const headerView = new DataView(new ArrayBuffer(FILE_HEADER_SIZE));
+    if (accessHandle.read(headerView, { at: 0 }) !== headerView.byteLength) {
+      return null;
+    }
+
+    if (headerView.getUint32(0) !== MAGIC) return null;
+
+    const checksum = new Checksum();
+    checksum.update(new Uint8Array(headerView.buffer, 0, FILE_HEADER_SIZE - 8));
+    if (!checksum.matches(headerView.getUint32(24), headerView.getUint32(28))) {
+      return null;
+    }
+
+    return {
+      nextTxId: Number(headerView.getBigUint64(8)),
+      salt1: headerView.getUint32(16),
+      salt2: headerView.getUint32(20),
+    };
+  }
+
+  /**
+   * @param {number} offset
+   */
+  #readFrame(offset) {
+    const headerView = new DataView(new ArrayBuffer(FRAME_HEADER_SIZE));
+    if (this.#activeHandle.read(headerView, { at: offset }) !== headerView.byteLength) {
+      // EOF, not an error.
+      return null;
+    }
+
+    // Verify the frame header salt values match the file header.
+    const frameSalt1 = headerView.getUint32(16);
+    const frameSalt2 = headerView.getUint32(20);
+    if (frameSalt1 !== this.#activeHeader.salt1 || frameSalt2 !== this.#activeHeader.salt2) {
+      // Not necessarily an error, could be from a restart without truncation.
+      return null;
+    }
+
+    const payloadSize = (size => size === 1 ? 65536 : size)(headerView.getUint16(2));
+    /** @type {Uint8Array} */ let payloadData;
+    if (payloadSize) {
+      payloadData = new Uint8Array(payloadSize);
+      const payloadBytesRead = this.#activeHandle.read(
+        payloadData,
+        { at: offset + FRAME_HEADER_SIZE }
+      );
+      if (payloadBytesRead !== payloadSize) return null;
+    }
+
+    const checksum = new Checksum();
+    checksum.update(new Uint8Array(headerView.buffer, 0, FRAME_HEADER_SIZE - 8));
+    if (payloadData) {
+      checksum.update(payloadData);
+    }
+    if (!checksum.matches(headerView.getUint32(24), headerView.getUint32(28))) {
+      // Not necessarily an error, could be from a restart without truncation.
+      return null;
+    }
+
+    const frameType = headerView.getUint8(0);
+    if (frameType === FRAME_TYPE_PAGE) {
+      return {
+        frameType,
+        byteLength: FRAME_HEADER_SIZE + payloadSize,
+        pageOffset: Number(headerView.getBigUint64(8)),
+        pageData: payloadData,
+      };
+    } else if (frameType === FRAME_TYPE_COMMIT) {
+      return {
+        frameType,
+        byteLength: FRAME_HEADER_SIZE,
+        flags: headerView.getUint8(1),
+        dbFileSize: Number(headerView.getBigUint64(8)),
+      };
+    } else if (frameType === FRAME_TYPE_END) {
+      // Handling the end frame and new file header must be atomic, so
+      // we validate the new file header before returning the frame.
+      // If the file header is corrupt, the end frame effectively does
+      // not exist.
+      //
+      // A corrupt file header should be repaired by the next writer
+      // that attempts to swap WAL files.
+      const fileHeader = this.#readFileHeader(this.#getInactiveHandle());
+      if (fileHeader?.salt1 !== ((this.#activeHeader.salt1 + 1) >>> 0)) return null;
+
+      return {
+        frameType,
+        byteLength: FRAME_HEADER_SIZE,
+        fileHeader,
+      };
+    }
+    throw new Error(`Invalid frame type: ${frameType}`);
+  }
+
+  #writeFileHeader(prevSalt1 = this.#activeHeader.salt1) {
+    // Derive new values from the previous values.
+    const nextTxId = this.#txId + 1;
+    const salt1 = (prevSalt1 + 1) >>> 0;
+    const salt2 = Math.floor(Math.random() * 0xffffffff) >>> 0;
+    const headerView = new DataView(new ArrayBuffer(FILE_HEADER_SIZE));
+    headerView.setUint32(0, MAGIC);
+    headerView.setBigUint64(8, BigInt(nextTxId));
+    headerView.setUint32(16, salt1);
+    headerView.setUint32(20, salt2);
+
+    const checksum = new Checksum();
+    checksum.update(new Uint8Array(headerView.buffer, 0, FILE_HEADER_SIZE - 8));
+    headerView.setUint32(24, checksum.s0);
+    headerView.setUint32(28, checksum.s1);
+
+    // The even/odd parity of salt1 determines which file is written to.
+    const accessHandle = this.#waHandles[salt1 & 1];
+    const bytesWritten = accessHandle.write(headerView, { at: 0 });
+    if (bytesWritten !== headerView.byteLength) {
+      throw new Error('write failed');
+    }
+
+    return { nextTxId, salt1, salt2 };
+  }
+}
+
+// https://www.sqlite.org/fileformat.html#checksum_algorithm
+class Checksum {
+  /** @type {number} */ s0 = 0;
+  /** @type {number} */ s1 = 0;
+
+  /**
+   * @param {ArrayBuffer|ArrayBufferView} data
+   */
+  update(data) {
+    if ((data.byteLength % 8) !== 0) throw new Error('Data must be a multiple of 8 bytes');
+    const words = ArrayBuffer.isView(data) ?
+      new Uint32Array(data.buffer, data.byteOffset, data.byteLength / 4) :
+      new Uint32Array(data);
+    for (let i = 0; i < words.length; i += 2) {
+      this.s0 = (this.s0 + words[i] + this.s1) >>> 0;
+      this.s1 = (this.s1 + words[i + 1] + this.s0) >>> 0;
+    }
+  }
+
+  matches(s0, s1) {
+    return this.s0 === s0 && this.s1 === s1;
+  }
+}
+
+
+/***/ }
+
+}]);
+//# sourceMappingURL=node_modules_pnpm_journeyapps_wa-sqlite_1_7_0_node_modules_journeyapps_wa-sqlite_src_examples-2fb422.umd.js.map