indexeddbshim 17.0.0 → 17.1.0

package/dist/indexeddbshim-UnicodeIdentifiers-node.cjs

@@ -1,12 +1,11 @@
-/*! indexeddbshim - v17.0.0 - 7/28/2026 */
+/*! indexeddbshim - v17.1.0 - 8/6/2026 */
 
 'use strict';
 
 var fs$1 = require('node:fs');
 var path = require('path');
 var require$$0 = require('fs');
-var require$$2 = require('events');
-var require$$0$1 = require('util');
+var require$$2 = require('util');
 
 function _typeof(obj) {
   "@babel/helpers - typeof";
@@ -980,6 +979,7 @@ function setPrototypeOfCustomEvent() {
  *   sqlBusyTimeout: number,
  *   sqlTrace: () => void,
  *   sqlProfile: () => void,
+ *   escapeNULForSQLiteStatements: boolean,
  *   createIndexes: boolean
  * }} ConfigValues
  */
@@ -1134,8 +1134,8 @@ val => {
 // Callback not used by default
 'sqlProfile',
 // Callback not used by default
-
-'createIndexes'].forEach(prop => {
+// Defaults to true except in Node builds where we can preserve literal NUL with better-sqlite3
+'escapeNULForSQLiteStatements', 'createIndexes'].forEach(prop => {
   /** @type {(val: any) => void} */
   let validator;
   if (Array.isArray(prop)) {
@@ -1215,7 +1215,8 @@ function escapeNameForSQLiteIdentifier(arg) {
  * @returns {string}
  */
 function escapeSQLiteStatement(arg) {
-  return escapeUnmatchedSurrogates(arg.replaceAll('^', '^^').replaceAll('\0', '^0'));
+  const escaped = arg.replaceAll('^', '^^');
+  return escapeUnmatchedSurrogates(CFG.escapeNULForSQLiteStatements === false ? escaped : escaped.replaceAll('\0', '^0'));
 }
 
 /**
@@ -1223,7 +1224,11 @@ function escapeSQLiteStatement(arg) {
  * @returns {string}
  */
 function unescapeSQLiteResponse(arg) {
-  return unescapeUnmatchedSurrogates(arg).replaceAll(/(\^+)0/gu, (_, esc) => {
+  const unescaped = unescapeUnmatchedSurrogates(arg);
+  if (CFG.escapeNULForSQLiteStatements === false) {
+    return unescaped.replaceAll('^^', '^');
+  }
+  return unescaped.replaceAll(/(\^+)0/gu, (_, esc) => {
     return esc.length % 2 ? esc.slice(1) + '\0' : _;
   }).replaceAll('^^', '^');
 }
@@ -1638,6 +1643,56 @@ function isNullish(v) {
   return v === null || v === undefined;
 }
 
+/**
+ * Cursor/request continuation chains can call each other synchronously
+ * (e.g. walking a large prefetched buffer, or advancing many interleaved
+ * cursors in one transaction) which, for large enough record counts, can
+ * exceed the JS engine's call stack ("Maximum call stack size exceeded").
+ *
+ * This can't be fixed by deferring continuations to a microtask/macrotask:
+ * the transaction machinery synchronously checks (once the current call
+ * stack unwinds) whether there are any pending requests left in order to
+ * decide it's safe to commit; deferring a continuation opens a real gap in
+ * which that check runs first and the transaction completes prematurely,
+ * with the deferred continuation then acting on an already-finished
+ * transaction (a hang, since it can never resolve).
+ *
+ * Instead, this implements a true trampoline: the first call starts a
+ * synchronous work queue and drains it in a flat loop; any call made while
+ * already draining (i.e. a continuation triggering another continuation)
+ * is simply appended to that same queue and returns immediately instead of
+ * recursing. This keeps everything synchronous (so no completion-check
+ * race is introduced) while preventing the call stack from growing with
+ * each successive continuation.
+ */
+const continuationState = {
+  /** @type {Array<() => void>|null} */
+  queue: null
+};
+
+/**
+ * @param {() => void} fn
+ * @returns {void}
+ */
+function runContinuationSafely(fn) {
+  if (continuationState.queue) {
+    continuationState.queue.push(fn);
+    return;
+  }
+  const queue = [fn];
+  continuationState.queue = queue;
+  try {
+    while (queue.length) {
+      const next = /** @type {() => void} */queue.shift();
+      next();
+    }
+  } finally {
+    // Ensure a thrown exception can't leave the queue permanently
+    // stuck (which would silently swallow all future continuations).
+    continuationState.queue = null;
+  }
+}
+
 /**
  * @typedef {Error} DebuggingError
  */
@@ -2313,16 +2368,15 @@ Object.defineProperty(IDBOpenDBRequest, 'prototype', {
 /* eslint-disable promise/prefer-await-to-callbacks -- Needed for API */
 /* eslint-disable promise/catch-or-return, n/callback-return,
     promise/always-return -- Not needed */
-/* eslint-disable unicorn/no-this-assignment -- Clarity */
 // Since [immediate](https://github.com/calvinmetcalf/immediate) is
 //   not doing the trick for our WebSQL transactions (at least in Node),
 //   we are forced to make the promises run fully synchronously.
 
-// Todo: Use ES6 classes
-
+/* eslint-disable jsdoc/reject-any-type -- Truly arbitrary */
 /**
  * @typedef {any} ArbitraryValue
  */
+/* eslint-enable jsdoc/reject-any-type -- Truly arbitrary */
 
 /**
  * @callback Resolve
@@ -2382,209 +2436,219 @@ const PENDING = 2,
   REJECTED = 1;
 
 /**
- * @class
- * @param {(
- *   resolve: (value: ArbitraryValue | PromiseLike<ArbitraryValue>) => void,
- *   reject: (reason?: any) => void
- * ) => void} fn
+ *
  */
-function SyncPromise(fn) {
-  const that = this;
-  // Value, this will be set to either a resolved value or rejected reason
-  that.v = 0;
-  // State of the promise
-  that.s = PENDING;
-  // Callbacks c[0] is fulfillment and c[1] contains rejection callbacks
-  /** @type {Callbacks|null} */
-  that.c = [[], []];
+class SyncPromise {
   /**
-   *
-   * @param {ArbitraryValue} val
-   * @param {0|1} state
-   * @returns {void}
+   * @param {unknown[]|[]} promises
+   * @returns {SyncPromise}
    */
-  function transist(val, state) {
-    that.v = val;
-    that.s = state;
-
-    // console.log('state', state);
-    /** @type {Callbacks} */
-    that.c[state].forEach(function (func) {
-      func(val);
+  static all(promises) {
+    return new SyncPromise(/** @type {ResolveReject} */
+    (resolve, reject) => {
+      let l = promises.length;
+      /** @type {ArbitraryValue[]} */
+      const newPromises = [];
+      if (!l) {
+        resolve(newPromises);
+        return;
+      }
+      promises.forEach((p, i) => {
+        if (isPromise(/** @type {PromiseLike<ArbitraryValue>} */p)) {
+          addReject(/** @type {PromiseLike<ArbitraryValue>} */p.then(/** @type {OnFulfilled} */
+          res => {
+            newPromises[i] = res;
+            --l;
+            if (!l) {
+              resolve(newPromises);
+            }
+          }), reject);
+        } else {
+          newPromises[i] = p;
+          --l;
+          if (!l) {
+            resolve(promises);
+          }
+        }
+      });
     });
-    // Release memory, but if no handlers have been added, as we
-    //   assume that we will resolve/reject (truly) synchronously
-    //   and thus we avoid flagging checks about whether we've
-    //   already resolved/rejected.
-    if (/** @type {Callbacks} */that.c[state].length) {
-      that.c = null;
-    }
   }
 
-  /** @type {Resolve} */
-  function resolve(val) {
-    if (!that.c) ; else if (isPromise(val)) {
-      addReject(val.then(resolve), reject);
-    } else {
-      transist(val, FULFILLED);
-    }
+  /**
+   * @param {unknown[]|[]} promises
+   * @returns {SyncPromise}
+   */
+  static race(promises) {
+    let resolved = false;
+    return new SyncPromise(/** @type {ResolveReject} */
+    (resolve, reject) => {
+      // eslint-disable-next-line @stylistic/max-len -- Long
+      // eslint-disable-next-line unicorn/no-unused-array-method-return -- Shortcuts
+      promises.some(p => {
+        if (isPromise(/** @type {PromiseLike<ArbitraryValue>} */p)) {
+          addReject(/** @type {PromiseLike<ArbitraryValue>} */p.then(/** @type {OnFulfilled} */
+          res => {
+            if (resolved) {
+              return;
+            }
+            resolve(res);
+            resolved = true;
+          }), reject);
+          return false;
+        }
+        resolve(p);
+        resolved = true;
+        return true;
+      });
+    });
   }
 
-  /** @type {Reject} */
-  function reject(reason) {
-    if (!that.c) ; else if (isPromise(reason)) {
-      addReject(reason.then(reject), reject);
-    } else {
-      transist(reason, REJECTED);
-    }
-  }
-  try {
-    fn(resolve, reject);
-  } catch (err) {
-    reject(err);
+  /**
+   * @param {ArbitraryValue} val
+   * @returns {SyncPromise}
+   */
+  static resolve(val) {
+    return new SyncPromise(/** @type {ResolveReject} */
+    resolve => {
+      resolve(val);
+    });
   }
-}
 
-/* eslint-disable unicorn/no-thenable -- Promise API */
-/**
- * @param {((value: ArbitraryValue) => ArbitraryValue)|null|undefined} [cb]
- * @param {(reason: any) => PromiseLike<never>} [errBack]
- * @returns {SyncPromise}
- */
-SyncPromise.prototype.then = function (cb, errBack) {
-  /* eslint-enable unicorn/no-thenable -- Promise API */
-  const that = this;
-  return new SyncPromise(/** @type {ResolveReject} */
-  function (resolve, reject) {
-    const rej = typeof errBack === 'function' ? errBack : reject;
+  /**
+   * @param {ArbitraryValue} val
+   * @returns {SyncPromise}
+   */
+  static reject(val) {
+    return new SyncPromise(/** @type {ResolveReject} */
+    (resolve, reject) => {
+      reject(val);
+    });
+  }
 
-    /** @type {Settle} */
-    function settle() {
-      try {
-        resolve(cb ? cb(that.v) : that.v);
-      } catch (e) {
-        rej(e);
-      }
-    }
-    if (that.s === FULFILLED) {
-      settle();
-    } else if (that.s === REJECTED) {
-      rej(that.v);
-    } else {
-      /** @type {Callbacks} */that.c[FULFILLED].push(settle);
-      /** @type {Callbacks} */
-      that.c[REJECTED].push(rej);
-    }
-  });
-};
+  // Value, this will be set to either a resolved value or rejected reason
+  v = 0;
 
-/**
- * @param {(reason: any) => PromiseLike<never>|null|undefined} cb
- * @returns {SyncPromise}
- */
-SyncPromise.prototype.catch = function (cb) {
-  const that = this;
-  return new SyncPromise(/** @type {ResolveReject} */
-  function (resolve, reject) {
+  /**
+   * @param {(
+   *   resolve: (value: ArbitraryValue | PromiseLike<ArbitraryValue>) => void,
+   *   reject: (reason?: ArbitraryValue) => void
+   * ) => void} fn
+   */
+  constructor(fn) {
+    // State of the promise
+    this.s = PENDING;
+    // Callbacks c[0] is fulfillment and c[1] contains rejection callbacks
+    /** @type {Callbacks|null} */
+    this.c = [[], []];
     /**
+     *
+     * @param {ArbitraryValue} val
+     * @param {0|1} state
      * @returns {void}
      */
-    function settle() {
-      try {
-        resolve(cb(that.v));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    if (that.s === REJECTED) {
-      settle();
-    } else if (that.s === FULFILLED) {
-      resolve(that.v);
-    } else {
-      /** @type {Callbacks} */that.c[REJECTED].push(settle);
+    const transist = (val, state) => {
+      this.v = val;
+      this.s = state;
+
+      // console.log('state', state);
       /** @type {Callbacks} */
-      that.c[FULFILLED].push(resolve);
-    }
-  });
-};
+      this.c[state].forEach(func => {
+        func(val);
+      });
+      // Release memory, but if no handlers have been added, as we
+      //   assume that we will resolve/reject (truly) synchronously
+      //   and thus we avoid flagging checks about whether we've
+      //   already resolved/rejected.
+      if (/** @type {Callbacks} */this.c[state].length) {
+        this.c = null;
+      }
+    };
 
-/**
- * @param {unknown[]|[]} promises
- * @returns {SyncPromise}
- */
-SyncPromise.all = function (promises) {
-  return new SyncPromise(/** @type {ResolveReject} */
-  (resolve, reject) => {
-    let l = promises.length;
-    /** @type {ArbitraryValue[]} */
-    const newPromises = [];
-    if (!l) {
-      resolve(newPromises);
-      return;
+    /** @type {Resolve} */
+    const resolve = val => {
+      if (!this.c) ; else if (isPromise(val)) {
+        addReject(val.then(resolve), reject);
+      } else {
+        transist(val, FULFILLED);
+      }
+    };
+
+    /** @type {Reject} */
+    const reject = reason => {
+      if (!this.c) ; else if (isPromise(reason)) {
+        addReject(reason.then(reject), reject);
+      } else {
+        transist(reason, REJECTED);
+      }
+    };
+    try {
+      fn(resolve, reject);
+    } catch (err) {
+      reject(err);
     }
-    promises.forEach((p, i) => {
-      if (isPromise(/** @type {PromiseLike<any>} */p)) {
-        addReject(/** @type {PromiseLike<any>} */p.then(/** @type {OnFulfilled} */
-        res => {
-          newPromises[i] = res;
-          --l || resolve(newPromises);
-        }), reject);
+  }
+
+  /* eslint-disable unicorn/no-thenable -- Promise API */
+  /**
+   * @param {((value: ArbitraryValue) => ArbitraryValue)|null|undefined} [cb]
+   * @param {(reason: ArbitraryValue) => PromiseLike<never>} [errBack]
+   * @returns {SyncPromise}
+   */
+  then(cb, errBack) {
+    /* eslint-enable unicorn/no-thenable -- Promise API */
+    return new SyncPromise(/** @type {ResolveReject} */
+    (resolve, reject) => {
+      const rej = typeof errBack === 'function' ? errBack : reject;
+
+      /** @type {Settle} */
+      const settle = () => {
+        try {
+          resolve(cb ? cb(this.v) : this.v);
+        } catch (e) {
+          rej(e);
+        }
+      };
+      if (this.s === FULFILLED) {
+        settle();
+      } else if (this.s === REJECTED) {
+        rej(this.v);
       } else {
-        newPromises[i] = p;
-        --l || resolve(promises);
+        /** @type {Callbacks} */this.c[FULFILLED].push(settle);
+        /** @type {Callbacks} */
+        this.c[REJECTED].push(rej);
       }
     });
-  });
-};
+  }
 
-/**
- * @param {unknown[]|[]} promises
- * @returns {SyncPromise}
- */
-SyncPromise.race = function (promises) {
-  let resolved = false;
-  return new SyncPromise(/** @type {ResolveReject} */
-  (resolve, reject) => {
-    promises.some((p, i) => {
-      if (isPromise(/** @type {PromiseLike<any>} */p)) {
-        addReject(/** @type {PromiseLike<any>} */p.then(/** @type {OnFulfilled} */
-        res => {
-          if (resolved) {
-            return;
-          }
-          resolve(res);
-          resolved = true;
-        }), reject);
-        return false;
+  /**
+   * @param {(reason: ArbitraryValue) => PromiseLike<never>|null|undefined} cb
+   * @returns {SyncPromise}
+   */
+  catch(cb) {
+    return new SyncPromise(/** @type {ResolveReject} */
+    (resolve, reject) => {
+      /**
+       * @returns {void}
+       */
+      const settle = () => {
+        try {
+          resolve(cb(this.v));
+        } catch (e) {
+          reject(e);
+        }
+      };
+      if (this.s === REJECTED) {
+        settle();
+      } else if (this.s === FULFILLED) {
+        resolve(this.v);
+      } else {
+        /** @type {Callbacks} */this.c[REJECTED].push(settle);
+        /** @type {Callbacks} */
+        this.c[FULFILLED].push(resolve);
       }
-      resolve(p);
-      resolved = true;
-      return true;
     });
-  });
-};
-
-/**
- * @param {ArbitraryValue} val
- * @returns {SyncPromise}
- */
-SyncPromise.resolve = function (val) {
-  return new SyncPromise(/** @type {ResolveReject} */
-  (resolve, reject) => {
-    resolve(val);
-  });
-};
-
-/**
- * @param {ArbitraryValue} val
- * @returns {SyncPromise}
- */
-SyncPromise.reject = function (val) {
-  return new SyncPromise(/** @type {ResolveReject} */
-  (resolve, reject) => {
-    reject(val);
-  });
-};
+  }
+}
 
 /**
  * Compares two keys.
@@ -2885,14 +2949,22 @@ const types = {
         encoded[i] = encodedItem;
       }
       encoded.push(keyTypeToEncodedChar.invalid + '-'); // append an extra item, so empty arrays sort correctly
-      return keyTypeToEncodedChar.array + '-' + JSON.stringify(encoded);
+      let encodedKey = JSON.stringify(encoded);
+      if (CFG.escapeNULForSQLiteStatements === false) {
+        encodedKey = encodedKey.replaceAll(String.raw`\u0000`, '\0');
+      }
+      return keyTypeToEncodedChar.array + '-' + encodedKey;
     },
     /**
      * @param {string} key
      * @returns {ValueTypeArray}
      */
     decode(key) {
-      const decoded = JSON.parse(key.slice(2));
+      let decodedKey = key.slice(2);
+      if (CFG.escapeNULForSQLiteStatements === false) {
+        decodedKey = decodedKey.replaceAll('\0', String.raw`\u0000`);
+      }
+      const decoded = JSON.parse(decodedKey);
       decoded.pop(); // remove the extra item
       for (let i = 0; i < decoded.length; i++) {
         const item = decoded[i];
@@ -4312,6 +4384,7 @@ const readonlyProperties$3 = ['objectStoreNames', 'mode', 'db', 'error'];
  *   },
  *   __requestsFinished: boolean,
  *   __transFinishedCb: (err: boolean, cb: ((bool?: boolean) => void)) => void,
+ *   __callTransFinishedCb: (err: boolean, cb: ((bool?: boolean) => void)) => void,
  *   __transactionEndCallback: () => void,
  *   __transactionFinished: boolean,
  *   __completed: boolean,
@@ -4420,6 +4493,35 @@ IDBTransaction.prototype = EventTargetFactory.createInstance({
 IDBTransaction.prototype.__transFinishedCb = function (err, cb) {
   cb(Boolean(err));
 };
+
+/**
+ * In Node, the real (SQL-commit-capable) `__transFinishedCb` is only
+ * installed once the underlying WebSQL driver's own SQL-queue-idle check
+ * has fired at least once for this transaction (asynchronously, via the
+ * `nonstandardTransCb` passed to `db.transaction`/`.readTransaction`).
+ * Since our own request processing can now finish synchronously (e.g., a
+ * trivial upgrade using a synchronous SQL driver), it is possible to reach
+ * transaction completion here before that has happened, in which case
+ * `__transFinishedCb` is still the non-committing default above. Calling
+ * that default directly would silently skip the actual SQL commit and
+ * leave the underlying WebSQL transaction "running" forever, hanging any
+ * later transaction on that same database connection. So, if the real
+ * callback isn't installed yet, defer and retry until it is.
+ * @this {IDBTransactionFull}
+ * @param {boolean} err
+ * @param {(bool?: boolean) => void} cb
+ * @returns {void}
+ */
+IDBTransaction.prototype.__callTransFinishedCb = function (err, cb) {
+  const me = this;
+  if (me.__transFinishedCb === IDBTransaction.prototype.__transFinishedCb) {
+    setTimeout(() => {
+      me.__callTransFinishedCb(err, cb);
+    }, 0);
+    return;
+  }
+  me.__transFinishedCb(err, cb);
+};
 /**
  * @this {IDBTransactionFull}
  * @returns {void}
@@ -4479,7 +4581,7 @@ IDBTransaction.prototype.__executeRequests = function () {
         me.__abortTransaction(createDOMException('AbortError', 'A request was aborted (in user handler after success).'));
         return;
       }
-      executeNextRequest();
+      runContinuationSafely(executeNextRequest);
     }
 
     /**
@@ -4551,7 +4653,7 @@ IDBTransaction.prototype.__executeRequests = function () {
         try {
           q = me.__requests[i];
           if (!q.req) {
-            q.op(tx, q.args, executeNextRequest, error);
+            q.op(tx, q.args, () => runContinuationSafely(executeNextRequest), error);
             return;
           }
           if (q.req.__done) {
@@ -6925,7 +7027,7 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
                 reject(err);
               });
             }));
-            SyncPromise.all(indexCreations).then(finish, /** @type {(reason: any) => PromiseLike<never>} */
+            SyncPromise.all(indexCreations).then(finish).catch(/** @type {(reason: any) => PromiseLike<never>} */
             error).catch(err => {
               console.log('Index rename error');
               throw err;
@@ -9070,7 +9172,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
                 /** @type {import('./IDBDatabase.js').IDBDatabaseFull} */
                 req.__result.__versionTransaction = null;
                 sysdbFinishedCb(systx, false, function () {
-                  req.transaction.__transFinishedCb(false, function () {
+                  req.transaction.__callTransFinishedCb(false, function () {
                     ev.complete();
                     req.__transaction = null;
                   });
@@ -9181,6 +9283,13 @@ IDBFactory.prototype.open = function (name /* , version */) {
   function openDB(oldVersion) {
     /** @type {DatabaseFull} */
     let db;
+    if (version === undefined) {
+      // Resolve before use as a cache key below, or a `open(name)` call
+      //  (no explicit version) would cache/look up under `undefined`
+      //  instead of the actual version, causing a second, separate
+      //  connection to be opened for the same database on reopen.
+      version = oldVersion || 1;
+    }
     if ((useMemoryDatabase || useDatabaseCache) && Object.hasOwn(websqlDBCache, name) && Object.hasOwn(websqlDBCache[name], version)) {
       db = websqlDBCache[name][version];
     } else {
@@ -9192,9 +9301,6 @@ IDBFactory.prototype.open = function (name /* , version */) {
         websqlDBCache[name][version] = db;
       }
     }
-    if (version === undefined) {
-      version = oldVersion || 1;
-    }
     if (oldVersion > version) {
       const err = createDOMException('VersionError', 'An attempt was made to open a database using a lower version than the existing version.', version);
       if (useDatabaseCache) {
@@ -9363,7 +9469,6 @@ IDBFactory.prototype.deleteDatabase = function (name) {
           } = data.rows.item(0));
           const openConnections = me.__connections[name] || [];
           triggerAnyVersionChangeAndBlockedEvents(openConnections, req, version, null).then(function () {
-            // eslint-disable-line promise/catch-or-return -- Sync promise
             // Since we need two databases which can't be in a single transaction, we
             //  do this deleting from `dbVersions` first since the `__sys__` deleting
             //  only impacts file memory whereas this one is critical for avoiding it
@@ -9392,7 +9497,7 @@ IDBFactory.prototype.deleteDatabase = function (name) {
             });
             return undefined;
             // @ts-expect-error It's ok
-          }, dbError);
+          }).catch(dbError);
           return undefined;
         }, dbError);
       });
@@ -9574,6 +9679,9 @@ const shimIndexedDB = IDBFactory.__createInstance();
  *   __unique: boolean,
  *   __sqlDirection: "DESC"|"ASC",
  *   __matchedKeys: {[key: string]: true},
+ *   __continuationKey: import('./Key.js').Key|undefined,
+ *   __continuationPrimaryKey: import('./Key.js').Key|undefined,
+ *   __multiEntryExhausted: boolean,
  *   __invalidateCache: () => void
  * }} IDBCursorFull
  */
@@ -9647,6 +9755,9 @@ IDBCursor.__super = function IDBCursor(query, direction, store, source, keyColum
   this.__valueDecoder = this.__keyOnly ? Key : Sca;
   this.__count = count;
   this.__prefetchedIndex = -1;
+  this.__continuationKey = undefined;
+  this.__continuationPrimaryKey = undefined;
+  this.__multiEntryExhausted = false;
   this.__multiEntryIndex = this.__indexSource ? 'multiEntry' in source && source.multiEntry : false;
   this.__unique = this.direction.includes('unique');
   this.__sqlDirection = ['prev', 'prevunique'].includes(this.direction) ? 'DESC' : 'ASC';
@@ -9799,73 +9910,96 @@ const leftBracketRegex = /\[/gu;
  * @param {SQLTransaction} tx
  * @param {KeySuccess} success
  * @param {FindError} error
- * @param {Integer|undefined} recordsToLoad
+ * @param {Integer} [recordsToLoad]
  * @this {IDBCursorFull}
  * @returns {void}
  */
-IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, error, recordsToLoad) {
+IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, error, recordsToLoad = 1) {
   const me = this;
-  if (me.__prefetchedData && me.__prefetchedData.length === me.__prefetchedIndex) {
+  if (me.__multiEntryExhausted) {
     if (CFG.DEBUG) {
-      console.log('Reached end of multiEntry cursor');
+      console.log('[multiEntry] Reached end of multiEntry cursor (already exhausted)');
     }
     success(undefined, undefined, undefined);
     return;
   }
   const quotedKeyColumnName = sqlQuote(me.__keyColumnName);
-  const sql = ['SELECT * FROM', escapeStoreNameForSQL(me.__store.__currentName)];
-  /** @type {string[]} */
-  const sqlValues = [];
-  sql.push('WHERE', quotedKeyColumnName, 'NOT NULL');
-  if (me.__range && me.__range.lower !== undefined && Array.isArray(me.__range.upper)) {
-    if (me.__range.upper.indexOf(me.__range.lower) === 0) {
-      sql.push('AND', quotedKeyColumnName, "LIKE ? ESCAPE '^'");
-      sqlValues.push('%' + sqlLIKEEscape(/** @type {string} */me.__range.__lowerCached.slice(0, -1)) + '%');
-    }
-  }
+  const quotedKey = sqlQuote('key');
 
   // Determine the ORDER BY direction based on the cursor.
   const direction = me.__sqlDirection;
   const op = direction === 'ASC' ? '>' : '<';
-  const quotedKey = sqlQuote('key');
-  if (primaryKey !== undefined) {
-    sql.push('AND', quotedKey, op + '= ?');
-    // Key.convertValueToKey(primaryKey); // Already checked by `continuePrimaryKey`
-    sqlValues.push(/** @type {string} */encode$1(primaryKey));
-  }
-  if (key !== undefined) {
-    sql.push('AND', quotedKeyColumnName, op + '= ?');
-    // Key.convertValueToKey(key); // Already checked by `continue` or `continuePrimaryKey`
-    sqlValues.push(/** @type {string} */encode$1(key));
-  } else if (me.__key !== undefined) {
-    sql.push('AND', quotedKeyColumnName, op + ' ?');
-    // Key.convertValueToKey(me.__key); // Already checked when entered
-    sqlValues.push(/** @type {string} */encode$1(me.__key));
-  }
-  if (!me.__count) {
-    // 1. Sort by key
-    sql.push('ORDER BY', quotedKeyColumnName, direction);
 
-    // 2. Sort by primaryKey (if defined and not unique)
-    if (!me.__unique && me.__keyColumnName !== 'key') {
-      // Avoid adding 'key' twice
-      sql.push(',', sqlQuote('key'), direction);
+  /**
+   * Runs (and, if a batch of underlying rows produces no matching
+   * multi-entry values, repeatedly re-runs) the query for the next batch
+   * of underlying rows, advancing `me.__continuationKey`/
+   * `me.__continuationPrimaryKey` (tracking the last *physical* row
+   * scanned) each time, until either some matches are found or the
+   * underlying table is exhausted.
+   * @returns {void}
+   */
+  function runQuery() {
+    const sql = ['SELECT * FROM', escapeStoreNameForSQL(me.__store.__currentName)];
+    /** @type {string[]} */
+    const sqlValues = [];
+    sql.push('WHERE', quotedKeyColumnName, 'NOT NULL');
+    if (me.__range && me.__range.lower !== undefined && Array.isArray(me.__range.upper)) {
+      if (me.__range.upper.indexOf(me.__range.lower) === 0) {
+        sql.push('AND', quotedKeyColumnName, "LIKE ? ESCAPE '^'");
+        sqlValues.push('%' + sqlLIKEEscape(/** @type {string} */me.__range.__lowerCached.slice(0, -1)) + '%');
+      }
+    }
+    if (primaryKey !== undefined) {
+      sql.push('AND', quotedKey, op + '= ?');
+      // Key.convertValueToKey(primaryKey); // Already checked by `continuePrimaryKey`
+      sqlValues.push(/** @type {string} */encode$1(primaryKey));
     }
-
-    // 3. Sort by position (if defined)
-
-    if (!me.__unique && me.__indexSource) {
-      // 4. Sort by object store position (if defined and not unique)
-      sql.push(',', sqlQuote(me.__valueColumnName), direction);
+    if (key !== undefined) {
+      sql.push('AND', quotedKeyColumnName, op + '= ?');
+      // Key.convertValueToKey(key); // Already checked by `continue` or `continuePrimaryKey`
+      sqlValues.push(/** @type {string} */encode$1(key));
+    } else if (me.__continuationKey !== undefined) {
+      // Resume from the last underlying (physical) row we scanned, not
+      // from the last *matching* multi-entry value (which lives in a
+      // different key-space than the raw index column and cannot be
+      // reliably compared against it, e.g. for array index keys).
+      sql.push('AND (', quotedKeyColumnName, op, '?', 'OR (', quotedKeyColumnName, '= ?', 'AND', quotedKey, op, '?))');
+      const encodedContinuationKey = /** @type {string} */
+      encode$1(me.__continuationKey, true);
+      sqlValues.push(encodedContinuationKey, encodedContinuationKey, /** @type {string} */encode$1(me.__continuationPrimaryKey));
+    }
+    if (!me.__count) {
+      // 1. Sort by key
+      sql.push('ORDER BY', quotedKeyColumnName, direction);
+
+      // 2. Sort by primaryKey (if defined and not unique)
+      if (!me.__unique && me.__keyColumnName !== 'key') {
+        // Avoid adding 'key' twice
+        sql.push(',', sqlQuote('key'), direction);
+      }
+
+      // 3. Sort by position (if defined)
+
+      if (!me.__unique && me.__indexSource) {
+        // 4. Sort by object store position (if defined and not unique)
+        sql.push(',', sqlQuote(me.__valueColumnName), direction);
+      }
+      sql.push('LIMIT', String(recordsToLoad));
+    }
+    const sqlStr = sql.join(' ');
+    if (CFG.DEBUG) {
+      console.log('[multiEntry] query', sqlStr, sqlValues);
     }
-    sql.push('LIMIT', String(recordsToLoad));
-  }
-  const sqlStr = sql.join(' ');
-  if (CFG.DEBUG) {
-    console.log(sqlStr, sqlValues);
-  }
-  tx.executeSql(sqlStr, sqlValues, function (tx, data) {
-    if (data.rows.length > 0) {
+    tx.executeSql(sqlStr, sqlValues, function (tx, data) {
+      if (data.rows.length === 0) {
+        me.__multiEntryExhausted = true;
+        if (CFG.DEBUG) {
+          console.log('[multiEntry] Reached end of multiEntry cursor (no more rows)');
+        }
+        success(undefined, undefined, undefined);
+        return;
+      }
       if (me.__count) {
         // Avoid caching and other processing below
         let ct = 0;
@@ -9878,6 +10012,16 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
         success(undefined, ct, undefined);
         return;
       }
+
+      // Track how far we've physically scanned, regardless of whether
+      // this batch produced any matches, so the next batch (if any)
+      // resumes after this one instead of re-scanning or stopping early.
+      const lastRawRow = data.rows.item(data.rows.length - 1);
+      me.__continuationKey = decode$1(lastRawRow[me.__keyColumnName], true);
+      me.__continuationPrimaryKey = decode$1(lastRawRow.key);
+      if (data.rows.length < recordsToLoad) {
+        me.__multiEntryExhausted = true;
+      }
       const rows = [];
       for (let i = 0; i < data.rows.length; i++) {
         const rowItem = data.rows.item(i);
@@ -9897,6 +10041,20 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
           rows.push(clone);
         }
       }
+      if (rows.length === 0) {
+        if (me.__multiEntryExhausted) {
+          if (CFG.DEBUG) {
+            console.log('[multiEntry] Reached end of multiEntry cursor (last batch had no matches)');
+          }
+          success(undefined, undefined, undefined);
+          return;
+        }
+        if (CFG.DEBUG) {
+          console.log('[multiEntry] batch had no matches; fetching next batch');
+        }
+        runQuery();
+        return;
+      }
       const reverse = me.direction.indexOf('prev') === 0;
       rows.sort(function (a, b) {
         if (a.matchingKey.replaceAll(leftBracketRegex, 'z') < b.matchingKey.replaceAll(leftBracketRegex, 'z')) {
@@ -9913,47 +10071,31 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
         }
         return 0;
       });
-      if (rows.length > 1) {
-        me.__prefetchedIndex = 0;
-        me.__prefetchedData = {
-          data: rows,
-          length: rows.length,
-          /**
-           * @param {Integer} index
-           * @returns {RowItemNonNull}
-           */
-          item(index) {
-            return this.data[index];
-          }
-        };
-        if (CFG.DEBUG) {
-          console.log('Preloaded ' + me.__prefetchedData.length + ' records for multiEntry cursor');
-        }
-        me.__decode(rows[0], success);
-      } else if (rows.length === 1) {
-        if (CFG.DEBUG) {
-          console.log('Reached end of multiEntry cursor');
-        }
-        me.__decode(rows[0], success);
-      } else {
-        if (CFG.DEBUG) {
-          console.log('Reached end of multiEntry cursor');
+      me.__prefetchedIndex = 0;
+      me.__prefetchedData = {
+        data: rows,
+        length: rows.length,
+        /**
+         * @param {Integer} index
+         * @returns {RowItemNonNull}
+         */
+        item(index) {
+          return this.data[index];
         }
-        success(undefined, undefined, undefined);
+      };
+      if (CFG.DEBUG) {
+        console.log('[multiEntry] Preloaded ' + me.__prefetchedData.length + ' records for multiEntry cursor');
       }
-    } else {
+      me.__decode(rows[0], success);
+    }, function (tx, err) {
       if (CFG.DEBUG) {
-        console.log('Reached end of multiEntry cursor');
+        console.log('[multiEntry] Could not execute Cursor.continue', sqlStr, sqlValues);
       }
-      success(undefined, undefined, undefined);
-    }
-  }, function (tx, err) {
-    if (CFG.DEBUG) {
-      console.log('Could not execute Cursor.continue', sqlStr, sqlValues);
-    }
-    error(err);
-    return false;
-  });
+      error(err);
+      return false;
+    });
+  }
+  runQuery();
 };
 
 /**
@@ -10062,6 +10204,7 @@ IDBCursor.prototype.__sourceOrEffectiveObjStoreDeleted = function () {
 IDBCursor.prototype.__invalidateCache = function () {
   // @ts-expect-error Why is this not being found?
   this.__prefetchedData = null;
+  this.__multiEntryExhausted = false;
 };
 
 /**
@@ -10117,8 +10260,8 @@ IDBCursor.prototype.__continueFinish = function (key, primaryKey, advanceState)
           me.__advanceCount--;
           me.__key = k;
           me.__continue(undefined, true);
-          /** @type {() => void} */
-          executeNextRequest(); // We don't call success yet but do need to advance the transaction queue
+          // We don't call success yet but do need to advance the transaction queue
+          runContinuationSafely(/** @type {() => void} */executeNextRequest);
           return;
         }
         me.__advanceCount = undefined;
@@ -10140,11 +10283,11 @@ IDBCursor.prototype.__continueFinish = function (key, primaryKey, advanceState)
               return;
             }
             // @ts-expect-error Todo: Our bug to fix
-            cursorContinue(tx, args, success, error);
+            runContinuationSafely(() => cursorContinue(tx, args, success, error));
           }
           if (me.__unique && !me.__multiEntryIndex && encKey === encode$1(me.key, me.__multiEntryIndex)) {
             // @ts-expect-error Todo: Our bug to fix
-            cursorContinue(tx, args, success, error);
+            runContinuationSafely(() => cursorContinue(tx, args, success, error));
             return;
           }
           checkKey();
@@ -10747,21 +10890,21 @@ function requireNextTick() {
   return nextTick;
 }
 
-var queueMicrotask = {};
+var queueMicrotask$1 = {};
 
 var hasRequiredQueueMicrotask;
 function requireQueueMicrotask() {
-  if (hasRequiredQueueMicrotask) return queueMicrotask;
+  if (hasRequiredQueueMicrotask) return queueMicrotask$1;
   hasRequiredQueueMicrotask = 1;
-  queueMicrotask.test = function () {
+  queueMicrotask$1.test = function () {
     return typeof commonjsGlobal.queueMicrotask === 'function';
   };
-  queueMicrotask.install = function (func) {
+  queueMicrotask$1.install = function (func) {
     return function () {
       commonjsGlobal.queueMicrotask(func);
     };
   };
-  return queueMicrotask;
+  return queueMicrotask$1;
 }
 
 var mutation = {};
@@ -10860,11 +11003,11 @@ function requireTimeout() {
   return timeout;
 }
 
-var lib;
-var hasRequiredLib;
-function requireLib() {
-  if (hasRequiredLib) return lib;
-  hasRequiredLib = 1;
+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;
@@ -10939,7 +11082,7 @@ function requireLib() {
         return fun.apply(null, array);
     }
   };
-  lib = immediate;
+  lib$1 = immediate;
   function immediate(task) {
     var args = new Array(arguments.length - 1);
     if (arguments.length > 1) {
@@ -10953,11 +11096,11 @@ function requireLib() {
       scheduleDrain();
     }
   }
-  return lib;
+  return lib$1;
 }
 
-var libExports = requireLib();
-var immediate = /*@__PURE__*/getDefaultExportFromCjs(libExports);
+var libExports$1 = requireLib$1();
+var immediate = /*@__PURE__*/getDefaultExportFromCjs(libExports$1);
 
 var tinyQueue;
 var hasRequiredTinyQueue;
@@ -11314,584 +11457,1026 @@ function customOpenDatabase(SQLiteDatabase, opts) {
   return (...args) => openDatabase(args);
 }
 
-var sqlite3$1 = {exports: {}};
+var lib = {exports: {}};
 
-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 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 bindings = {exports: {}};
+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 fileUriToPath_1;
-var hasRequiredFileUriToPath;
-function requireFileUriToPath() {
-  if (hasRequiredFileUriToPath) return fileUriToPath_1;
-  hasRequiredFileUriToPath = 1;
-  /**
-   * Module dependencies.
-   */
+var wrappers = {};
 
-  var sep = path.sep || '/';
+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;
+}
 
-  /**
-   * Module exports.
-   */
+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;
 
-  fileUriToPath_1 = fileUriToPath;
+    // 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);
 
-  /**
-   * File URI to Path function.
-   *
-   * @param {String} uri
-   * @return {String} path
-   * @api public
-   */
+    // Return the default version of the transaction function
+    return properties.default.value;
+  };
 
-  function fileUriToPath(uri) {
-    if ('string' != typeof uri || uri.length <= 7 || 'file://' != uri.substring(0, 7)) {
-      throw new TypeError('must pass in a file:// URI to convert to a file path');
+  // 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)
+      });
     }
-    var rest = decodeURI(uri.substring(7));
-    var firstSlash = rest.indexOf('/');
-    var host = rest.substring(0, firstSlash);
-    var path = rest.substring(firstSlash + 1);
+    return controller;
+  };
 
-    // 2.  Scheme Definition
-    // As a special case, <host> can be the string "localhost" or the empty
-    // string; this is interpreted as "the machine from which the URL is
-    // being interpreted".
-    if ('localhost' == host) host = '';
-    if (host) {
-      host = sep + sep + host;
+  // 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;
+}
 
-    // 3.2  Drives, drive letters, mount points, file system root
-    // Drive letters are mapped into the top of a file URI in various ways,
-    // depending on the implementation; some applications substitute
-    // vertical bar ("|") for the colon after the drive letter, yielding
-    // "file:///c|/tmp/test.txt".  In some cases, the colon is left
-    // unchanged, as in "file:///c:/tmp/test.txt".  In other cases, the
-    // colon is simply omitted, as in "file:///c/tmp/test.txt".
-    path = path.replace(/^(.+)\|/, '$1:');
+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;
+}
 
-    // for Windows, we need to invert the path separators from what a URI uses
-    if (sep == '\\') {
-      path = path.replace(/\//g, '\\');
-    }
-    if (/^.+\:/.test(path)) ; else {
-      // unix path…
-      path = sep + path;
-    }
-    return host + path;
-  }
-  return fileUriToPath_1;
+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;
 }
 
-/**
- * Module dependencies.
- */
-var hasRequiredBindings;
-function requireBindings() {
-  if (hasRequiredBindings) return bindings.exports;
-  hasRequiredBindings = 1;
-  (function (module, exports) {
-    var fs = require$$0,
-      path$1 = path,
-      fileURLToPath = requireFileUriToPath(),
-      join = path$1.join,
-      dirname = path$1.dirname,
-      exists = fs.accessSync && function (path) {
+var backup;
+var hasRequiredBackup;
+function requireBackup() {
+  if (hasRequiredBackup) return backup;
+  hasRequiredBackup = 1;
+  const fs = require$$0;
+  const path$1 = path;
+  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$1.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 {
-          fs.accessSync(path);
-        } catch (e) {
-          return false;
+          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 true;
-      } || fs.existsSync || path$1.existsSync,
-      defaults = {
-        arrow: process.env.NODE_BINDINGS_ARROW || ' → ',
-        compiled: process.env.NODE_BINDINGS_COMPILED_DIR || 'compiled',
-        platform: process.platform,
-        arch: process.arch,
-        nodePreGyp: 'node-v' + process.versions.modules + '-' + process.platform + '-' + process.arch,
-        version: process.versions.node,
-        bindings: 'bindings.node',
-        try: [
-        // node-gyp's linked version in the "build" dir
-        ['module_root', 'build', 'bindings'],
-        // node-waf and gyp_addon (a.k.a node-gyp)
-        ['module_root', 'build', 'Debug', 'bindings'], ['module_root', 'build', 'Release', 'bindings'],
-        // Debug files, for development (legacy behavior, remove for node v0.9)
-        ['module_root', 'out', 'Debug', 'bindings'], ['module_root', 'Debug', 'bindings'],
-        // Release files, but manually compiled (legacy behavior, remove for node v0.9)
-        ['module_root', 'out', 'Release', 'bindings'], ['module_root', 'Release', 'bindings'],
-        // Legacy from node-waf, node <= 0.4.x
-        ['module_root', 'build', 'default', 'bindings'],
-        // Production "Release" buildtype binary (meh...)
-        ['module_root', 'compiled', 'version', 'platform', 'arch', 'bindings'],
-        // node-qbs builds
-        ['module_root', 'addon-build', 'release', 'install-root', 'bindings'], ['module_root', 'addon-build', 'debug', 'install-root', 'bindings'], ['module_root', 'addon-build', 'default', 'install-root', 'bindings'],
-        // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
-        ['module_root', 'lib', 'binding', 'nodePreGyp', 'bindings']]
-      };
-
-    /**
-     * The main `bindings()` function loads the compiled bindings for a given module.
-     * It uses V8's Error API to determine the parent filename that this function is
-     * being invoked from, which is then used to find the root directory.
-     */
+      });
+    });
+  };
+  return backup;
+}
 
-    function bindings(opts) {
-      // Argument surgery
-      if (typeof opts == 'string') {
-        opts = {
-          bindings: opts
-        };
-      } else if (!opts) {
-        opts = {};
-      }
+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;
+}
 
-      // maps `defaults` onto `opts` object
-      Object.keys(defaults).map(function (i) {
-        if (!(i in opts)) opts[i] = defaults[i];
-      });
+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;
+}
 
-      // Get the module root
-      if (!opts.module_root) {
-        opts.module_root = exports.getRoot(exports.getFileName());
-      }
+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;
+}
 
-      // Ensure the given bindings name ends with .node
-      if (path$1.extname(opts.bindings) != '.node') {
-        opts.bindings += '.node';
-      }
+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
+      };
 
-      // https://github.com/webpack/webpack/issues/4175#issuecomment-342931035
-      var requireFunc = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : commonjsRequire;
-      var tries = [],
-        i = 0,
-        l = opts.try.length,
-        n,
-        b,
-        err;
-      for (; i < l; i++) {
-        n = join.apply(null, opts.try[i].map(function (p) {
-          return opts[p] || p;
-        }));
-        tries.push(n);
-        try {
-          b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
-          if (!opts.path) {
-            b.path = n;
-          }
-          return b;
-        } catch (e) {
-          if (e.code !== 'MODULE_NOT_FOUND' && e.code !== 'QUALIFIED_PATH_RESOLUTION_FAILED' && !/not find/i.test(e.message)) {
-            throw e;
-          }
-        }
+      // 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`);
       }
-      err = new Error('Could not locate the bindings file. Tried:\n' + tries.map(function (a) {
-        return opts.arrow + a;
-      }).join('\n'));
-      err.tries = tries;
-      throw err;
+      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`);
     }
-    module.exports = exports = bindings;
-
-    /**
-     * Gets the filename of the JavaScript file that invokes this function.
-     * Used to help find the root directory of a module.
-     * Optionally accepts an filename argument to skip when searching for the invoking filename
-     */
 
-    exports.getFileName = function getFileName(calling_file) {
-      var origPST = Error.prepareStackTrace,
-        origSTL = Error.stackTraceLimit,
-        dummy = {},
-        fileName;
-      Error.stackTraceLimit = 10;
-      Error.prepareStackTrace = function (e, st) {
-        for (var i = 0, l = st.length; i < l; i++) {
-          fileName = st[i].getFileName();
-          if (fileName !== __filename) {
-            if (calling_file) {
-              if (fileName !== calling_file) {
-                return;
-              }
-            } else {
-              return;
-            }
-          }
-        }
-      };
+    // 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)`);
+    }
 
-      // run the 'prepareStackTrace' function above
-      Error.captureStackTrace(dummy);
-      dummy.stack;
+    // 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`);
+    }
 
-      // cleanup
-      Error.prepareStackTrace = origPST;
-      Error.stackTraceLimit = origSTL;
+    // 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`);
+      }
+    }
 
-      // handle filename that starts with "file://"
-      var fileSchema = 'file://';
-      if (fileName.indexOf(fileSchema) === 0) {
-        fileName = fileURLToPath(fileName);
+    // 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)`);
       }
-      return fileName;
-    };
+      safeIntegers = +bool;
+    }
 
-    /**
-     * Gets the root directory of a module, given an arbitrary filename
-     * somewhere in the module tree. The "root directory" is the directory
-     * containing the `package.json` file.
-     *
-     *   In:  /home/nate/node-native-module/lib/index.js
-     *   Out: /home/nate/node-native-module
-     */
+    // 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)`);
+      }
+    }
 
-    exports.getRoot = function getRoot(file) {
-      var dir = dirname(file),
-        prev;
-      while (true) {
-        if (dir === '.') {
-          // Avoids an infinite loop in rare cases, like the REPL
-          dir = process.cwd();
-        }
-        if (exists(join(dir, 'package.json')) || exists(join(dir, 'node_modules'))) {
-          // Found the 'package.json' file or 'node_modules' dir; we're done
-          return dir;
-        }
-        if (prev === dir) {
-          // Got to the top
-          throw new Error('Could not find module root given file: "' + file + '". Do you have a `package.json` file? ');
+    // 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`);
         }
-        // Try the parent dir next
-        prev = dir;
-        dir = join(dir, '..');
       }
     };
-  })(bindings, bindings.exports);
-  return bindings.exports;
-}
-
-var sqlite3Binding;
-var hasRequiredSqlite3Binding;
-function requireSqlite3Binding() {
-  if (hasRequiredSqlite3Binding) return sqlite3Binding;
-  hasRequiredSqlite3Binding = 1;
-  sqlite3Binding = requireBindings()('node_sqlite3.node');
-  return sqlite3Binding;
-}
-
-var trace = {};
-
-var hasRequiredTrace;
-function requireTrace() {
-  if (hasRequiredTrace) return trace;
-  hasRequiredTrace = 1;
-  // Inspired by https://github.com/tlrobinson/long-stack-traces
-  const util = require$$0$1;
-  function extendTrace(object, property, pos) {
-    const old = object[property];
-    object[property] = function () {
-      const error = new Error();
-      const name = object.constructor.name + '#' + property + '(' + Array.prototype.slice.call(arguments).map(function (el) {
-        return util.inspect(el, false, 0);
-      }).join(', ') + ')';
-      if (typeof pos === 'undefined') pos = -1;
-      if (pos < 0) pos += arguments.length;
-      const cb = arguments[pos];
-      if (typeof arguments[pos] === 'function') {
-        arguments[pos] = function replacement() {
-          const err = arguments[0];
-          if (err && err.stack && !err.__augmented) {
-            err.stack = filter(err).join('\n');
-            err.stack += '\n--> in ' + name;
-            err.stack += '\n' + filter(error).slice(1).join('\n');
-            err.__augmented = true;
-          }
-          return cb.apply(this, arguments);
-        };
+  }
+  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}"`);
       }
-      return old.apply(this, arguments);
-    };
+      output[index] = row[key];
+      count += 1;
+    }
+    if (count !== columnMap.size) {
+      throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+    }
   }
-  trace.extendTrace = extendTrace;
-  function filter(error) {
-    return error.stack.split('\n').filter(function (line) {
-      return line.indexOf(__filename) < 0;
-    });
+  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;
   }
-  return trace;
+  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 hasRequiredSqlite3;
-function requireSqlite3() {
-  if (hasRequiredSqlite3) return sqlite3$1.exports;
-  hasRequiredSqlite3 = 1;
-  (function (module, exports) {
-    const path$1 = path;
-    const sqlite3 = requireSqlite3Binding();
-    const EventEmitter = require$$2.EventEmitter;
-    module.exports = sqlite3;
-    function normalizeMethod(fn) {
-      return function (sql) {
-        let errBack;
-        const args = Array.prototype.slice.call(arguments, 1);
-        if (typeof args[args.length - 1] === 'function') {
-          const callback = args[args.length - 1];
-          errBack = function (err) {
-            if (err) {
-              callback(err);
-            }
-          };
-        }
-        const statement = new Statement(this, sql, errBack);
-        return fn.call(this, statement, args);
-      };
+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$1 = path;
+  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$1.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
+      });
     }
-    function inherits(target, source) {
-      for (const k in source.prototype) target.prototype[k] = source.prototype[k];
+    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];
     }
-    sqlite3.cached = {
-      Database: function (file, a, b) {
-        if (file === '' || file === ':memory:') {
-          // Don't cache special databases.
-          return new Database(file, a, b);
-        }
-        let db;
-        file = path$1.resolve(file);
-        if (!sqlite3.cached.objects[file]) {
-          db = sqlite3.cached.objects[file] = new Database(file, a, b);
-        } else {
-          // Make sure the callback is called.
-          db = sqlite3.cached.objects[file];
-          const callback = typeof a === 'number' ? b : a;
-          if (typeof callback === 'function') {
-            function cb() {
-              callback.call(db, null);
-            }
-            if (db.open) process.nextTick(cb);else db.once('open', cb);
-          }
-        }
-        return db;
-      },
-      objects: {}
+  }
+  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;
     };
-    const Database = sqlite3.Database;
-    const Statement = sqlite3.Statement;
-    const Backup = sqlite3.Backup;
-    inherits(Database, EventEmitter);
-    inherits(Statement, EventEmitter);
-    inherits(Backup, EventEmitter);
-
-    // Database#prepare(sql, [bind1, bind2, ...], [callback])
-    Database.prototype.prepare = normalizeMethod(function (statement, params) {
-      return params.length ? statement.bind.apply(statement, params) : statement;
-    });
+  }
+  function recordFactory(value) {
+    return {
+      value,
+      done: false
+    };
+  }
+  return database;
+}
 
-    // Database#run(sql, [bind1, bind2, ...], [callback])
-    Database.prototype.run = normalizeMethod(function (statement, params) {
-      statement.run.apply(statement, params).finalize();
-      return this;
-    });
+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.');
+}
 
-    // Database#get(sql, [bind1, bind2, ...], [callback])
-    Database.prototype.get = normalizeMethod(function (statement, params) {
-      statement.get.apply(statement, params).finalize();
-      return this;
-    });
+var binding = {exports: {}};
 
-    // Database#all(sql, [bind1, bind2, ...], [callback])
-    Database.prototype.all = normalizeMethod(function (statement, params) {
-      statement.all.apply(statement, params).finalize();
-      return this;
-    });
+var hasRequiredBinding;
+function requireBinding() {
+  if (hasRequiredBinding) return binding.exports;
+  hasRequiredBinding = 1;
+  (function (module, exports) {
 
-    // Database#each(sql, [bind1, bind2, ...], [callback], [complete])
-    Database.prototype.each = normalizeMethod(function (statement, params) {
-      statement.each.apply(statement, params).finalize();
-      return this;
-    });
-    Database.prototype.map = normalizeMethod(function (statement, params) {
-      statement.map.apply(statement, params).finalize();
-      return this;
-    });
+    const fs = require$$0;
+    const path$1 = path;
+    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$1.resolve(nativeBinding).replace(/(\.node)?$/, '.node'));
+      }
 
-    // Database#backup(filename, [callback])
-    // Database#backup(filename, destName, sourceName, filenameIsDest, [callback])
-    Database.prototype.backup = function () {
-      let backup;
-      if (arguments.length <= 2) {
-        // By default, we write the main database out to the main database of the named file.
-        // This is the most likely use of the backup api.
-        backup = new Backup(this, arguments[0], 'main', 'main', true, arguments[1]);
-      } else {
-        // Otherwise, give the user full control over the sqlite3_backup_init arguments.
-        backup = new Backup(this, arguments[0], arguments[1], arguments[2], arguments[3], arguments[4]);
+      // If an object was provided, use it as the binding directly.
+      if (typeof nativeBinding === 'object' && nativeBinding !== null) {
+        return nativeBinding;
       }
-      // Per the sqlite docs, exclude the following errors as non-fatal by default.
-      backup.retryErrors = [sqlite3.BUSY, sqlite3.LOCKED];
-      return backup;
-    };
-    Statement.prototype.map = function () {
-      const params = Array.prototype.slice.call(arguments);
-      const callback = params.pop();
-      params.push(function (err, rows) {
-        if (err) return callback(err);
-        const result = {};
-        if (rows.length) {
-          const keys = Object.keys(rows[0]);
-          const key = keys[0];
-          if (keys.length > 2) {
-            // Value is an object
-            for (let i = 0; i < rows.length; i++) {
-              result[rows[i][key]] = rows[i];
-            }
-          } else {
-            const value = keys[1];
-            // Value is a plain value
-            for (let i = 0; i < rows.length; i++) {
-              result[rows[i][key]] = rows[i][value];
-            }
-          }
-        }
-        callback(err, result);
-      });
-      return this.all.apply(this, params);
-    };
-    let isVerbose = false;
-    const supportedEvents = ['trace', 'profile', 'change'];
-    Database.prototype.addListener = Database.prototype.on = function (type) {
-      const val = EventEmitter.prototype.addListener.apply(this, arguments);
-      if (supportedEvents.indexOf(type) >= 0) {
-        this.configure(type, true);
-      }
-      return val;
-    };
-    Database.prototype.removeListener = function (type) {
-      const val = EventEmitter.prototype.removeListener.apply(this, arguments);
-      if (supportedEvents.indexOf(type) >= 0 && !this._events[type]) {
-        this.configure(type, false);
+
+      // If we're using the default binding and it already exists, just return it.
+      if (DEFAULT_ADDON) {
+        return DEFAULT_ADDON;
       }
-      return val;
-    };
-    Database.prototype.removeAllListeners = function (type) {
-      const val = EventEmitter.prototype.removeAllListeners.apply(this, arguments);
-      if (supportedEvents.indexOf(type) >= 0) {
-        this.configure(type, false);
+
+      // Otherwise, try to find the binding as a prebuilt binary.
+      let filename = getPrebuildPath();
+      if (filename) {
+        return DEFAULT_ADDON = commonjsRequire(filename);
       }
-      return val;
-    };
 
-    // Save the stack trace over EIO callbacks.
-    sqlite3.verbose = function () {
-      if (!isVerbose) {
-        const trace = requireTrace();
-        ['prepare', 'get', 'run', 'all', 'each', 'map', 'close', 'exec'].forEach(function (name) {
-          trace.extendTrace(Database.prototype, name);
-        });
-        ['bind', 'get', 'run', 'all', 'each', 'map', 'reset', 'finalize'].forEach(function (name) {
-          trace.extendTrace(Statement.prototype, name);
-        });
-        isVerbose = true;
+      // If no prebuilt binary was found, try the default node-gyp locations.
+      filename = path$1.join(__dirname, '..', 'build', 'Debug', 'better_sqlite3.node');
+      if (!fs.existsSync(filename)) {
+        filename = path$1.join(__dirname, '..', 'build', 'Release', 'better_sqlite3.node');
       }
-      return sqlite3;
-    };
-  })(sqlite3$1);
-  return sqlite3$1.exports;
+      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$1.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 sqlite3Exports = requireSqlite3();
-var sqlite3 = /*@__PURE__*/getDefaultExportFromCjs(sqlite3Exports);
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib.exports;
+  hasRequiredLib = 1;
+  lib.exports = requireDatabase()(requireBinding().getBinding, true);
+  lib.exports.SqliteError = requireSqliteError();
+  return lib.exports;
+}
 
-function SQLiteResult(error, insertId, rowsAffected, rows) {
-  this.error = error;
-  this.insertId = insertId;
-  this.rowsAffected = rowsAffected;
-  this.rows = rows;
+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)');
 
-var READ_ONLY_ERROR = new Error('could not prepare statement (23 not authorized)');
-function SQLiteDatabase(name, opts) {
-  opts = opts || {};
-  this._db = new sqlite3.Database(name);
+/**
+ * @typedef {(sql: string, duration: number) => void} SQLProfileCallback
+ */
+
+/**
+ * @typedef {((sql: string) => void)|undefined} SQLTraceCallback
+ */
+
+/**
+ * @param {string} name
+ * @param {{busyTimeout?: number, trace?: (sql: string) => void, profile?: SQLProfileCallback}} [opts]
+ * @returns {void}
+ */
+function SQLiteDatabase(name, opts = {}) {
+  /** @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) {
-    this._db.configure('busyTimeout', opts.busyTimeout); // Default is 1000
-  }
-  if (opts.trace) {
-    this._db.configure('trace', opts.trace);
+    db.pragma('busy_timeout = ' + Number(opts.busyTimeout));
   }
-  if (opts.profile) {
-    this._db.configure('profile', opts.profile);
-  }
-}
-function runSelect(db, sql, args, cb) {
-  db.all(sql, args, function (err, rows) {
-    if (err) {
-      return cb(new SQLiteResult(err));
+
+  // 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'} 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;
+      }
+    },
+    /**
+     * 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;
     }
-    var insertId = void 0;
-    var rowsAffected = 0;
-    var resultSet = new SQLiteResult(null, insertId, rowsAffected, rows);
-    cb(resultSet);
-  });
+  };
 }
-function runNonSelect(db, sql, args, cb) {
-  db.run(sql, args, function (err) {
-    if (err) {
-      return cb(new SQLiteResult(err));
-    }
-    /* jshint validthis:true */
-    var executionResult = this;
-    var insertId = executionResult.lastID;
-    var rowsAffected = executionResult.changes;
-    var rows = [];
-    var resultSet = new SQLiteResult(null, insertId, rowsAffected, rows);
-    cb(resultSet);
-  });
+
+/**
+ * @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) {
-  var db = this._db;
-  var len = queries.length;
-  var results = new Array(len);
-  var i = 0;
-  function checkDone() {
-    if (++i === len) {
-      callback(null, results);
-    } else {
-      doNext();
-    }
-  }
-  function onQueryComplete(i) {
-    return function (res) {
-      results[i] = res;
-      checkDone();
-    };
-  }
-  function doNext() {
-    var query = queries[i];
-    var sql = query.sql;
-    var args = query.args;
-
-    // TODO: It seems like the node-sqlite3 API either allows:
-    // 1) all(), which returns results but not rowsAffected or lastID
-    // 2) run(), which doesn't return results, but returns rowsAffected and lastID
-    // So we try to sniff whether it's a SELECT query or not.
-    // This is inherently error-prone, although it will probably work in the 99%
-    // case.
-    var isSelect = /^\s*SELECT\b/i.test(sql);
+  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) {
-      onQueryComplete(i)(new SQLiteResult(READ_ONLY_ERROR));
-    } else if (isSelect) {
-      runSelect(db, sql, args, onQueryComplete(i));
-    } else {
-      runNonSelect(db, sql, args, onQueryComplete(i));
+      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));
+      }
     }
   }
-  doNext();
+  queueMicrotask(() => {
+    callback(null, results);
+  });
 };
 
 /**
@@ -11904,11 +12489,9 @@ function wrappedSQLiteDatabase(name) {
     db._db.configure('busyTimeout', /** @type {number} */CFG.sqlBusyTimeout); // Default is 1000
   }
   if (CFG.sqlTrace) {
-    // @ts-expect-error native API?
     db._db.configure('trace', CFG.sqlTrace);
   }
   if (CFG.sqlProfile) {
-    // @ts-expect-error native API?
     db._db.configure('profile', CFG.sqlProfile);
   }
   return db;
@@ -11939,6 +12522,7 @@ CFG.win = {
 const __setGlobalVars = function (idb, initialConfig = {}) {
   const obj = setGlobalVars(idb, {
     fs: fs$1,
+    escapeNULForSQLiteStatements: false,
     ...initialConfig
   });
   /* istanbul ignore next -- TS guard */