indexeddbshim 17.0.0 → 17.2.0

package/dist/indexeddbshim-UnicodeIdentifiers-node.cjs

@@ -1,12 +1,11 @@
-/*! indexeddbshim - v17.0.0 - 7/28/2026 */
+/*! indexeddbshim - v17.2.0 - 8/18/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
  */
@@ -2100,11 +2155,11 @@ const createDOMException = useNativeDOMException
 // eslint-disable-next-line @stylistic/operator-linebreak -- Need JSDoc
 ?
 /**
-* @param {string} name
-* @param {string} message
-* @param {ErrorLike} [error]
-* @returns {DOMException}
-*/
+ * @param {string} name
+ * @param {string} message
+ * @param {ErrorLike} [error]
+ * @returns {DOMException}
+ */
 function (name, message, error) {
   logError(name, message, error);
   return createNativeDOMException(name, message);
@@ -2112,11 +2167,11 @@ function (name, message, error) {
 // eslint-disable-next-line @stylistic/operator-linebreak -- Need JSDoc
 :
 /**
-* @param {string} name
-* @param {string} message
-* @param {ErrorLike} [error]
-* @returns {Error}
-*/
+ * @param {string} name
+ * @param {string} message
+ * @param {ErrorLike} [error]
+ * @returns {Error}
+ */
 function (name, message, error) {
   logError(name, message, error);
   return createNonNativeDOMException(name, message);
@@ -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.
@@ -2650,14 +2714,14 @@ function cmp(first, second) {
  */
 
 /**
-* @typedef {object} KeyValueObject
-* @property {KeyType|"NaN"|"null"|"undefined"|"boolean"|"object"|"symbol"|
-*   "function"|"bigint"} type If not `KeyType`, indicates invalid value
-* @property {Value} [value]
-* @property {boolean} [invalid]
-* @property {string} [message]
-* @todo Specify acceptable `value` more precisely
-*/
+ * @typedef {object} KeyValueObject
+ * @property {KeyType|"NaN"|"null"|"undefined"|"boolean"|"object"|"symbol"|
+ *   "function"|"bigint"} type If not `KeyType`, indicates invalid value
+ * @property {Value} [value]
+ * @property {boolean} [invalid]
+ * @property {string} [message]
+ * @todo Specify acceptable `value` more precisely
+ */
 
 /**
  * @typedef {number|string|Date|ArrayBuffer} ValueTypePrimitive
@@ -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];
@@ -3066,10 +3138,10 @@ function convertValueToKey(input, seen) {
 }
 
 /**
-* Currently not in use.
-* @param {Value} input
-* @returns {KeyValueObject}
-*/
+ * Currently not in use.
+ * @param {Value} input
+ * @returns {KeyValueObject}
+ */
 function convertValueToMultiEntryKey(input) {
   return convertValueToKeyValueDecoded(input, null, true, true);
 }
@@ -3104,17 +3176,17 @@ function getCopyBytesHeldByBufferSource(O) {
 }
 
 /**
-* Shortcut utility to avoid returning full keys from `convertValueToKey`
-*   and subsequent need to process in calling code unless `fullKeys` is
-*   set; may throw.
-* @param {Value} input
-* @param {Value[]|null} [seen]
-* @param {boolean} [multiEntry]
-* @param {boolean} [fullKeys]
-* @throws {TypeError} See `getCopyBytesHeldByBufferSource`
-* @todo Document other allowable `input`
-* @returns {KeyValueObject}
-*/
+ * Shortcut utility to avoid returning full keys from `convertValueToKey`
+ *   and subsequent need to process in calling code unless `fullKeys` is
+ *   set; may throw.
+ * @param {Value} input
+ * @param {Value[]|null} [seen]
+ * @param {boolean} [multiEntry]
+ * @param {boolean} [fullKeys]
+ * @throws {TypeError} See `getCopyBytesHeldByBufferSource`
+ * @todo Document other allowable `input`
+ * @returns {KeyValueObject}
+ */
 function convertValueToKeyValueDecoded(input, seen, multiEntry, fullKeys) {
   seen ||= [];
   if (seen.includes(input)) {
@@ -3256,12 +3328,12 @@ function convertValueToMultiEntryKeyDecoded(key, fullKeys) {
 }
 
 /**
-* An internal utility.
-* @param {Value} input
-* @param {Value[]|null|undefined} [seen]
-* @throws {DOMException} `DataError`
-* @returns {KeyValueObject}
-*/
+ * An internal utility.
+ * @param {Value} input
+ * @param {Value[]|null|undefined} [seen]
+ * @throws {DOMException} `DataError`
+ * @returns {KeyValueObject}
+ */
 function convertValueToKeyRethrowingAndIfInvalid(input, seen) {
   const key = convertValueToKey(input, seen);
   if (key.invalid) {
@@ -3282,26 +3354,26 @@ function extractKeyFromValueUsingKeyPath(value, keyPath, multiEntry) {
   return extractKeyValueDecodedFromValueUsingKeyPath(value, keyPath, multiEntry, true);
 }
 /**
-* Not currently in use.
-* @param {Value} value
-* @param {KeyPath} keyPath
-* @param {boolean} multiEntry
-* @returns {KeyPathEvaluateValue}
-*/
+ * Not currently in use.
+ * @param {Value} value
+ * @param {KeyPath} keyPath
+ * @param {boolean} multiEntry
+ * @returns {KeyPathEvaluateValue}
+ */
 function evaluateKeyPathOnValue(value, keyPath, multiEntry) {
   return evaluateKeyPathOnValueToDecodedValue(value, keyPath);
 }
 
 /**
-* May throw, return `{failure: true}` (e.g., non-object on keyPath resolution)
-*    or `{invalid: true}` (e.g., `NaN`).
-* @param {Value} value
-* @param {KeyPath} keyPath
-* @param {boolean} [multiEntry]
-* @param {boolean} [fullKeys]
-* @returns {KeyValueObject|KeyPathEvaluateValue}
-* @todo Document other possible return?
-*/
+ * May throw, return `{failure: true}` (e.g., non-object on keyPath resolution)
+ *    or `{invalid: true}` (e.g., `NaN`).
+ * @param {Value} value
+ * @param {KeyPath} keyPath
+ * @param {boolean} [multiEntry]
+ * @param {boolean} [fullKeys]
+ * @returns {KeyValueObject|KeyPathEvaluateValue}
+ * @todo Document other possible return?
+ */
 function extractKeyValueDecodedFromValueUsingKeyPath(value, keyPath, multiEntry, fullKeys) {
   const r = evaluateKeyPathOnValueToDecodedValue(value, keyPath);
   if (r.failure) {
@@ -3513,11 +3585,11 @@ function findMultiEntryMatches(keyEntry, range) {
 }
 
 /**
-* Not currently in use but keeping for spec parity.
-* @param {Key} key
-* @throws {Error} Upon a "bad key"
-* @returns {ValueType}
-*/
+ * Not currently in use but keeping for spec parity.
+ * @param {Key} key
+ * @throws {Error} Upon a "bad key"
+ * @returns {ValueType}
+ */
 function convertKeyToValue(key) {
   const {
     type,
@@ -3611,10 +3683,10 @@ const MAX_ALLOWED_CURRENT_NUMBER = 9007199254740992; // 2 ^ 53 (Also equal to `N
  */
 
 /**
-* @callback SQLFailureCallback
-* @param {DOMException|Error} exception
-* @returns {void}
-*/
+ * @callback SQLFailureCallback
+ * @param {DOMException|Error} exception
+ * @returns {void}
+ */
 
 /**
  *
@@ -3783,11 +3855,11 @@ const readonlyProperties$4 = /** @type {const} */['lower', 'upper', 'lowerOpen',
 
 /**
  * @typedef {globalThis.IDBKeyRange & {
-*   __lowerCached: string|null|false,
-*   __upperCached: string|null|false,
-*   __lowerOpen: boolean,
-* }} IDBKeyRangeFull
-*/
+ *   __lowerCached: string|null|false,
+ *   __upperCached: string|null|false,
+ *   __lowerOpen: boolean,
+ * }} IDBKeyRangeFull
+ */
 
 /**
  * The IndexedDB KeyRange object.
@@ -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) {
@@ -5015,10 +5117,10 @@ IDBTransaction.__assertActive = function (tx) {
 };
 
 /**
-* Used by our `EventTarget.prototype` library to implement bubbling/capturing.
+ * Used by our `EventTarget.prototype` library to implement bubbling/capturing.
  * @this {IDBTransactionFull}
-* @returns {import('./IDBDatabase.js').IDBDatabaseFull}
-*/
+ * @returns {import('./IDBDatabase.js').IDBDatabaseFull}
+ */
 IDBTransaction.prototype.__getParent = function () {
   return this.db;
 };
@@ -5052,7 +5154,7 @@ TypesonPromise.__typeson__type__ = "TypesonPromise", "undefined" != typeof Symbo
     }).then(r, n);
   });
 }, TypesonPromise.prototype.catch = function (e) {
-  return this.then(() => {}, e);
+  return this.then(void 0, e);
 }, TypesonPromise.resolve = function (e) {
   return new TypesonPromise(t => {
     t(e);
@@ -5108,26 +5210,31 @@ function escapeKeyPathComponent(e) {
 function unescapeKeyPathComponent(e) {
   return e.replaceAll("~1", ".").replaceAll("~0", "~").replace(/^''$/u, "").replaceAll("''''", "''");
 }
-function getByKeyPath(e, t) {
-  if ("" === t) return e;
-  if (null === e || "object" != typeof e) throw new TypeError("Unexpected non-object type");
-  const r = t.indexOf(".");
-  if (-1 !== r) {
-    const n = e[unescapeKeyPathComponent(t.slice(0, r))];
-    return void 0 === n ? void 0 : getByKeyPath(n, t.slice(r + 1));
+function getByKeyPath(t, r, n) {
+  if ("" === r) return t;
+  if (null === t || "object" != typeof t) throw new TypeError("Unexpected non-object type");
+  const o = r.indexOf("."),
+    s = unescapeKeyPathComponent(-1 === o ? r : r.slice(0, o));
+  if (e(t, s)) {
+    if (-1 !== o) {
+      const e = t[s];
+      return void 0 === e ? void 0 : getByKeyPath(e, r.slice(o + 1));
+    }
+    return t[s];
   }
-  return e[unescapeKeyPathComponent(t)];
 }
-function setAtKeyPath(e, t, r) {
-  if ("" === t) return r;
-  let n = e,
-    o = t;
+function setAtKeyPath(t, r, n, o) {
+  if ("" === r) return n;
+  let s = t,
+    a = r;
   for (;;) {
-    if (!n || "object" != typeof n) throw new TypeError("Unexpected non-object type");
-    if ("__proto__" === o) throw new TypeError("Invalid property");
-    const t = o.indexOf(".");
-    if (-1 === t) return n[unescapeKeyPathComponent(o)] = r, e;
-    n = n[unescapeKeyPathComponent(o.slice(0, t))], o = o.slice(t + 1);
+    if (!s || "object" != typeof s) throw new TypeError("Unexpected non-object type");
+    const r = a.indexOf("."),
+      i = unescapeKeyPathComponent(-1 === r ? a : a.slice(0, r));
+    if ("__proto__" === i) throw new TypeError("Invalid property");
+    if (-1 === r) return s[i] = n, t;
+    if (!e(s, i)) throw new TypeError("Invalid property");
+    s = s[i], a = a.slice(r + 1);
   }
 }
 function getJSONType(e) {
@@ -5137,7 +5244,7 @@ function getJSONType(e) {
  * @file Typeson - JSON with types.
  * @license The MIT License (MIT)
  * @copyright (c) 2016-2018 David Fahlander, Brett Zamir
-*/
+ */
 const {
     keys: r,
     hasOwn: n
@@ -5146,6 +5253,14 @@ const {
     isArray: o
   } = Array,
   s = ["type", "replaced", "iterateIn", "iterateUnsetNumeric", "addLength"];
+function setOwnEnumerable(e, t, r) {
+  Object.defineProperty(e, t, {
+    configurable: true,
+    enumerable: true,
+    value: r,
+    writable: true
+  });
+}
 function nestedPathsFirst(e, t) {
   if ("" === e.keypath) return -1;
   let r = e.keypath.match(/\./gu) ?? 0,
@@ -5201,10 +5316,16 @@ class Typeson {
     });
   }
   specialTypeNames(e, t, r = {}) {
-    return r.returnTypeNames = true, this.encapsulate(e, t, r);
+    return this.encapsulate(e, t, {
+      ...r,
+      returnTypeNames: true
+    });
   }
   rootTypeName(e, t, r = {}) {
-    return r.iterateNone = true, this.encapsulate(e, t, r);
+    return this.encapsulate(e, t, {
+      ...r,
+      iterateNone: true
+    });
   }
   encapsulate(e, t, a) {
     const i = {
@@ -5216,12 +5337,13 @@ class Typeson {
         sync: c
       } = i,
       y = {},
-      l = [],
       u = [],
+      l = [],
       p = [],
       f = !("cyclic" in i) || i.cyclic,
       {
-        encapsulateObserver: d
+        encapsulateObserver: d,
+        encapsulateError: m
       } = i,
       finish = e => {
         const t = Object.values(y);
@@ -5245,14 +5367,10 @@ class Typeson {
         return await Promise.all(r.map(async function (r) {
           const n = [],
             [o] = t.splice(0, 1),
-            [s,, a, i, c, y, l] = o,
-            u = _encapsulate(s, r, a, i, n, true, l),
-            p = hasConstructorOf(u, TypesonPromise);
-          if (s && p) {
-            const t = await u.p;
-            return c[y] = t, checkPromises(e, n);
-          }
-          return s ? c[y] = u : e = p ? u.p : u, checkPromises(e, n);
+            [s,, a, i, c, y, u] = o,
+            l = _encapsulate(s, r, a, i, n, true, u),
+            p = hasConstructorOf(l, TypesonPromise);
+          return s && p ? (setOwnEnumerable(c, y, await l.p), checkPromises(e, n)) : (s ? setOwnEnumerable(c, y, l) : e = p ? l.p : l, checkPromises(e, n));
         })), e;
       },
       _adaptBuiltinStateObjectProperties = (e, t, r) => {
@@ -5266,45 +5384,70 @@ class Typeson {
         });
       },
       _encapsulate = (e, t, s, a, c, p, f) => {
-        let m,
-          h = {};
-        const g = d ? function (r) {
-          const n = f ?? a.type ?? getJSONType(t);
-          d(Object.assign(r ?? h, {
-            keypath: e,
-            value: t,
-            cyclic: s,
-            stateObj: a,
-            promisesData: c,
-            resolvingTypesonPromise: p,
-            awaitingTypesonPromise: hasConstructorOf(t, TypesonPromise)
-          }, {
-            type: n
-          }));
-        } : null;
-        if (["string", "boolean", "number", "undefined"].includes(typeof t)) return void 0 === t || t === 1 / 0 || 0 === t || t === -1 / 0 || Number.isNaN(t) ? (m = a.replaced ? t : replace(e, t, a, c, false, p, g), m !== t && (h = {
-          replaced: m
-        })) : m = t, g && g(), m;
-        if (null === t) return g && g(), t;
+        let h,
+          g = {};
+        const b = d ? function (r) {
+            const n = f ?? a.type ?? getJSONType(t);
+            d(Object.assign(r ?? g, {
+              keypath: e,
+              value: t,
+              cyclic: s,
+              stateObj: a,
+              promisesData: c,
+              resolvingTypesonPromise: p,
+              awaitingTypesonPromise: hasConstructorOf(t, TypesonPromise)
+            }, {
+              type: n
+            }));
+          } : null,
+          getEncapsulatedValue = (e, t, r) => {
+            try {
+              return {
+                value: _encapsulate(e, t[r], Boolean(s), a, c, p)
+              };
+            } catch (n) {
+              if (!m) throw n;
+              const o = f ?? a.type ?? getJSONType(t),
+                s = m({
+                  keypath: e,
+                  error: n,
+                  parent: t,
+                  key: r,
+                  stateObj: a,
+                  type: o
+                });
+              if (!s) throw n;
+              if ("substitute" in s) return {
+                value: s.substitute,
+                substitute: true
+              };
+              if (s.ignore) return;
+              throw n;
+            }
+          };
+        if (["string", "boolean", "number", "undefined"].includes(typeof t)) return void 0 === t || t === 1 / 0 || 0 === t || t === -1 / 0 || Number.isNaN(t) ? (h = a.replaced ? t : replace(e, t, a, c, false, p, b), h !== t && (g = {
+          replaced: h
+        })) : h = t, b && b(), h;
+        if (null === t) return b && b(), t;
         if (s && t && "object" == typeof t && !a.iterateIn && !a.iterateUnsetNumeric) {
-          const r = l.indexOf(t);
-          if (-1 !== r) return y[e] = "#", g && g({
-            cyclicKeypath: u[r]
-          }), "#" + u[r];
-          true === s && (l.push(t), u.push(e));
+          const r = u.indexOf(t);
+          if (-1 !== r) return y[e] = "#", b && b({
+            cyclicKeypath: l[r]
+          }), "#" + l[r];
+          true === s && (u.push(t), l.push(e));
         }
-        const b = isPlainObject(t),
-          v = o(t),
-          O = (b || v) && (!this.plainObjectReplacers.length || a.replaced) || a.iterateIn ? t : replace(e, t, a, c, b || v, null, g);
-        let w;
-        if (O !== t ? (m = O, h = {
-          replaced: O
-        }) : "" === e && hasConstructorOf(t, TypesonPromise) ? (c.push([e, t, s, a, void 0, void 0, a.type]), m = t) : v && "object" !== a.iterateIn || "array" === a.iterateIn ? (w = new Array(t.length), h = {
-          clone: w
-        }) : !b && (["function", "symbol"].includes(typeof t) || "toJSON" in t || hasConstructorOf(t, TypesonPromise) || hasConstructorOf(t, Promise) || hasConstructorOf(t, ArrayBuffer)) && "object" !== a.iterateIn ? m = t : (w = {}, a.addLength && (w.length = t.length), h = {
-          clone: w
-        }), g && g(), i.iterateNone) return w ?? m;
-        if (!w) return m;
+        const v = isPlainObject(t),
+          O = o(t),
+          w = (v || O) && (!this.plainObjectReplacers.length || a.replaced) || a.iterateIn ? t : replace(e, t, a, c, v || O, null, b);
+        let T;
+        if (w !== t ? (h = w, g = {
+          replaced: w
+        }) : "" === e && hasConstructorOf(t, TypesonPromise) ? (c.push([e, t, s, a, void 0, void 0, a.type]), h = t) : O && "object" !== a.iterateIn || "array" === a.iterateIn ? (T = new Array(t.length), g = {
+          clone: T
+        }) : !v && ("object" != typeof t || "toJSON" in t || hasConstructorOf(t, TypesonPromise) || hasConstructorOf(t, Promise) || hasConstructorOf(t, ArrayBuffer)) && "object" !== a.iterateIn ? h = t : (T = {}, a.addLength && (T.length = t.length), g = {
+          clone: T
+        }), b && b(), i.iterateNone) return T ?? h;
+        if (!T) return h;
         if (a.iterateIn) {
           for (const r in t) {
             const o = {
@@ -5312,11 +5455,12 @@ class Typeson {
             };
             _adaptBuiltinStateObjectProperties(a, o, () => {
               const n = e + (e ? "." : "") + escapeKeyPathComponent(r),
-                o = _encapsulate(n, t[r], Boolean(s), a, c, p);
-              hasConstructorOf(o, TypesonPromise) ? c.push([n, o, Boolean(s), a, w, r, a.type]) : void 0 !== o && (w[r] = o);
+                o = getEncapsulatedValue(n, t, r),
+                i = o && o.value;
+              hasConstructorOf(i, TypesonPromise) ? c.push([n, i, Boolean(s), a, T, r, a.type]) : o && (void 0 !== i || "substitute" in o) && setOwnEnumerable(T, r, i);
             });
           }
-          g && g({
+          b && b({
             endIterateIn: true,
             end: true
           });
@@ -5325,10 +5469,11 @@ class Typeson {
           _adaptBuiltinStateObjectProperties(a, {
             ownKeys: true
           }, () => {
-            const e = _encapsulate(n, t[r], Boolean(s), a, c, p);
-            hasConstructorOf(e, TypesonPromise) ? c.push([n, e, Boolean(s), a, w, r, a.type]) : void 0 !== e && (w[r] = e);
+            const e = getEncapsulatedValue(n, t, r),
+              o = e && e.value;
+            hasConstructorOf(o, TypesonPromise) ? c.push([n, o, Boolean(s), a, T, r, a.type]) : e && (void 0 !== o || "substitute" in e) && setOwnEnumerable(T, r, o);
           });
-        }), g && g({
+        }), b && b({
           endIterateOwn: true,
           end: true
         });
@@ -5341,21 +5486,21 @@ class Typeson {
               ownKeys: false
             }, () => {
               const e = _encapsulate(r, void 0, Boolean(s), a, c, p);
-              hasConstructorOf(e, TypesonPromise) ? c.push([r, e, Boolean(s), a, w, n, a.type]) : void 0 !== e && (w[n] = e);
+              hasConstructorOf(e, TypesonPromise) ? c.push([r, e, Boolean(s), a, T, n, a.type]) : void 0 !== e && setOwnEnumerable(T, n, e);
             });
           }
-          g && g({
+          b && b({
             endIterateUnsetNumeric: true,
             end: true
           });
         }
-        return w;
+        return T;
       },
       replace = (e, t, r, n, o, s, a) => {
         const i = o ? this.plainObjectReplacers : this.nonplainObjectReplacers;
-        let l = i.length;
-        for (; l--;) {
-          const o = i[l];
+        let u = i.length;
+        for (; u--;) {
+          const o = i[u];
           if (o.test(t, r)) {
             const {
               type: i
@@ -5370,24 +5515,24 @@ class Typeson {
             }), (c || !o.replaceAsync) && !o.replace) return a && a({
               typeDetected: true
             }), _encapsulate(e, t, f && "readonly", r, n, s, i);
-            let l;
+            let u;
             if (a && a({
               replacing: true
             }), c || !o.replaceAsync) {
               if (void 0 === o.replace) throw new TypeError("Missing replacer");
-              l = o.replace(t, r);
-            } else l = o.replaceAsync(t, r);
-            return _encapsulate(e, l, f && "readonly", r, n, s, i);
+              u = o.replace(t, r);
+            } else u = o.replaceAsync(t, r);
+            return _encapsulate(e, u, f && "readonly", r, n, s, i);
           }
         }
         return t;
       },
-      m = _encapsulate("", e, f, t ?? {}, p);
+      h = _encapsulate("", e, f, t ?? {}, p);
     if (p.length) return c && i.throwOnBadSyncType ? (() => {
       throw new TypeError("Sync method requested but async result obtained");
-    })() : Promise.resolve(checkPromises(m, p)).then(finish);
+    })() : Promise.resolve(checkPromises(h, p)).then(finish);
     if (!c && i.throwOnBadSyncType) throw new TypeError("Async method requested but sync result obtained");
-    return c && i.stringification ? [finish(m)] : c ? finish(m) : Promise.resolve(finish(m));
+    return c && i.stringification ? [finish(h)] : c ? finish(h) : Promise.resolve(finish(h));
   }
   encapsulateSync(e, t, r) {
     return this.encapsulate(e, t, {
@@ -5423,15 +5568,15 @@ class Typeson {
     if (!i || "object" != typeof i || Array.isArray(i)) return finishRevival(e);
     const c = [],
       y = Object.create(null),
-      l = {};
-    let u = true;
-    i.$ && isPlainObject(i.$) && (e = e.$, i = i.$, u = false);
+      u = {};
+    let l = true;
+    i.$ && isPlainObject(i.$) && (e = e.$, i = i.$, l = false);
     const executeReviver = (e, t) => {
         const [r] = this.revivers[e] ?? [];
         if (!r) throw new Error("Unregistered type: " + e);
         if (a && !("revive" in r)) return t;
-        if (!a && r.reviveAsync) return r.reviveAsync(t, l);
-        if (r.revive) return r.revive(t, l);
+        if (!a && r.reviveAsync) return r.reviveAsync(t, u);
+        if (r.revive) return r.revive(t, u);
         throw new Error("Missing reviver");
       },
       p = [];
@@ -5469,23 +5614,23 @@ class Typeson {
       }, void 0);
     })();
     let d;
-    return hasConstructorOf(f, TypesonPromise) ? d = f.then(() => e) : (d = function _revive(e, t, s, l, f) {
-      if (u && "$types" === e) return;
+    return hasConstructorOf(f, TypesonPromise) ? d = f.then(() => e) : (d = function _revive(e, t, s, u, f) {
+      if (l && "$types" === e) return;
       const d = p.length,
-        m = i[e],
+        m = n(i, e) ? i[e] : void 0,
         h = o(t);
       if (h || isPlainObject(t)) {
         const o = h ? new Array(t.length) : {};
         for (r(t).forEach(r => {
           const n = _revive(e + (e ? "." : "") + escapeKeyPathComponent(r), t[r], s ?? o, o, r),
-            set = e => (hasConstructorOf(e, Undefined) ? o[r] = void 0 : void 0 !== e && (o[r] = e), e);
+            set = e => (hasConstructorOf(e, Undefined) ? setOwnEnumerable(o, r, void 0) : void 0 !== e && setOwnEnumerable(o, r, e), e);
           hasConstructorOf(n, TypesonPromise) ? p.push(n.then(e => set(e))) : set(n);
         }), t = o; c.length;) {
           const [[e, t, r, o]] = c,
             s = n(y, t),
             a = s ? y[t] : getByKeyPath(e, t);
           if (!s && void 0 === a) break;
-          r[o] = a, c.shift();
+          setOwnEnumerable(r, o, a), c.shift();
         }
       }
       if (!m) return y[e] = t, t;
@@ -5493,7 +5638,7 @@ class Typeson {
         const e = t.slice(1),
           r = n(y, e),
           o = r ? y[e] : getByKeyPath(s, e);
-        return r || void 0 !== o || c.push([s, e, l, f]), o;
+        return r || void 0 !== o || c.push([s, e, u, f]), o;
       }
       const applyType = t => {
         const r = [].concat(m).reduce(function reducer(e, t) {
@@ -5533,11 +5678,10 @@ class Typeson {
           if ("#" === t) throw new TypeError("# cannot be used as a type name as it is reserved for cyclic objects");
           if (a.includes(t)) throw new TypeError("Plain JSON object types are reserved as type names");
           let r = e[t];
-          const s = r && "function" != typeof r && !Array.isArray(r) && r.testPlainObjects ? this.plainObjectReplacers : this.nonplainObjectReplacers,
-            i = s.filter(function (e) {
-              return e.type === t;
-            });
-          if (i.length && (s.splice(s.indexOf(i[0]), 1), delete this.revivers[t], delete this.types[t]), "function" == typeof r) {
+          if ([this.plainObjectReplacers, this.nonplainObjectReplacers].forEach(e => {
+            const r = e.findIndex(e => e.type === t);
+            -1 !== r && e.splice(r, 1);
+          }), delete this.revivers[t], delete this.types[t], "function" == typeof r) {
             const e = r;
             r = {
               test: t => t && t.constructor === e,
@@ -5555,13 +5699,13 @@ class Typeson {
             };
           }
           if (!r?.test) return;
-          const c = {
+          const s = {
             type: t,
             test: r.test.bind(r)
           };
-          r.replace && (c.replace = r.replace.bind(r)), r.replaceAsync && (c.replaceAsync = r.replaceAsync.bind(r));
-          const y = "number" == typeof n.fallback ? n.fallback : n.fallback ? 0 : 1 / 0;
-          if (r.testPlainObjects ? this.plainObjectReplacers.splice(y, 0, c) : this.nonplainObjectReplacers.splice(y, 0, c), r.revive || r.reviveAsync) {
+          r.replace && (s.replace = r.replace.bind(r)), r.replaceAsync && (s.replaceAsync = r.replaceAsync.bind(r));
+          const i = "number" == typeof n.fallback ? n.fallback : n.fallback ? 0 : 1 / 0;
+          if (r.testPlainObjects ? this.plainObjectReplacers.splice(i, 0, s) : this.nonplainObjectReplacers.splice(i, 0, s), r.revive || r.reviveAsync) {
             const e = {};
             r.revive && (e.revive = r.revive.bind(r)), r.reviveAsync && (e.reviveAsync = r.reviveAsync.bind(r)), this.revivers[t] = [e, {
               plain: r.testPlainObjects
@@ -5579,12 +5723,12 @@ class Undefined {}
 Undefined.__typeson__type__ = "TypesonUndefined";
 const a = ["null", "boolean", "number", "string", "array", "object"];
 for (var i = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", c = new Uint8Array(256), y = 0; y < 64; y++) c[i.codePointAt(y)] = y;
-var l = function encode(e, t, r) {
+var u = function encode(e, t, r) {
     null == r && (r = e.byteLength);
     for (var n = new Uint8Array(e, 0, r), o = n.length, s = "", a = 0; a < o; a += 3) s += i[n[a] >> 2], s += i[(3 & n[a]) << 4 | n[a + 1] >> 4], s += i[(15 & n[a + 1]) << 2 | n[a + 2] >> 6], s += i[63 & n[a + 2]];
     return o % 3 == 2 ? s = s.slice(0, -1) + "=" : o % 3 == 1 && (s = s.slice(0, -2) + "=="), s;
   },
-  u = function decode(e, t) {
+  l = function decode(e, t) {
     var r = e.length;
     if (r % 4) throw new Error("Bad base64 length: not divisible by four");
     var n,
@@ -5594,8 +5738,8 @@ var l = function encode(e, t, r) {
       i = .75 * e.length,
       y = 0;
     "=" === e[e.length - 1] && (i--, "=" === e[e.length - 2] && i--);
-    for (var l = new ArrayBuffer(i, t), u = new Uint8Array(l), p = 0; p < r; p += 4) n = c[e.codePointAt(p)], o = c[e.codePointAt(p + 1)], s = c[e.codePointAt(p + 2)], a = c[e.codePointAt(p + 3)], u[y++] = n << 2 | o >> 4, u[y++] = (15 & o) << 4 | s >> 2, u[y++] = (3 & s) << 6 | 63 & a;
-    return l;
+    for (var u = new ArrayBuffer(i, t), l = new Uint8Array(u), p = 0; p < r; p += 4) n = c[e.codePointAt(p)], o = c[e.codePointAt(p + 1)], s = c[e.codePointAt(p + 2)], a = c[e.codePointAt(p + 3)], l[y++] = n << 2 | o >> 4, l[y++] = (15 & o) << 4 | s >> 2, l[y++] = (3 & s) << 6 | 63 & a;
+    return u;
   };
 const p = {
     arraybuffer: {
@@ -5606,14 +5750,14 @@ const p = {
         return -1 !== r ? {
           index: r
         } : (t.buffers.push(e), {
-          s: l(e),
+          s: u(e),
           maxByteLength: e.maxByteLength,
           resizable: e.resizable
         });
       },
       revive(e, t) {
         if (t.buffers || (t.buffers = []), Object.hasOwn(e, "index")) return t.buffers[e.index];
-        const r = u(e.s, e.resizable ? {
+        const r = l(e.s, e.resizable ? {
           maxByteLength: e.maxByteLength
         } : void 0);
         return t.buffers.push(r), r;
@@ -5716,7 +5860,7 @@ const b = {
           byteOffset: t,
           byteLength: r
         } : (n.buffers.push(e), {
-          encoded: l(e),
+          encoded: u(e),
           maxByteLength: e.maxByteLength,
           resizable: e.resizable,
           byteOffset: t,
@@ -5734,7 +5878,7 @@ const b = {
           resizable: i
         } = e;
         let c;
-        return "index" in e ? c = t.buffers[s] : (c = u(o, i ? {
+        return "index" in e ? c = t.buffers[s] : (c = l(o, i ? {
           maxByteLength: a
         } : a), t.buffers.push(c)), new DataView(c, r, n);
       }
@@ -5907,7 +6051,7 @@ function create$2(e) {
   };
 }
 [TypeError, RangeError, SyntaxError, ReferenceError, EvalError, URIError].forEach(e => create$2(e)), "undefined" != typeof AggregateError && create$2(AggregateError), "function" == typeof InternalError && create$2(InternalError);
-const N = {
+const E = {
     file: {
       test: e => "File" === toStringTag(e),
       replace(e) {
@@ -5944,8 +6088,8 @@ const N = {
       })
     }
   },
-  _ = {
-    file: N.file,
+  N = {
+    file: E.file,
     filelist: {
       test: e => "FileList" === toStringTag(e),
       replace(e) {
@@ -5969,7 +6113,7 @@ const N = {
       }
     }
   },
-  B = {
+  _ = {
     imagebitmap: {
       test: e => "ImageBitmap" === toStringTag(e) || e && e.dataset && "ImageBitmap" === e.dataset.toStringTag,
       replace(e) {
@@ -6004,7 +6148,7 @@ const N = {
       }
     }
   },
-  E = {
+  B = {
     imagedata: {
       test: e => "ImageData" === toStringTag(e),
       replace: e => ({
@@ -6015,7 +6159,7 @@ const N = {
       revive: e => new ImageData(new Uint8ClampedArray(e.array), e.width, e.height)
     }
   },
-  C = {
+  I = {
     infinity: {
       test: e => e === 1 / 0,
       replace: () => "Infinity",
@@ -6050,7 +6194,7 @@ const N = {
       revive: () => -0
     }
   },
-  k = {
+  R = {
     StringObject: {
       test: e => "String" === toStringTag(e) && "object" == typeof e,
       replace: String,
@@ -6067,7 +6211,7 @@ const N = {
       revive: e => new Number(e)
     }
   },
-  $ = {
+  K = {
     regexp: {
       test: e => "RegExp" === toStringTag(e),
       replace: e => ({
@@ -6080,7 +6224,7 @@ const N = {
       }) => new RegExp(e, t)
     }
   },
-  J = {
+  z = {
     set: {
       test: e => "Set" === toStringTag(e),
       replace: e => e.values().toArray(),
@@ -6115,7 +6259,7 @@ const W = {};
       } : (n.buffers.push(e), {
         maxByteLength: e.maxByteLength,
         resizable: e.resizable,
-        encoded: l(e),
+        encoded: u(e),
         byteOffset: t,
         length: r
       });
@@ -6131,7 +6275,7 @@ const W = {};
         resizable: c
       } = t;
       let y;
-      return "index" in t ? y = r.buffers[a] : (y = u(s, c ? {
+      return "index" in t ? y = r.buffers[a] : (y = l(s, c ? {
         maxByteLength: i
       } : void 0), r.buffers.push(y)), new e(y, n, o);
     }
@@ -6173,8 +6317,8 @@ const Q = {
       revive() {}
     }
   }],
-  X = [M, C, L, D],
-  re = [G, Q, H, k, X, O, $, E, B, N, _, m, x, j].concat("function" == typeof Map ? U : [], "function" == typeof Set ? J : [], "function" == typeof ArrayBuffer ? p : [], "function" == typeof Uint8Array ? W : [], "function" == typeof DataView ? v : [], "undefined" != typeof crypto ? b : [], "undefined" != typeof BigInt ? [d, f] : [], "undefined" != typeof DOMException ? w : [], "undefined" != typeof DOMRect ? S : [], "undefined" != typeof DOMPoint ? A : [], "undefined" != typeof DOMQuad ? P : [], "undefined" != typeof DOMMatrix ? T : []),
+  X = [M, I, L, D],
+  re = [G, Q, H, R, X, O, K, B, _, E, N, m, x, j].concat("function" == typeof Map ? U : [], "function" == typeof Set ? z : [], "function" == typeof ArrayBuffer ? p : [], "function" == typeof Uint8Array ? W : [], "function" == typeof DataView ? v : [], "undefined" != typeof crypto ? b : [], "undefined" != typeof BigInt ? [d, f] : [], "undefined" != typeof DOMException ? w : [], "undefined" != typeof DOMRect ? S : [], "undefined" != typeof DOMPoint ? A : [], "undefined" != typeof DOMQuad ? P : [], "undefined" != typeof DOMMatrix ? T : []),
   ne = re.concat({
     checkDataCloneException: {
       test(e) {
@@ -6925,7 +7069,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;
@@ -8879,7 +9023,7 @@ function IDBFactory() {
  *   __connections: {
  *     [key: string]: import('./IDBDatabase.js').IDBDatabaseFull[]
  *   }
-* }} IDBFactoryFull
+ * }} IDBFactoryFull
  */
 
 const IDBFactoryAlias = IDBFactory;
@@ -9070,7 +9214,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 +9325,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 +9343,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 +9511,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 +9539,7 @@ IDBFactory.prototype.deleteDatabase = function (name) {
             });
             return undefined;
             // @ts-expect-error It's ok
-          }, dbError);
+          }).catch(dbError);
           return undefined;
         }, dbError);
       });
@@ -9423,14 +9570,14 @@ IDBFactory.prototype.cmp = function (key1, key2) {
 };
 
 /**
-* May return outdated information if a database has since been deleted.
-* @see https://github.com/w3c/IndexedDB/pull/240/files
-* @this {IDBFactoryFull}
-* @returns {Promise<{
-*   name: string,
-*   version: Integer
-* }[]>}
-*/
+ * May return outdated information if a database has since been deleted.
+ * @see https://github.com/w3c/IndexedDB/pull/240/files
+ * @this {IDBFactoryFull}
+ * @returns {Promise<{
+ *   name: string,
+ *   version: Integer
+ * }[]>}
+ */
 IDBFactory.prototype.databases = function () {
   const me = this;
   let calledDbCreateError = false;
@@ -9479,20 +9626,20 @@ IDBFactory.prototype.databases = function () {
 };
 
 /**
-* @todo forceClose: Test
-* This is provided to facilitate unit-testing of the
-*  closing of a database connection with a forced flag:
-* <https://w3c.github.io/IndexedDB/#steps-for-closing-a-database-connection>
-* @param {string} dbName
-* @param {Integer} connIdx
-* @param {string} msg
-* @throws {TypeError}
-* @this {IDBFactoryFull}
-* @returns {void}
-*/
-IDBFactory.prototype.__forceClose = function (dbName, connIdx, msg) {
-  const me = this;
-  /**
+ * @todo forceClose: Test
+ * This is provided to facilitate unit-testing of the
+ *  closing of a database connection with a forced flag:
+ * <https://w3c.github.io/IndexedDB/#steps-for-closing-a-database-connection>
+ * @param {string} dbName
+ * @param {Integer} connIdx
+ * @param {string} msg
+ * @throws {TypeError}
+ * @this {IDBFactoryFull}
+ * @returns {void}
+ */
+IDBFactory.prototype.__forceClose = function (dbName, connIdx, msg) {
+  const me = this;
+  /**
    *
    * @param {import('./IDBDatabase.js').IDBDatabaseFull} conn
    * @returns {void}
@@ -9574,6 +9721,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 +9797,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 +9952,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 +10054,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 +10083,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 +10113,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();
 };
 
 /**
@@ -9965,19 +10149,19 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
  */
 
 /**
-* @callback SuccessArg
-* @param {StructuredCloneValue} value
-* @param {import('./IDBRequest.js').IDBRequestFull} req
-* @returns {void}
-*/
+ * @callback SuccessArg
+ * @param {StructuredCloneValue} value
+ * @param {import('./IDBRequest.js').IDBRequestFull} req
+ * @returns {void}
+ */
 
 /**
-* @callback SuccessCallback
-* @param {IndexedDBKey} key
-* @param {StructuredCloneValue} value
-* @param {IndexedDBKey} primaryKey
-* @returns {void}
-*/
+ * @callback SuccessCallback
+ * @param {IndexedDBKey} key
+ * @param {StructuredCloneValue} value
+ * @param {IndexedDBKey} primaryKey
+ * @returns {void}
+ */
 
 /**
  * Creates an "onsuccess" callback.
@@ -10005,11 +10189,11 @@ IDBCursor.prototype.__onsuccess = function (success) {
 
 /**
  * @typedef {{
-*   matchingKey: string,
-*   key: string,
-*   [k: string]: string
-* }} RowItemNonNull
-*/
+ *   matchingKey: string,
+ *   key: string,
+ *   [k: string]: string
+ * }} RowItemNonNull
+ */
 
 /**
  *
@@ -10062,6 +10246,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 +10302,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 +10325,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 +10932,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 +11045,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 +11124,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 +11138,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 +11499,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 hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib.exports;
+  hasRequiredLib = 1;
+  lib.exports = requireDatabase()(requireBinding().getBinding, true);
+  lib.exports.SqliteError = requireSqliteError();
+  return lib.exports;
 }
 
-var sqlite3Exports = requireSqlite3();
-var sqlite3 = /*@__PURE__*/getDefaultExportFromCjs(sqlite3Exports);
+var libExports = requireLib();
+var Database = /*@__PURE__*/getDefaultExportFromCjs(libExports);
 
-function SQLiteResult(error, insertId, rowsAffected, rows) {
-  this.error = error;
-  this.insertId = insertId;
-  this.rowsAffected = rowsAffected;
-  this.rows = rows;
+/**
+ *
+ */
+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);
-  }
-  if (opts.profile) {
-    this._db.configure('profile', opts.profile);
+    db.pragma('busy_timeout = ' + Number(opts.busyTimeout));
   }
-}
-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 +12531,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 +12564,7 @@ CFG.win = {
 const __setGlobalVars = function (idb, initialConfig = {}) {
   const obj = setGlobalVars(idb, {
     fs: fs$1,
+    escapeNULForSQLiteStatements: false,
     ...initialConfig
   });
   /* istanbul ignore next -- TS guard */