indexeddbshim 17.0.0 → 17.2.0

package/dist/indexeddbshim.js

@@ -1,4 +1,4 @@
-/*! indexeddbshim - v17.0.0 - 7/28/2026 */
+/*! indexeddbshim - v17.2.0 - 8/18/2026 */
 
 (function (factory) {
   typeof define === 'function' && define.amd ? define(factory) :
@@ -58,7 +58,7 @@
     }
   }
   function _createClass(e, r, t) {
-    return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
+    return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
       writable: false
     }), e;
   }
@@ -301,6 +301,13 @@
   function _slicedToArray(r, e) {
     return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
   }
+  function _taggedTemplateLiteral(e, t) {
+    return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, {
+      raw: {
+        value: Object.freeze(t)
+      }
+    }));
+  }
   function _toConsumableArray(r) {
     return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
   }
@@ -1307,6 +1314,7 @@
    *   sqlBusyTimeout: number,
    *   sqlTrace: () => void,
    *   sqlProfile: () => void,
+   *   escapeNULForSQLiteStatements: boolean,
    *   createIndexes: boolean
    * }} ConfigValues
    */
@@ -1461,8 +1469,8 @@
   // Callback not used by default
   'sqlProfile',
   // Callback not used by default
-
-  'createIndexes'].forEach(function (prop) {
+  // Defaults to true except in Node builds where we can preserve literal NUL with better-sqlite3
+  'escapeNULForSQLiteStatements', 'createIndexes'].forEach(function (prop) {
     /** @type {(val: any) => void} */
     var validator;
     if (Array.isArray(prop)) {
@@ -1543,7 +1551,8 @@
    * @returns {string}
    */
   function escapeSQLiteStatement(arg) {
-    return escapeUnmatchedSurrogates(arg.replaceAll('^', '^^').replaceAll('\0', '^0'));
+    var escaped = arg.replaceAll('^', '^^');
+    return escapeUnmatchedSurrogates(CFG.escapeNULForSQLiteStatements === false ? escaped : escaped.replaceAll('\0', '^0'));
   }
 
   /**
@@ -1551,7 +1560,11 @@
    * @returns {string}
    */
   function unescapeSQLiteResponse(arg) {
-    return unescapeUnmatchedSurrogates(arg).replaceAll(/(\^+)0/g, function (_, esc) {
+    var unescaped = unescapeUnmatchedSurrogates(arg);
+    if (CFG.escapeNULForSQLiteStatements === false) {
+      return unescaped.replaceAll('^^', '^');
+    }
+    return unescaped.replaceAll(/(\^+)0/g, function (_, esc) {
       return esc.length % 2 ? esc.slice(1) + '\0' : _;
     }).replaceAll('^^', '^');
   }
@@ -1952,6 +1965,56 @@
     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.
+   */
+  var continuationState = {
+    /** @type {Array<() => void>|null} */
+    queue: null
+  };
+
+  /**
+   * @param {() => void} fn
+   * @returns {void}
+   */
+  function runContinuationSafely(fn) {
+    if (continuationState.queue) {
+      continuationState.queue.push(fn);
+      return;
+    }
+    var queue = [fn];
+    continuationState.queue = queue;
+    try {
+      while (queue.length) {
+        var 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
    */
@@ -2422,11 +2485,11 @@
   // 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);
@@ -2434,11 +2497,11 @@
   // 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);
@@ -2633,16 +2696,15 @@
   /* 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
@@ -2702,209 +2764,235 @@
     REJECTED = 1;
 
   /**
-   * @class
-   * @param {(
-   *   resolve: (value: ArbitraryValue | PromiseLike<ArbitraryValue>) => void,
-   *   reject: (reason?: any) => void
-   * ) => void} fn
-   */
-  function SyncPromise(fn) {
-    var 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 = [[], []];
+   *
+   */
+  var SyncPromise = /*#__PURE__*/function () {
     /**
-     *
-     * @param {ArbitraryValue} val
-     * @param {0|1} state
-     * @returns {void}
+     * @param {(
+     *   resolve: (value: ArbitraryValue | PromiseLike<ArbitraryValue>) => void,
+     *   reject: (reason?: ArbitraryValue) => void
+     * ) => void} fn
      */
-    function transist(val, state) {
-      that.v = val;
-      that.s = state;
-
-      // console.log('state', state);
-      /** @type {Callbacks} */
-      that.c[state].forEach(function (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} */that.c[state].length) {
-        that.c = null;
-      }
-    }
+    function SyncPromise(fn) {
+      var _this = this;
+      _classCallCheck(this, SyncPromise);
+      // Value, this will be set to either a resolved value or rejected reason
+      _defineProperty(this, "v", 0);
+      // 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}
+       */
+      var transist = function transist(val, state) {
+        _this.v = val;
+        _this.s = state;
 
-    /** @type {Resolve} */
-    function resolve(val) {
-      if (!that.c) ; else if (isPromise(val)) {
-        addReject(val.then(resolve), reject);
-      } else {
-        transist(val, FULFILLED);
-      }
-    }
+        // console.log('state', state);
+        /** @type {Callbacks} */
+        _this.c[state].forEach(function (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;
+        }
+      };
 
-    /** @type {Reject} */
-    function reject(reason) {
-      if (!that.c) ; else if (isPromise(reason)) {
-        addReject(reason.then(reject), reject);
-      } else {
-        transist(reason, REJECTED);
+      /** @type {Resolve} */
+      var _resolve = function resolve(val) {
+        if (!_this.c) ; else if (isPromise(val)) {
+          addReject(val.then(_resolve), _reject);
+        } else {
+          transist(val, FULFILLED);
+        }
+      };
+
+      /** @type {Reject} */
+      var _reject = function 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);
       }
     }
-    try {
-      fn(resolve, reject);
-    } catch (err) {
-      reject(err);
-    }
-  }
 
-  /* 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 */
-    var that = this;
-    return new SyncPromise(/** @type {ResolveReject} */
-    function (resolve, reject) {
-      var rej = typeof errBack === 'function' ? errBack : reject;
+    /* eslint-disable unicorn/no-thenable -- Promise API */
+    /**
+     * @param {((value: ArbitraryValue) => ArbitraryValue)|null|undefined} [cb]
+     * @param {(reason: ArbitraryValue) => PromiseLike<never>} [errBack]
+     * @returns {SyncPromise}
+     */
+    return _createClass(SyncPromise, [{
+      key: "then",
+      value: function then(cb, errBack) {
+        var _this2 = this;
+        /* eslint-enable unicorn/no-thenable -- Promise API */
+        return new SyncPromise(/** @type {ResolveReject} */
+        function (resolve, reject) {
+          var rej = typeof errBack === 'function' ? errBack : reject;
 
-      /** @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);
+          /** @type {Settle} */
+          var settle = function settle() {
+            try {
+              resolve(cb ? cb(_this2.v) : _this2.v);
+            } catch (e) {
+              rej(e);
+            }
+          };
+          if (_this2.s === FULFILLED) {
+            settle();
+          } else if (_this2.s === REJECTED) {
+            rej(_this2.v);
+          } else {
+            /** @type {Callbacks} */_this2.c[FULFILLED].push(settle);
+            /** @type {Callbacks} */
+            _this2.c[REJECTED].push(rej);
+          }
+        });
       }
-    });
-  };
 
-  /**
-   * @param {(reason: any) => PromiseLike<never>|null|undefined} cb
-   * @returns {SyncPromise}
-   */
-  SyncPromise.prototype.catch = function (cb) {
-    var that = this;
-    return new SyncPromise(/** @type {ResolveReject} */
-    function (resolve, reject) {
       /**
-       * @returns {void}
+       * @param {(reason: ArbitraryValue) => PromiseLike<never>|null|undefined} cb
+       * @returns {SyncPromise}
        */
-      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);
-        /** @type {Callbacks} */
-        that.c[FULFILLED].push(resolve);
+    }, {
+      key: "catch",
+      value: function _catch(cb) {
+        var _this3 = this;
+        return new SyncPromise(/** @type {ResolveReject} */
+        function (resolve, reject) {
+          /**
+           * @returns {void}
+           */
+          var settle = function settle() {
+            try {
+              resolve(cb(_this3.v));
+            } catch (e) {
+              reject(e);
+            }
+          };
+          if (_this3.s === REJECTED) {
+            settle();
+          } else if (_this3.s === FULFILLED) {
+            resolve(_this3.v);
+          } else {
+            /** @type {Callbacks} */_this3.c[REJECTED].push(settle);
+            /** @type {Callbacks} */
+            _this3.c[FULFILLED].push(resolve);
+          }
+        });
       }
-    });
-  };
-
-  /**
-   * @param {unknown[]|[]} promises
-   * @returns {SyncPromise}
-   */
-  SyncPromise.all = function (promises) {
-    return new SyncPromise(/** @type {ResolveReject} */
-    function (resolve, reject) {
-      var l = promises.length;
-      /** @type {ArbitraryValue[]} */
-      var newPromises = [];
-      if (!l) {
-        resolve(newPromises);
-        return;
+    }], [{
+      key: "all",
+      value:
+      /**
+       * @param {unknown[]|[]} promises
+       * @returns {SyncPromise}
+       */
+      function all(promises) {
+        return new SyncPromise(/** @type {ResolveReject} */
+        function (resolve, reject) {
+          var l = promises.length;
+          /** @type {ArbitraryValue[]} */
+          var newPromises = [];
+          if (!l) {
+            resolve(newPromises);
+            return;
+          }
+          promises.forEach(function (p, i) {
+            if (isPromise(/** @type {PromiseLike<ArbitraryValue>} */p)) {
+              addReject(/** @type {PromiseLike<ArbitraryValue>} */p.then(/** @type {OnFulfilled} */
+              function (res) {
+                newPromises[i] = res;
+                --l;
+                if (!l) {
+                  resolve(newPromises);
+                }
+              }), reject);
+            } else {
+              newPromises[i] = p;
+              --l;
+              if (!l) {
+                resolve(promises);
+              }
+            }
+          });
+        });
       }
-      promises.forEach(function (p, i) {
-        if (isPromise(/** @type {PromiseLike<any>} */p)) {
-          addReject(/** @type {PromiseLike<any>} */p.then(/** @type {OnFulfilled} */
-          function (res) {
-            newPromises[i] = res;
-            --l || resolve(newPromises);
-          }), reject);
-        } else {
-          newPromises[i] = p;
-          --l || resolve(promises);
-        }
-      });
-    });
-  };
 
-  /**
-   * @param {unknown[]|[]} promises
-   * @returns {SyncPromise}
-   */
-  SyncPromise.race = function (promises) {
-    var resolved = false;
-    return new SyncPromise(/** @type {ResolveReject} */
-    function (resolve, reject) {
-      promises.some(function (p, i) {
-        if (isPromise(/** @type {PromiseLike<any>} */p)) {
-          addReject(/** @type {PromiseLike<any>} */p.then(/** @type {OnFulfilled} */
-          function (res) {
-            if (resolved) {
-              return;
+      /**
+       * @param {unknown[]|[]} promises
+       * @returns {SyncPromise}
+       */
+    }, {
+      key: "race",
+      value: function race(promises) {
+        var resolved = false;
+        return new SyncPromise(/** @type {ResolveReject} */
+        function (resolve, reject) {
+          // eslint-disable-next-line @stylistic/max-len -- Long
+          // eslint-disable-next-line unicorn/no-unused-array-method-return -- Shortcuts
+          promises.some(function (p) {
+            if (isPromise(/** @type {PromiseLike<ArbitraryValue>} */p)) {
+              addReject(/** @type {PromiseLike<ArbitraryValue>} */p.then(/** @type {OnFulfilled} */
+              function (res) {
+                if (resolved) {
+                  return;
+                }
+                resolve(res);
+                resolved = true;
+              }), reject);
+              return false;
             }
-            resolve(res);
+            resolve(p);
             resolved = true;
-          }), reject);
-          return false;
-        }
-        resolve(p);
-        resolved = true;
-        return true;
-      });
-    });
-  };
+            return true;
+          });
+        });
+      }
 
-  /**
-   * @param {ArbitraryValue} val
-   * @returns {SyncPromise}
-   */
-  SyncPromise.resolve = function (val) {
-    return new SyncPromise(/** @type {ResolveReject} */
-    function (resolve, reject) {
-      resolve(val);
-    });
-  };
+      /**
+       * @param {ArbitraryValue} val
+       * @returns {SyncPromise}
+       */
+    }, {
+      key: "resolve",
+      value: function resolve(val) {
+        return new SyncPromise(/** @type {ResolveReject} */
+        function (resolve) {
+          resolve(val);
+        });
+      }
 
-  /**
-   * @param {ArbitraryValue} val
-   * @returns {SyncPromise}
-   */
-  SyncPromise.reject = function (val) {
-    return new SyncPromise(/** @type {ResolveReject} */
-    function (resolve, reject) {
-      reject(val);
-    });
-  };
+      /**
+       * @param {ArbitraryValue} val
+       * @returns {SyncPromise}
+       */
+    }, {
+      key: "reject",
+      value: function reject(val) {
+        return new SyncPromise(/** @type {ResolveReject} */
+        function (resolve, reject) {
+          reject(val);
+        });
+      }
+    }]);
+  }();
 
   /**
    * Compares two keys.
@@ -2941,6 +3029,8 @@
     return result;
   }
 
+  var _templateObject, _templateObject2;
+
   /**
    * @typedef {NodeJS.TypedArray|DataView} ArrayBufferView
    */
@@ -2970,14 +3060,14 @@
    */
 
   /**
-  * @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
@@ -3216,14 +3306,22 @@
           _iterator.f();
         }
         encoded.push(keyTypeToEncodedChar.invalid + '-'); // append an extra item, so empty arrays sort correctly
-        return keyTypeToEncodedChar.array + '-' + JSON.stringify(encoded);
+        var encodedKey = JSON.stringify(encoded);
+        if (CFG.escapeNULForSQLiteStatements === false) {
+          encodedKey = encodedKey.replaceAll(String.raw(_templateObject || (_templateObject = _taggedTemplateLiteral(["\0"], ["\\u0000"]))), '\0');
+        }
+        return keyTypeToEncodedChar.array + '-' + encodedKey;
       },
       /**
        * @param {string} key
        * @returns {ValueTypeArray}
        */
       decode: function decode(key) {
-        var decoded = JSON.parse(key.slice(2));
+        var decodedKey = key.slice(2);
+        if (CFG.escapeNULForSQLiteStatements === false) {
+          decodedKey = decodedKey.replaceAll('\0', String.raw(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\0"], ["\\u0000"]))));
+        }
+        var decoded = JSON.parse(decodedKey);
         decoded.pop(); // remove the extra item
         for (var i = 0; i < decoded.length; i++) {
           var item = decoded[i];
@@ -3409,10 +3507,10 @@
   }
 
   /**
-  * 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);
   }
@@ -3447,17 +3545,17 @@
   }
 
   /**
-  * 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 || (seen = []);
     if (seen.includes(input)) {
@@ -3613,12 +3711,12 @@
   }
 
   /**
-  * 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) {
     var key = convertValueToKey(input, seen);
     if (key.invalid) {
@@ -3639,26 +3737,26 @@
     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) {
     var r = evaluateKeyPathOnValueToDecodedValue(value, keyPath);
     if (r.failure) {
@@ -3888,11 +3986,11 @@
   }
 
   /**
-  * 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) {
     var type = key.type,
       value = key.value;
@@ -3984,10 +4082,10 @@
    */
 
   /**
-  * @callback SQLFailureCallback
-  * @param {DOMException|Error} exception
-  * @returns {void}
-  */
+   * @callback SQLFailureCallback
+   * @param {DOMException|Error} exception
+   * @returns {void}
+   */
 
   /**
    *
@@ -4156,11 +4254,11 @@
 
   /**
    * @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.
@@ -4687,6 +4785,7 @@
    *   },
    *   __requestsFinished: boolean,
    *   __transFinishedCb: (err: boolean, cb: ((bool?: boolean) => void)) => void,
+   *   __callTransFinishedCb: (err: boolean, cb: ((bool?: boolean) => void)) => void,
    *   __transactionEndCallback: () => void,
    *   __transactionFinished: boolean,
    *   __completed: boolean,
@@ -4796,6 +4895,35 @@
   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) {
+    var me = this;
+    if (me.__transFinishedCb === IDBTransaction.prototype.__transFinishedCb) {
+      setTimeout(function () {
+        me.__callTransFinishedCb(err, cb);
+      }, 0);
+      return;
+    }
+    me.__transFinishedCb(err, cb);
+  };
   /**
    * @this {IDBTransactionFull}
    * @returns {void}
@@ -4855,7 +4983,7 @@
           me.__abortTransaction(createDOMException('AbortError', 'A request was aborted (in user handler after success).'));
           return;
         }
-        executeNextRequest();
+        runContinuationSafely(executeNextRequest);
       }
 
       /**
@@ -4930,7 +5058,9 @@
           try {
             q = me.__requests[i];
             if (!q.req) {
-              q.op(tx, q.args, executeNextRequest, error);
+              q.op(tx, q.args, function () {
+                return runContinuationSafely(executeNextRequest);
+              }, error);
               return;
             }
             if (q.req.__done) {
@@ -5396,10 +5526,10 @@
   };
 
   /**
-  * 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;
   };
@@ -5435,7 +5565,7 @@
       }).then(r, n);
     });
   }, TypesonPromise.prototype.catch = function (e) {
-    return this.then(function () {}, e);
+    return this.then(void 0, e);
   }, TypesonPromise.resolve = function (e) {
     return new TypesonPromise(function (t) {
       t(e);
@@ -5495,26 +5625,31 @@
   function unescapeKeyPathComponent(e) {
     return e.replaceAll("~1", ".").replaceAll("~0", "~").replace(/^''$/, "").replaceAll("''''", "''");
   }
-  function getByKeyPath(e, t) {
-    if ("" === t) return e;
-    if (null === e || "object" != _typeof$1(e)) throw new TypeError("Unexpected non-object type");
-    var r = t.indexOf(".");
-    if (-1 !== r) {
-      var _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$1(t)) throw new TypeError("Unexpected non-object type");
+    var o = r.indexOf("."),
+      s = unescapeKeyPathComponent(-1 === o ? r : r.slice(0, o));
+    if (e(t, s)) {
+      if (-1 !== o) {
+        var _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;
-    var n = e,
-      o = t;
+  function setAtKeyPath(t, r, n, o) {
+    if ("" === r) return n;
+    var s = t,
+      a = r;
     for (;;) {
-      if (!n || "object" != _typeof$1(n)) throw new TypeError("Unexpected non-object type");
-      if ("__proto__" === o) throw new TypeError("Invalid property");
-      var _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$1(s)) throw new TypeError("Unexpected non-object type");
+      var _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) {
@@ -5524,11 +5659,19 @@
    * @file Typeson - JSON with types.
    * @license The MIT License (MIT)
    * @copyright (c) 2016-2018 David Fahlander, Brett Zamir
-  */
+   */
   var r = Object.keys,
     n = Object.hasOwn,
     o = Array.isArray,
     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) {
     var _e$keypath$match, _t$keypath$match;
     if ("" === e.keypath) return -1;
@@ -5599,13 +5742,17 @@
       key: "specialTypeNames",
       value: function specialTypeNames(e, t) {
         var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-        return r.returnTypeNames = true, this.encapsulate(e, t, r);
+        return this.encapsulate(e, t, _objectSpread2(_objectSpread2({}, r), {}, {
+          returnTypeNames: true
+        }));
       }
     }, {
       key: "rootTypeName",
       value: function rootTypeName(e, t) {
         var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-        return r.iterateNone = true, this.encapsulate(e, t, r);
+        return this.encapsulate(e, t, _objectSpread2(_objectSpread2({}, r), {}, {
+          iterateNone: true
+        }));
       }
     }, {
       key: "encapsulate",
@@ -5616,11 +5763,12 @@
           }, this.options), a),
           c = i.sync,
           y = {},
-          l = [],
           u = [],
+          l = [],
           p = [],
           f = !("cyclic" in i) || i.cyclic,
           d = i.encapsulateObserver,
+          m = i.encapsulateError,
           finish = function finish(e) {
             var t = Object.values(y);
             if (i.iterateNone) return t.length ? t[0] : getJSONType(e);
@@ -5653,22 +5801,29 @@
                     _context2.n = 2;
                     return Promise.all(r.map(/*#__PURE__*/function () {
                       var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(r) {
-                        var n, _t$splice, _t$splice2, o, _o, s, a, i, c, y, l, u, p, _t2;
+                        var n, _t$splice, _t$splice2, o, _o, s, a, i, c, y, u, l, p, _t, _t2, _t3, _t4;
                         return _regenerator().w(function (_context) {
                           while (1) switch (_context.n) {
                             case 0:
-                              n = [], _t$splice = t.splice(0, 1), _t$splice2 = _slicedToArray(_t$splice, 1), o = _t$splice2[0], _o = _slicedToArray(o, 7), s = _o[0], a = _o[2], i = _o[3], c = _o[4], y = _o[5], l = _o[6], u = _encapsulate2(s, r, a, i, n, true, l), p = hasConstructorOf(u, TypesonPromise);
+                              n = [], _t$splice = t.splice(0, 1), _t$splice2 = _slicedToArray(_t$splice, 1), o = _t$splice2[0], _o = _slicedToArray(o, 7), s = _o[0], a = _o[2], i = _o[3], c = _o[4], y = _o[5], u = _o[6], l = _encapsulate2(s, r, a, i, n, true, u), p = hasConstructorOf(l, TypesonPromise);
                               if (!(s && p)) {
                                 _context.n = 2;
                                 break;
                               }
+                              _t2 = setOwnEnumerable;
+                              _t3 = c;
+                              _t4 = y;
                               _context.n = 1;
-                              return u.p;
+                              return l.p;
                             case 1:
-                              _t2 = _context.v;
-                              return _context.a(2, (c[y] = _t2, _checkPromises(e, n)));
+                              _t2(_t3, _t4, _context.v);
+                              _t = _checkPromises(e, n);
+                              _context.n = 3;
+                              break;
                             case 2:
-                              return _context.a(2, (s ? c[y] = u : e = p ? u.p : u, _checkPromises(e, n)));
+                              _t = (s ? setOwnEnumerable(c, y, l) : e = p ? l.p : l, _checkPromises(e, n));
+                            case 3:
+                              return _context.a(2, _t);
                           }
                         }, _callee);
                       }));
@@ -5697,61 +5852,88 @@
             });
           },
           _encapsulate2 = function _encapsulate(e, t, s, a, c, p, f) {
-            var m,
-              h = {};
-            var g = d ? function (r) {
-              var _ref2;
-              var n = (_ref2 = f !== null && f !== void 0 ? f : a.type) !== null && _ref2 !== void 0 ? _ref2 : getJSONType(t);
-              d(Object.assign(r !== null && r !== void 0 ? 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$1(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;
+            var h,
+              g = {};
+            var b = d ? function (r) {
+                var _ref2;
+                var n = (_ref2 = f !== null && f !== void 0 ? f : a.type) !== null && _ref2 !== void 0 ? _ref2 : getJSONType(t);
+                d(Object.assign(r !== null && r !== void 0 ? r : g, {
+                  keypath: e,
+                  value: t,
+                  cyclic: s,
+                  stateObj: a,
+                  promisesData: c,
+                  resolvingTypesonPromise: p,
+                  awaitingTypesonPromise: hasConstructorOf(t, TypesonPromise)
+                }, {
+                  type: n
+                }));
+              } : null,
+              getEncapsulatedValue = function getEncapsulatedValue(e, t, r) {
+                try {
+                  return {
+                    value: _encapsulate2(e, t[r], Boolean(s), a, c, p)
+                  };
+                } catch (n) {
+                  var _ref3;
+                  if (!m) throw n;
+                  var _o2 = (_ref3 = f !== null && f !== void 0 ? f : a.type) !== null && _ref3 !== void 0 ? _ref3 : getJSONType(t),
+                    _s = m({
+                      keypath: e,
+                      error: n,
+                      parent: t,
+                      key: r,
+                      stateObj: a,
+                      type: _o2
+                    });
+                  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$1(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$1(t) && !a.iterateIn && !a.iterateUnsetNumeric) {
-              var _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));
+              var _r2 = u.indexOf(t);
+              if (-1 !== _r2) return y[e] = "#", b && b({
+                cyclicKeypath: l[_r2]
+              }), "#" + l[_r2];
+              true === s && (u.push(t), l.push(e));
             }
-            var b = isPlainObject(t),
-              v = o(t),
-              O = (b || v) && (!_this2.plainObjectReplacers.length || a.replaced) || a.iterateIn ? t : replace(e, t, a, c, b || v, null, g);
-            var 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$1(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 !== null && w !== void 0 ? w : m;
-            if (!w) return m;
+            var v = isPlainObject(t),
+              O = o(t),
+              w = (v || O) && (!_this2.plainObjectReplacers.length || a.replaced) || a.iterateIn ? t : replace(e, t, a, c, v || O, null, b);
+            var 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$1(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 !== null && T !== void 0 ? T : h;
+            if (!T) return h;
             if (a.iterateIn) {
-              var _loop = function _loop(_r2) {
+              var _loop = function _loop(_r3) {
                 var o = {
-                  ownKeys: n(t, _r2)
+                  ownKeys: n(t, _r3)
                 };
                 _adaptBuiltinStateObjectProperties(a, o, function () {
-                  var n = e + (e ? "." : "") + escapeKeyPathComponent(_r2),
-                    o = _encapsulate2(n, t[_r2], Boolean(s), a, c, p);
-                  hasConstructorOf(o, TypesonPromise) ? c.push([n, o, Boolean(s), a, w, _r2, a.type]) : void 0 !== o && (w[_r2] = o);
+                  var n = e + (e ? "." : "") + escapeKeyPathComponent(_r3),
+                    o = getEncapsulatedValue(n, t, _r3),
+                    i = o && o.value;
+                  hasConstructorOf(i, TypesonPromise) ? c.push([n, i, Boolean(s), a, T, _r3, a.type]) : o && (void 0 !== i || "substitute" in o) && setOwnEnumerable(T, _r3, i);
                 });
               };
-              for (var _r2 in t) {
-                _loop(_r2);
+              for (var _r3 in t) {
+                _loop(_r3);
               }
-              g && g({
+              b && b({
                 endIterateIn: true,
                 end: true
               });
@@ -5760,70 +5942,71 @@
               _adaptBuiltinStateObjectProperties(a, {
                 ownKeys: true
               }, function () {
-                var e = _encapsulate2(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);
+                var 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
             });
             if (a.iterateUnsetNumeric) {
-              var _r3 = t.length;
-              var _loop2 = function _loop2(_n2) {
-                if (_n2 in t) return 1; // continue
-                var r = "".concat(e).concat(e ? "." : "").concat(String(_n2));
+              var _r4 = t.length;
+              var _loop2 = function _loop2(_n) {
+                if (_n in t) return 1; // continue
+                var r = "".concat(e).concat(e ? "." : "").concat(String(_n));
                 _adaptBuiltinStateObjectProperties(a, {
                   ownKeys: false
                 }, function () {
                   var e = _encapsulate2(r, void 0, Boolean(s), a, c, p);
-                  hasConstructorOf(e, TypesonPromise) ? c.push([r, e, Boolean(s), a, w, _n2, a.type]) : void 0 !== e && (w[_n2] = e);
+                  hasConstructorOf(e, TypesonPromise) ? c.push([r, e, Boolean(s), a, T, _n, a.type]) : void 0 !== e && setOwnEnumerable(T, _n, e);
                 });
               };
-              for (var _n2 = 0; _n2 < _r3; _n2++) {
-                if (_loop2(_n2)) continue;
+              for (var _n = 0; _n < _r4; _n++) {
+                if (_loop2(_n)) continue;
               }
-              g && g({
+              b && b({
                 endIterateUnsetNumeric: true,
                 end: true
               });
             }
-            return w;
+            return T;
           },
           replace = function replace(e, t, r, n, o, s, a) {
             var i = o ? _this2.plainObjectReplacers : _this2.nonplainObjectReplacers;
-            var l = i.length;
-            for (; l--;) {
-              var _o2 = i[l];
-              if (_o2.test(t, r)) {
-                var _i = _o2.type;
-                if (Object.hasOwn(_this2.revivers, _i)) {
-                  var _t3 = y[e];
-                  y[e] = _t3 ? [_i].concat(_t3) : _i;
+            var u = i.length;
+            for (; u--;) {
+              var _o3 = i[u];
+              if (_o3.test(t, r)) {
+                var _i2 = _o3.type;
+                if (Object.hasOwn(_this2.revivers, _i2)) {
+                  var _t5 = y[e];
+                  y[e] = _t5 ? [_i2].concat(_t5) : _i2;
                 }
                 if (Object.assign(r, {
-                  type: _i,
+                  type: _i2,
                   replaced: true
-                }), (c || !_o2.replaceAsync) && !_o2.replace) return a && a({
+                }), (c || !_o3.replaceAsync) && !_o3.replace) return a && a({
                   typeDetected: true
-                }), _encapsulate2(e, t, f && "readonly", r, n, s, _i);
-                var _l = void 0;
+                }), _encapsulate2(e, t, f && "readonly", r, n, s, _i2);
+                var _u = void 0;
                 if (a && a({
                   replacing: true
-                }), c || !_o2.replaceAsync) {
-                  if (void 0 === _o2.replace) throw new TypeError("Missing replacer");
-                  _l = _o2.replace(t, r);
-                } else _l = _o2.replaceAsync(t, r);
-                return _encapsulate2(e, _l, f && "readonly", r, n, s, _i);
+                }), c || !_o3.replaceAsync) {
+                  if (void 0 === _o3.replace) throw new TypeError("Missing replacer");
+                  _u = _o3.replace(t, r);
+                } else _u = _o3.replaceAsync(t, r);
+                return _encapsulate2(e, _u, f && "readonly", r, n, s, _i2);
               }
             }
             return t;
           },
-          m = _encapsulate2("", e, f, t !== null && t !== void 0 ? t : {}, p);
+          h = _encapsulate2("", e, f, t !== null && t !== void 0 ? t : {}, p);
         if (p.length) return c && i.throwOnBadSyncType ? function () {
           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));
       }
     }, {
       key: "encapsulateSync",
@@ -5862,18 +6045,18 @@
         if (!i || "object" != _typeof$1(i) || Array.isArray(i)) return finishRevival(e);
         var c = [],
           y = Object.create(null),
-          l = {};
-        var u = true;
-        i.$ && isPlainObject(i.$) && (e = e.$, i = i.$, u = false);
+          u = {};
+        var l = true;
+        i.$ && isPlainObject(i.$) && (e = e.$, i = i.$, l = false);
         var executeReviver = function executeReviver(e, t) {
             var _this3$revivers$e;
-            var _ref3 = (_this3$revivers$e = _this3.revivers[e]) !== null && _this3$revivers$e !== void 0 ? _this3$revivers$e : [],
-              _ref4 = _slicedToArray(_ref3, 1),
-              r = _ref4[0];
+            var _ref4 = (_this3$revivers$e = _this3.revivers[e]) !== null && _this3$revivers$e !== void 0 ? _this3$revivers$e : [],
+              _ref5 = _slicedToArray(_ref4, 1),
+              r = _ref5[0];
             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 = [];
@@ -5883,23 +6066,23 @@
         var f = function () {
           if (!i) throw new Error("Found bad `types`");
           var t = [];
-          if (Object.entries(i).forEach(function (_ref5) {
-            var _ref6 = _slicedToArray(_ref5, 2),
-              e = _ref6[0],
-              r = _ref6[1];
+          if (Object.entries(i).forEach(function (_ref6) {
+            var _ref7 = _slicedToArray(_ref6, 2),
+              e = _ref7[0],
+              r = _ref7[1];
             "#" !== r && [].concat(r).forEach(function (r) {
               var _this3$revivers$r;
-              var _ref7 = (_this3$revivers$r = _this3.revivers[r]) !== null && _this3$revivers$r !== void 0 ? _this3$revivers$r : [null, {}],
-                _ref8 = _slicedToArray(_ref7, 2),
-                n = _ref8[1].plain;
+              var _ref8 = (_this3$revivers$r = _this3.revivers[r]) !== null && _this3$revivers$r !== void 0 ? _this3$revivers$r : [null, {}],
+                _ref9 = _slicedToArray(_ref8, 2),
+                n = _ref9[1].plain;
               n && (t.push({
                 keypath: e,
                 type: r
               }), delete i[e]);
             });
-          }), t.length) return t.sort(nestedPathsFirst), t.reduce(function reducer(t, _ref9) {
-            var r = _ref9.keypath,
-              n = _ref9.type;
+          }), t.length) return t.sort(nestedPathsFirst), t.reduce(function reducer(t, _ref0) {
+            var r = _ref0.keypath,
+              n = _ref0.type;
             if (isThenable(t)) return t.then(function (e) {
               return reducer(e, {
                 keypath: r,
@@ -5918,39 +6101,39 @@
         var d;
         return hasConstructorOf(f, TypesonPromise) ? d = f.then(function () {
           return e;
-        }) : (d = function _revive(e, t, s, l, f) {
-          if (u && "$types" === e) return;
+        }) : (d = function _revive(e, t, s, u, f) {
+          if (l && "$types" === e) return;
           var d = p.length,
-            m = i[e],
+            m = n(i, e) ? i[e] : void 0,
             h = o(t);
           if (h || isPlainObject(t)) {
-            var _o3 = h ? new Array(t.length) : {};
+            var _o4 = h ? new Array(t.length) : {};
             for (r(t).forEach(function (r) {
-              var n = _revive(e + (e ? "." : "") + escapeKeyPathComponent(r), t[r], s !== null && s !== void 0 ? s : _o3, _o3, r),
+              var n = _revive(e + (e ? "." : "") + escapeKeyPathComponent(r), t[r], s !== null && s !== void 0 ? s : _o4, _o4, r),
                 set = function set(e) {
-                  return hasConstructorOf(e, Undefined) ? _o3[r] = void 0 : void 0 !== e && (_o3[r] = e), e;
+                  return hasConstructorOf(e, Undefined) ? setOwnEnumerable(_o4, r, void 0) : void 0 !== e && setOwnEnumerable(_o4, r, e), e;
                 };
               hasConstructorOf(n, TypesonPromise) ? p.push(n.then(function (e) {
                 return set(e);
               })) : set(n);
-            }), t = _o3; c.length;) {
+            }), t = _o4; c.length;) {
               var _c$ = _slicedToArray(c[0], 4),
-                _e = _c$[0],
-                _t4 = _c$[1],
-                _r4 = _c$[2],
-                _o4 = _c$[3],
-                _s = n(y, _t4),
-                _a = _s ? y[_t4] : getByKeyPath(_e, _t4);
-              if (!_s && void 0 === _a) break;
-              _r4[_o4] = _a, c.shift();
+                _e2 = _c$[0],
+                _t6 = _c$[1],
+                _r5 = _c$[2],
+                _o5 = _c$[3],
+                _s2 = n(y, _t6),
+                _a = _s2 ? y[_t6] : getByKeyPath(_e2, _t6);
+              if (!_s2 && void 0 === _a) break;
+              setOwnEnumerable(_r5, _o5, _a), c.shift();
             }
           }
           if (!m) return y[e] = t, t;
           if ("#" === m) {
-            var _e2 = t.slice(1),
-              _r5 = n(y, _e2),
-              _o5 = _r5 ? y[_e2] : getByKeyPath(s, _e2);
-            return _r5 || void 0 !== _o5 || c.push([s, _e2, l, f]), _o5;
+            var _e3 = t.slice(1),
+              _r6 = n(y, _e3),
+              _o6 = _r6 ? y[_e3] : getByKeyPath(s, _e3);
+            return _r6 || void 0 !== _o6 || c.push([s, _e3, u, f]), _o6;
           }
           var applyType = function applyType(t) {
             var r = [].concat(m).reduce(function reducer(e, t) {
@@ -5969,9 +6152,9 @@
           }) : applyType(t);
         }("", e, null), p.length && (d = TypesonPromise.resolve(d).then(function (e) {
           return TypesonPromise.all([e].concat(p));
-        }).then(function (_ref0) {
-          var _ref1 = _slicedToArray(_ref0, 1),
-            e = _ref1[0];
+        }).then(function (_ref1) {
+          var _ref10 = _slicedToArray(_ref1, 1),
+            e = _ref10[0];
           return e;
         }))), isThenable(d) ? a && s.throwOnBadSyncType ? function () {
           throw new TypeError("Sync method requested but async result obtained");
@@ -6006,49 +6189,50 @@
             o(e) ? e.forEach(function (e) {
               _reg(e);
             }) : r(e).forEach(function (t) {
-              var _r8;
+              var _r9;
               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");
               var r = e[t];
-              var s = r && "function" != typeof r && !Array.isArray(r) && r.testPlainObjects ? _this4.plainObjectReplacers : _this4.nonplainObjectReplacers,
-                i = s.filter(function (e) {
+              if ([_this4.plainObjectReplacers, _this4.nonplainObjectReplacers].forEach(function (e) {
+                var r = e.findIndex(function (e) {
                   return e.type === t;
                 });
-              if (i.length && (s.splice(s.indexOf(i[0]), 1), delete _this4.revivers[t], delete _this4.types[t]), "function" == typeof r) {
-                var _e3 = r;
+                -1 !== r && e.splice(r, 1);
+              }), delete _this4.revivers[t], delete _this4.types[t], "function" == typeof r) {
+                var _e4 = r;
                 r = {
                   test: function test(t) {
-                    return t && t.constructor === _e3;
+                    return t && t.constructor === _e4;
                   },
                   replace: function replace(e) {
                     return _objectSpread2({}, e);
                   },
                   revive: function revive(t) {
-                    return Object.assign(Object.create(_e3.prototype), t);
+                    return Object.assign(Object.create(_e4.prototype), t);
                   }
                 };
               } else if (o(r)) {
-                var _r6 = r,
-                  _r7 = _slicedToArray(_r6, 3),
-                  _e4 = _r7[0],
-                  _t5 = _r7[1],
-                  _n3 = _r7[2];
+                var _r7 = r,
+                  _r8 = _slicedToArray(_r7, 3),
+                  _e5 = _r8[0],
+                  _t7 = _r8[1],
+                  _n2 = _r8[2];
                 r = {
-                  test: _e4,
-                  replace: _t5,
-                  revive: _n3
+                  test: _e5,
+                  replace: _t7,
+                  revive: _n2
                 };
               }
-              if (!((_r8 = r) !== null && _r8 !== void 0 && _r8.test)) return;
-              var c = {
+              if (!((_r9 = r) !== null && _r9 !== void 0 && _r9.test)) return;
+              var s = {
                 type: t,
                 test: r.test.bind(r)
               };
-              r.replace && (c.replace = r.replace.bind(r)), r.replaceAsync && (c.replaceAsync = r.replaceAsync.bind(r));
-              var y = "number" == typeof n.fallback ? n.fallback : n.fallback ? 0 : 1 / 0;
-              if (r.testPlainObjects ? _this4.plainObjectReplacers.splice(y, 0, c) : _this4.nonplainObjectReplacers.splice(y, 0, c), r.revive || r.reviveAsync) {
-                var _e5 = {};
-                r.revive && (_e5.revive = r.revive.bind(r)), r.reviveAsync && (_e5.reviveAsync = r.reviveAsync.bind(r)), _this4.revivers[t] = [_e5, {
+              r.replace && (s.replace = r.replace.bind(r)), r.replaceAsync && (s.replaceAsync = r.replaceAsync.bind(r));
+              var i = "number" == typeof n.fallback ? n.fallback : n.fallback ? 0 : 1 / 0;
+              if (r.testPlainObjects ? _this4.plainObjectReplacers.splice(i, 0, s) : _this4.nonplainObjectReplacers.splice(i, 0, s), r.revive || r.reviveAsync) {
+                var _e6 = {};
+                r.revive && (_e6.revive = r.revive.bind(r)), r.reviveAsync && (_e6.reviveAsync = r.reviveAsync.bind(r)), _this4.revivers[t] = [_e6, {
                   plain: r.testPlainObjects
                 }];
               }
@@ -6067,12 +6251,12 @@
   Undefined.__typeson__type__ = "TypesonUndefined";
   var 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,
@@ -6082,8 +6266,8 @@
         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;
     };
   var p = {
       arraybuffer: {
@@ -6096,14 +6280,14 @@
           return -1 !== r ? {
             index: r
           } : (t.buffers.push(e), {
-            s: l(e),
+            s: u(e),
             maxByteLength: e.maxByteLength,
             resizable: e.resizable
           });
         },
         revive: function revive(e, t) {
           if (t.buffers || (t.buffers = []), Object.hasOwn(e, "index")) return t.buffers[e.index];
-          var r = u(e.s, e.resizable ? {
+          var r = l(e.s, e.resizable ? {
             maxByteLength: e.maxByteLength
           } : void 0);
           return t.buffers.push(r), r;
@@ -6139,7 +6323,7 @@
   }
   function string2arraybuffer(e) {
     var t = new Uint8Array(e.length);
-    for (var _r9 = 0; _r9 < e.length; _r9++) t[_r9] = e.charCodeAt(_r9);
+    for (var _r0 = 0; _r0 < e.length; _r0++) t[_r0] = e.charCodeAt(_r0);
     return t.buffer;
   }
   var m = {
@@ -6184,8 +6368,8 @@
         },
         replaceAsync: function replaceAsync(e) {
           return new TypesonPromise(/*#__PURE__*/function () {
-            var _ref10 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(t, r) {
-              var n, _t6;
+            var _ref11 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(t, r) {
+              var n, _t8;
               return _regenerator().w(function (_context3) {
                 while (1) switch (_context3.p = _context3.n) {
                   case 0:
@@ -6198,8 +6382,8 @@
                     break;
                   case 2:
                     _context3.p = 2;
-                    _t6 = _context3.v;
-                    return _context3.a(2, void r(_t6));
+                    _t8 = _context3.v;
+                    return _context3.a(2, void r(_t8));
                   case 3:
                     t({
                       jwk: n,
@@ -6212,7 +6396,7 @@
               }, _callee3, null, [[0, 2]]);
             }));
             return function (_x4, _x5) {
-              return _ref10.apply(this, arguments);
+              return _ref11.apply(this, arguments);
             };
           }());
         },
@@ -6229,10 +6413,10 @@
         test: function test(e) {
           return "DataView" === toStringTag(e);
         },
-        replace: function replace(_ref11, n) {
-          var e = _ref11.buffer,
-            t = _ref11.byteOffset,
-            r = _ref11.byteLength;
+        replace: function replace(_ref12, n) {
+          var e = _ref12.buffer,
+            t = _ref12.byteOffset,
+            r = _ref12.byteLength;
           n.buffers || (n.buffers = []);
           var o = n.buffers.indexOf(e);
           return -1 !== o ? {
@@ -6240,7 +6424,7 @@
             byteOffset: t,
             byteLength: r
           } : (n.buffers.push(e), {
-            encoded: l(e),
+            encoded: u(e),
             maxByteLength: e.maxByteLength,
             resizable: e.resizable,
             byteOffset: t,
@@ -6256,7 +6440,7 @@
             a = e.maxByteLength,
             i = e.resizable;
           var 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);
         }
@@ -6287,9 +6471,9 @@
             message: e.message
           };
         },
-        revive: function revive(_ref12) {
-          var e = _ref12.message,
-            t = _ref12.name;
+        revive: function revive(_ref13) {
+          var e = _ref13.message,
+            t = _ref13.name;
           return new DOMException(e, t);
         }
       }
@@ -6347,11 +6531,11 @@
           w: e.w
         };
       },
-      revive: function revive(_ref13) {
-        var t = _ref13.x,
-          r = _ref13.y,
-          n = _ref13.z,
-          o = _ref13.w;
+      revive: function revive(_ref14) {
+        var t = _ref14.x,
+          r = _ref14.y,
+          n = _ref14.z,
+          o = _ref14.w;
         return new e(t, r, n, o);
       }
     };
@@ -6370,11 +6554,11 @@
             p4: e.p4
           };
         },
-        revive: function revive(_ref14) {
-          var e = _ref14.p1,
-            t = _ref14.p2,
-            r = _ref14.p3,
-            n = _ref14.p4;
+        revive: function revive(_ref15) {
+          var e = _ref15.p1,
+            t = _ref15.p2,
+            r = _ref15.p3,
+            n = _ref15.p4;
           return new DOMQuad(e, t, r, n);
         }
       }
@@ -6393,11 +6577,11 @@
           height: e.height
         };
       },
-      revive: function revive(_ref15) {
-        var t = _ref15.x,
-          r = _ref15.y,
-          n = _ref15.width,
-          o = _ref15.height;
+      revive: function revive(_ref16) {
+        var t = _ref16.x,
+          r = _ref16.y,
+          n = _ref16.width,
+          o = _ref16.height;
         return new e(t, r, n, o);
       }
     };
@@ -6408,14 +6592,14 @@
         test: function test(e) {
           return "Error" === toStringTag(e);
         },
-        replace: function replace(_ref16) {
-          var e = _ref16.name,
-            t = _ref16.message,
-            r = _ref16.cause,
-            n = _ref16.stack,
-            o = _ref16.fileName,
-            s = _ref16.lineNumber,
-            a = _ref16.columnNumber;
+        replace: function replace(_ref17) {
+          var e = _ref17.name,
+            t = _ref17.message,
+            r = _ref17.cause,
+            n = _ref17.stack,
+            o = _ref17.fileName,
+            s = _ref17.lineNumber,
+            a = _ref17.columnNumber;
           return {
             name: e,
             message: t,
@@ -6438,15 +6622,15 @@
       test: function test(t) {
         return hasConstructorOf(t, e);
       },
-      replace: function replace(_ref17) {
-        var e = _ref17.name,
-          t = _ref17.message,
-          r = _ref17.cause,
-          n = _ref17.stack,
-          o = _ref17.fileName,
-          s = _ref17.lineNumber,
-          a = _ref17.columnNumber,
-          i = _ref17.errors;
+      replace: function replace(_ref18) {
+        var e = _ref18.name,
+          t = _ref18.message,
+          r = _ref18.cause,
+          n = _ref18.stack,
+          o = _ref18.fileName,
+          s = _ref18.lineNumber,
+          a = _ref18.columnNumber,
+          i = _ref18.errors;
         return {
           name: e,
           message: t,
@@ -6467,7 +6651,7 @@
   [TypeError, RangeError, SyntaxError, ReferenceError, EvalError, URIError].forEach(function (e) {
     return create$2(e);
   }), "undefined" != typeof AggregateError && create$2(AggregateError), "function" == typeof InternalError && create$2(InternalError);
-  var N = {
+  var E = {
       file: {
         test: function test(e) {
           return "File" === toStringTag(e);
@@ -6482,11 +6666,11 @@
             lastModified: e.lastModified
           };
         },
-        revive: function revive(_ref18) {
-          var e = _ref18.name,
-            t = _ref18.type,
-            r = _ref18.stringContents,
-            n = _ref18.lastModified;
+        revive: function revive(_ref19) {
+          var e = _ref19.name,
+            t = _ref19.type,
+            r = _ref19.stringContents,
+            n = _ref19.lastModified;
           return new File([string2arraybuffer(r)], e, {
             type: t,
             lastModified: n
@@ -6509,15 +6693,15 @@
         }
       }
     },
-    _ = {
-      file: N.file,
+    N = {
+      file: E.file,
       filelist: {
         test: function test(e) {
           return "FileList" === toStringTag(e);
         },
         replace: function replace(e) {
           var t = [];
-          for (var _r0 = 0; _r0 < e.length; _r0++) t[_r0] = e.item(_r0);
+          for (var _r1 = 0; _r1 < e.length; _r1++) t[_r1] = e.item(_r1);
           return t;
         },
         revive: function revive(e) {
@@ -6542,7 +6726,7 @@
         }
       }
     },
-    B = {
+    _ = {
       imagebitmap: {
         test: function test(e) {
           return "ImageBitmap" === toStringTag(e) || e && e.dataset && "ImageBitmap" === e.dataset.toStringTag;
@@ -6570,36 +6754,36 @@
           return n.addEventListener("load", function () {
             r.drawImage(n, 0, 0);
           }), n.src = e.dataURL, new TypesonPromise(/*#__PURE__*/function () {
-            var _ref19 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(e, r) {
-              var _t7, _t8;
+            var _ref20 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(e, r) {
+              var _t9, _t0;
               return _regenerator().w(function (_context4) {
                 while (1) switch (_context4.p = _context4.n) {
                   case 0:
                     _context4.p = 0;
-                    _t7 = e;
+                    _t9 = e;
                     _context4.n = 1;
                     return createImageBitmap(t);
                   case 1:
-                    _t7(_context4.v);
+                    _t9(_context4.v);
                     _context4.n = 3;
                     break;
                   case 2:
                     _context4.p = 2;
-                    _t8 = _context4.v;
-                    r(_t8);
+                    _t0 = _context4.v;
+                    r(_t0);
                   case 3:
                     return _context4.a(2);
                 }
               }, _callee4, null, [[0, 2]]);
             }));
             return function (_x6, _x7) {
-              return _ref19.apply(this, arguments);
+              return _ref20.apply(this, arguments);
             };
           }());
         }
       }
     },
-    E = {
+    B = {
       imagedata: {
         test: function test(e) {
           return "ImageData" === toStringTag(e);
@@ -6616,7 +6800,7 @@
         }
       }
     },
-    C = {
+    I = {
       infinity: {
         test: function test(e) {
           return e === 1 / 0;
@@ -6681,7 +6865,7 @@
         }
       }
     },
-    k = {
+    R = {
       StringObject: {
         test: function test(e) {
           return "String" === toStringTag(e) && "object" == _typeof$1(e);
@@ -6712,7 +6896,7 @@
         }
       }
     },
-    $ = {
+    K = {
       regexp: {
         test: function test(e) {
           return "RegExp" === toStringTag(e);
@@ -6723,14 +6907,14 @@
             flags: (e.global ? "g" : "") + (e.ignoreCase ? "i" : "") + (e.multiline ? "m" : "") + (e.sticky ? "y" : "") + (e.unicode ? "u" : "") + (e.unicodeSets ? "v" : "") + (e.hasIndices ? "d" : "") + (e.dotAll ? "s" : "")
           };
         },
-        revive: function revive(_ref21) {
-          var e = _ref21.source,
-            t = _ref21.flags;
+        revive: function revive(_ref22) {
+          var e = _ref22.source,
+            t = _ref22.flags;
           return new RegExp(e, t);
         }
       }
     },
-    J = {
+    z = {
       set: {
         test: function test(e) {
           return "Set" === toStringTag(e);
@@ -6768,10 +6952,10 @@
         test: function test(e) {
           return toStringTag(e) === t;
         },
-        replace: function replace(_ref22, n) {
-          var e = _ref22.buffer,
-            t = _ref22.byteOffset,
-            r = _ref22.length;
+        replace: function replace(_ref23, n) {
+          var e = _ref23.buffer,
+            t = _ref23.byteOffset,
+            r = _ref23.length;
           n.buffers || (n.buffers = []);
           var o = n.buffers.indexOf(e);
           return -1 !== o ? {
@@ -6781,7 +6965,7 @@
           } : (n.buffers.push(e), {
             maxByteLength: e.maxByteLength,
             resizable: e.resizable,
-            encoded: l(e),
+            encoded: u(e),
             byteOffset: t,
             length: r
           });
@@ -6795,7 +6979,7 @@
             i = t.maxByteLength,
             c = t.resizable;
           var 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);
         }
@@ -6842,10 +7026,10 @@
         revive: function revive(e) {
           if (Array.isArray(e)) return e;
           var t = [];
-          return Object.entries(e).forEach(function (_ref23) {
-            var _ref24 = _slicedToArray(_ref23, 2),
-              e = _ref24[0],
-              r = _ref24[1];
+          return Object.entries(e).forEach(function (_ref24) {
+            var _ref25 = _slicedToArray(_ref24, 2),
+              e = _ref25[0],
+              r = _ref25[1];
             t[e] = r;
           }), t;
         }
@@ -6861,8 +7045,8 @@
         revive: function 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: function test(e) {
@@ -7626,7 +7810,7 @@
                   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(function (err) {
                 console.log('Index rename error');
                 throw err;
@@ -9819,7 +10003,7 @@
    *   __connections: {
    *     [key: string]: import('./IDBDatabase.js').IDBDatabaseFull[]
    *   }
-  * }} IDBFactoryFull
+   * }} IDBFactoryFull
    */
 
   var IDBFactoryAlias = IDBFactory;
@@ -10010,7 +10194,7 @@
                   /** @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;
                     });
@@ -10121,6 +10305,13 @@
     function openDB(oldVersion) {
       /** @type {DatabaseFull} */
       var 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 {
@@ -10132,9 +10323,6 @@
           websqlDBCache[name][version] = db;
         }
       }
-      if (version === undefined) {
-        version = oldVersion || 1;
-      }
       if (oldVersion > version) {
         var err = createDOMException('VersionError', 'An attempt was made to open a database using a lower version than the existing version.', version);
         if (useDatabaseCache) {
@@ -10302,7 +10490,6 @@
             version = _data$rows$item.version;
             var 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
@@ -10331,7 +10518,7 @@
               });
               return undefined;
               // @ts-expect-error It's ok
-            }, dbError);
+            }).catch(dbError);
             return undefined;
           }, dbError);
         });
@@ -10362,14 +10549,14 @@
   };
 
   /**
-  * 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 () {
     var me = this;
     var calledDbCreateError = false;
@@ -10417,17 +10604,17 @@
   };
 
   /**
-  * @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}
-  */
+   * @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) {
     var me = this;
     /**
@@ -10513,6 +10700,9 @@
    *   __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
    */
@@ -10586,6 +10776,9 @@
     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';
@@ -10749,73 +10942,97 @@
    * @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) {
+    var recordsToLoad = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
     var 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;
     }
     var quotedKeyColumnName = sqlQuote(me.__keyColumnName);
-    var sql = ['SELECT * FROM', escapeStoreNameForSQL(me.__store.__currentName)];
-    /** @type {string[]} */
-    var 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)) + '%');
-      }
-    }
+    var quotedKey = sqlQuote('key');
 
     // Determine the ORDER BY direction based on the cursor.
     var direction = me.__sqlDirection;
     var op = direction === 'ASC' ? '>' : '<';
-    var quotedKey = sqlQuote('key');
-    if (primaryKey !== undefined) {
-      sql.push('AND', quotedKey, op + '= ?');
-      // Key.convertValueToKey(primaryKey); // Already checked by `continuePrimaryKey`
-      sqlValues.push(/** @type {string} */_encode(primaryKey));
-    }
-    if (key !== undefined) {
-      sql.push('AND', quotedKeyColumnName, op + '= ?');
-      // Key.convertValueToKey(key); // Already checked by `continue` or `continuePrimaryKey`
-      sqlValues.push(/** @type {string} */_encode(key));
-    } else if (me.__key !== undefined) {
-      sql.push('AND', quotedKeyColumnName, op + ' ?');
-      // Key.convertValueToKey(me.__key); // Already checked when entered
-      sqlValues.push(/** @type {string} */_encode(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() {
+      var sql = ['SELECT * FROM', escapeStoreNameForSQL(me.__store.__currentName)];
+      /** @type {string[]} */
+      var 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(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(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, '?))');
+        var encodedContinuationKey = /** @type {string} */
+        _encode(me.__continuationKey, true);
+        sqlValues.push(encodedContinuationKey, encodedContinuationKey, /** @type {string} */_encode(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));
+      }
+      var sqlStr = sql.join(' ');
+      if (CFG.DEBUG) {
+        console.log('[multiEntry] query', sqlStr, sqlValues);
       }
-      sql.push('LIMIT', String(recordsToLoad));
-    }
-    var 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
           var ct = 0;
@@ -10828,6 +11045,16 @@
           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.
+        var lastRawRow = data.rows.item(data.rows.length - 1);
+        me.__continuationKey = _decode(lastRawRow[me.__keyColumnName], true);
+        me.__continuationPrimaryKey = _decode(lastRawRow.key);
+        if (data.rows.length < recordsToLoad) {
+          me.__multiEntryExhausted = true;
+        }
         var rows = [];
         for (var _i = 0; _i < data.rows.length; _i++) {
           var _rowItem = data.rows.item(_i);
@@ -10854,6 +11081,20 @@
             _iterator.f();
           }
         }
+        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;
+        }
         var reverse = me.direction.indexOf('prev') === 0;
         rows.sort(function (a, b) {
           if (a.matchingKey.replaceAll(leftBracketRegex, 'z') < b.matchingKey.replaceAll(leftBracketRegex, 'z')) {
@@ -10870,47 +11111,31 @@
           }
           return 0;
         });
-        if (rows.length > 1) {
-          me.__prefetchedIndex = 0;
-          me.__prefetchedData = {
-            data: rows,
-            length: rows.length,
-            /**
-             * @param {Integer} index
-             * @returns {RowItemNonNull}
-             */
-            item: function 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: function 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();
   };
 
   /**
@@ -10922,19 +11147,19 @@
    */
 
   /**
-  * @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.
@@ -10962,11 +11187,11 @@
 
   /**
    * @typedef {{
-  *   matchingKey: string,
-  *   key: string,
-  *   [k: string]: string
-  * }} RowItemNonNull
-  */
+   *   matchingKey: string,
+   *   key: string,
+   *   [k: string]: string
+   * }} RowItemNonNull
+   */
 
   /**
    *
@@ -11019,6 +11244,7 @@
   IDBCursor.prototype.__invalidateCache = function () {
     // @ts-expect-error Why is this not being found?
     this.__prefetchedData = null;
+    this.__multiEntryExhausted = false;
   };
 
   /**
@@ -11074,8 +11300,8 @@
             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;
@@ -11097,11 +11323,15 @@
                 return;
               }
               // @ts-expect-error Todo: Our bug to fix
-              cursorContinue(tx, args, success, error);
+              runContinuationSafely(function () {
+                return cursorContinue(tx, args, success, error);
+              });
             }
             if (me.__unique && !me.__multiEntryIndex && encKey === _encode(me.key, me.__multiEntryIndex)) {
               // @ts-expect-error Todo: Our bug to fix
-              cursorContinue(tx, args, success, error);
+              runContinuationSafely(function () {
+                return cursorContinue(tx, args, success, error);
+              });
               return;
             }
             checkKey();