indexeddbshim 17.4.3 → 17.6.0

package/dist/indexeddbshim-UnicodeIdentifiers-node.cjs

@@ -1,12 +1,11 @@
-/*! indexeddbshim - v17.4.3 - 8/29/2026 */
+/*! indexeddbshim - v17.6.0 - 9/1/2026 */
 
 'use strict';
 
 var fs$1 = require('node:fs');
 var path = require('node:path');
-var require$$0 = require('fs');
-var require$$1 = require('path');
-var require$$2 = require('util');
+var customOpenDatabase = require('websql-configurable/custom/index.js');
+var SQLiteDatabase = require('websql-configurable/lib/sqlite/SQLiteDatabase.js');
 
 /* eslint-disable no-restricted-syntax -- Instanceof checks */
 /* eslint-disable unicorn/no-this-assignment -- TS */
@@ -1567,7 +1566,7 @@ val => {
 
 // @ts-nocheck
 
-function getDefaultExportFromCjs$1(x) {
+function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 var regex$1;
@@ -1579,7 +1578,7 @@ function requireRegex() {
   return regex$1;
 }
 var regexExports = requireRegex();
-var regex = /*@__PURE__*/getDefaultExportFromCjs$1(regexExports);
+var regex = /*@__PURE__*/getDefaultExportFromCjs(regexExports);
 
 /* eslint-disable new-cap -- ToString is how it is defined */
 
@@ -4948,7 +4947,7 @@ const readonlyProperties$4 = ['objectStoreNames', 'mode', 'durability', 'db', 'e
  *   __requestsFinished: boolean,
  *   __transFinishedCb: (err: boolean, cb: ((bool?: boolean) => void)) => void,
  *   __callTransFinishedCb: (err: boolean, cb: ((bool?: boolean) => void)) => void,
- *   __transactionEndCallback: () => void,
+ *   __transactionEndCallback: (() => void)|undefined,
  *   __transactionFinished: boolean,
  *   __completed: boolean,
  *   __transFinishedCbFired: boolean,
@@ -4983,6 +4982,19 @@ const readonlyProperties$4 = ['objectStoreNames', 'mode', 'durability', 'db', 'e
  * }} IDBTransactionFull
  */
 
+/**
+ * @param {IDBTransactionFull} tx
+ * @returns {void}
+ */
+function releaseFinishedTransaction(tx) {
+  const pos = tx.db.__transactions.indexOf(tx);
+  if (pos !== -1) {
+    tx.db.__transactions.splice(pos, 1);
+  }
+  tx.__transactionEndCallback = undefined;
+  tx.__requests = [];
+}
+
 /**
  * The IndexedDB Transaction.
  * @see https://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#idl-def-IDBTransaction
@@ -5540,6 +5552,7 @@ IDBTransaction.prototype.__executeRequests = function () {
       } finally {
         activeTransactions.delete(me);
         me.__storeHandles = {};
+        releaseFinishedTransaction(me);
       }
     }
     if (me.mode === 'readwrite' || me.mode === 'readonly') {
@@ -5824,6 +5837,7 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
         me.dispatchEvent(evt);
         me.__storeHandles = {};
         me.dispatchEvent(createEvent('__abort'));
+        releaseFinishedTransaction(me);
       }, 0);
       return undefined;
     }).catch(err => {
@@ -10229,9 +10243,7 @@ function triggerAnyVersionChangeAndBlockedEvents(openConnections, req, oldVersio
 /**
  * @typedef {import('websql-configurable/lib/websql/WebSQLDatabase.js').default & {
  *   _db: {
- *     _db: {
- *       close: (errBack: (err: Error) => void) => void
- *     }
+ *     close: (errBack: (err: Error) => void) => void
  *   }
  * }} DatabaseFull
  */
@@ -10309,7 +10321,7 @@ function closeCachedWebSQLConnections(name, cb) {
     return;
   }
   dbs.forEach(db => {
-    const sqliteDB = db._db && db._db._db;
+    const sqliteDB = db._db;
     if (!sqliteDB || !sqliteDB.close) {
       remaining--;
       if (remaining === 0) {
@@ -10351,9 +10363,9 @@ function cleanupDatabaseResources(__openDatabase, name, escapedDatabaseName, dat
       databaseDeleted();
       return;
     }
-    const sqliteDB = latestSQLiteDBCached._db && latestSQLiteDBCached._db._db;
+    const sqliteDB = latestSQLiteDBCached._db;
     if (!sqliteDB || !sqliteDB.close) {
-      console.error('The `openDatabase` implementation does not have the expected `._db._db.close` method for closing the database');
+      console.error('The `openDatabase` implementation does not have the expected `._db.close` method for closing the database');
       return;
     }
     sqliteDB.close(
@@ -11159,7 +11171,7 @@ IDBFactory.prototype.databases = function () {
   let calledDbCreateError = false;
   // Snapshotted *now*, synchronously, at call time -- not read later
   // from inside the SQL query's callback below, which runs on a
-  //   deferred macrotask (see `nodeSQLiteDatabase.js`'s `exec`) and so
+  //   deferred macrotask (see `websql-configurable`'s `SQLiteDatabase#exec`) and so
   //   could otherwise race against (and lose to) an in-flight upgrade's
   //   own commit/abort handler clearing its `pendingVersionChanges`
   //   entry in the meantime -- which would make this method incorrectly
@@ -12970,1999 +12982,6 @@ function setGlobalVars(idb, initialConfig) {
   return /** @type {ShimmedObject} */IDB;
 }
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-var nextTick = {};
-
-var hasRequiredNextTick;
-function requireNextTick() {
-  if (hasRequiredNextTick) return nextTick;
-  hasRequiredNextTick = 1;
-  nextTick.test = function () {
-    // Don't get fooled by e.g. browserify environments.
-    return typeof process !== 'undefined' && !process.browser;
-  };
-  nextTick.install = function (func) {
-    return function () {
-      process.nextTick(func);
-    };
-  };
-  return nextTick;
-}
-
-var queueMicrotask$1 = {};
-
-var hasRequiredQueueMicrotask;
-function requireQueueMicrotask() {
-  if (hasRequiredQueueMicrotask) return queueMicrotask$1;
-  hasRequiredQueueMicrotask = 1;
-  queueMicrotask$1.test = function () {
-    return typeof commonjsGlobal.queueMicrotask === 'function';
-  };
-  queueMicrotask$1.install = function (func) {
-    return function () {
-      commonjsGlobal.queueMicrotask(func);
-    };
-  };
-  return queueMicrotask$1;
-}
-
-var mutation = {};
-
-var hasRequiredMutation;
-function requireMutation() {
-  if (hasRequiredMutation) return mutation;
-  hasRequiredMutation = 1;
-  //based off rsvp https://github.com/tildeio/rsvp.js
-  //license https://github.com/tildeio/rsvp.js/blob/master/LICENSE
-  //https://github.com/tildeio/rsvp.js/blob/master/lib/rsvp/asap.js
-
-  var Mutation = commonjsGlobal.MutationObserver || commonjsGlobal.WebKitMutationObserver;
-  mutation.test = function () {
-    return Mutation;
-  };
-  mutation.install = function (handle) {
-    var called = 0;
-    var observer = new Mutation(handle);
-    var element = commonjsGlobal.document.createTextNode('');
-    observer.observe(element, {
-      characterData: true
-    });
-    return function () {
-      element.data = called = ++called % 2;
-    };
-  };
-  return mutation;
-}
-
-var messageChannel = {};
-
-var hasRequiredMessageChannel;
-function requireMessageChannel() {
-  if (hasRequiredMessageChannel) return messageChannel;
-  hasRequiredMessageChannel = 1;
-  messageChannel.test = function () {
-    if (commonjsGlobal.setImmediate) {
-      // we can only get here in IE10
-      // which doesn't handel postMessage well
-      return false;
-    }
-    return typeof commonjsGlobal.MessageChannel !== 'undefined';
-  };
-  messageChannel.install = function (func) {
-    var channel = new commonjsGlobal.MessageChannel();
-    channel.port1.onmessage = func;
-    return function () {
-      channel.port2.postMessage(0);
-    };
-  };
-  return messageChannel;
-}
-
-var stateChange = {};
-
-var hasRequiredStateChange;
-function requireStateChange() {
-  if (hasRequiredStateChange) return stateChange;
-  hasRequiredStateChange = 1;
-  stateChange.test = function () {
-    return 'document' in commonjsGlobal && 'onreadystatechange' in commonjsGlobal.document.createElement('script');
-  };
-  stateChange.install = function (handle) {
-    return function () {
-      // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
-      // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
-      var scriptEl = commonjsGlobal.document.createElement('script');
-      scriptEl.onreadystatechange = function () {
-        handle();
-        scriptEl.onreadystatechange = null;
-        scriptEl.parentNode.removeChild(scriptEl);
-        scriptEl = null;
-      };
-      commonjsGlobal.document.documentElement.appendChild(scriptEl);
-      return handle;
-    };
-  };
-  return stateChange;
-}
-
-var timeout = {};
-
-var hasRequiredTimeout;
-function requireTimeout() {
-  if (hasRequiredTimeout) return timeout;
-  hasRequiredTimeout = 1;
-  timeout.test = function () {
-    return true;
-  };
-  timeout.install = function (t) {
-    return function () {
-      setTimeout(t, 0);
-    };
-  };
-  return timeout;
-}
-
-var lib$1;
-var hasRequiredLib$1;
-function requireLib$1() {
-  if (hasRequiredLib$1) return lib$1;
-  hasRequiredLib$1 = 1;
-  var types = [requireNextTick(), requireQueueMicrotask(), requireMutation(), requireMessageChannel(), requireStateChange(), requireTimeout()];
-  var draining;
-  var currentQueue;
-  var queueIndex = -1;
-  var queue = [];
-  var scheduled = false;
-  function cleanUpNextTick() {
-    if (!draining || !currentQueue) {
-      return;
-    }
-    draining = false;
-    if (currentQueue.length) {
-      queue = currentQueue.concat(queue);
-    } else {
-      queueIndex = -1;
-    }
-    if (queue.length) {
-      nextTick();
-    }
-  }
-
-  //named nextTick for less confusing stack traces
-  function nextTick() {
-    if (draining) {
-      return;
-    }
-    scheduled = false;
-    draining = true;
-    var len = queue.length;
-    var timeout = setTimeout(cleanUpNextTick);
-    while (len) {
-      currentQueue = queue;
-      queue = [];
-      while (currentQueue && ++queueIndex < len) {
-        currentQueue[queueIndex].run();
-      }
-      queueIndex = -1;
-      len = queue.length;
-    }
-    currentQueue = null;
-    queueIndex = -1;
-    draining = false;
-    clearTimeout(timeout);
-  }
-  var scheduleDrain;
-  var i = -1;
-  var len = types.length;
-  while (++i < len) {
-    if (types[i] && types[i].test && types[i].test()) {
-      scheduleDrain = types[i].install(nextTick);
-      break;
-    }
-  }
-  // v8 likes predictible objects
-  function Item(fun, array) {
-    this.fun = fun;
-    this.array = array;
-  }
-  Item.prototype.run = function () {
-    var fun = this.fun;
-    var array = this.array;
-    switch (array.length) {
-      case 0:
-        return fun();
-      case 1:
-        return fun(array[0]);
-      case 2:
-        return fun(array[0], array[1]);
-      case 3:
-        return fun(array[0], array[1], array[2]);
-      default:
-        return fun.apply(null, array);
-    }
-  };
-  lib$1 = immediate;
-  function immediate(task) {
-    var args = new Array(arguments.length - 1);
-    if (arguments.length > 1) {
-      for (var i = 1; i < arguments.length; i++) {
-        args[i - 1] = arguments[i];
-      }
-    }
-    queue.push(new Item(task, args));
-    if (!scheduled && !draining) {
-      scheduled = true;
-      scheduleDrain();
-    }
-  }
-  return lib$1;
-}
-
-var libExports$1 = requireLib$1();
-var immediate = /*@__PURE__*/getDefaultExportFromCjs(libExports$1);
-
-var tinyQueue;
-var hasRequiredTinyQueue;
-function requireTinyQueue() {
-  if (hasRequiredTinyQueue) return tinyQueue;
-  hasRequiredTinyQueue = 1;
-
-  // Simple FIFO queue implementation to avoid having to do shift()
-  // on an array, which is slow.
-
-  function Queue() {
-    this.length = 0;
-  }
-  Queue.prototype.push = function (item) {
-    var node = {
-      item: item
-    };
-    if (this.last) {
-      this.last = this.last.next = node;
-    } else {
-      this.last = this.first = node;
-    }
-    this.length++;
-  };
-  Queue.prototype.shift = function () {
-    var node = this.first;
-    if (node) {
-      this.first = node.next;
-      if (! --this.length) {
-        this.last = undefined;
-      }
-      return node.item;
-    }
-  };
-  Queue.prototype.slice = function (start, end) {
-    start = typeof start === 'undefined' ? 0 : start;
-    end = typeof end === 'undefined' ? Infinity : end;
-    var output = [];
-    var i = 0;
-    for (var node = this.first; node; node = node.next) {
-      if (--end < 0) {
-        break;
-      } else if (++i > start) {
-        output.push(node.item);
-      }
-    }
-    return output;
-  };
-  tinyQueue = Queue;
-  return tinyQueue;
-}
-
-var tinyQueueExports = requireTinyQueue();
-var Queue = /*@__PURE__*/getDefaultExportFromCjs(tinyQueueExports);
-
-var noopFn;
-var hasRequiredNoopFn;
-function requireNoopFn() {
-  if (hasRequiredNoopFn) return noopFn;
-  hasRequiredNoopFn = 1;
-  noopFn = function () {};
-  return noopFn;
-}
-
-var noopFnExports = requireNoopFn();
-var noop = /*@__PURE__*/getDefaultExportFromCjs(noopFnExports);
-
-/**
- *
- */
-class WebSQLRows {
-  /**
-   * @param {unknown[]} array
-   */
-  constructor(array) {
-    this._array = array;
-    this.length = array.length;
-  }
-
-  /**
-   * @param {number} i
-   */
-  item(i) {
-    return this._array[i];
-  }
-}
-
-/**
- *
- */
-class WebSQLResultSet {
-  /**
-   * @param {number} [insertId]
-   * @param {number} [rowsAffected]
-   * @param {unknown[]} [rows]
-   */
-  constructor(insertId, rowsAffected, rows) {
-    this.insertId = insertId;
-    this.rowsAffected = rowsAffected;
-    this.rows = new WebSQLRows(rows || []);
-  }
-}
-
-/**
- * These deliberately don't reuse the WebSQL spec's global
- * `SQLStatementCallback`/`SQLStatementErrorCallback`/`SQLError` types:
- * this library never constructs a real `SQLError` (errors here are
- * always plain `Error`s coming from the underlying SQL driver), and
- * `WebSQLResultSet#insertId`/`rowsAffected` are genuinely `number |
- * undefined` (see `massageSQLResult` below), which the spec's
- * `SQLResultSet` doesn't allow. Typing against the spec here would just
- * paper over that mismatch with unsound casts.
- * @typedef {(transaction: WebSQLTransaction, resultSet: WebSQLResultSet) => void} SqlCallback
- * @typedef {(transaction: WebSQLTransaction, error: Error) => boolean | void} SqlErrorCallback
- */
-
-/**
- *
- */
-function errorUnhandled() {
-  return true; // a non-truthy return indicates error was handled
-}
-
-// WebSQL has some bizarre behavior regarding insertId/rowsAffected. To try
-// to match the observed behavior of Chrome/Safari as much as possible, we
-// sniff the SQL message to try to massage the returned insertId/rowsAffected.
-// This helps us pass the tests, although it's error-prone and should
-// probably be revised.
-/**
- * @param {string} sql
- * @param {number} [insertId]
- * @param {number} [rowsAffected]
- * @param {unknown[]} [rows]
- */
-function massageSQLResult(sql, insertId, rowsAffected, rows) {
-  if (/^\s*UPDATE\b/iu.test(sql)) {
-    // insertId is always undefined for "UPDATE" statements
-    insertId = undefined;
-  } else if (/^\s*CREATE\s+TABLE\b/iu.test(sql)) {
-    // WebSQL always returns an insertId of 0 for "CREATE TABLE" statements
-    insertId = 0;
-    rowsAffected = 0;
-  } else if (/^\s*DROP\s+TABLE\b/iu.test(sql)) {
-    // WebSQL always returns insertId=undefined and rowsAffected=0
-    // for "DROP TABLE" statements. Go figure.
-    insertId = undefined;
-    rowsAffected = 0;
-  } else if (!/^\s*INSERT\b/iu.test(sql)) {
-    // for all non-inserts (deletes, etc.) insertId is always undefined
-    // ¯\_(ツ)_/¯
-    insertId = undefined;
-  }
-  return new WebSQLResultSet(insertId, rowsAffected, rows);
-}
-
-/**
- *
- */
-class SQLTask {
-  /**
-   * @param {string} sql
-   * @param {unknown[]} args
-   * @param {SqlCallback} sqlCallback
-   * @param {SqlErrorCallback} sqlErrorCallback
-   */
-  constructor(sql, args, sqlCallback, sqlErrorCallback) {
-    this.sql = sql;
-    this.args = args;
-    this.sqlCallback = sqlCallback;
-    this.sqlErrorCallback = sqlErrorCallback;
-  }
-}
-
-/**
- * @param {WebSQLTransaction} self
- * @param {SQLTask[]} batch
- */
-function runBatch(self, batch) {
-  /**
-   *
-   */
-  function onDone() {
-    self._running = false;
-    runAllSql(self);
-  }
-  const {
-    readOnly
-  } = self._task;
-  self._websqlDatabase._db.exec(batch, readOnly, function (err, results) {
-    /* c8 ignore next */
-    if (err || !results) {
-      self._error = err || new Error('exec() did not return results');
-      onDone();
-      return;
-    }
-    for (const [i, res] of results.entries()) {
-      const batchTask = batch[i];
-      if (res.error) {
-        if (batchTask.sqlErrorCallback(self, res.error)) {
-          // user didn't handle the error
-          self._error = res.error;
-          onDone();
-          return;
-        }
-      } else {
-        try {
-          batchTask.sqlCallback(self, massageSQLResult(batch[i].sql, res.insertId, res.rowsAffected, res.rows));
-        } catch (err) {
-          self._error = /** @type {Error} */err;
-          runAllSql(self);
-        }
-      }
-    }
-    onDone();
-  });
-}
-
-/**
- * @param {WebSQLTransaction} self
- */
-function runAllSql(self) {
-  if (self._running || self._complete) {
-    return;
-  }
-  if (self._error) {
-    self._complete = true;
-    self._websqlDatabase._onTransactionComplete(self._error, self);
-    return;
-  }
-  if (!self._sqlQueue.length) {
-    // Do not mark `_complete` here: the caller (via `nonstandardTransCb`,
-    // see `WebSQLDatabase#_onTransactionComplete`) may choose to defer the
-    // actual commit/rollback decision, in which case more SQL might still
-    // be queued via `executeSql()` later and must still be able to run.
-    // `_complete` is only set once that decision is actually final (see
-    // `_onTransactionComplete`'s `done`).
-    self._websqlDatabase._onTransactionComplete(self._error, self);
-    return;
-  }
-  self._running = true;
-  /** @type {SQLTask[]} */
-  const batch = [];
-  let task;
-  while (task = self._sqlQueue.shift()) {
-    batch.push(task);
-  }
-  runBatch(self, batch);
-}
-
-/**
- * @param {WebSQLTransaction} self
- * @param {string} sql
- * @param {unknown[]} args
- * @param {SqlCallback} sqlCallback
- * @param {SqlErrorCallback} sqlErrorCallback
- * @param {import('../types.js').Delay} executeDelay
- */
-function executeSql(self, sql, args, sqlCallback, sqlErrorCallback, executeDelay) {
-  self._sqlQueue.push(new SQLTask(sql, args, sqlCallback, sqlErrorCallback));
-  if (self._runningTimeout) {
-    return;
-  }
-  self._runningTimeout = true;
-  executeDelay(function () {
-    self._runningTimeout = false;
-    runAllSql(self);
-  });
-}
-
-/**
- *
- */
-class WebSQLTransaction {
-  /**
-   * @param {import('./WebSQLDatabase.js').default} websqlDatabase
-   * @param {import('./WebSQLDatabase.js').TransactionTask} task
-   * @param {import('../types.js').Delay} [executeDelay]
-   */
-  constructor(websqlDatabase, task, executeDelay) {
-    this._websqlDatabase = websqlDatabase;
-    this._task = task;
-    /** @type {Error | null} */
-    this._error = null;
-    this._complete = false;
-    this._running = false;
-    this._runningTimeout = false;
-    this._executeDelay = executeDelay || immediate;
-    /** @type {import('tiny-queue').default<SQLTask>} */
-    this._sqlQueue = new Queue();
-    if (!task.readOnly) {
-      // A read-only task never needs a transaction wrapper for its own
-      // sake (reads don't need atomicity against each other) -- true
-      // whether or not `concurrentReaders` (see `WebSQLDatabase`) lets
-      // multiple read-only tasks actually run at once. This is a perf
-      // boost either way. A non-read-only task always still gets one, and
-      // always still runs with full exclusivity (see
-      // `WebSQLDatabase#runNextTransaction`).
-      this._sqlQueue.push(new SQLTask('BEGIN;', [], noop, noop));
-    }
-  }
-
-  /**
-   * @param {string} sql
-   * @param {unknown[]} [args]
-   * @param {SqlCallback} [sqlCallback]
-   * @param {SqlErrorCallback} [sqlErrorCallback]
-   */
-  executeSql(sql, args, sqlCallback, sqlErrorCallback) {
-    args = Array.isArray(args) ? args : [];
-    sqlCallback = typeof sqlCallback === 'function' ? sqlCallback : noop;
-    sqlErrorCallback = typeof sqlErrorCallback === 'function' ? sqlErrorCallback : errorUnhandled;
-    executeSql(this, sql, args, sqlCallback, sqlErrorCallback, this._executeDelay);
-  }
-
-  /**
-   * Not a true `#private` method: `WebSQLDatabase` calls this right after
-   * handing a freshly-created transaction to the caller's `txnCallback`.
-   */
-  // eslint-disable-next-line unicorn/prefer-private-class-fields -- see above
-  _checkDone() {
-    runAllSql(this);
-  }
-}
-
-/**
- * @typedef {(
- *   currentTask: TransactionTask,
- *   err: Error | null,
- *   done: (er?: Error | boolean | null) => void,
- *   rollback: (err: Error | boolean, cb: () => void) => void,
- *   commit: (cb: () => void) => void
- * ) => boolean} NonstandardTransCb
- */
-
-const ROLLBACK = [{
-  sql: 'ROLLBACK;',
-  args: []
-}];
-const COMMIT = [{
-  sql: 'END;',
-  args: []
-}];
-
-/**
- * V8 likes predictable objects.
- */
-class TransactionTask {
-  /**
-   * @param {boolean} readOnly
-   * @param {(trans: WebSQLTransaction) => void} txnCallback
-   * @param {(err: Error) => void} errorCallback
-   * @param {() => void} successCallback
-   * @param {NonstandardTransCb} [nonstandardTransCb]
-   */
-  constructor(readOnly, txnCallback, errorCallback, successCallback, nonstandardTransCb) {
-    this.readOnly = readOnly;
-    this.txnCallback = txnCallback;
-    this.errorCallback = errorCallback;
-    this.successCallback = successCallback;
-    this.nonstandardTransCb = nonstandardTransCb;
-  }
-}
-
-/**
- * The WebSQL `Database` object.
- */
-class WebSQLDatabase {
-  /**
-   * @param {string} dbVersion
-   * @param {import('../types.js').SqlDriver} db
-   * @param {import('../types.js').WebSQLOverrides} webSQLOverrides
-   */
-  constructor(dbVersion, db, webSQLOverrides) {
-    this.version = dbVersion;
-    this._db = db;
-    /** @type {import('tiny-queue').default<TransactionTask>} */
-    this._txnQueue = new Queue();
-    // Off by default: queued transactions -- read or write alike -- run
-    // strictly one at a time, in the order requested, per the WebSQL spec
-    // (see `#runNextTransaction`). When true, any number of read-only
-    // tasks may instead run concurrently; a non-read-only task still
-    // always runs with full exclusivity either way.
-    this._concurrentReaders = Boolean(webSQLOverrides.concurrentReaders);
-    /** @type {Set<TransactionTask>} */
-    this._activeReaders = new Set();
-    /** @type {TransactionTask | null} */
-    this._activeWriter = null;
-    this._transactionDelay = webSQLOverrides.transactionDelay || immediate;
-    this._executeDelay = webSQLOverrides.executeDelay || immediate;
-  }
-
-  /**
-   * @param {TransactionTask} task
-   */
-  #runTransaction(task) {
-    const txn = new WebSQLTransaction(this, task, this._executeDelay);
-    this._transactionDelay(() => {
-      task.txnCallback(txn);
-      txn._checkDone();
-    });
-  }
-
-  /**
-   * Starts as many queued tasks as the current lock state allows. With
-   * `concurrentReaders` off (the default), a task only starts once
-   * nothing else is active at all -- full mutual exclusion, matching the
-   * WebSQL spec's strict one-at-a-time, in-request-order guarantee (see
-   * this file's own test suite, "callback order 2"). With it on, any
-   * leading run of read-only tasks can all start together instead
-   * (concurrent reads are always fine); a non-read-only task still needs
-   * exclusivity regardless, so nothing past it may start until it
-   * finishes. Not starvation-proof in the `concurrentReaders` case -- a
-   * steady stream of arriving readers could in principle keep a waiting
-   * writer waiting indefinitely -- but that's an acceptable tradeoff over
-   * the added complexity of tracking arrival order across reader/writer
-   * kinds.
-   */
-  #runNextTransaction() {
-    for (;;) {
-      const [nextTask] = this._txnQueue.slice(0, 1);
-      if (!nextTask) {
-        return;
-      }
-      const readerMayShare = this._concurrentReaders && nextTask.readOnly;
-      if (readerMayShare) {
-        if (this._activeWriter) {
-          return;
-        }
-      } else if (this._activeWriter || this._activeReaders.size) {
-        return;
-      }
-      this._txnQueue.shift();
-      if (nextTask.readOnly) {
-        this._activeReaders.add(nextTask);
-      } else {
-        this._activeWriter = nextTask;
-      }
-      this.#runTransaction(nextTask);
-    }
-  }
-
-  /**
-   * @param {boolean} readOnly
-   * @param {(trans: WebSQLTransaction) => void} txnCallback
-   * @param {(err: Error) => void} [errorCallback]
-   * @param {() => void} [successCallback]
-   * @param {NonstandardTransCb} [nonstandardTransCb]
-   */
-  #createTransaction(readOnly, txnCallback, errorCallback, successCallback, nonstandardTransCb) {
-    errorCallback ||= noop;
-    successCallback ||= noop;
-    if (typeof txnCallback !== 'function') {
-      throw new TypeError('The callback provided as parameter 1 is not a function.');
-    }
-    this._txnQueue.push(new TransactionTask(readOnly, txnCallback, errorCallback, successCallback, nonstandardTransCb));
-    this.#runNextTransaction();
-  }
-
-  /**
-   * Not a true `#private` method: `WebSQLTransaction` calls this on its
-   * owning `WebSQLDatabase` once it's finished running its SQL queue.
-   * @param {Error | null} err
-   * @param {WebSQLTransaction} transaction
-   */
-  // eslint-disable-next-line unicorn/prefer-private-class-fields -- see above
-  _onTransactionComplete(err, transaction) {
-    const task = transaction._task;
-    /**
-     * @param {Error | boolean | null} [er]
-     */
-    const done = er => {
-      if (transaction) {
-        // Only now -- once the transaction has genuinely committed, rolled
-        // back, or been confirmed read-only-complete -- is it truly done.
-        // Marking this any earlier (e.g. as soon as its SQL queue merely
-        // looked empty) would permanently stop it from accepting further
-        // `executeSql()` calls even when `nonstandardTransCb` (below) chose
-        // to defer the commit/rollback decision instead of finalizing here.
-        transaction._complete = true;
-      }
-      if (er) {
-        task.errorCallback(/** @type {Error} */er);
-      } else {
-        task.successCallback();
-      }
-      if (task.readOnly) {
-        this._activeReaders.delete(task);
-      } else if (this._activeWriter === task) {
-        this._activeWriter = null;
-      }
-      this.#runNextTransaction();
-    };
-    /**
-     * @param {Error | boolean} er
-     * @param {() => void} [cb]
-     */
-    const rollback = (er, cb) => {
-      this._db.exec(ROLLBACK, false, () => {
-        done(er);
-        if (cb) {
-          cb();
-        }
-      });
-    };
-    /**
-     * @param {() => void} [cb]
-     */
-    const commit = cb => {
-      this._db.exec(COMMIT, false, () => {
-        done();
-        if (cb) {
-          cb();
-        }
-      });
-    };
-    if (task.nonstandardTransCb) {
-      const cont = task.nonstandardTransCb.call(this, task, err, done, rollback, commit);
-      if (!cont) {
-        return;
-      }
-    }
-    if (task.readOnly) {
-      done(err); // read-only doesn't require a transaction
-    } else if (err) {
-      rollback(err);
-    } else {
-      commit();
-    }
-  }
-
-  /**
-   * @param {(trans: WebSQLTransaction) => void} txnCallback
-   * @param {(err: Error) => void} [errorCallback]
-   * @param {() => void} [successCallback]
-   * @param {NonstandardTransCb} [nonstandardTransCb]
-   */
-  transaction(txnCallback, errorCallback, successCallback, nonstandardTransCb) {
-    this.#createTransaction(false, txnCallback, errorCallback, successCallback, nonstandardTransCb);
-  }
-
-  /**
-   * @param {(trans: WebSQLTransaction) => void} txnCallback
-   * @param {(err: Error) => void} [errorCallback]
-   * @param {() => void} [successCallback]
-   * @param {NonstandardTransCb} [nonstandardTransCb]
-   */
-  readTransaction(txnCallback, errorCallback, successCallback, nonstandardTransCb) {
-    this.#createTransaction(true, txnCallback, errorCallback, successCallback, nonstandardTransCb);
-  }
-}
-
-/**
- * @template Opts
- * @param {import('./types.js').SqlDriverConstructor<Opts>} SQLiteDatabase
- * @param {{ sqlite?: Opts, websql?: import('./types.js').WebSQLOverrides }} [opts]
- */
-function customOpenDatabase(SQLiteDatabase, opts) {
-  opts ||= {};
-  const sqliteOpts = opts.sqlite;
-  const webSQLOverrides = opts.websql || {};
-  const openDelay = webSQLOverrides.openDelay || immediate;
-
-  /**
-   * @param {string} dbName
-   * @param {string} dbVersion
-   */
-  function createDb(dbName, dbVersion) {
-    const sqliteDatabase = new SQLiteDatabase(dbName, sqliteOpts);
-    return new WebSQLDatabase(dbVersion, sqliteDatabase, webSQLOverrides);
-  }
-
-  /**
-   * @param {unknown[]} args
-   * @throws {Error} If fewer than 4 arguments are given.
-   */
-  function openDatabase(args) {
-    if (args.length < 4) {
-      throw new Error('Failed to execute \'openDatabase\': ' + '4 arguments required, but only ' + args.length + ' present');
-    }
-    const dbName = /** @type {string} */args[0];
-    const dbVersion = /** @type {string} */args[1];
-    // db description and size are ignored
-    const callback = /** @type {((db: WebSQLDatabase) => void) | undefined} */args[4];
-    const db = createDb(dbName, dbVersion);
-    if (typeof callback === 'function') {
-      const onOpen = callback;
-      openDelay(function () {
-        onOpen(db);
-      });
-    }
-    return db;
-  }
-  return (/** @type {unknown[]} */...args) => openDatabase(args);
-}
-
-var lib = {exports: {}};
-
-var util = {};
-
-var hasRequiredUtil;
-function requireUtil() {
-  if (hasRequiredUtil) return util;
-  hasRequiredUtil = 1;
-  util.getBooleanOption = (options, key) => {
-    let value = false;
-    if (key in options && typeof (value = options[key]) !== 'boolean') {
-      throw new TypeError(`Expected the "${key}" option to be a boolean`);
-    }
-    return value;
-  };
-  util.cppdb = Symbol();
-  util.inspect = Symbol.for('nodejs.util.inspect.custom');
-  return util;
-}
-
-var sqliteError;
-var hasRequiredSqliteError;
-function requireSqliteError() {
-  if (hasRequiredSqliteError) return sqliteError;
-  hasRequiredSqliteError = 1;
-  class SqliteError extends Error {
-    constructor(message, code) {
-      if (typeof code !== 'string') {
-        throw new TypeError('Expected second argument to be a string');
-      }
-      super('' + message);
-      this.code = code;
-      if (typeof Error.captureStackTrace === 'function') {
-        Error.captureStackTrace(this, SqliteError);
-      }
-    }
-  }
-  Object.defineProperty(SqliteError.prototype, 'name', {
-    value: 'SqliteError',
-    writable: true,
-    enumerable: false,
-    configurable: true
-  });
-  sqliteError = SqliteError;
-  return sqliteError;
-}
-
-var wrappers = {};
-
-var hasRequiredWrappers;
-function requireWrappers() {
-  if (hasRequiredWrappers) return wrappers;
-  hasRequiredWrappers = 1;
-  const {
-    cppdb
-  } = requireUtil();
-  wrappers.prepare = function prepare(sql) {
-    return this[cppdb].prepare(sql, this, false, false);
-  };
-  wrappers.exec = function exec(sql) {
-    this[cppdb].exec(sql);
-    return this;
-  };
-  wrappers.close = function close() {
-    this[cppdb].close();
-    return this;
-  };
-  wrappers.loadExtension = function loadExtension(...args) {
-    this[cppdb].loadExtension(...args);
-    return this;
-  };
-  wrappers.defaultSafeIntegers = function defaultSafeIntegers(...args) {
-    this[cppdb].defaultSafeIntegers(...args);
-    return this;
-  };
-  wrappers.unsafeMode = function unsafeMode(...args) {
-    this[cppdb].unsafeMode(...args);
-    return this;
-  };
-  wrappers.getters = {
-    name: {
-      get: function name() {
-        return this[cppdb].name;
-      },
-      enumerable: true
-    },
-    open: {
-      get: function open() {
-        return this[cppdb].open;
-      },
-      enumerable: true
-    },
-    inTransaction: {
-      get: function inTransaction() {
-        return this[cppdb].inTransaction;
-      },
-      enumerable: true
-    },
-    readonly: {
-      get: function readonly() {
-        return this[cppdb].readonly;
-      },
-      enumerable: true
-    },
-    memory: {
-      get: function memory() {
-        return this[cppdb].memory;
-      },
-      enumerable: true
-    }
-  };
-  return wrappers;
-}
-
-var transaction;
-var hasRequiredTransaction;
-function requireTransaction() {
-  if (hasRequiredTransaction) return transaction;
-  hasRequiredTransaction = 1;
-  const {
-    cppdb
-  } = requireUtil();
-  const controllers = new WeakMap();
-  transaction = function transaction(fn) {
-    if (typeof fn !== 'function') throw new TypeError('Expected first argument to be a function');
-    const db = this[cppdb];
-    const controller = getController(db, this);
-    const {
-      apply
-    } = Function.prototype;
-
-    // Each version of the transaction function has these same properties
-    const properties = {
-      default: {
-        value: wrapTransaction(apply, fn, db, controller.default)
-      },
-      deferred: {
-        value: wrapTransaction(apply, fn, db, controller.deferred)
-      },
-      immediate: {
-        value: wrapTransaction(apply, fn, db, controller.immediate)
-      },
-      exclusive: {
-        value: wrapTransaction(apply, fn, db, controller.exclusive)
-      },
-      database: {
-        value: this,
-        enumerable: true
-      }
-    };
-    Object.defineProperties(properties.default.value, properties);
-    Object.defineProperties(properties.deferred.value, properties);
-    Object.defineProperties(properties.immediate.value, properties);
-    Object.defineProperties(properties.exclusive.value, properties);
-
-    // Return the default version of the transaction function
-    return properties.default.value;
-  };
-
-  // Return the database's cached transaction controller, or create a new one
-  const getController = (db, self) => {
-    let controller = controllers.get(db);
-    if (!controller) {
-      const shared = {
-        commit: db.prepare('COMMIT', self, false, false),
-        rollback: db.prepare('ROLLBACK', self, false, false),
-        savepoint: db.prepare('SAVEPOINT `\t_bs3.\t`', self, false, false),
-        release: db.prepare('RELEASE `\t_bs3.\t`', self, false, false),
-        rollbackTo: db.prepare('ROLLBACK TO `\t_bs3.\t`', self, false, false)
-      };
-      controllers.set(db, controller = {
-        default: Object.assign({
-          begin: db.prepare('BEGIN', self, false, false)
-        }, shared),
-        deferred: Object.assign({
-          begin: db.prepare('BEGIN DEFERRED', self, false, false)
-        }, shared),
-        immediate: Object.assign({
-          begin: db.prepare('BEGIN IMMEDIATE', self, false, false)
-        }, shared),
-        exclusive: Object.assign({
-          begin: db.prepare('BEGIN EXCLUSIVE', self, false, false)
-        }, shared)
-      });
-    }
-    return controller;
-  };
-
-  // Return a new transaction function by wrapping the given function
-  const wrapTransaction = (apply, fn, db, {
-    begin,
-    commit,
-    rollback,
-    savepoint,
-    release,
-    rollbackTo
-  }) => function sqliteTransaction() {
-    let before, after, undo;
-    if (db.inTransaction) {
-      before = savepoint;
-      after = release;
-      undo = rollbackTo;
-    } else {
-      before = begin;
-      after = commit;
-      undo = rollback;
-    }
-    before.run();
-    try {
-      const result = apply.call(fn, this, arguments);
-      if (result && typeof result.then === 'function') {
-        throw new TypeError('Transaction function cannot return a promise');
-      }
-      after.run();
-      return result;
-    } catch (ex) {
-      if (db.inTransaction) {
-        undo.run();
-        if (undo !== rollback) after.run();
-      }
-      throw ex;
-    }
-  };
-  return transaction;
-}
-
-var pragma;
-var hasRequiredPragma;
-function requirePragma() {
-  if (hasRequiredPragma) return pragma;
-  hasRequiredPragma = 1;
-  const {
-    getBooleanOption,
-    cppdb
-  } = requireUtil();
-  pragma = function pragma(source, options) {
-    if (options == null) options = {};
-    if (typeof source !== 'string') throw new TypeError('Expected first argument to be a string');
-    if (typeof options !== 'object') throw new TypeError('Expected second argument to be an options object');
-    const simple = getBooleanOption(options, 'simple');
-    const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true, false);
-    return simple ? stmt.pluck().get() : stmt.all();
-  };
-  return pragma;
-}
-
-var explain;
-var hasRequiredExplain;
-function requireExplain() {
-  if (hasRequiredExplain) return explain;
-  hasRequiredExplain = 1;
-  const {
-    cppdb
-  } = requireUtil();
-  explain = function explain(source) {
-    if (typeof source !== 'string') throw new TypeError('Expected first argument to be a string');
-    const stmt = this[cppdb].prepare(`EXPLAIN ${source}`, this, false, true);
-    return stmt.all();
-  };
-  return explain;
-}
-
-var backup;
-var hasRequiredBackup;
-function requireBackup() {
-  if (hasRequiredBackup) return backup;
-  hasRequiredBackup = 1;
-  const fs = require$$0;
-  const path = require$$1;
-  const {
-    promisify
-  } = require$$2;
-  const {
-    cppdb
-  } = requireUtil();
-  const fsAccess = promisify(fs.access);
-  backup = async function backup(filename, options) {
-    if (options == null) options = {};
-
-    // Validate arguments
-    if (typeof filename !== 'string') throw new TypeError('Expected first argument to be a string');
-    if (typeof options !== 'object') throw new TypeError('Expected second argument to be an options object');
-
-    // Interpret options
-    filename = filename.trim();
-    const attachedName = 'attached' in options ? options.attached : 'main';
-    const handler = 'progress' in options ? options.progress : null;
-
-    // Validate interpreted options
-    if (!filename) throw new TypeError('Backup filename cannot be an empty string');
-    if (filename === ':memory:') throw new TypeError('Invalid backup filename ":memory:"');
-    if (typeof attachedName !== 'string') throw new TypeError('Expected the "attached" option to be a string');
-    if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
-    if (handler != null && typeof handler !== 'function') throw new TypeError('Expected the "progress" option to be a function');
-
-    // Make sure the specified directory exists
-    await fsAccess(path.dirname(filename)).catch(() => {
-      throw new TypeError('Cannot save backup because the directory does not exist');
-    });
-    const isNewFile = await fsAccess(filename).then(() => false, () => true);
-    return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
-  };
-  const runBackup = (backup, handler) => {
-    let rate = 0;
-    let useDefault = true;
-    return new Promise((resolve, reject) => {
-      setImmediate(function step() {
-        try {
-          const progress = backup.transfer(rate);
-          if (!progress.remainingPages) {
-            backup.close();
-            resolve(progress);
-            return;
-          }
-          if (useDefault) {
-            useDefault = false;
-            rate = 100;
-          }
-          if (handler) {
-            const ret = handler(progress);
-            if (ret !== undefined) {
-              if (typeof ret === 'number' && ret === ret) rate = Math.max(0, Math.min(0x7fffffff, Math.round(ret)));else throw new TypeError('Expected progress callback to return a number or undefined');
-            }
-          }
-          setImmediate(step);
-        } catch (err) {
-          backup.close();
-          reject(err);
-        }
-      });
-    });
-  };
-  return backup;
-}
-
-var serialize;
-var hasRequiredSerialize;
-function requireSerialize() {
-  if (hasRequiredSerialize) return serialize;
-  hasRequiredSerialize = 1;
-  const {
-    cppdb
-  } = requireUtil();
-  serialize = function serialize(options) {
-    if (options == null) options = {};
-
-    // Validate arguments
-    if (typeof options !== 'object') throw new TypeError('Expected first argument to be an options object');
-
-    // Interpret and validate options
-    const attachedName = 'attached' in options ? options.attached : 'main';
-    if (typeof attachedName !== 'string') throw new TypeError('Expected the "attached" option to be a string');
-    if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
-    return this[cppdb].serialize(attachedName);
-  };
-  return serialize;
-}
-
-var _function;
-var hasRequired_function;
-function require_function() {
-  if (hasRequired_function) return _function;
-  hasRequired_function = 1;
-  const {
-    getBooleanOption,
-    cppdb
-  } = requireUtil();
-  _function = function defineFunction(name, options, fn) {
-    // Apply defaults
-    if (options == null) options = {};
-    if (typeof options === 'function') {
-      fn = options;
-      options = {};
-    }
-
-    // Validate arguments
-    if (typeof name !== 'string') throw new TypeError('Expected first argument to be a string');
-    if (typeof fn !== 'function') throw new TypeError('Expected last argument to be a function');
-    if (typeof options !== 'object') throw new TypeError('Expected second argument to be an options object');
-    if (!name) throw new TypeError('User-defined function name cannot be an empty string');
-
-    // Interpret options
-    const safeIntegers = 'safeIntegers' in options ? +getBooleanOption(options, 'safeIntegers') : 2;
-    const deterministic = getBooleanOption(options, 'deterministic');
-    const directOnly = getBooleanOption(options, 'directOnly');
-    const varargs = getBooleanOption(options, 'varargs');
-    let argCount = -1;
-
-    // Determine argument count
-    if (!varargs) {
-      argCount = fn.length;
-      if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError('Expected function.length to be a positive integer');
-      if (argCount > 100) throw new RangeError('User-defined functions cannot have more than 100 arguments');
-    }
-    this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
-    return this;
-  };
-  return _function;
-}
-
-var aggregate;
-var hasRequiredAggregate;
-function requireAggregate() {
-  if (hasRequiredAggregate) return aggregate;
-  hasRequiredAggregate = 1;
-  const {
-    getBooleanOption,
-    cppdb
-  } = requireUtil();
-  aggregate = function defineAggregate(name, options) {
-    // Validate arguments
-    if (typeof name !== 'string') throw new TypeError('Expected first argument to be a string');
-    if (typeof options !== 'object' || options === null) throw new TypeError('Expected second argument to be an options object');
-    if (!name) throw new TypeError('User-defined function name cannot be an empty string');
-
-    // Interpret options
-    const start = 'start' in options ? options.start : null;
-    const step = getFunctionOption(options, 'step', true);
-    const inverse = getFunctionOption(options, 'inverse', false);
-    const result = getFunctionOption(options, 'result', false);
-    const safeIntegers = 'safeIntegers' in options ? +getBooleanOption(options, 'safeIntegers') : 2;
-    const deterministic = getBooleanOption(options, 'deterministic');
-    const directOnly = getBooleanOption(options, 'directOnly');
-    const varargs = getBooleanOption(options, 'varargs');
-    let argCount = -1;
-
-    // Determine argument count
-    if (!varargs) {
-      argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
-      if (argCount > 0) argCount -= 1;
-      if (argCount > 100) throw new RangeError('User-defined functions cannot have more than 100 arguments');
-    }
-    this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
-    return this;
-  };
-  const getFunctionOption = (options, key, required) => {
-    const value = key in options ? options[key] : null;
-    if (typeof value === 'function') return value;
-    if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
-    if (required) throw new TypeError(`Missing required option "${key}"`);
-    return null;
-  };
-  const getLength = ({
-    length
-  }) => {
-    if (Number.isInteger(length) && length >= 0) return length;
-    throw new TypeError('Expected function.length to be a positive integer');
-  };
-  return aggregate;
-}
-
-var table;
-var hasRequiredTable;
-function requireTable() {
-  if (hasRequiredTable) return table;
-  hasRequiredTable = 1;
-  const {
-    cppdb
-  } = requireUtil();
-  table = function defineTable(name, factory) {
-    // Validate arguments
-    if (typeof name !== 'string') throw new TypeError('Expected first argument to be a string');
-    if (!name) throw new TypeError('Virtual table module name cannot be an empty string');
-
-    // Determine whether the module is eponymous-only or not
-    let eponymous = false;
-    if (typeof factory === 'object' && factory !== null) {
-      eponymous = true;
-      factory = defer(parseTableDefinition(factory, 'used', name));
-    } else {
-      if (typeof factory !== 'function') throw new TypeError('Expected second argument to be a function or a table definition object');
-      factory = wrapFactory(factory);
-    }
-    this[cppdb].table(factory, name, eponymous);
-    return this;
-  };
-  function wrapFactory(factory) {
-    return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
-      const thisObject = {
-        module: moduleName,
-        database: databaseName,
-        table: tableName
-      };
-
-      // Generate a new table definition by invoking the factory
-      const def = apply.call(factory, thisObject, args);
-      if (typeof def !== 'object' || def === null) {
-        throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
-      }
-      return parseTableDefinition(def, 'returned', moduleName);
-    };
-  }
-  function parseTableDefinition(def, verb, moduleName) {
-    // Validate required properties
-    if (!hasOwnProperty.call(def, 'rows')) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
-    }
-    if (!hasOwnProperty.call(def, 'columns')) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
-    }
-
-    // Validate "rows" property
-    const rows = def.rows;
-    if (typeof rows !== 'function' || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
-    }
-
-    // Validate "columns" property
-    let columns = def.columns;
-    if (!Array.isArray(columns) || !isStringArray(columns = [...columns])) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
-    }
-    if (columns.length !== new Set(columns).size) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
-    }
-    if (!columns.length) {
-      throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
-    }
-
-    // Validate "parameters" property
-    let parameters;
-    if (hasOwnProperty.call(def, 'parameters')) {
-      parameters = def.parameters;
-      if (!Array.isArray(parameters) || !isStringArray(parameters = [...parameters])) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
-      }
-    } else {
-      parameters = inferParameters(rows);
-    }
-    if (parameters.length !== new Set(parameters).size) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
-    }
-    if (parameters.length > 32) {
-      throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
-    }
-    for (const parameter of parameters) {
-      if (columns.includes(parameter)) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
-      }
-    }
-
-    // Validate "safeIntegers" option
-    let safeIntegers = 2;
-    if (hasOwnProperty.call(def, 'safeIntegers')) {
-      const bool = def.safeIntegers;
-      if (typeof bool !== 'boolean') {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
-      }
-      safeIntegers = +bool;
-    }
-
-    // Validate "directOnly" option
-    let directOnly = false;
-    if (hasOwnProperty.call(def, 'directOnly')) {
-      directOnly = def.directOnly;
-      if (typeof directOnly !== 'boolean') {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
-      }
-    }
-
-    // Generate SQL for the virtual table definition
-    const columnDefinitions = [...parameters.map(identifier).map(str => `${str} HIDDEN`), ...columns.map(identifier)];
-    return [`CREATE TABLE x(${columnDefinitions.join(', ')});`, wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName), parameters, safeIntegers, directOnly];
-  }
-  function wrapGenerator(generator, columnMap, moduleName) {
-    return function* virtualTable(...args) {
-      /*
-      	We must defensively clone any buffers in the arguments, because
-      	otherwise the generator could mutate one of them, which would cause
-      	us to return incorrect values for hidden columns, potentially
-      	corrupting the database.
-       */
-      const output = args.map(x => Buffer.isBuffer(x) ? Buffer.from(x) : x);
-      for (let i = 0; i < columnMap.size; ++i) {
-        output.push(null); // Fill with nulls to prevent gaps in array (v8 optimization)
-      }
-      for (const row of generator(...args)) {
-        if (Array.isArray(row)) {
-          extractRowArray(row, output, columnMap.size, moduleName);
-          yield output;
-        } else if (typeof row === 'object' && row !== null) {
-          extractRowObject(row, output, columnMap, moduleName);
-          yield output;
-        } else {
-          throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
-        }
-      }
-    };
-  }
-  function extractRowArray(row, output, columnCount, moduleName) {
-    if (row.length !== columnCount) {
-      throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
-    }
-    const offset = output.length - columnCount;
-    for (let i = 0; i < columnCount; ++i) {
-      output[i + offset] = row[i];
-    }
-  }
-  function extractRowObject(row, output, columnMap, moduleName) {
-    let count = 0;
-    for (const key of Object.keys(row)) {
-      const index = columnMap.get(key);
-      if (index === undefined) {
-        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
-      }
-      output[index] = row[key];
-      count += 1;
-    }
-    if (count !== columnMap.size) {
-      throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
-    }
-  }
-  function inferParameters({
-    length
-  }) {
-    if (!Number.isInteger(length) || length < 0) {
-      throw new TypeError('Expected function.length to be a positive integer');
-    }
-    const params = [];
-    for (let i = 0; i < length; ++i) {
-      params.push(`$${i + 1}`);
-    }
-    return params;
-  }
-  const {
-    hasOwnProperty
-  } = Object.prototype;
-  const {
-    apply
-  } = Function.prototype;
-  const GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {});
-  const identifier = str => `"${str.replace(/"/g, '""')}"`;
-  const defer = x => () => x;
-  const isStringArray = arr => {
-    for (let i = 0; i < arr.length; ++i) {
-      if (typeof arr[i] !== 'string') return false;
-    }
-    return true;
-  };
-  return table;
-}
-
-var inspect;
-var hasRequiredInspect;
-function requireInspect() {
-  if (hasRequiredInspect) return inspect;
-  hasRequiredInspect = 1;
-  const DatabaseInspection = function Database() {};
-  inspect = function inspect(depth, opts) {
-    return Object.assign(new DatabaseInspection(), this);
-  };
-  return inspect;
-}
-
-var database;
-var hasRequiredDatabase;
-function requireDatabase() {
-  if (hasRequiredDatabase) return database;
-  hasRequiredDatabase = 1;
-  const fs = require$$0;
-  const path = require$$1;
-  const util = requireUtil();
-  const SqliteError = requireSqliteError();
-  database = function createDatabase(getAddon, allowNativeBinding) {
-    function Database(filenameGiven, options) {
-      if (new.target == null) {
-        return new Database(filenameGiven, options);
-      }
-
-      // Apply defaults
-      let buffer;
-      if (Buffer.isBuffer(filenameGiven)) {
-        buffer = filenameGiven;
-        filenameGiven = ':memory:';
-      }
-      if (filenameGiven == null) filenameGiven = '';
-      if (options == null) options = {};
-
-      // Validate arguments
-      if (typeof filenameGiven !== 'string') throw new TypeError('Expected first argument to be a string');
-      if (typeof options !== 'object') throw new TypeError('Expected second argument to be an options object');
-      if ('readOnly' in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
-      if ('memory' in options) throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
-
-      // Interpret options
-      const filename = filenameGiven.trim();
-      const anonymous = filename === '' || filename === ':memory:';
-      const readonly = util.getBooleanOption(options, 'readonly');
-      const fileMustExist = util.getBooleanOption(options, 'fileMustExist');
-      const timeout = 'timeout' in options ? options.timeout : 5000;
-      const verbose = 'verbose' in options ? options.verbose : null;
-      const nativeBinding = 'nativeBinding' in options ? options.nativeBinding : null;
-
-      // Validate interpreted options
-      if (readonly && anonymous && !buffer) throw new TypeError('In-memory/temporary databases cannot be readonly');
-      if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
-      if (timeout > 0x7fffffff) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
-      if (verbose != null && typeof verbose !== 'function') throw new TypeError('Expected the "verbose" option to be a function');
-      if (!allowNativeBinding && 'nativeBinding' in options) throw new TypeError('The "nativeBinding" option is only supported by the default better-sqlite3 entrypoint');
-      if (allowNativeBinding && nativeBinding != null && typeof nativeBinding !== 'string' && typeof nativeBinding !== 'object') throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
-
-      // Load the native addon
-      const addon = getAddon(nativeBinding);
-      if (!addon.isInitialized) {
-        addon.initialize(SqliteError, arrayFactory, arrayAppender, rowFactory, recordFactory);
-        addon.isInitialized = true;
-      }
-
-      // Make sure the specified directory exists
-      if (!anonymous && !filename.startsWith('file:') && !fs.existsSync(path.dirname(filename))) {
-        throw new TypeError('Cannot open database because the directory does not exist');
-      }
-      Object.defineProperties(this, {
-        [util.cppdb]: {
-          value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer || null)
-        },
-        ...wrappers.getters
-      });
-    }
-    const wrappers = requireWrappers();
-    Database.prototype.prepare = wrappers.prepare;
-    Database.prototype.transaction = requireTransaction();
-    Database.prototype.pragma = requirePragma();
-    Database.prototype.explain = requireExplain();
-    Database.prototype.backup = requireBackup();
-    Database.prototype.serialize = requireSerialize();
-    Database.prototype.function = require_function();
-    Database.prototype.aggregate = requireAggregate();
-    Database.prototype.table = requireTable();
-    Database.prototype.loadExtension = wrappers.loadExtension;
-    Database.prototype.exec = wrappers.exec;
-    Database.prototype.close = wrappers.close;
-    Database.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
-    Database.prototype.unsafeMode = wrappers.unsafeMode;
-    Database.prototype[util.inspect] = requireInspect();
-    return Database;
-  };
-  function arrayFactory(...values) {
-    return values;
-  }
-  function arrayAppender(array, ...values) {
-    const offset = array.length;
-    for (let i = 0; i < values.length; ++i) {
-      array[offset + i] = values[i];
-    }
-  }
-  function rowFactory(...keys) {
-    if (!keys.includes('__proto__')) {
-      const parameters = keys.map((_, index) => `v${index}`).join(',');
-      const properties = keys.map((key, index) => `${JSON.stringify(key)}:v${index}`).join(',');
-      return Function(`return (${parameters}) => ({${properties}})`)();
-    }
-    return (...values) => {
-      const row = {};
-      for (let i = 0; i < keys.length; ++i) row[keys[i]] = values[i];
-      return row;
-    };
-  }
-  function recordFactory(value) {
-    return {
-      value,
-      done: false
-    };
-  }
-  return database;
-}
-
-function commonjsRequire(path) {
-	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
-}
-
-var binding = {exports: {}};
-
-var hasRequiredBinding;
-function requireBinding() {
-  if (hasRequiredBinding) return binding.exports;
-  hasRequiredBinding = 1;
-  (function (module, exports) {
-
-    const fs = require$$0;
-    const path = require$$1;
-    const PREBUILD_PLATFORMS = ['linux', 'darwin', 'win32'];
-    const PREBUILD_ARCHS = ['x64', 'arm64'];
-    let DEFAULT_ADDON;
-    function getBinding(nativeBinding) {
-      // If a path was provided, load the binding from the filesystem.
-      if (typeof nativeBinding === 'string') {
-        // See <https://webpack.js.org/api/module-variables/#__non_webpack_require__-webpack-specific>
-        const requireFunc = typeof __non_webpack_require__ === 'function' ? __non_webpack_require__ : commonjsRequire;
-        return requireFunc(path.resolve(nativeBinding).replace(/(\.node)?$/, '.node'));
-      }
-
-      // If an object was provided, use it as the binding directly.
-      if (typeof nativeBinding === 'object' && nativeBinding !== null) {
-        return nativeBinding;
-      }
-
-      // If we're using the default binding and it already exists, just return it.
-      if (DEFAULT_ADDON) {
-        return DEFAULT_ADDON;
-      }
-
-      // Otherwise, try to find the binding as a prebuilt binary.
-      let filename = getPrebuildPath();
-      if (filename) {
-        return DEFAULT_ADDON = commonjsRequire(filename);
-      }
-
-      // If no prebuilt binary was found, try the default node-gyp locations.
-      filename = path.join(__dirname, '..', 'build', 'Debug', 'better_sqlite3.node');
-      if (!fs.existsSync(filename)) {
-        filename = path.join(__dirname, '..', 'build', 'Release', 'better_sqlite3.node');
-      }
-      return DEFAULT_ADDON = commonjsRequire(filename);
-    }
-    function getPrebuildPath() {
-      if (PREBUILD_PLATFORMS.includes(process.platform) && PREBUILD_ARCHS.includes(process.arch)) {
-        const target = `${isLinuxMusl() ? 'linuxmusl' : process.platform}-${process.arch}`;
-        const filename = path.join(__dirname, '..', 'prebuilds', `${target}.node`);
-        if (fs.existsSync(filename)) {
-          return filename;
-        }
-      }
-      return null;
-    }
-    function isLinuxMusl() {
-      return process.platform === 'linux' && !process.report.getReport().header.glibcVersionRuntime;
-    }
-    exports.getBinding = getBinding;
-    exports.getPrebuildPath = getPrebuildPath;
-
-    // This script is executed directly by binding.gyp to detect prebuilt binaries.
-    if (require.main === module) {
-      process.stdout.write(getPrebuildPath() ? '1' : '0');
-    }
-  })(binding, binding.exports);
-  return binding.exports;
-}
-
-var hasRequiredLib;
-function requireLib() {
-  if (hasRequiredLib) return lib.exports;
-  hasRequiredLib = 1;
-  lib.exports = requireDatabase()(requireBinding().getBinding, true);
-  lib.exports.SqliteError = requireSqliteError();
-  return lib.exports;
-}
-
-var libExports = requireLib();
-var Database = /*@__PURE__*/getDefaultExportFromCjs(libExports);
-
-/**
- *
- */
-class SQLiteResult {
-  /**
-   * @param {Error|null|undefined} error
-   * @param {number|undefined} [insertId]
-   * @param {number} [rowsAffected]
-   * @param {object[]} [rows]
-   */
-  constructor(error, insertId, rowsAffected, rows) {
-    this.error = error;
-    this.insertId = insertId;
-    this.rowsAffected = rowsAffected;
-    this.rows = rows;
-  }
-}
-const READ_ONLY_ERROR = new Error('could not prepare statement (23 not authorized)');
-
-/**
- * @typedef {(sql: string, duration: number) => void} SQLProfileCallback
- */
-
-/**
- * @typedef {((sql: string) => void)|undefined} SQLTraceCallback
- */
-
-// Two separate `better-sqlite3` connections (i.e., two separate
-//   `SQLiteDatabase` instances) can legitimately point at the same
-//   underlying file at once -- e.g. an old, about-to-close IndexedDB
-//   connection and a newly-opened one during an upgrade. `PRAGMA
-//   busy_timeout` can't safely arbitrate between them here: it blocks the
-//   single JS thread synchronously while it retries, but the lock holder's
-//   own release is itself scheduled via `setImmediate` below, which can
-//   never fire while that retry loop is blocking the same thread -- so
-//   instead of waiting, a second connection's write just fails with
-//   "database is locked".
-//
-// `fileReaders`/`fileWriter` implement a simple (not starvation-proof --
-//   see the release loop below) reader/writer lock per file path instead:
-//   any number of `readonly` transactions may hold the file concurrently,
-//   matching what SQLite itself already natively supports (multiple
-//   readers never need to exclude each other, only a writer needs
-//   exclusivity), while a non-`readonly` transaction still waits for
-//   exclusive access -- no concurrent readers, no concurrent writer. A
-//   simple single-owner mutex (this file's prior implementation) would
-//   otherwise serialize even purely-concurrent-reader scenarios that
-//   never touch a writer at all, for no reason `better-sqlite3`/SQLite
-//   itself requires.
-/** @type {Map<string, Set<{_db: any, _qFilePath: string}>>} */
-const fileReaders = new Map();
-/** @type {Map<string, {_db: any, _qFilePath: string}>} */
-const fileWriter = new Map();
-/** @type {Map<string, {isReader: boolean, resume: () => void}[]>} */
-const fileWaiters = new Map();
-const beginRe = /^\s*BEGIN\b/iu;
-const endRe = /^\s*(END|COMMIT|ROLLBACK)\b/iu;
-
-/**
- * @class
- * @param {string} name
- * @param {{busyTimeout?: number, trace?: (sql: string) => void, profile?: SQLProfileCallback}} [opts]
- * @this {{_db: any, _qFilePath: string}}
- * @returns {void}
- */
-function SQLiteDatabase(name, opts = {}) {
-  this._qFilePath = name;
-  /** @type {import('better-sqlite3').Database} */
-  const db = new Database(name);
-
-  /** @type {SQLTraceCallback} */
-  // eslint-disable-next-line prefer-destructuring -- TS
-  let trace = opts.trace;
-  /** @type {SQLProfileCallback|undefined} */
-  // eslint-disable-next-line prefer-destructuring -- TS
-  let profile = opts.profile;
-  if (opts.busyTimeout) {
-    db.pragma('busy_timeout = ' + Number(opts.busyTimeout));
-  }
-
-  // Kept untyped (rather than the better-sqlite3 `Database` type) since that
-  //  type is internal to `@types/better-sqlite3` and can't be named in this
-  //  file's emitted declaration.
-  this._db = /** @type {any} */{
-    _db: db,
-    /**
-     * Compatibility with node-sqlite3's configure API.
-     * @param {'busyTimeout'|'trace'|'profile'|'memoryQuota'} option
-     * @param {number|((sql: string, duration?: number) => void)} value
-     * @returns {void}
-     */
-    configure(option, value) {
-      if (option === 'busyTimeout') {
-        db.pragma('busy_timeout = ' + Number(/** @type {number} */value));
-        return;
-      }
-      if (option === 'trace') {
-        trace = /** @type {(sql: string) => void} */value;
-        return;
-      }
-      if (option === 'profile') {
-        profile = /** @type {SQLProfileCallback} */value;
-        return;
-      }
-      if (option === 'memoryQuota') {
-        const bytes = Number(value);
-        // `better-sqlite3` doesn't have a direct `sqlite3_quota_set` binding,
-        // but we can limit the max pages:
-        const pageSizeObj = db.pragma('page_size', {
-          simple: true
-        });
-        const pageSize = Number(pageSizeObj);
-        db.pragma('max_page_count = ' + Math.ceil(bytes / pageSize));
-      }
-    },
-    /**
-     * Compatibility with callback-oriented close semantics.
-     * @param {(err?: Error|null) => void} [cb]
-     * @returns {void}
-     */
-    close(cb) {
-      try {
-        db.close();
-        if (cb) {
-          return cb(null);
-        }
-      } catch (err) {
-        if (cb) {
-          return cb(/** @type {Error} */err);
-        }
-      }
-      return undefined;
-    },
-    getTrace() {
-      return trace;
-    },
-    getProfile() {
-      return profile;
-    }
-  };
-}
-
-/**
- * @param {import('better-sqlite3').Database} db
- * @param {string} sql
- * @param {unknown[]} args
- * @returns {object[]}
- */
-function runSelect(db, sql, args) {
-  const stmt = db.prepare(sql);
-  return stmt.reader ? (/** @type {object[]} */stmt.all(...args)) : [];
-}
-
-/**
- * @param {import('better-sqlite3').Database} db
- * @param {string} sql
- * @param {unknown[]} args
- * @returns {import('better-sqlite3').RunResult}
- */
-function runNonSelect(db, sql, args) {
-  const stmt = db.prepare(sql);
-  return stmt.run(...args);
-}
-
-/**
- * @param {{sql: string, args: unknown[]}[]} queries
- * @param {boolean} readOnly
- * @param {(err: Error|null, results?: SQLiteResult[]) => void} callback
- * @returns {void}
- */
-SQLiteDatabase.prototype.exec = function exec(queries, readOnly, callback) {
-  // `:memory:` (SQLite/`better-sqlite3`'s own sentinel for an isolated,
-  //   non-shared in-memory database) can never actually collide with a
-  //   different connection -- each `new Database(':memory:')` call is
-  //   already fully independent -- so there is nothing to serialize.
-  const filePath = this._qFilePath === ':memory:' ? null : this._qFilePath;
-  if (filePath && queries[0] && beginRe.test(queries[0].sql)) {
-    const activeReaders = fileReaders.get(filePath);
-    const hasActiveReaders = Boolean(activeReaders && activeReaders.size);
-    const activeWriter = fileWriter.get(filePath);
-    const blockedByWriter = Boolean(activeWriter && activeWriter !== this);
-    const blocked = blockedByWriter || !readOnly && hasActiveReaders;
-    if (blocked) {
-      const waiters = fileWaiters.get(filePath) || [];
-      waiters.push({
-        isReader: readOnly,
-        resume: () => this.exec(queries, readOnly, callback)
-      });
-      fileWaiters.set(filePath, waiters);
-      return;
-    }
-    if (readOnly) {
-      if (activeReaders) {
-        activeReaders.add(this);
-      } else {
-        fileReaders.set(filePath, new Set([this]));
-      }
-    } else {
-      fileWriter.set(filePath, this);
-    }
-  }
-  const db = this._db._db;
-  const len = queries.length;
-  const results = Array.from({
-    length: len
-  });
-  for (let i = 0; i < len; i++) {
-    const query = queries[i];
-    const {
-      sql,
-      args
-    } = query;
-    const isSelect = /^\s*SELECT\b/iu.test(sql);
-    if (readOnly && !isSelect) {
-      results[i] = new SQLiteResult(READ_ONLY_ERROR);
-      continue;
-    }
-    const trace = this._db.getTrace();
-    const profile = this._db.getProfile();
-    // eslint-disable-next-line unicorn/prefer-bigint-literals -- `0n` needs ES2020+ target for tsc
-    const start = profile ? process.hrtime.bigint() : BigInt(0);
-    try {
-      if (trace) {
-        trace(sql);
-      }
-      if (isSelect) {
-        const rows = runSelect(db, sql, args);
-        results[i] = new SQLiteResult(null, undefined, 0, rows);
-      } else {
-        const executionResult = runNonSelect(db, sql, args);
-        const insertId = Number(executionResult.lastInsertRowid);
-        results[i] = new SQLiteResult(null, insertId, executionResult.changes, []);
-      }
-    } catch (err) {
-      results[i] = new SQLiteResult(/** @type {Error} */err);
-    } finally {
-      if (profile) {
-        profile(sql, Number(process.hrtime.bigint() - start));
-      }
-    }
-  }
-  // A real macrotask (not `queueMicrotask`) so this yields properly:
-  //   code that synchronously issues a new request from within each
-  //   request's callback (e.g. to keep a transaction alive) would
-  //   otherwise chain microtask to microtask forever, starving out any
-  //   `setTimeout`-based code (including IndexedDB's own internal request
-  //   scheduling) that never gets a turn to run. `setImmediate` (Node's
-  //   "check" phase) still yields the same way `setTimeout(..., 0)` did,
-  //   but runs sooner in Node's event loop.
-  setImmediate(() => {
-    // Release the file lock (if held) and hand it to the next waiting
-    //   connection, if any, only once this transaction has genuinely
-    //   finished -- and only here, on its own turn, so a resumed
-    //   waiter's own `exec` call can't run reentrantly inside this one.
-    // Checked across the whole batch, not just `queries[0]`: when a
-    //   transaction's `BEGIN` and its later `ROLLBACK`/`COMMIT` are both
-    //   queued synchronously before `websql-configurable`'s async flush
-    //   gets a turn to run (e.g. an immediate `transaction.abort()`
-    //   inside `onupgradeneeded`), they arrive coalesced into a single
-    //   batch/`exec()` call, with the terminal statement anywhere but
-    //   first -- so only checking `queries[0]` would acquire the lock
-    //   and never see the matching release, deadlocking every later
-    //   connection to the same file.
-    if (filePath && queries.some(q => endRe.test(q.sql))) {
-      const activeReaders = fileReaders.get(filePath);
-      if (activeReaders) {
-        activeReaders.delete(this);
-        if (!activeReaders.size) {
-          fileReaders.delete(filePath);
-        }
-      }
-      if (fileWriter.get(filePath) === this) {
-        fileWriter.delete(filePath);
-      }
-      // Resume as many waiters as the lock now genuinely allows:
-      //   any leading run of readers (concurrent reads are always
-      //   fine), then at most one writer, since a writer needs
-      //   exclusivity -- stop there rather than looking past it.
-      //   Not starvation-proof: a steady stream of arriving readers
-      //   could in principle keep a waiting writer waiting
-      //   indefinitely, but that's an acceptable tradeoff here over
-      //   the added complexity of tracking arrival order across
-      //   reader/writer kinds.
-      const waiters = fileWaiters.get(filePath);
-      if (waiters) {
-        while (waiters.length) {
-          if (fileWriter.has(filePath)) {
-            break;
-          }
-          const next = waiters[0];
-          const stillHasReaders = fileReaders.get(filePath);
-          if (!next.isReader && stillHasReaders && stillHasReaders.size) {
-            break;
-          }
-          waiters.shift();
-          next.resume();
-          if (!next.isReader) {
-            // A writer just took exclusive ownership (inside
-            //   `resume()`, synchronously, via the acquire
-            //   logic above) -- nothing else may proceed now.
-            break;
-          }
-        }
-        if (!waiters.length) {
-          fileWaiters.delete(filePath);
-        }
-      }
-    }
-    callback(null, results);
-  });
-};
-
 /**
  * @typedef {{
  *   _db: any,
@@ -14990,16 +13009,16 @@ function wrappedSQLiteDatabase(name) {
   // @ts-ignore It's ok; needed under some TS versions
   const db = new SQLiteDatabase(name, {});
   if (CFG.sqlBusyTimeout) {
-    db._db.configure('busyTimeout', /** @type {number} */CFG.sqlBusyTimeout); // Default is 1000
+    db.configure('busyTimeout', /** @type {number} */CFG.sqlBusyTimeout); // Default is 1000
   }
   if (CFG.sqlTrace) {
-    db._db.configure('trace', CFG.sqlTrace);
+    db.configure('trace', CFG.sqlTrace);
   }
   if (CFG.sqlProfile) {
-    db._db.configure('profile', CFG.sqlProfile);
+    db.configure('profile', CFG.sqlProfile);
   }
   if (CFG.sqlMemoryQuota) {
-    db._db.configure('memoryQuota', /** @type {number} */CFG.sqlMemoryQuota);
+    db.configure('memoryQuota', /** @type {number} */CFG.sqlMemoryQuota);
   }
   return db;
 }