indexeddbshim 13.0.0-pre.1 → 14.0.0

package/dist/indexeddbshim-UnicodeIdentifiers.js

@@ -1,4 +1,4 @@
-/*! indexeddbshim - v12.0.0-pre.0 - 6/7/2023 */
+/*! indexeddbshim - v13.0.0 - 7/7/2024 */
 
 (function (factory) {
   typeof define === 'function' && define.amd ? define(factory) :
@@ -17,568 +17,524 @@
     UnicodeIDStart: UnicodeIDStart
   });
 
-  function _defineAccessor(type, obj, key, fn) {
-    var desc = {
+  function _arrayLikeToArray$1(r, a) {
+    (null == a || a > r.length) && (a = r.length);
+    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+    return n;
+  }
+  function _arrayWithHoles(r) {
+    if (Array.isArray(r)) return r;
+  }
+  function _arrayWithoutHoles(r) {
+    if (Array.isArray(r)) return _arrayLikeToArray$1(r);
+  }
+  function asyncGeneratorStep(n, t, e, r, o, a, c) {
+    try {
+      var i = n[a](c),
+        u = i.value;
+    } catch (n) {
+      return void e(n);
+    }
+    i.done ? t(u) : Promise.resolve(u).then(r, o);
+  }
+  function _asyncToGenerator(n) {
+    return function () {
+      var t = this,
+        e = arguments;
+      return new Promise(function (r, o) {
+        var a = n.apply(t, e);
+        function _next(n) {
+          asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+        }
+        function _throw(n) {
+          asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+        }
+        _next(void 0);
+      });
+    };
+  }
+  function _classCallCheck$1(a, n) {
+    if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+  }
+  function _construct(t, e, r) {
+    if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+    var o = [null];
+    o.push.apply(o, e);
+    var p = new (t.bind.apply(t, o))();
+    return p;
+  }
+  function _defineProperties(e, r) {
+    for (var t = 0; t < r.length; t++) {
+      var o = r[t];
+      o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey$1(o.key), o);
+    }
+  }
+  function _createClass$1(e, r, t) {
+    return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
+      writable: !1
+    }), e;
+  }
+  function _createForOfIteratorHelper(r, e) {
+    var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+    if (!t) {
+      if (Array.isArray(r) || (t = _unsupportedIterableToArray$1(r)) || e  ) {
+        t && (r = t);
+        var n = 0,
+          F = function () {};
+        return {
+          s: F,
+          n: function () {
+            return n >= r.length ? {
+              done: !0
+            } : {
+              done: !1,
+              value: r[n++]
+            };
+          },
+          e: function (r) {
+            throw r;
+          },
+          f: F
+        };
+      }
+      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+    var o,
+      a = !0,
+      u = !1;
+    return {
+      s: function () {
+        t = t.call(r);
+      },
+      n: function () {
+        var r = t.next();
+        return a = r.done, r;
+      },
+      e: function (r) {
+        u = !0, o = r;
+      },
+      f: function () {
+        try {
+          a || null == t.return || t.return();
+        } finally {
+          if (u) throw o;
+        }
+      }
+    };
+  }
+  function _defineAccessor(e, r, n, t) {
+    var c = {
       configurable: !0,
       enumerable: !0
     };
-    return desc[type] = fn, Object.defineProperty(obj, key, desc);
-  }
-  function _iterableToArrayLimit(arr, i) {
-    var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
-    if (null != _i) {
-      var _s,
-        _e,
-        _x,
-        _r,
-        _arr = [],
-        _n = !0,
-        _d = !1;
+    return c[e] = t, Object.defineProperty(r, n, c);
+  }
+  function _defineProperty$1(e, r, t) {
+    return (r = _toPropertyKey$1(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }) : e[r] = t, e;
+  }
+  function _isNativeReflectConstruct() {
+    try {
+      var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    } catch (t) {}
+    return (_isNativeReflectConstruct = function () {
+      return !!t;
+    })();
+  }
+  function _iterableToArray(r) {
+    if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+  }
+  function _iterableToArrayLimit(r, l) {
+    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+    if (null != t) {
+      var e,
+        n,
+        i,
+        u,
+        a = [],
+        f = !0,
+        o = !1;
       try {
-        if (_x = (_i = _i.call(arr)).next, 0 === i) {
-          if (Object(_i) !== _i) return;
-          _n = !1;
-        } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
-      } catch (err) {
-        _d = !0, _e = err;
+        if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+      } catch (r) {
+        o = !0, n = r;
       } finally {
         try {
-          if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return;
+          if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
         } finally {
-          if (_d) throw _e;
+          if (o) throw n;
         }
       }
-      return _arr;
+      return a;
     }
   }
-  function ownKeys$1(object, enumerableOnly) {
-    var keys = Object.keys(object);
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function ownKeys$1(e, r) {
+    var t = Object.keys(e);
     if (Object.getOwnPropertySymbols) {
-      var symbols = Object.getOwnPropertySymbols(object);
-      enumerableOnly && (symbols = symbols.filter(function (sym) {
-        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-      })), keys.push.apply(keys, symbols);
-    }
-    return keys;
-  }
-  function _objectSpread2$1(target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = null != arguments[i] ? arguments[i] : {};
-      i % 2 ? ownKeys$1(Object(source), !0).forEach(function (key) {
-        _defineProperty$1(target, key, source[key]);
-      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) {
-        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function (r) {
+        return Object.getOwnPropertyDescriptor(e, r).enumerable;
+      })), t.push.apply(t, o);
+    }
+    return t;
+  }
+  function _objectSpread2$1(e) {
+    for (var r = 1; r < arguments.length; r++) {
+      var t = null != arguments[r] ? arguments[r] : {};
+      r % 2 ? ownKeys$1(Object(t), !0).forEach(function (r) {
+        _defineProperty$1(e, r, t[r]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$1(Object(t)).forEach(function (r) {
+        Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
       });
     }
-    return target;
+    return e;
   }
   function _regeneratorRuntime() {
     _regeneratorRuntime = function () {
-      return exports;
+      return e;
     };
-    var exports = {},
-      Op = Object.prototype,
-      hasOwn = Op.hasOwnProperty,
-      defineProperty = Object.defineProperty || function (obj, key, desc) {
-        obj[key] = desc.value;
+    var t,
+      e = {},
+      r = Object.prototype,
+      n = r.hasOwnProperty,
+      o = Object.defineProperty || function (t, e, r) {
+        t[e] = r.value;
       },
-      $Symbol = "function" == typeof Symbol ? Symbol : {},
-      iteratorSymbol = $Symbol.iterator || "@@iterator",
-      asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
-      toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
-    function define(obj, key, value) {
-      return Object.defineProperty(obj, key, {
-        value: value,
+      i = "function" == typeof Symbol ? Symbol : {},
+      a = i.iterator || "@@iterator",
+      c = i.asyncIterator || "@@asyncIterator",
+      u = i.toStringTag || "@@toStringTag";
+    function define(t, e, r) {
+      return Object.defineProperty(t, e, {
+        value: r,
         enumerable: !0,
         configurable: !0,
         writable: !0
-      }), obj[key];
+      }), t[e];
     }
     try {
       define({}, "");
-    } catch (err) {
-      define = function (obj, key, value) {
-        return obj[key] = value;
+    } catch (t) {
+      define = function (t, e, r) {
+        return t[e] = r;
       };
     }
-    function wrap(innerFn, outerFn, self, tryLocsList) {
-      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
-        generator = Object.create(protoGenerator.prototype),
-        context = new Context(tryLocsList || []);
-      return defineProperty(generator, "_invoke", {
-        value: makeInvokeMethod(innerFn, self, context)
-      }), generator;
+    function wrap(t, e, r, n) {
+      var i = e && e.prototype instanceof Generator ? e : Generator,
+        a = Object.create(i.prototype),
+        c = new Context(n || []);
+      return o(a, "_invoke", {
+        value: makeInvokeMethod(t, r, c)
+      }), a;
     }
-    function tryCatch(fn, obj, arg) {
+    function tryCatch(t, e, r) {
       try {
         return {
           type: "normal",
-          arg: fn.call(obj, arg)
+          arg: t.call(e, r)
         };
-      } catch (err) {
+      } catch (t) {
         return {
           type: "throw",
-          arg: err
+          arg: t
         };
       }
     }
-    exports.wrap = wrap;
-    var ContinueSentinel = {};
+    e.wrap = wrap;
+    var h = "suspendedStart",
+      l = "suspendedYield",
+      f = "executing",
+      s = "completed",
+      y = {};
     function Generator() {}
     function GeneratorFunction() {}
     function GeneratorFunctionPrototype() {}
-    var IteratorPrototype = {};
-    define(IteratorPrototype, iteratorSymbol, function () {
+    var p = {};
+    define(p, a, function () {
       return this;
     });
-    var getProto = Object.getPrototypeOf,
-      NativeIteratorPrototype = getProto && getProto(getProto(values([])));
-    NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
-    var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
-    function defineIteratorMethods(prototype) {
-      ["next", "throw", "return"].forEach(function (method) {
-        define(prototype, method, function (arg) {
-          return this._invoke(method, arg);
+    var d = Object.getPrototypeOf,
+      v = d && d(d(values([])));
+    v && v !== r && n.call(v, a) && (p = v);
+    var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+    function defineIteratorMethods(t) {
+      ["next", "throw", "return"].forEach(function (e) {
+        define(t, e, function (t) {
+          return this._invoke(e, t);
         });
       });
     }
-    function AsyncIterator(generator, PromiseImpl) {
-      function invoke(method, arg, resolve, reject) {
-        var record = tryCatch(generator[method], generator, arg);
-        if ("throw" !== record.type) {
-          var result = record.arg,
-            value = result.value;
-          return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
-            invoke("next", value, resolve, reject);
-          }, function (err) {
-            invoke("throw", err, resolve, reject);
-          }) : PromiseImpl.resolve(value).then(function (unwrapped) {
-            result.value = unwrapped, resolve(result);
-          }, function (error) {
-            return invoke("throw", error, resolve, reject);
+    function AsyncIterator(t, e) {
+      function invoke(r, o, i, a) {
+        var c = tryCatch(t[r], t, o);
+        if ("throw" !== c.type) {
+          var u = c.arg,
+            h = u.value;
+          return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
+            invoke("next", t, i, a);
+          }, function (t) {
+            invoke("throw", t, i, a);
+          }) : e.resolve(h).then(function (t) {
+            u.value = t, i(u);
+          }, function (t) {
+            return invoke("throw", t, i, a);
           });
         }
-        reject(record.arg);
+        a(c.arg);
       }
-      var previousPromise;
-      defineProperty(this, "_invoke", {
-        value: function (method, arg) {
+      var r;
+      o(this, "_invoke", {
+        value: function (t, n) {
           function callInvokeWithMethodAndArg() {
-            return new PromiseImpl(function (resolve, reject) {
-              invoke(method, arg, resolve, reject);
+            return new e(function (e, r) {
+              invoke(t, n, e, r);
             });
           }
-          return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+          return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
         }
       });
     }
-    function makeInvokeMethod(innerFn, self, context) {
-      var state = "suspendedStart";
-      return function (method, arg) {
-        if ("executing" === state) throw new Error("Generator is already running");
-        if ("completed" === state) {
-          if ("throw" === method) throw arg;
-          return doneResult();
-        }
-        for (context.method = method, context.arg = arg;;) {
-          var delegate = context.delegate;
-          if (delegate) {
-            var delegateResult = maybeInvokeDelegate(delegate, context);
-            if (delegateResult) {
-              if (delegateResult === ContinueSentinel) continue;
-              return delegateResult;
+    function makeInvokeMethod(e, r, n) {
+      var o = h;
+      return function (i, a) {
+        if (o === f) throw Error("Generator is already running");
+        if (o === s) {
+          if ("throw" === i) throw a;
+          return {
+            value: t,
+            done: !0
+          };
+        }
+        for (n.method = i, n.arg = a;;) {
+          var c = n.delegate;
+          if (c) {
+            var u = maybeInvokeDelegate(c, n);
+            if (u) {
+              if (u === y) continue;
+              return u;
             }
           }
-          if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
-            if ("suspendedStart" === state) throw state = "completed", context.arg;
-            context.dispatchException(context.arg);
-          } else "return" === context.method && context.abrupt("return", context.arg);
-          state = "executing";
-          var record = tryCatch(innerFn, self, context);
-          if ("normal" === record.type) {
-            if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+          if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
+            if (o === h) throw o = s, n.arg;
+            n.dispatchException(n.arg);
+          } else "return" === n.method && n.abrupt("return", n.arg);
+          o = f;
+          var p = tryCatch(e, r, n);
+          if ("normal" === p.type) {
+            if (o = n.done ? s : l, p.arg === y) continue;
             return {
-              value: record.arg,
-              done: context.done
+              value: p.arg,
+              done: n.done
             };
           }
-          "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+          "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
         }
       };
     }
-    function maybeInvokeDelegate(delegate, context) {
-      var methodName = context.method,
-        method = delegate.iterator[methodName];
-      if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel;
-      var record = tryCatch(method, delegate.iterator, context.arg);
-      if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
-      var info = record.arg;
-      return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
-    }
-    function pushTryEntry(locs) {
-      var entry = {
-        tryLoc: locs[0]
+    function maybeInvokeDelegate(e, r) {
+      var n = r.method,
+        o = e.iterator[n];
+      if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
+      var i = tryCatch(o, e.iterator, r.arg);
+      if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
+      var a = i.arg;
+      return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
+    }
+    function pushTryEntry(t) {
+      var e = {
+        tryLoc: t[0]
       };
-      1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+      1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
     }
-    function resetTryEntry(entry) {
-      var record = entry.completion || {};
-      record.type = "normal", delete record.arg, entry.completion = record;
+    function resetTryEntry(t) {
+      var e = t.completion || {};
+      e.type = "normal", delete e.arg, t.completion = e;
     }
-    function Context(tryLocsList) {
+    function Context(t) {
       this.tryEntries = [{
         tryLoc: "root"
-      }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
-    }
-    function values(iterable) {
-      if (iterable) {
-        var iteratorMethod = iterable[iteratorSymbol];
-        if (iteratorMethod) return iteratorMethod.call(iterable);
-        if ("function" == typeof iterable.next) return iterable;
-        if (!isNaN(iterable.length)) {
-          var i = -1,
-            next = function next() {
-              for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
-              return next.value = undefined, next.done = !0, next;
+      }], t.forEach(pushTryEntry, this), this.reset(!0);
+    }
+    function values(e) {
+      if (e || "" === e) {
+        var r = e[a];
+        if (r) return r.call(e);
+        if ("function" == typeof e.next) return e;
+        if (!isNaN(e.length)) {
+          var o = -1,
+            i = function next() {
+              for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
+              return next.value = t, next.done = !0, next;
             };
-          return next.next = next;
+          return i.next = i;
         }
       }
-      return {
-        next: doneResult
-      };
-    }
-    function doneResult() {
-      return {
-        value: undefined,
-        done: !0
-      };
+      throw new TypeError(typeof e + " is not iterable");
     }
-    return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
+    return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
       value: GeneratorFunctionPrototype,
       configurable: !0
-    }), defineProperty(GeneratorFunctionPrototype, "constructor", {
+    }), o(GeneratorFunctionPrototype, "constructor", {
       value: GeneratorFunction,
       configurable: !0
-    }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
-      var ctor = "function" == typeof genFun && genFun.constructor;
-      return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
-    }, exports.mark = function (genFun) {
-      return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
-    }, exports.awrap = function (arg) {
+    }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
+      var e = "function" == typeof t && t.constructor;
+      return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
+    }, e.mark = function (t) {
+      return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
+    }, e.awrap = function (t) {
       return {
-        __await: arg
+        __await: t
       };
-    }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+    }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
       return this;
-    }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
-      void 0 === PromiseImpl && (PromiseImpl = Promise);
-      var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
-      return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
-        return result.done ? result.value : iter.next();
+    }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
+      void 0 === i && (i = Promise);
+      var a = new AsyncIterator(wrap(t, r, n, o), i);
+      return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
+        return t.done ? t.value : a.next();
       });
-    }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+    }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
       return this;
-    }), define(Gp, "toString", function () {
+    }), define(g, "toString", function () {
       return "[object Generator]";
-    }), exports.keys = function (val) {
-      var object = Object(val),
-        keys = [];
-      for (var key in object) keys.push(key);
-      return keys.reverse(), function next() {
-        for (; keys.length;) {
-          var key = keys.pop();
-          if (key in object) return next.value = key, next.done = !1, next;
+    }), e.keys = function (t) {
+      var e = Object(t),
+        r = [];
+      for (var n in e) r.push(n);
+      return r.reverse(), function next() {
+        for (; r.length;) {
+          var t = r.pop();
+          if (t in e) return next.value = t, next.done = !1, next;
         }
         return next.done = !0, next;
       };
-    }, exports.values = values, Context.prototype = {
+    }, e.values = values, Context.prototype = {
       constructor: Context,
-      reset: function (skipTempReset) {
-        if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+      reset: function (e) {
+        if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
       },
       stop: function () {
         this.done = !0;
-        var rootRecord = this.tryEntries[0].completion;
-        if ("throw" === rootRecord.type) throw rootRecord.arg;
+        var t = this.tryEntries[0].completion;
+        if ("throw" === t.type) throw t.arg;
         return this.rval;
       },
-      dispatchException: function (exception) {
-        if (this.done) throw exception;
-        var context = this;
-        function handle(loc, caught) {
-          return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
-        }
-        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-          var entry = this.tryEntries[i],
-            record = entry.completion;
-          if ("root" === entry.tryLoc) return handle("end");
-          if (entry.tryLoc <= this.prev) {
-            var hasCatch = hasOwn.call(entry, "catchLoc"),
-              hasFinally = hasOwn.call(entry, "finallyLoc");
-            if (hasCatch && hasFinally) {
-              if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
-              if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
-            } else if (hasCatch) {
-              if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+      dispatchException: function (e) {
+        if (this.done) throw e;
+        var r = this;
+        function handle(n, o) {
+          return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
+        }
+        for (var o = this.tryEntries.length - 1; o >= 0; --o) {
+          var i = this.tryEntries[o],
+            a = i.completion;
+          if ("root" === i.tryLoc) return handle("end");
+          if (i.tryLoc <= this.prev) {
+            var c = n.call(i, "catchLoc"),
+              u = n.call(i, "finallyLoc");
+            if (c && u) {
+              if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+              if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+            } else if (c) {
+              if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
             } else {
-              if (!hasFinally) throw new Error("try statement without catch or finally");
-              if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+              if (!u) throw Error("try statement without catch or finally");
+              if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
             }
           }
         }
       },
-      abrupt: function (type, arg) {
-        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-          var entry = this.tryEntries[i];
-          if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
-            var finallyEntry = entry;
+      abrupt: function (t, e) {
+        for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+          var o = this.tryEntries[r];
+          if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
+            var i = o;
             break;
           }
         }
-        finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
-        var record = finallyEntry ? finallyEntry.completion : {};
-        return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+        i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
+        var a = i ? i.completion : {};
+        return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
       },
-      complete: function (record, afterLoc) {
-        if ("throw" === record.type) throw record.arg;
-        return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+      complete: function (t, e) {
+        if ("throw" === t.type) throw t.arg;
+        return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
       },
-      finish: function (finallyLoc) {
-        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-          var entry = this.tryEntries[i];
-          if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+      finish: function (t) {
+        for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+          var r = this.tryEntries[e];
+          if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
         }
       },
-      catch: function (tryLoc) {
-        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-          var entry = this.tryEntries[i];
-          if (entry.tryLoc === tryLoc) {
-            var record = entry.completion;
-            if ("throw" === record.type) {
-              var thrown = record.arg;
-              resetTryEntry(entry);
+      catch: function (t) {
+        for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+          var r = this.tryEntries[e];
+          if (r.tryLoc === t) {
+            var n = r.completion;
+            if ("throw" === n.type) {
+              var o = n.arg;
+              resetTryEntry(r);
             }
-            return thrown;
+            return o;
           }
         }
-        throw new Error("illegal catch attempt");
+        throw Error("illegal catch attempt");
       },
-      delegateYield: function (iterable, resultName, nextLoc) {
+      delegateYield: function (e, r, n) {
         return this.delegate = {
-          iterator: values(iterable),
-          resultName: resultName,
-          nextLoc: nextLoc
-        }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+          iterator: values(e),
+          resultName: r,
+          nextLoc: n
+        }, "next" === this.method && (this.arg = t), y;
       }
-    }, exports;
-  }
-  function _typeof$2(obj) {
-    "@babel/helpers - typeof";
-
-    return _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
-      return typeof obj;
-    } : function (obj) {
-      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-    }, _typeof$2(obj);
-  }
-  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-    try {
-      var info = gen[key](arg);
-      var value = info.value;
-    } catch (error) {
-      reject(error);
-      return;
-    }
-    if (info.done) {
-      resolve(value);
-    } else {
-      Promise.resolve(value).then(_next, _throw);
-    }
-  }
-  function _asyncToGenerator(fn) {
-    return function () {
-      var self = this,
-        args = arguments;
-      return new Promise(function (resolve, reject) {
-        var gen = fn.apply(self, args);
-        function _next(value) {
-          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-        }
-        function _throw(err) {
-          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-        }
-        _next(undefined);
-      });
-    };
-  }
-  function _classCallCheck$1(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-      throw new TypeError("Cannot call a class as a function");
-    }
-  }
-  function _defineProperties$1(target, props) {
-    for (var i = 0; i < props.length; i++) {
-      var descriptor = props[i];
-      descriptor.enumerable = descriptor.enumerable || false;
-      descriptor.configurable = true;
-      if ("value" in descriptor) descriptor.writable = true;
-      Object.defineProperty(target, _toPropertyKey$1(descriptor.key), descriptor);
-    }
-  }
-  function _createClass$1(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties$1(Constructor, staticProps);
-    Object.defineProperty(Constructor, "prototype", {
-      writable: false
-    });
-    return Constructor;
-  }
-  function _defineProperty$1(obj, key, value) {
-    key = _toPropertyKey$1(key);
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else {
-      obj[key] = value;
-    }
-    return obj;
+    }, e;
   }
-  function _setPrototypeOf(o, p) {
-    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-      o.__proto__ = p;
-      return o;
-    };
-    return _setPrototypeOf(o, p);
+  function _slicedToArray$1(r, e) {
+    return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray$1(r, e) || _nonIterableRest();
   }
-  function _isNativeReflectConstruct() {
-    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-    if (Reflect.construct.sham) return false;
-    if (typeof Proxy === "function") return true;
-    try {
-      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
-      return true;
-    } catch (e) {
-      return false;
-    }
+  function _toConsumableArray(r) {
+    return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray$1(r) || _nonIterableSpread();
   }
-  function _construct(Parent, args, Class) {
-    if (_isNativeReflectConstruct()) {
-      _construct = Reflect.construct.bind();
-    } else {
-      _construct = function _construct(Parent, args, Class) {
-        var a = [null];
-        a.push.apply(a, args);
-        var Constructor = Function.bind.apply(Parent, a);
-        var instance = new Constructor();
-        if (Class) _setPrototypeOf(instance, Class.prototype);
-        return instance;
-      };
+  function _toPrimitive(t, r) {
+    if ("object" != typeof t || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r || "default");
+      if ("object" != typeof i) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
     }
-    return _construct.apply(null, arguments);
+    return ("string" === r ? String : Number)(t);
   }
-  function _slicedToArray$1(arr, i) {
-    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest();
+  function _toPropertyKey$1(t) {
+    var i = _toPrimitive(t, "string");
+    return "symbol" == typeof i ? i : i + "";
   }
-  function _toConsumableArray(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread();
-  }
-  function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray$1(arr);
-  }
-  function _arrayWithHoles(arr) {
-    if (Array.isArray(arr)) return arr;
-  }
-  function _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-  }
-  function _unsupportedIterableToArray$1(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray$1(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(o);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen);
-  }
-  function _arrayLikeToArray$1(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-    return arr2;
-  }
-  function _nonIterableSpread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-  function _nonIterableRest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-  function _createForOfIteratorHelper(o, allowArrayLike) {
-    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-    if (!it) {
-      if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") {
-        if (it) o = it;
-        var i = 0;
-        var F = function () {};
-        return {
-          s: F,
-          n: function () {
-            if (i >= o.length) return {
-              done: true
-            };
-            return {
-              done: false,
-              value: o[i++]
-            };
-          },
-          e: function (e) {
-            throw e;
-          },
-          f: F
-        };
-      }
-      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-    }
-    var normalCompletion = true,
-      didErr = false,
-      err;
-    return {
-      s: function () {
-        it = it.call(o);
-      },
-      n: function () {
-        var step = it.next();
-        normalCompletion = step.done;
-        return step;
-      },
-      e: function (e) {
-        didErr = true;
-        err = e;
-      },
-      f: function () {
-        try {
-          if (!normalCompletion && it.return != null) it.return();
-        } finally {
-          if (didErr) throw err;
-        }
-      }
-    };
+  function _typeof$2(o) {
+    "@babel/helpers - typeof";
+
+    return _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+      return typeof o;
+    } : function (o) {
+      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+    }, _typeof$2(o);
   }
-  function _toPrimitive(input, hint) {
-    if (typeof input !== "object" || input === null) return input;
-    var prim = input[Symbol.toPrimitive];
-    if (prim !== undefined) {
-      var res = prim.call(input, hint || "default");
-      if (typeof res !== "object") return res;
-      throw new TypeError("@@toPrimitive must return a primitive value.");
+  function _unsupportedIterableToArray$1(r, a) {
+    if (r) {
+      if ("string" == typeof r) return _arrayLikeToArray$1(r, a);
+      var t = {}.toString.call(r).slice(8, -1);
+      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$1(r, a) : void 0;
     }
-    return (hint === "string" ? String : Number)(input);
-  }
-  function _toPropertyKey$1(arg) {
-    var key = _toPrimitive(arg, "string");
-    return typeof key === "symbol" ? key : String(key);
   }
 
   function _typeof$1(obj) {
@@ -725,10 +681,9 @@
       pr;
       Object.defineProperty(_this, prop, {
         get: function get() {
-          return (/* prop in _evCfg && */_evCfg[prop] !== undefined ? _evCfg[prop] : prop in _ev ? _ev[prop] :
-            // Defaults
-            prop === 'eventPhase' ? 0 : prop === 'defaultPrevented' ? false : null
-          );
+          return /* prop in _evCfg && */_evCfg[prop] !== undefined ? _evCfg[prop] : prop in _ev ? _ev[prop] :
+          // Defaults
+          prop === 'eventPhase' ? 0 : prop === 'defaultPrevented' ? false : null;
         }
       });
     });
@@ -1223,7 +1178,6 @@
           }
         });
       }
-
       var _eventCopy = eventCopy,
         type = _eventCopy.type;
 
@@ -1977,12 +1931,11 @@
    */
   function defineOuterInterface(obj, props) {
     props.forEach(function (prop) {
-      var _o;
-      var o = (_o = {}, _defineAccessor("get", _o, prop, function () {
+      var o = _defineAccessor("set", _defineAccessor("get", {}, prop, function () {
         throw new TypeError('Illegal invocation');
-      }), _defineAccessor("set", _o, prop, function (val) {
+      }), prop, function (val) {
         throw new TypeError('Illegal invocation');
-      }), _o);
+      });
       var desc = /** @type {PropertyDescriptor} */
       Object.getOwnPropertyDescriptor(o, prop);
       Object.defineProperty(obj, prop, desc);
@@ -2017,12 +1970,11 @@
   function defineListenerProperties(obj, listeners) {
     listeners = typeof listeners === 'string' ? [listeners] : listeners;
     listeners.forEach(function (listener) {
-      var _o3;
-      var o = (_o3 = {}, _defineAccessor("get", _o3, listener, function () {
+      var o = _defineAccessor("set", _defineAccessor("get", {}, listener, function () {
         return obj['__' + listener];
-      }), _defineAccessor("set", _o3, listener, function (val) {
+      }), listener, function (val) {
         obj['__' + listener] = val;
-      }), _o3);
+      });
       var desc = /** @type {PropertyDescriptor} */
       Object.getOwnPropertyDescriptor(o, listener);
       // desc.enumerable = true; // Default
@@ -2405,7 +2357,7 @@
     function DOMException(message, name) {
       // const err = Error.prototype.constructor.call(this, message); // Any use to this? Won't set this.message
       this[Symbol.toStringTag] = 'DOMException';
-      this._code = name in codes ? codes[/** @type {Code} */name] : legacyCodes[/** @type {LegacyCode} */name] || 0;
+      this._code = name in codes ? codes[( /** @type {Code} */name)] : legacyCodes[( /** @type {LegacyCode} */name)] || 0;
       this._name = name || 'Error';
       // We avoid `String()` in this next line as it converts Symbols
       this._message = message === undefined ? '' : '' + message; // eslint-disable-line no-implicit-coercion
@@ -2542,10 +2494,12 @@
    */
   function logError(name, message, error) {
     if (CFG.DEBUG) {
-      var msg = error && _typeof$2(error) === 'object' && error.message ? error.message : /** @type {string} */error;
+      var msg = error && _typeof$2(error) === 'object' && error.message ? error.message : ( /** @type {string} */error);
       var method = typeof console.error === 'function' ? 'error' : 'log';
       console[method](name + ': ' + message + '. ' + (msg || ''));
-      console.trace && console.trace();
+      if (console.trace) {
+        console.trace();
+      }
     }
   }
 
@@ -2653,7 +2607,7 @@
     }
   } catch (e) {}
   var createDOMException = useNativeDOMException
-  // eslint-disable-next-line operator-linebreak -- Need JSDoc
+  // eslint-disable-next-line @stylistic/operator-linebreak -- Need JSDoc
   ?
   /**
   * @param {string} name
@@ -2665,7 +2619,7 @@
     logError(name, message, error);
     return createNativeDOMException(name, message);
   }
-  // eslint-disable-next-line operator-linebreak -- Need JSDoc
+  // eslint-disable-next-line @stylistic/operator-linebreak -- Need JSDoc
   :
   /**
   * @param {string} name
@@ -2725,7 +2679,6 @@
     this.__setOptions({
       legacyOutputDidListenersThrowFlag: true // Event hook for IndexedB
     });
-
     doneFlagGetters.forEach(function (prop) {
       Object.defineProperty(_this, '__' + prop, {
         enumerable: false,
@@ -3254,17 +3207,15 @@
   var types = {
     invalid: {
       /**
-       * @param {AnyValue} _key
        * @returns {string}
        */
-      encode: function encode(_key) {
+      encode: function encode() {
         return keyTypeToEncodedChar.invalid + '-';
       },
       /**
-       * @param {string} _key
        * @returns {undefined}
        */
-      decode: function decode(_key) {
+      decode: function decode() {
         return undefined;
       }
     },
@@ -3602,11 +3553,17 @@
    * @returns {KeyType|"invalid"}
    */
   function getKeyType(key) {
-    if (Array.isArray(key)) return 'array';
-    if (isDate(key)) return 'date';
-    if (isBinary(key)) return 'binary';
+    if (Array.isArray(key)) {
+      return 'array';
+    }
+    if (isDate(key)) {
+      return 'date';
+    }
+    if (isBinary(key)) {
+      return 'binary';
+    }
     var keyType = _typeof$2(key);
-    return ['string', 'number'].includes(keyType) ? /** @type {"string"|"number"} */keyType : 'invalid';
+    return ['string', 'number'].includes(keyType) ? ( /** @type {"string"|"number"} */keyType) : 'invalid';
   }
 
   /**
@@ -3703,13 +3660,11 @@
               value: 0
             };
           }
-          return (/** @type {{type: KeyType; value: Value}} */ret
-          );
+          return /** @type {{type: KeyType; value: Value}} */ret;
         }
       case 'string':
         {
-          return (/** @type {{type: KeyType; value: Value}} */ret
-          );
+          return /** @type {{type: KeyType; value: Value}} */ret;
         }
       case 'binary':
         {
@@ -3732,48 +3687,49 @@
           /** @type {(KeyValueObject|Value)[]} */
           var keys = [];
           var _loop = function _loop() {
-            // We cannot iterate here with array extras as we must ensure sparse arrays are invalidated
-            if (!multiEntry && !Object.hasOwn(arr, i)) {
-              return {
-                v: {
-                  type: type,
-                  invalid: true,
-                  message: 'Does not have own index property'
-                }
-              };
-            }
-            try {
-              var entry = arr[i];
-              var key = convertValueToKeyValueDecoded(entry, seen, false, fullKeys); // Though steps do not list rethrowing, the next is returnifabrupt when not multiEntry
-              if (key.invalid) {
-                if (multiEntry) {
-                  return "continue";
-                }
+              // We cannot iterate here with array extras as we must ensure sparse arrays are invalidated
+              if (!multiEntry && !Object.hasOwn(arr, i)) {
                 return {
                   v: {
                     type: type,
                     invalid: true,
-                    message: 'Bad array entry value-to-key conversion'
+                    message: 'Does not have own index property'
                   }
                 };
               }
-              if (!multiEntry || !fullKeys && keys.every(function (k) {
-                return cmp(k, key.value) !== 0;
-              }) || fullKeys && keys.every(function (k) {
-                return cmp(k, key) !== 0;
-              })) {
-                keys.push(fullKeys ? key : key.value);
-              }
-            } catch (err) {
-              if (!multiEntry) {
-                throw err;
+              try {
+                var entry = arr[i];
+                var key = convertValueToKeyValueDecoded(entry, seen, false, fullKeys); // Though steps do not list rethrowing, the next is returnifabrupt when not multiEntry
+                if (key.invalid) {
+                  if (multiEntry) {
+                    return 0; // continue
+                  }
+                  return {
+                    v: {
+                      type: type,
+                      invalid: true,
+                      message: 'Bad array entry value-to-key conversion'
+                    }
+                  };
+                }
+                if (!multiEntry || !fullKeys && keys.every(function (k) {
+                  return cmp(k, key.value) !== 0;
+                }) || fullKeys && keys.every(function (k) {
+                  return cmp(k, key) !== 0;
+                })) {
+                  keys.push(fullKeys ? key : key.value);
+                }
+              } catch (err) {
+                if (!multiEntry) {
+                  throw err;
+                }
               }
-            }
-          };
+            },
+            _ret;
           for (var i = 0; i < len; i++) {
-            var _ret = _loop();
-            if (_ret === "continue") continue;
-            if (_typeof$2(_ret) === "object") return _ret.v;
+            _ret = _loop();
+            if (_ret === 0) continue;
+            if (_ret) return _ret.v;
           }
           return {
             type: type,
@@ -3935,7 +3891,7 @@
       };
     }
     var identifiers = keyPath.split('.');
-    return identifiers.some(function (idntfr, i) {
+    return identifiers.some(function (idntfr) {
       if (idntfr === 'length' && (typeof value === 'string' || Array.isArray(value))) {
         value = value.length;
       } else if (isBlob(value)) {
@@ -3986,7 +3942,7 @@
       }
       value = value[identifier];
     });
-    value[/** @type {string} */last] = key; // key is already a `keyValue` in our processing so no need to convert
+    value[( /** @type {string} */last)] = key; // key is already a `keyValue` in our processing so no need to convert
   }
 
   /**
@@ -4158,6 +4114,7 @@
       return null;
     }
     // array, date, number, string, binary (should already have detected "invalid")
+    // @ts-expect-error Argument may be ignored
     return types[getKeyType(key)].encode(key, inArray);
   }
 
@@ -4219,7 +4176,7 @@
       }
     }, function (tx, error) {
       sqlFailCb(createDOMException('DataError', 'Could not get the auto increment value for key', error));
-      return true;
+      return false;
     });
   }
 
@@ -4235,12 +4192,14 @@
   function assignCurrentNumber(tx, store, num, successCb, failCb) {
     var sql = 'UPDATE __sys__ SET "currNum" = ? WHERE "name" = ?';
     var sqlValues = [num, escapeSQLiteStatement(store.__currentName)];
-    CFG.DEBUG && console.log(sql, sqlValues);
-    tx.executeSql(sql, sqlValues, function (tx, data) {
+    if (CFG.DEBUG) {
+      console.log(sql, sqlValues);
+    }
+    tx.executeSql(sql, sqlValues, function () {
       successCb(num);
     }, function (tx, err) {
       failCb(createDOMException('UnknownError', 'Could not set the auto increment value for key', err));
-      return true;
+      return false;
     });
   }
 
@@ -4407,7 +4366,7 @@
         convertValueToKeyRethrowingAndIfInvalid(upper);
       }
       if (lower !== undefined && upper !== undefined && lower !== upper) {
-        if ( /** @type {string} */_encode(lower) > /** @type {string} */_encode(upper)) {
+        if ( /** @type {string} */_encode(lower) > ( /** @type {string} */_encode(upper))) {
           throw createDOMException('DataError', '`lower` must not be greater than `upper` argument in `bound()` call.');
         }
       }
@@ -4454,7 +4413,7 @@
    * @param {import('./Key.js').Value} value
    * @returns {globalThis.IDBKeyRange}
    */
-  IDBKeyRange.lowerBound = function (value /*, open */) {
+  IDBKeyRange.lowerBound = function (value /* , open */) {
     if (!arguments.length) {
       throw new TypeError('IDBKeyRange.lowerBound requires a value argument');
     }
@@ -4466,7 +4425,7 @@
    * @param {import('./Key.js').Value} value
    * @returns {globalThis.IDBKeyRange}
    */
-  IDBKeyRange.upperBound = function (value /*, open */) {
+  IDBKeyRange.upperBound = function (value /* , open */) {
     if (!arguments.length) {
       throw new TypeError('IDBKeyRange.upperBound requires a value argument');
     }
@@ -4532,7 +4491,9 @@
    */
   function setSQLForKeyRange(range, quotedKeyColumnName, sql, sqlValues, addAnd, checkCached) {
     if (range && (range.lower !== undefined || range.upper !== undefined)) {
-      if (addAnd) sql.push('AND');
+      if (addAnd) {
+        sql.push('AND');
+      }
       var encodedLowerKey, encodedUpperKey;
       var hasLower = range.lower !== undefined;
       var hasUpper = range.upper !== undefined;
@@ -4550,7 +4511,9 @@
         }
         sql.push(quotedKeyColumnName, range.lowerOpen ? '>' : '>=', '?');
       }
-      hasLower && hasUpper && sql.push('AND');
+      if (hasLower && hasUpper) {
+        sql.push('AND');
+      }
       if (hasUpper) {
         sql.push(quotedKeyColumnName, range.upperOpen ? '<' : '<=', '?');
         sqlValues.push(escapeSQLiteStatement( /** @type {string} */encodedUpperKey));
@@ -4578,12 +4541,10 @@
       }
       return undefined; // Represents unbounded
     }
-
     convertValueToKeyRethrowingAndIfInvalid(value);
     return IDBKeyRange.only(value);
   }
 
-  var _DOMStringList$protot;
   /**
    * @typedef {number} Integer
    */
@@ -4636,7 +4597,7 @@
   };
 
   // @ts-expect-error It's ok
-  DOMStringList.prototype = (_DOMStringList$protot = {
+  DOMStringList.prototype = _defineProperty$1(_defineProperty$1({
     constructor: DOMStringList,
     // Interface.
     /**
@@ -4747,7 +4708,7 @@
       }
       this.sortList();
     }
-  }, _defineProperty$1(_DOMStringList$protot, Symbol.toStringTag, 'DOMStringListPrototype'), _defineProperty$1(_DOMStringList$protot, Symbol.iterator, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+  }, Symbol.toStringTag, 'DOMStringListPrototype'), Symbol.iterator, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
     var i;
     return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
@@ -4768,7 +4729,7 @@
           return _context.stop();
       }
     }, _callee, this);
-  })), _DOMStringList$protot);
+  }));
 
   /**
    * @typedef {any} AnyValue
@@ -4807,8 +4768,7 @@
         this._length = 0;
       };
       DOMStringList.prototype = DOMStringListAlias.prototype;
-      return (/** @type {DOMStringListFull} */new DOMStringList()
-      );
+      return /** @type {DOMStringListFull} */new DOMStringList();
     }
   });
   if (cleanInterface) {
@@ -4955,7 +4915,6 @@
       me.__setOptions({
         legacyOutputDidListenersThrowFlag: true // Event hook for IndexedB
       });
-
       readonlyProperties$3.forEach(function (readonlyProp) {
         Object.defineProperty(_this, readonlyProp, {
           configurable: true
@@ -4977,6 +4936,7 @@
 
   // @ts-expect-error It's ok
   IDBTransaction.prototype = EventTargetFactory.createInstance({
+    // eslint-disable-next-line n/no-sync -- API
     defaultSync: true,
     // Ensure EventTarget preserves our properties
     extraProperties: ['complete']
@@ -4998,7 +4958,9 @@
   IDBTransaction.prototype.__executeRequests = function () {
     var me = this;
     if (me.__running) {
-      CFG.DEBUG && console.log('Looks like the request set is already running', me.mode);
+      if (CFG.DEBUG) {
+        console.log('Looks like the request set is already running', me.mode);
+      }
       return;
     }
     me.__running = true;
@@ -5027,7 +4989,6 @@
         if (req) {
           q.req = req; // Need to do this in case of cursors
         }
-
         if (!q.req) {
           // TS guard
           return;
@@ -5191,7 +5152,9 @@
        */
       function complete() {
         me.__completed = true;
-        CFG.DEBUG && console.log('Transaction completed');
+        if (CFG.DEBUG) {
+          console.log('Transaction completed');
+        }
         var evt = createEvent('complete');
         try {
           me.__internal = true;
@@ -5416,11 +5379,15 @@
      */
     function abort(tx, errOrResult) {
       if (!tx) {
-        CFG.DEBUG && console.log('Rollback not possible due to missing transaction', me);
+        if (CFG.DEBUG) {
+          console.log('Rollback not possible due to missing transaction', me);
+        }
       } else if (errOrResult && 'code' in errOrResult && typeof errOrResult.code === 'number') {
-        CFG.DEBUG && console.log('Rollback erred; feature is probably not supported as per WebSQL', me);
-      } else {
-        CFG.DEBUG && console.log('Rollback succeeded', me);
+        if (CFG.DEBUG) {
+          console.log('Rollback erred; feature is probably not supported as per WebSQL', me);
+        }
+      } else if (CFG.DEBUG) {
+        console.log('Rollback succeeded', me);
       }
       me.dispatchEvent(createEvent('__preabort'));
       me.__requests.filter(function (q, i, arr) {
@@ -5512,7 +5479,9 @@
     if (!(me instanceof IDBTransaction)) {
       throw new TypeError('Illegal invocation');
     }
-    CFG.DEBUG && console.log('The transaction was aborted', me);
+    if (CFG.DEBUG) {
+      console.log('The transaction was aborted', me);
+    }
     IDBTransaction.__assertNotFinished(me);
     me.__abortTransaction(null);
   };
@@ -5632,14 +5601,13 @@
   function _classCallCheck(e, t) {
     if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
   }
-  function _defineProperties(e, t) {
-    for (var r = 0; r < t.length; r++) {
-      var n = t[r];
-      n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(e, _toPropertyKey(n.key), n);
-    }
-  }
   function _createClass(e, t, r) {
-    return t && _defineProperties(e.prototype, t), r && _defineProperties(e, r), Object.defineProperty(e, "prototype", {
+    return t && function _defineProperties(e, t) {
+      for (var r = 0; r < t.length; r++) {
+        var n = t[r];
+        n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(e, _toPropertyKey(n.key), n);
+      }
+    }(e.prototype, t), Object.defineProperty(e, "prototype", {
       writable: !1
     }), e;
   }
@@ -5658,24 +5626,24 @@
       var r = null == e ? null : "undefined" != typeof Symbol && e[Symbol.iterator] || e["@@iterator"];
       if (null != r) {
         var n,
-          o,
           a,
+          o,
           i,
           c = [],
           s = !0,
           u = !1;
         try {
-          if (a = (r = r.call(e)).next, 0 === t) {
+          if (o = (r = r.call(e)).next, 0 === t) {
             if (Object(r) !== r) return;
             s = !1;
-          } else for (; !(s = (n = a.call(r)).done) && (c.push(n.value), c.length !== t); s = !0);
+          } else for (; !(s = (n = o.call(r)).done) && (c.push(n.value), c.length !== t); s = !0);
         } catch (e) {
-          u = !0, o = e;
+          u = !0, a = e;
         } finally {
           try {
             if (!s && null != r["return"] && (i = r["return"](), Object(i) !== i)) return;
           } finally {
-            if (u) throw o;
+            if (u) throw a;
           }
         }
         return c;
@@ -5701,11 +5669,11 @@
       if ("object" != _typeof$2(e) || null === e) return e;
       var r = e[Symbol.toPrimitive];
       if (void 0 !== r) {
-        var n = r.call(e, t || "default");
+        var n = r.call(e, t );
         if ("object" != _typeof$2(n)) return n;
         throw new TypeError("@@toPrimitive must return a primitive value.");
       }
-      return ("string" === t ? String : Number)(e);
+      return (String )(e);
     }(e, "string");
     return "symbol" == _typeof$2(t) ? t : String(t);
   }
@@ -5718,12 +5686,12 @@
     }
   }), e.prototype.then = function (t, r) {
     var n = this;
-    return new e(function (e, o) {
+    return new e(function (e, a) {
       n.p.then(function (r) {
         e(t ? t(r) : r);
       })["catch"](function (e) {
         return r ? r(e) : Promise.reject(e);
-      }).then(e, o);
+      }).then(e, a);
     });
   }, e.prototype["catch"] = function (e) {
     return this.then(function () {}, e);
@@ -5757,17 +5725,17 @@
   var t = Object.hasOwn,
     r = Object.getPrototypeOf;
   function isThenable(e, t) {
-    return isObject(e) && "function" == typeof e.then && (!t || "function" == typeof e["catch"]);
+    return isObject(e) && "function" == typeof e.then && (!t );
   }
   function toStringTag(e) {
     return Object.prototype.toString.call(e).slice(8, -1);
   }
   function hasConstructorOf(e, n) {
     if (!e || "object" !== _typeof(e)) return !1;
-    var o = r(e);
-    if (!o) return null === n;
-    var a = t(o, "constructor") && o.constructor;
-    return "function" != typeof a ? null === n : n === a || null !== n && Function.prototype.toString.call(a) === Function.prototype.toString.call(n) || "function" == typeof n && "string" == typeof a.__typeson__type__ && a.__typeson__type__ === n.__typeson__type__;
+    var a = r(e);
+    if (!a) return null === n;
+    var o = t(a, "constructor") && a.constructor;
+    return "function" != typeof o ? null === n : n === o || null !== n && Function.prototype.toString.call(o) === Function.prototype.toString.call(n) || "function" == typeof n && "string" == typeof o.__typeson__type__ && o.__typeson__type__ === n.__typeson__type__;
   }
   function isPlainObject(e) {
     return !(!e || "Object" !== toStringTag(e)) && (!r(e) || hasConstructorOf(e, Object));
@@ -5781,10 +5749,10 @@
     return null !== e && "object" === _typeof(e);
   }
   function escapeKeyPathComponent(e) {
-    return e.replace(/''/g, "''''").replace(/^$/, "''").replace(/~/g, "~0").replace(/\./g, "~1");
+    return e.replaceAll("''", "''''").replace(/^$/, "''").replaceAll("~", "~0").replaceAll(".", "~1");
   }
   function unescapeKeyPathComponent(e) {
-    return e.replace(/~1/g, ".").replace(/~0/g, "~").replace(/^''$/, "").replace(/''''/g, "''");
+    return e.replaceAll("~1", ".").replaceAll("~0", "~").replace(/^''$/, "").replaceAll("''''", "''");
   }
   function getByKeyPath(e, t) {
     if ("" === t) return e;
@@ -5806,11 +5774,11 @@
     return null === e ? "null" : Array.isArray(e) ? "array" : _typeof(e);
   }
   function _await(e, t, r) {
-    return r ? t ? t(e) : e : (e && e.then || (e = Promise.resolve(e)), t ? e.then(t) : e);
+    return e && e.then || (e = Promise.resolve(e)), t ? e.then(t) : e;
   }
   var n = Object.keys,
-    o = Object.hasOwn,
-    a = Array.isArray,
+    a = Object.hasOwn,
+    o = Array.isArray,
     i = ["type", "replaced", "iterateIn", "iterateUnsetNumeric", "addLength"];
   function _async(e) {
     return function () {
@@ -5825,9 +5793,9 @@
   function nestedPathsFirst(e, t) {
     var r, n;
     if ("" === e.keypath) return -1;
-    var o = null !== (r = e.keypath.match(/\./g)) && void 0 !== r ? r : 0,
-      a = null !== (n = t.keypath.match(/\./g)) && void 0 !== n ? n : 0;
-    return o && (o = o.length), a && (a = a.length), o > a ? -1 : o < a ? 1 : e.keypath < t.keypath ? -1 : e.keypath > t.keypath ? 1 : 0;
+    var a = null !== (r = e.keypath.match(/\./g)) && void 0 !== r ? r : 0,
+      o = null !== (n = t.keypath.match(/\./g)) && void 0 !== n ? n : 0;
+    return a && (a = a.length), o && (o = o.length), a > o ? -1 : a < o ? 1 : e.keypath < t.keypath ? -1 : e.keypath > t.keypath ? 1 : 0;
   }
   var c = function () {
       function Typeson(e) {
@@ -5839,8 +5807,8 @@
           n = _objectSpread2(_objectSpread2(_objectSpread2({}, this.options), n), {}, {
             stringification: !0
           });
-          var o = this.encapsulate(e, null, n);
-          return a(o) ? JSON.stringify(o[0], t, r) : o.then(function (e) {
+          var a = this.encapsulate(e, null, n);
+          return o(a) ? JSON.stringify(a[0], t, r) : a.then(function (e) {
             return JSON.stringify(e, t, r);
           });
         }
@@ -5912,8 +5880,8 @@
             p = [],
             d = [],
             v = !("cyclic" in u) || u.cyclic,
-            b = u.encapsulateObserver,
-            h = function finish(e) {
+            m = u.encapsulateObserver,
+            b = function finish(e) {
               var t = Object.values(f);
               if (u.iterateNone) return t.length ? t[0] : getJSONType(e);
               if (t.length) {
@@ -5926,25 +5894,25 @@
                     throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
                   }();
                 }(new Set(t));
-                e && isPlainObject(e) && !o(e, "$types") ? e.$types = f : e = {
+                e && isPlainObject(e) && !a(e, "$types") ? e.$types = f : e = {
                   $: e,
                   $types: {
                     $: f
                   }
                 };
-              } else isObject(e) && o(e, "$types") && (e = {
+              } else isObject(e) && a(e, "$types") && (e = {
                 $: e,
                 $types: !0
               });
               return !u.returnTypeNames && e;
             },
-            g = _async(function (t, r) {
+            h = _async(function (t, r) {
               return _await(Promise.all(r.map(function (e) {
                 return e[1].p;
               })), function (n) {
                 return _await(Promise.all(n.map(_async(function (n) {
-                  var o = !1,
-                    a = [],
+                  var a = !1,
+                    o = [],
                     i = _slicedToArray(r.splice(0, 1), 1),
                     c = _slicedToArray(i[0], 7),
                     s = c[0],
@@ -5953,7 +5921,7 @@
                     f = c[4],
                     y = c[5],
                     p = c[6],
-                    d = _(s, n, u, l, a, !0, p),
+                    d = O(s, n, u, l, o, !0, p),
                     v = hasConstructorOf(d, e);
                   return function _invoke(e, t) {
                     var r = e();
@@ -5961,18 +5929,18 @@
                   }(function () {
                     if (s && v) return _await(d.p, function (e) {
                       f[y] = e;
-                      var r = g(t, a);
-                      return o = !0, r;
+                      var r = h(t, o);
+                      return a = !0, r;
                     });
                   }, function (e) {
-                    return o ? e : (s ? f[y] = d : t = v ? d.p : d, g(t, a));
+                    return a ? e : (s ? f[y] = d : t = v ? d.p : d, h(t, o));
                   });
                 }))), function () {
                   return t;
                 });
               });
             }),
-            m = function _adaptBuiltinStateObjectProperties(e, t, r) {
+            g = function _adaptBuiltinStateObjectProperties(e, t, r) {
               Object.assign(e, t);
               var n = i.map(function (t) {
                 var r = e[t];
@@ -5982,14 +5950,14 @@
                 e[t] = n[r];
               });
             },
-            _ = function _encapsulate(t, r, i, c, l, d, v) {
-              var h,
-                g = {},
-                _ = _typeof(r),
-                w = b ? function (n) {
-                  var o,
-                    a = null !== (o = null != v ? v : c.type) && void 0 !== o ? o : getJSONType(r);
-                  b(Object.assign(null != n ? n : g, {
+            O = function _encapsulate(t, r, i, c, l, d, v) {
+              var b,
+                h = {},
+                O = _typeof(r),
+                _ = m ? function (n) {
+                  var a,
+                    o = null !== (a = null != v ? v : c.type) && void 0 !== a ? a : getJSONType(r);
+                  m(Object.assign(null != n ? n : h, {
                     keypath: t,
                     value: r,
                     cyclic: i,
@@ -5998,16 +5966,16 @@
                     resolvingTypesonPromise: d,
                     awaitingTypesonPromise: hasConstructorOf(r, e)
                   }, {
-                    type: a
+                    type: o
                   }));
                 } : null;
-              if (["string", "boolean", "number", "undefined"].includes(_)) return void 0 === r || Number.isNaN(r) || r === Number.NEGATIVE_INFINITY || r === Number.POSITIVE_INFINITY || 0 === r ? (h = c.replaced ? r : O(t, r, c, l, !1, d, w)) !== r && (g = {
-                replaced: h
-              }) : h = r, w && w(), h;
-              if (null === r) return w && w(), r;
+              if (["string", "boolean", "number", "undefined"].includes(O)) return void 0 === r || Number.isNaN(r) || r === Number.NEGATIVE_INFINITY || r === Number.POSITIVE_INFINITY || 0 === r ? (b = c.replaced ? r : w(t, r, c, l, !1, d, _)) !== r && (h = {
+                replaced: b
+              }) : b = r, _ && _(), b;
+              if (null === r) return _ && _(), r;
               if (i && !c.iterateIn && !c.iterateUnsetNumeric && r && "object" === _typeof(r)) {
                 var A = y.indexOf(r);
-                if (!(A < 0)) return f[t] = "#", w && w({
+                if (!(A < 0)) return f[t] = "#", _ && _({
                   cyclicKeypath: p[A]
                 }), "#" + p[A];
                 !0 === i && (y.push(r), p.push(t));
@@ -6015,65 +5983,65 @@
               var S,
                 j,
                 T = isPlainObject(r),
-                I = a(r),
-                N = (T || I) && (!s.plainObjectReplacers.length || c.replaced) || c.iterateIn ? r : O(t, r, c, l, T || I, null, w);
-              if (N !== r ? (h = N, g = {
+                I = o(r),
+                N = (T || I) && (!s.plainObjectReplacers.length || c.replaced) || c.iterateIn ? r : w(t, r, c, l, T || I, null, _);
+              if (N !== r ? (b = N, h = {
                 replaced: N
-              }) : "" === t && hasConstructorOf(r, e) ? (l.push([t, r, i, c, void 0, void 0, c.type]), h = r) : I && "object" !== c.iterateIn || "array" === c.iterateIn ? (S = new Array(r.length), g = {
+              }) : "" === t && hasConstructorOf(r, e) ? (l.push([t, r, i, c, void 0, void 0, c.type]), b = r) : I && "object" !== c.iterateIn || "array" === c.iterateIn ? (S = new Array(r.length), h = {
                 clone: S
-              }) : (["function", "symbol"].includes(_typeof(r)) || "toJSON" in r || hasConstructorOf(r, e) || hasConstructorOf(r, Promise) || hasConstructorOf(r, ArrayBuffer)) && !T && "object" !== c.iterateIn ? h = r : (S = {}, c.addLength && (S.length = r.length), g = {
+              }) : (["function", "symbol"].includes(_typeof(r)) || "toJSON" in r || hasConstructorOf(r, e) || hasConstructorOf(r, Promise) || hasConstructorOf(r, ArrayBuffer)) && !T && "object" !== c.iterateIn ? b = r : (S = {}, c.addLength && (S.length = r.length), h = {
                 clone: S
-              }), w && w(), u.iterateNone) return null !== (j = S) && void 0 !== j ? j : h;
-              if (!S) return h;
+              }), _ && _(), u.iterateNone) return null !== (j = S) && void 0 !== j ? j : b;
+              if (!S) return b;
               if (c.iterateIn) {
                 var P = function _loop(n) {
-                  var a = {
-                    ownKeys: o(r, n)
+                  var o = {
+                    ownKeys: a(r, n)
                   };
-                  m(c, a, function () {
-                    var o = t + (t ? "." : "") + escapeKeyPathComponent(n),
-                      a = _encapsulate(o, r[n], Boolean(i), c, l, d);
-                    hasConstructorOf(a, e) ? l.push([o, a, Boolean(i), c, S, n, c.type]) : void 0 !== a && (S[n] = a);
+                  g(c, o, function () {
+                    var a = t + (t ? "." : "") + escapeKeyPathComponent(n),
+                      o = _encapsulate(a, r[n], Boolean(i), c, l, d);
+                    hasConstructorOf(o, e) ? l.push([a, o, Boolean(i), c, S, n, c.type]) : void 0 !== o && (S[n] = o);
                   });
                 };
-                for (var E in r) P(E);
-                w && w({
+                for (var x in r) P(x);
+                _ && _({
                   endIterateIn: !0,
                   end: !0
                 });
               } else n(r).forEach(function (n) {
-                var o = t + (t ? "." : "") + escapeKeyPathComponent(n);
-                m(c, {
+                var a = t + (t ? "." : "") + escapeKeyPathComponent(n);
+                g(c, {
                   ownKeys: !0
                 }, function () {
-                  var t = _encapsulate(o, r[n], Boolean(i), c, l, d);
-                  hasConstructorOf(t, e) ? l.push([o, t, Boolean(i), c, S, n, c.type]) : void 0 !== t && (S[n] = t);
+                  var t = _encapsulate(a, r[n], Boolean(i), c, l, d);
+                  hasConstructorOf(t, e) ? l.push([a, t, Boolean(i), c, S, n, c.type]) : void 0 !== t && (S[n] = t);
                 });
-              }), w && w({
+              }), _ && _({
                 endIterateOwn: !0,
                 end: !0
               });
               if (c.iterateUnsetNumeric) {
-                for (var C = r.length, x = function _loop2(n) {
+                for (var E = r.length, C = function _loop2(n) {
                     if (!(n in r)) {
-                      var o = "".concat(t).concat(t ? "." : "").concat(n);
-                      m(c, {
+                      var a = "".concat(t).concat(t ? "." : "").concat(n);
+                      g(c, {
                         ownKeys: !1
                       }, function () {
-                        var t = _encapsulate(o, void 0, Boolean(i), c, l, d);
-                        hasConstructorOf(t, e) ? l.push([o, t, Boolean(i), c, S, n, c.type]) : void 0 !== t && (S[n] = t);
+                        var t = _encapsulate(a, void 0, Boolean(i), c, l, d);
+                        hasConstructorOf(t, e) ? l.push([a, t, Boolean(i), c, S, n, c.type]) : void 0 !== t && (S[n] = t);
                       });
                     }
-                  }, k = 0; k < C; k++) x(k);
-                w && w({
+                  }, B = 0; B < E; B++) C(B);
+                _ && _({
                   endIterateUnsetNumeric: !0,
                   end: !0
                 });
               }
               return S;
             },
-            O = function replace(e, t, r, n, o, a, i) {
-              for (var c = o ? s.plainObjectReplacers : s.nonplainObjectReplacers, u = c.length; u--;) {
+            w = function replace(e, t, r, n, a, o, i) {
+              for (var c = a ? s.plainObjectReplacers : s.nonplainObjectReplacers, u = c.length; u--;) {
                 var y = c[u];
                 if (y.test(t, r)) {
                   var p = y.type;
@@ -6086,26 +6054,26 @@
                     replaced: !0
                   }), (l || !y.replaceAsync) && !y.replace) return i && i({
                     typeDetected: !0
-                  }), _(e, t, v && "readonly", r, n, a, p);
+                  }), O(e, t, v && "readonly", r, n, o, p);
                   i && i({
                     replacing: !0
                   });
-                  var b = void 0;
+                  var m = void 0;
                   if (l || !y.replaceAsync) {
                     if (void 0 === y.replace) throw new TypeError("Missing replacer");
-                    b = y.replace(t, r);
-                  } else b = y.replaceAsync(t, r);
-                  return _(e, b, v && "readonly", r, n, a, p);
+                    m = y.replace(t, r);
+                  } else m = y.replaceAsync(t, r);
+                  return O(e, m, v && "readonly", r, n, o, p);
                 }
               }
               return t;
             },
-            w = _("", t, v, null != r ? r : {}, d);
+            _ = O("", t, v, null != r ? r : {}, d);
           if (d.length) return l && u.throwOnBadSyncType ? function () {
             throw new TypeError("Sync method requested but async result obtained");
-          }() : Promise.resolve(g(w, d)).then(h);
+          }() : Promise.resolve(h(_, d)).then(b);
           if (!l && u.throwOnBadSyncType) throw new TypeError("Async method requested but sync result obtained");
-          return u.stringification && l ? [h(w)] : l ? h(w) : Promise.resolve(h(w));
+          return u.stringification && l ? [b(_)] : l ? b(_) : Promise.resolve(b(_));
         }
       }, {
         key: "encapsulateSync",
@@ -6128,7 +6096,7 @@
       }, {
         key: "revive",
         value: function revive(t, r) {
-          var o = this,
+          var a = this,
             i = _objectSpread2(_objectSpread2({
               sync: !0
             }, this.options), r),
@@ -6148,7 +6116,7 @@
           u.$ && isPlainObject(u.$) && (t = t.$, u = u.$, y = !1);
           var p = function executeReviver(e, t) {
               var r,
-                n = _slicedToArray(null !== (r = o.revivers[e]) && void 0 !== r ? r : [], 1)[0];
+                n = _slicedToArray(null !== (r = a.revivers[e]) && void 0 !== r ? r : [], 1)[0];
               if (!n) throw new Error("Unregistered type: " + e);
               if (c && !("revive" in n)) return t;
               if (!c && n.reviveAsync) return n.reviveAsync(t, f);
@@ -6160,69 +6128,69 @@
             return hasConstructorOf(e, s) ? void 0 : e;
           }
           var v,
-            b = function revivePlainObjects() {
+            m = function revivePlainObjects() {
               var r = [];
               if (!u) throw new Error("Found bad `types`");
               if (Object.entries(u).forEach(function (e) {
                 var t = _slicedToArray(e, 2),
                   n = t[0],
-                  a = t[1];
-                "#" !== a && [].concat(a).forEach(function (e) {
+                  o = t[1];
+                "#" !== o && [].concat(o).forEach(function (e) {
                   var t;
-                  _slicedToArray(null !== (t = o.revivers[e]) && void 0 !== t ? t : [null, {}], 2)[1].plain && (r.push({
+                  _slicedToArray(null !== (t = a.revivers[e]) && void 0 !== t ? t : [null, {}], 2)[1].plain && (r.push({
                     keypath: n,
                     type: e
                   }), delete u[n]);
                 });
               }), r.length) return r.sort(nestedPathsFirst).reduce(function reducer(r, n) {
-                var o = n.keypath,
-                  a = n.type;
+                var a = n.keypath,
+                  o = n.type;
                 if (isThenable(r)) return r.then(function (e) {
                   return reducer(e, {
-                    keypath: o,
-                    type: a
+                    keypath: a,
+                    type: o
                   });
                 });
-                var i = getByKeyPath(t, o);
-                if (hasConstructorOf(i = p(a, i), e)) return i.then(function (e) {
-                  var r = setAtKeyPath(t, o, e);
+                var i = getByKeyPath(t, a);
+                if (hasConstructorOf(i = p(o, i), e)) return i.then(function (e) {
+                  var r = setAtKeyPath(t, a, e);
                   r === e && (t = r);
                 });
-                var c = setAtKeyPath(t, o, i);
+                var c = setAtKeyPath(t, a, i);
                 c === i && (t = c);
               }, void 0);
             }();
-          return hasConstructorOf(b, e) ? v = b.then(function () {
+          return hasConstructorOf(m, e) ? v = m.then(function () {
             return t;
-          }) : (v = function _revive(t, r, o, i, c) {
+          }) : (v = function _revive(t, r, a, i, c) {
             if (!y || "$types" !== t) {
               var f = u[t],
-                v = a(r);
+                v = o(r);
               if (v || isPlainObject(r)) {
-                var b = v ? new Array(r.length) : {};
+                var m = v ? new Array(r.length) : {};
                 for (n(r).forEach(function (n) {
-                  var a = _revive(t + (t ? "." : "") + escapeKeyPathComponent(n), r[n], null != o ? o : b, b, n),
+                  var o = _revive(t + (t ? "." : "") + escapeKeyPathComponent(n), r[n], null != a ? a : m, m, n),
                     i = function set(e) {
-                      return hasConstructorOf(e, s) ? b[n] = void 0 : void 0 !== e && (b[n] = e), e;
+                      return hasConstructorOf(e, s) ? m[n] = void 0 : void 0 !== e && (m[n] = e), e;
                     };
-                  hasConstructorOf(a, e) ? d.push(a.then(function (e) {
+                  hasConstructorOf(o, e) ? d.push(o.then(function (e) {
                     return i(e);
-                  })) : i(a);
-                }), r = b; l.length;) {
-                  var h = _slicedToArray(l[0], 4),
-                    g = h[0],
-                    m = h[1],
-                    _ = h[2],
-                    O = h[3],
-                    w = getByKeyPath(g, m);
-                  if (void 0 === w) break;
-                  _[O] = w, l.splice(0, 1);
+                  })) : i(o);
+                }), r = m; l.length;) {
+                  var b = _slicedToArray(l[0], 4),
+                    h = b[0],
+                    g = b[1],
+                    O = b[2],
+                    w = b[3],
+                    _ = getByKeyPath(h, g);
+                  if (void 0 === _) break;
+                  O[w] = _, l.splice(0, 1);
                 }
               }
               if (!f) return r;
               if ("#" === f) {
-                var A = getByKeyPath(o, r.slice(1));
-                return void 0 === A && l.push([o, r.slice(1), i, c]), A;
+                var A = getByKeyPath(a, r.slice(1));
+                return void 0 === A && l.push([a, r.slice(1), i, c]), A;
               }
               return [].concat(f).reduce(function reducer(t, r) {
                 if (hasConstructorOf(t, e)) return t.then(function (e) {
@@ -6264,9 +6232,9 @@
         key: "register",
         value: function register(e, t) {
           var r = this,
-            o = null != t ? t : {},
+            a = null != t ? t : {},
             i = function R(e) {
-              a(e) ? e.forEach(function (e) {
+              o(e) ? e.forEach(function (e) {
                 return R(e);
               }) : n(e).forEach(function (t) {
                 var n;
@@ -6290,7 +6258,7 @@
                       return Object.assign(Object.create(l.prototype), e);
                     }
                   };
-                } else if (a(i)) {
+                } else if (o(i)) {
                   var f = _slicedToArray(i, 3);
                   i = {
                     test: f[0],
@@ -6304,7 +6272,7 @@
                     test: i.test.bind(i)
                   };
                   i.replace && (y.replace = i.replace.bind(i)), i.replaceAsync && (y.replaceAsync = i.replaceAsync.bind(i));
-                  var p = "number" == typeof o.fallback ? o.fallback : o.fallback ? 0 : Number.POSITIVE_INFINITY;
+                  var p = "number" == typeof a.fallback ? a.fallback : a.fallback ? 0 : Number.POSITIVE_INFINITY;
                   if (i.testPlainObjects ? r.plainObjectReplacers.splice(p, 0, y) : r.nonplainObjectReplacers.splice(p, 0, y), i.revive || i.reviveAsync) {
                     var d = {};
                     i.revive && (d.revive = i.revive.bind(i)), i.reviveAsync && (d.reviveAsync = i.reviveAsync.bind(i)), r.revivers[t] = [d, {
@@ -6328,21 +6296,21 @@
   for (var u = ["null", "boolean", "number", "string", "array", "object"], l = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", f = new Uint8Array(256), y = 0; y < 64; y++) f[l.codePointAt(y)] = y;
   var p = function encode(e, t, r) {
       null == r && (r = e.byteLength);
-      for (var n = new Uint8Array(e, t || 0, r), o = n.length, a = "", i = 0; i < o; i += 3) a += l[n[i] >> 2], a += l[(3 & n[i]) << 4 | n[i + 1] >> 4], a += l[(15 & n[i + 1]) << 2 | n[i + 2] >> 6], a += l[63 & n[i + 2]];
-      return o % 3 == 2 ? a = a.slice(0, -1) + "=" : o % 3 == 1 && (a = a.slice(0, -2) + "=="), a;
+      for (var n = new Uint8Array(e, 0, r), a = n.length, o = "", i = 0; i < a; i += 3) o += l[n[i] >> 2], o += l[(3 & n[i]) << 4 | n[i + 1] >> 4], o += l[(15 & n[i + 1]) << 2 | n[i + 2] >> 6], o += l[63 & n[i + 2]];
+      return a % 3 == 2 ? o = o.slice(0, -1) + "=" : a % 3 == 1 && (o = o.slice(0, -2) + "=="), o;
     },
-    d = function decode(e) {
-      var t = e.length;
-      if (t % 4) throw new Error("Bad base64 length: not divisible by four");
-      var r,
-        n,
-        o,
+    d = function decode(e, t) {
+      var r = e.length;
+      if (r % 4) throw new Error("Bad base64 length: not divisible by four");
+      var n,
         a,
-        i = .75 * e.length,
-        c = 0;
-      "=" === e[e.length - 1] && (i--, "=" === e[e.length - 2] && i--);
-      for (var s = new ArrayBuffer(i), u = new Uint8Array(s), l = 0; l < t; l += 4) r = f[e.codePointAt(l)], n = f[e.codePointAt(l + 1)], o = f[e.codePointAt(l + 2)], a = f[e.codePointAt(l + 3)], u[c++] = r << 2 | n >> 4, u[c++] = (15 & n) << 4 | o >> 2, u[c++] = (3 & o) << 6 | 63 & a;
-      return s;
+        o,
+        i,
+        c = .75 * e.length,
+        s = 0;
+      "=" === e[e.length - 1] && (c--, "=" === e[e.length - 2] && c--);
+      for (var u = new ArrayBuffer(c, t), l = new Uint8Array(u), y = 0; y < r; y += 4) n = f[e.codePointAt(y)], a = f[e.codePointAt(y + 1)], o = f[e.codePointAt(y + 2)], i = f[e.codePointAt(y + 3)], l[s++] = n << 2 | a >> 4, l[s++] = (15 & a) << 4 | o >> 2, l[s++] = (3 & o) << 6 | 63 & i;
+      return u;
     };
   var v = {
       arraybuffer: {
@@ -6354,16 +6322,21 @@
           var r = t.buffers.indexOf(e);
           return r > -1 ? {
             index: r
-          } : (t.buffers.push(e), p(e));
+          } : (t.buffers.push(e), {
+            s: p(e),
+            maxByteLength: e.maxByteLength
+          });
         },
         revive: function revive(e, t) {
-          if (t.buffers || (t.buffers = []), "object" == _typeof$2(e)) return t.buffers[e.index];
-          var r = d(e);
+          if (t.buffers || (t.buffers = []), Object.hasOwn(e, "index")) return t.buffers[e.index];
+          var r = d(e.s, {
+            maxByteLength: e.maxByteLength
+          });
           return t.buffers.push(r), r;
         }
       }
     },
-    b = {
+    m = {
       bigintObject: {
         test: function test(e) {
           return "object" == _typeof$2(e) && hasConstructorOf(e, BigInt);
@@ -6374,7 +6347,7 @@
         }
       }
     },
-    h = {
+    b = {
       bigint: {
         test: function test(e) {
           return "bigint" == typeof e;
@@ -6390,7 +6363,7 @@
     for (var _r = 0; _r < e.length; _r++) t[_r] = e.charCodeAt(_r);
     return t.buffer;
   }
-  var g = {
+  var h = {
     blob: {
       test: function test(e) {
         return "Blob" === toStringTag(e);
@@ -6425,7 +6398,7 @@
       }
     }
   };
-  var O = {
+  var w = {
       cryptokey: {
         test: function test(e) {
           return "CryptoKey" === toStringTag(e) && e.extractable;
@@ -6473,7 +6446,7 @@
         }
       }
     },
-    w = {
+    _ = {
       dataview: {
         test: function test(e) {
           return "DataView" === toStringTag(e);
@@ -6483,13 +6456,14 @@
             t = _ref2.byteOffset,
             r = _ref2.byteLength;
           n.buffers || (n.buffers = []);
-          var o = n.buffers.indexOf(e);
-          return o > -1 ? {
-            index: o,
+          var a = n.buffers.indexOf(e);
+          return a > -1 ? {
+            index: a,
             byteOffset: t,
             byteLength: r
           } : (n.buffers.push(e), {
             encoded: p(e),
+            maxByteLength: e.maxByteLength,
             byteOffset: t,
             byteLength: r
           });
@@ -6498,10 +6472,13 @@
           t.buffers || (t.buffers = []);
           var r = e.byteOffset,
             n = e.byteLength,
-            o = e.encoded,
-            a = e.index;
-          var i;
-          return "index" in e ? i = t.buffers[a] : (i = d(o), t.buffers.push(i)), new DataView(i, r, n);
+            a = e.encoded,
+            o = e.index,
+            i = e.maxByteLength;
+          var c;
+          return "index" in e ? c = t.buffers[o] : (c = d(a, void 0 === i ? i : {
+            maxByteLength: i
+          }), t.buffers.push(c)), new DataView(c, r, n);
         }
       }
     },
@@ -6520,25 +6497,152 @@
       }
     },
     S = {
+      domexception: {
+        test: function test(e) {
+          return "DOMException" === toStringTag(e);
+        },
+        replace: function replace(e) {
+          return {
+            name: e.name,
+            message: e.message
+          };
+        },
+        revive: function revive(_ref3) {
+          var e = _ref3.message,
+            t = _ref3.name;
+          return new DOMException(e, t);
+        }
+      }
+    },
+    j = {};
+  function create$5(e) {
+    j[e.name.toLowerCase()] = {
+      test: function test(t) {
+        return toStringTag(t) === e.name;
+      },
+      replace: function replace(e) {
+        return e.is2D ? {
+          a: e.a,
+          b: e.b,
+          c: e.c,
+          d: e.d,
+          e: e.e,
+          f: e.f
+        } : {
+          m11: e.m11,
+          m12: e.m12,
+          m13: e.m13,
+          m14: e.m14,
+          m21: e.m21,
+          m22: e.m22,
+          m23: e.m23,
+          m24: e.m24,
+          m31: e.m31,
+          m32: e.m32,
+          m33: e.m33,
+          m34: e.m34,
+          m41: e.m41,
+          m42: e.m42,
+          m43: e.m43,
+          m44: e.m44
+        };
+      },
+      revive: function revive(t) {
+        return Object.hasOwn(t, "a") ? new e([t.a, t.b, t.c, t.d, t.e, t.f]) : new e([t.m11, t.m12, t.m13, t.m14, t.m21, t.m22, t.m23, t.m24, t.m31, t.m32, t.m33, t.m34, t.m41, t.m42, t.m43, t.m44]);
+      }
+    };
+  }
+  "undefined" != typeof DOMMatrix && create$5(DOMMatrix), "undefined" != typeof DOMMatrixReadOnly && create$5(DOMMatrixReadOnly);
+  var T = {};
+  function create$4(e) {
+    T[e.name.toLowerCase()] = {
+      test: function test(t) {
+        return toStringTag(t) === e.name;
+      },
+      replace: function replace(e) {
+        return {
+          x: e.x,
+          y: e.y,
+          z: e.z,
+          w: e.w
+        };
+      },
+      revive: function revive(_ref4) {
+        var t = _ref4.x,
+          r = _ref4.y,
+          n = _ref4.z,
+          a = _ref4.w;
+        return new e(t, r, n, a);
+      }
+    };
+  }
+  "undefined" != typeof DOMPoint && create$4(DOMPoint), "undefined" != typeof DOMPointReadOnly && create$4(DOMPointReadOnly);
+  var I = {
+      domquad: {
+        test: function test(e) {
+          return "DOMQuad" === toStringTag(e);
+        },
+        replace: function replace(e) {
+          return {
+            p1: e.p1,
+            p2: e.p2,
+            p3: e.p3,
+            p4: e.p4
+          };
+        },
+        revive: function revive(_ref5) {
+          var e = _ref5.p1,
+            t = _ref5.p2,
+            r = _ref5.p3,
+            n = _ref5.p4;
+          return new DOMQuad(e, t, r, n);
+        }
+      }
+    },
+    N = {};
+  function create$3(e) {
+    N[e.name.toLowerCase()] = {
+      test: function test(t) {
+        return toStringTag(t) === e.name;
+      },
+      replace: function replace(e) {
+        return {
+          x: e.x,
+          y: e.y,
+          width: e.width,
+          height: e.height
+        };
+      },
+      revive: function revive(_ref6) {
+        var t = _ref6.x,
+          r = _ref6.y,
+          n = _ref6.width,
+          a = _ref6.height;
+        return new e(t, r, n, a);
+      }
+    };
+  }
+  "undefined" != typeof DOMRect && create$3(DOMRect), "undefined" != typeof DOMRectReadOnly && create$3(DOMRectReadOnly);
+  var P = {
       error: {
         test: function test(e) {
           return "Error" === toStringTag(e);
         },
-        replace: function replace(_ref3) {
-          var e = _ref3.name,
-            t = _ref3.message,
-            r = _ref3.cause,
-            n = _ref3.stack,
-            o = _ref3.fileName,
-            a = _ref3.lineNumber,
-            i = _ref3.columnNumber;
+        replace: function replace(_ref7) {
+          var e = _ref7.name,
+            t = _ref7.message,
+            r = _ref7.cause,
+            n = _ref7.stack,
+            a = _ref7.fileName,
+            o = _ref7.lineNumber,
+            i = _ref7.columnNumber;
           return {
             name: e,
             message: t,
             cause: r,
             stack: n,
-            fileName: o,
-            lineNumber: a,
+            fileName: a,
+            lineNumber: o,
             columnNumber: i
           };
         },
@@ -6548,43 +6652,42 @@
         }
       }
     },
-    j = {};
+    x = {};
   function create$2(e) {
-    j[e.name.toLowerCase()] = {
+    x[e.name.toLowerCase()] = {
       test: function test(t) {
         return hasConstructorOf(t, e);
       },
-      replace: function replace(_ref4) {
-        var e = _ref4.name,
-          t = _ref4.message,
-          r = _ref4.cause,
-          n = _ref4.stack,
-          o = _ref4.fileName,
-          a = _ref4.lineNumber,
-          i = _ref4.columnNumber,
-          c = _ref4.errors;
+      replace: function replace(_ref8) {
+        var e = _ref8.name,
+          t = _ref8.message,
+          r = _ref8.cause,
+          n = _ref8.stack,
+          a = _ref8.fileName,
+          o = _ref8.lineNumber,
+          i = _ref8.columnNumber,
+          c = _ref8.errors;
         return {
           name: e,
           message: t,
           cause: r,
           stack: n,
-          fileName: o,
-          lineNumber: a,
+          fileName: a,
+          lineNumber: o,
           columnNumber: i,
           errors: c
         };
       },
       revive: function revive(t) {
-        var r = "undefined" != typeof AggregateError && e === AggregateError,
-          n = r ? new e(t.errors, t.message) : new e(t.message);
-        return n.name = t.name, n.cause = t.cause, n.stack = t.stack, n.fileName = t.fileName, n.lineNumber = t.lineNumber, n.columnNumber = t.columnNumber, r && (n.errors = t.errors), n;
+        var r = "undefined" != typeof AggregateError && e === AggregateError ? new e(t.errors, t.message) : new e(t.message);
+        return r.name = t.name, r.cause = t.cause, r.stack = t.stack, r.fileName = t.fileName, r.lineNumber = t.lineNumber, r.columnNumber = t.columnNumber, r;
       }
     };
   }
   [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 T = {
+  var E = {
       file: {
         test: function test(e) {
           return "File" === toStringTag(e);
@@ -6599,11 +6702,11 @@
             lastModified: e.lastModified
           };
         },
-        revive: function revive(_ref5) {
-          var e = _ref5.name,
-            t = _ref5.type,
-            r = _ref5.stringContents,
-            n = _ref5.lastModified;
+        revive: function revive(_ref9) {
+          var e = _ref9.name,
+            t = _ref9.type,
+            r = _ref9.stringContents,
+            n = _ref9.lastModified;
           return new File([string2arraybuffer(r)], e, {
             type: t,
             lastModified: n
@@ -6626,8 +6729,8 @@
         }
       }
     },
-    I = {
-      file: T.file,
+    C = {
+      file: E.file,
       filelist: {
         test: function test(e) {
           return "FileList" === toStringTag(e);
@@ -6638,53 +6741,56 @@
           return t;
         },
         revive: function revive(e) {
-          var FileList = /*#__PURE__*/function (_Symbol$toStringTag) {
+          var FileList = /*#__PURE__*/function () {
             function FileList() {
               _classCallCheck$1(this, FileList);
               this._files = arguments[0], this.length = this._files.length;
             }
-            _createClass$1(FileList, [{
+            return _createClass$1(FileList, [{
               key: "item",
               value: function item(e) {
                 return this._files[e];
               }
             }, {
-              key: _Symbol$toStringTag,
+              key: Symbol.toStringTag,
               get: function get() {
                 return "FileList";
               }
             }]);
-            return FileList;
-          }(Symbol.toStringTag);
+          }();
           return new FileList(e);
         }
       }
     },
-    N = {
+    B = {
       imagebitmap: {
         test: function test(e) {
           return "ImageBitmap" === toStringTag(e) || e && e.dataset && "ImageBitmap" === e.dataset.toStringTag;
         },
         replace: function replace(e) {
           var t = document.createElement("canvas");
-          return t.getContext("2d").drawImage(e, 0, 0), t.toDataURL();
+          return t.getContext("2d").drawImage(e, 0, 0), {
+            width: e.width,
+            height: e.height,
+            dataURL: t.toDataURL()
+          };
         },
         revive: function revive(e) {
-          var t = document.createElement("canvas"),
+          var t = "undefined" == typeof OffscreenCanvas ? document.createElement("canvas") : new OffscreenCanvas(e.width, e.height),
             r = t.getContext("2d"),
             n = document.createElement("img");
           return n.addEventListener("load", function () {
             r.drawImage(n, 0, 0);
-          }), n.src = e, t;
+          }), n.src = e.dataURL, "undefined" == typeof OffscreenCanvas ? t : t.transferToImageBitmap();
         },
         reviveAsync: function reviveAsync(t) {
           var r = document.createElement("canvas"),
             n = r.getContext("2d"),
-            o = document.createElement("img");
-          return o.addEventListener("load", function () {
-            n.drawImage(o, 0, 0);
-          }), o.src = t, new e( /*#__PURE__*/function () {
-            var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(e, t) {
+            a = document.createElement("img");
+          return a.addEventListener("load", function () {
+            n.drawImage(a, 0, 0);
+          }), a.src = t.dataURL, new e( /*#__PURE__*/function () {
+            var _ref10 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(e, t) {
               return _regeneratorRuntime().wrap(function _callee2$(_context2) {
                 while (1) switch (_context2.prev = _context2.next) {
                   case 0:
@@ -6708,13 +6814,13 @@
               }, _callee2, null, [[0, 8]]);
             }));
             return function (_x3, _x4) {
-              return _ref6.apply(this, arguments);
+              return _ref10.apply(this, arguments);
             };
           }());
         }
       }
     },
-    P = {
+    k = {
       imagedata: {
         test: function test(e) {
           return "ImageData" === toStringTag(e);
@@ -6731,56 +6837,20 @@
         }
       }
     },
-    E = {
+    U = {
       infinity: {
         test: function test(e) {
           return e === Number.POSITIVE_INFINITY;
         },
-        replace: function replace(e) {
+        replace: function replace() {
           return "Infinity";
         },
-        revive: function revive(e) {
+        revive: function revive() {
           return Number.POSITIVE_INFINITY;
         }
       }
     },
-    C = {
-      test: function test(e) {
-        return hasConstructorOf(e, Intl.Collator);
-      },
-      replace: function replace(e) {
-        return e.resolvedOptions();
-      },
-      revive: function revive(e) {
-        return new Intl.Collator(e.locale, e);
-      }
-    },
-    x = {
-      IntlCollator: C,
-      IntlDateTimeFormat: {
-        test: function test(e) {
-          return hasConstructorOf(e, Intl.DateTimeFormat);
-        },
-        replace: function replace(e) {
-          return e.resolvedOptions();
-        },
-        revive: function revive(e) {
-          return new Intl.DateTimeFormat(e.locale, e);
-        }
-      },
-      IntlNumberFormat: {
-        test: function test(e) {
-          return hasConstructorOf(e, Intl.NumberFormat);
-        },
-        replace: function replace(e) {
-          return e.resolvedOptions();
-        },
-        revive: function revive(e) {
-          return new Intl.NumberFormat(e.locale, e);
-        }
-      }
-    },
-    k = {
+    D = {
       map: {
         test: function test(e) {
           return "Map" === toStringTag(e);
@@ -6793,46 +6863,46 @@
         }
       }
     },
-    B = {
+    K = {
       nan: {
         test: function test(e) {
           return Number.isNaN(e);
         },
-        replace: function replace(e) {
+        replace: function replace() {
           return "NaN";
         },
-        revive: function revive(e) {
+        revive: function revive() {
           return Number.NaN;
         }
       }
     },
-    U = {
+    F = {
       negativeInfinity: {
         test: function test(e) {
           return e === Number.NEGATIVE_INFINITY;
         },
-        replace: function replace(e) {
+        replace: function replace() {
           return "-Infinity";
         },
-        revive: function revive(e) {
+        revive: function revive() {
           return Number.NEGATIVE_INFINITY;
         }
       }
     },
-    K = {
+    $ = {
       negativeZero: {
         test: function test(e) {
           return Object.is(e, -0);
         },
-        replace: function replace(e) {
+        replace: function replace() {
           return 0;
         },
-        revive: function revive(e) {
+        revive: function revive() {
           return -0;
         }
       }
     },
-    F = {
+    V = {
       StringObject: {
         test: function test(e) {
           return "String" === toStringTag(e) && "object" == _typeof$2(e);
@@ -6861,7 +6931,7 @@
         }
       }
     },
-    M = {
+    q = {
       regexp: {
         test: function test(e) {
           return "RegExp" === toStringTag(e);
@@ -6872,14 +6942,14 @@
             flags: (e.global ? "g" : "") + (e.ignoreCase ? "i" : "") + (e.multiline ? "m" : "") + (e.sticky ? "y" : "") + (e.unicode ? "u" : "")
           };
         },
-        revive: function revive(_ref7) {
-          var e = _ref7.source,
-            t = _ref7.flags;
+        revive: function revive(_ref11) {
+          var e = _ref11.source,
+            t = _ref11.flags;
           return new RegExp(e, t);
         }
       }
     },
-    J = {
+    G = {
       set: {
         test: function test(e) {
           return "Set" === toStringTag(e);
@@ -6892,11 +6962,11 @@
         }
       }
     },
-    V = {};
+    H = {};
   "function" == typeof Int8Array && [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array].concat(_toConsumableArray("function" == typeof BigInt64Array ? [BigInt64Array, BigUint64Array] : [])).forEach(function (e) {
     return function create$1(e) {
       var t = e.name;
-      V[t.toLowerCase()] = {
+      H[t.toLowerCase()] = {
         test: function test(e) {
           return toStringTag(e) === t;
         },
@@ -6909,25 +6979,26 @@
       };
     }(e);
   });
-  var Y = {};
+  var z = {};
   "function" == typeof Int8Array && [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array].concat(_toConsumableArray("function" == typeof BigInt64Array ? [BigInt64Array, BigUint64Array] : [])).forEach(function (e) {
     return function create(e) {
       var t = e.name;
-      Y[t.toLowerCase()] = {
+      z[t.toLowerCase()] = {
         test: function test(e) {
           return toStringTag(e) === t;
         },
-        replace: function replace(_ref8, n) {
-          var e = _ref8.buffer,
-            t = _ref8.byteOffset,
-            r = _ref8.length;
+        replace: function replace(_ref12, n) {
+          var e = _ref12.buffer,
+            t = _ref12.byteOffset,
+            r = _ref12.length;
           n.buffers || (n.buffers = []);
-          var o = n.buffers.indexOf(e);
-          return o > -1 ? {
-            index: o,
+          var a = n.buffers.indexOf(e);
+          return a > -1 ? {
+            index: a,
             byteOffset: t,
             length: r
           } : (n.buffers.push(e), {
+            maxByteLength: e.maxByteLength,
             encoded: p(e),
             byteOffset: t,
             length: r
@@ -6936,31 +7007,34 @@
         revive: function revive(t, r) {
           r.buffers || (r.buffers = []);
           var n = t.byteOffset,
-            o = t.length,
-            a = t.encoded,
-            i = t.index;
-          var c;
-          return "index" in t ? c = r.buffers[i] : (c = d(a), r.buffers.push(c)), new e(c, n, o);
+            a = t.length,
+            o = t.encoded,
+            i = t.index,
+            c = t.maxByteLength;
+          var s;
+          return "index" in t ? s = r.buffers[i] : (s = d(o, void 0 === c ? void 0 : {
+            maxByteLength: c
+          }), r.buffers.push(s)), new e(s, n, a);
         }
       };
     }(e);
   });
-  var q = {
+  var Q = {
       undef: {
         test: function test(e, t) {
           return void 0 === e && (t.ownKeys || !("ownKeys" in t));
         },
-        replace: function replace(e) {
+        replace: function replace() {
           return 0;
         },
-        revive: function revive(e) {
+        revive: function revive() {
           return new s();
         }
       }
     },
-    W = {
+    X = {
       userObject: {
-        test: function test(e, t) {
+        test: function test(e) {
           return isUserObject(e);
         },
         replace: function replace(e) {
@@ -6971,7 +7045,7 @@
         }
       }
     },
-    G = [{
+    Z = [{
       arrayNonindexKeys: {
         testPlainObjects: !0,
         test: function test(e, t) {
@@ -6985,10 +7059,10 @@
         revive: function revive(e) {
           if (Array.isArray(e)) return e;
           var t = [];
-          return Object.entries(e).forEach(function (_ref9) {
-            var _ref10 = _slicedToArray$1(_ref9, 2),
-              e = _ref10[0],
-              r = _ref10[1];
+          return Object.entries(e).forEach(function (_ref13) {
+            var _ref14 = _slicedToArray$1(_ref13, 2),
+              e = _ref14[0],
+              r = _ref14[1];
             t[e] = r;
           }), t;
         }
@@ -6998,19 +7072,19 @@
         test: function test(e, t) {
           return void 0 === e && !1 === t.ownKeys;
         },
-        replace: function replace(e) {
+        replace: function replace() {
           return 0;
         },
-        revive: function revive(e) {}
+        revive: function revive() {}
       }
     }],
-    H = [B, E, U, K],
-    ee = [W, q, G, F, H, A, M, P, N, T, I, g, S, j].concat("function" == typeof Map ? k : [], "function" == typeof Set ? J : [], "function" == typeof ArrayBuffer ? v : [], "function" == typeof Uint8Array ? Y : [], "function" == typeof DataView ? w : [], "undefined" != typeof Intl ? x : [], "undefined" != typeof crypto ? O : [], "undefined" != typeof BigInt ? [h, b] : []),
-    te = ee.concat({
+    ee = [K, U, F, $],
+    oe = [X, Q, Z, V, ee, A, q, k, B, E, C, h, P, x].concat("function" == typeof Map ? D : [], "function" == typeof Set ? G : [], "function" == typeof ArrayBuffer ? v : [], "function" == typeof Uint8Array ? z : [], "function" == typeof DataView ? _ : [], "undefined" != typeof crypto ? w : [], "undefined" != typeof BigInt ? [b, m] : [], "undefined" != typeof DOMException ? S : [], "undefined" != typeof DOMRect ? N : [], "undefined" != typeof DOMPoint ? T : [], "undefined" != typeof DOMQuad ? I : [], "undefined" != typeof DOMMatrix ? j : []),
+    ie = oe.concat({
       checkDataCloneException: {
         test: function test(e) {
           var t = {}.toString.call(e).slice(8, -1);
-          if (["symbol", "function"].includes(_typeof$2(e)) || ["Arguments", "Module", "Error", "Promise", "WeakMap", "WeakSet", "Event", "MessageChannel"].includes(t) || e && "object" == _typeof$2(e) && "number" == typeof e.nodeType && "function" == typeof e.insertBefore) throw new DOMException("The object cannot be cloned.", "DataCloneError");
+          if (["symbol", "function"].includes(_typeof$2(e)) || ["Arguments", "Module", "Promise", "WeakMap", "WeakSet", "Event", "MessageChannel"].includes(t) || e && "object" == _typeof$2(e) && "number" == typeof e.nodeType && "function" == typeof e.insertBefore) throw new DOMException("The object cannot be cloned.", "DataCloneError");
           return !1;
         }
       }
@@ -7018,7 +7092,7 @@
 
   // See: http://stackoverflow.com/questions/42170826/categories-for-rejection-by-the-structured-cloning-algorithm
 
-  var typeson = new c().register(te);
+  var typeson = new c().register(ie);
 
   /**
    * @param {(preset: import('typeson-registry').Preset) =>
@@ -7026,7 +7100,7 @@
    * @returns {void}
    */
   function register(func) {
-    typeson = new c().register(func(te));
+    typeson = new c().register(func(ie));
   }
 
   /**
@@ -7175,7 +7249,7 @@
          * @returns {string}
          */
         get: function get() {
-          return '__pendingName' in me ? /** @type {string} */me.__pendingName : me.name;
+          return '__pendingName' in me ? ( /** @type {string} */me.__pendingName) : me.name;
         }
       });
       Object.defineProperty(me, 'name', {
@@ -7323,7 +7397,9 @@
         IDBIndex.__updateIndexList(store, tx, function () {
           // Add index entries for all existing records
           tx.executeSql('SELECT "key", "value" FROM ' + escapeStoreNameForSQL(storeName), [], function (tx, data) {
-            CFG.DEBUG && console.log('Adding existing ' + storeName + ' records to the ' + indexName + ' index');
+            if (CFG.DEBUG) {
+              console.log('Adding existing ' + storeName + ' records to the ' + indexName + ' index');
+            }
             addIndexEntry(0);
 
             /**
@@ -7349,7 +7425,7 @@
                     }
                     indexValues[indexKeyStr] = true;
                   }
-                  tx.executeSql('UPDATE ' + escapeStoreNameForSQL(storeName) + ' SET ' + escapeIndexNameForSQL(indexName) + ' = ? WHERE "key" = ?', [escapeSQLiteStatement(indexKeyStr), data.rows.item(i).key], function (tx, data) {
+                  tx.executeSql('UPDATE ' + escapeStoreNameForSQL(storeName) + ' SET ' + escapeIndexNameForSQL(indexName) + ' = ? WHERE "key" = ?', [escapeSQLiteStatement(indexKeyStr), data.rows.item(i).key], function () {
                     addIndexEntry(i + 1);
                   }, /** @type {SQLStatementErrorCallback} */error);
                 } catch (e) {
@@ -7398,7 +7474,9 @@
       } else {
         // For a new index, add a new column to the object store, then apply the index
         var sql = ['ALTER TABLE', escapedStoreNameSQL, 'ADD', escapedIndexNameSQL, 'BLOB'].join(' ');
-        CFG.DEBUG && console.log(sql);
+        if (CFG.DEBUG) {
+          console.log(sql);
+        }
         tx.executeSql(sql, [], addIndexSQL, /** @type {SQLStatementErrorCallback} */error);
       }
     });
@@ -7486,7 +7564,9 @@
         deleted: Boolean(idx.__deleted)
       };
     }
-    CFG.DEBUG && console.log('Updating the index list for ' + store.__currentName, indexList);
+    if (CFG.DEBUG) {
+      console.log('Updating the index list for ' + store.__currentName, indexList);
+    }
     tx.executeSql('UPDATE __sys__ SET "indexList" = ? WHERE "name" = ?', [JSON.stringify(indexList), escapeSQLiteStatement(store.__currentName)], function () {
       success(store);
     }, /** @type {SQLStatementErrorCallback} */failure);
@@ -7520,13 +7600,12 @@
       throw createDOMException('DataError', 'No key or range was specified');
     }
     var fetchArgs = buildFetchIndexDataSQL(nullDisallowed, me, range, opType, false);
-    return (/** @type {import('./IDBTransaction.js').IDBTransactionFull} */me.objectStore.transaction.__addToTransactionQueue(function () {
-        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-          args[_key] = arguments[_key];
-        }
-        executeFetchIndexData.apply(void 0, [count].concat(_toConsumableArray(fetchArgs), args));
-      }, undefined, me)
-    );
+    return /** @type {import('./IDBTransaction.js').IDBTransactionFull} */me.objectStore.transaction.__addToTransactionQueue(function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      executeFetchIndexData.apply(void 0, [count].concat(_toConsumableArray(fetchArgs), args));
+    }, undefined, me);
   };
 
   /**
@@ -7697,17 +7776,25 @@
       // We don't query for indexes as we already have the info
       // This approach has the advantage of auto-deleting indexes via the DROP TABLE
       var sql = 'CREATE TABLE ' + escapedTmpStoreNameSQL + '(' + listColInfoToPreserve + escapedNewIndexNameSQL + ' ' + newNameType + ')';
-      CFG.DEBUG && console.log(sql);
+      if (CFG.DEBUG) {
+        console.log(sql);
+      }
       tx.executeSql(sql, [], function () {
         var sql = 'INSERT INTO ' + escapedTmpStoreNameSQL + '(' + listColsToPreserve + escapedNewIndexNameSQL + ') SELECT ' + listColsToPreserve + escapeIndexNameForSQL(oldName) + ' FROM ' + escapedStoreNameSQL;
-        CFG.DEBUG && console.log(sql);
+        if (CFG.DEBUG) {
+          console.log(sql);
+        }
         tx.executeSql(sql, [], function () {
           var sql = 'DROP TABLE ' + escapedStoreNameSQL;
-          CFG.DEBUG && console.log(sql);
+          if (CFG.DEBUG) {
+            console.log(sql);
+          }
           tx.executeSql(sql, [], function () {
             var sql = 'ALTER TABLE ' + escapedTmpStoreNameSQL + ' RENAME TO ' + escapedStoreNameSQL;
-            CFG.DEBUG && console.log(sql);
-            tx.executeSql(sql, [], function (tx, data) {
+            if (CFG.DEBUG) {
+              console.log(sql);
+            }
+            tx.executeSql(sql, [], function (tx) {
               if (!CFG.useSQLiteIndexes) {
                 finish();
                 return;
@@ -7717,40 +7804,39 @@
                 return new SyncPromise(function (resolve, reject) {
                   var escapedIndexToRecreate = sqlQuote(escapedStoreNameSQL.slice(1, -1) + '^5' + escapedIndexNameSQL.slice(1, -1));
                   // const sql = 'DROP INDEX IF EXISTS ' + escapedIndexToRecreate;
-                  // CFG.DEBUG && console.log(sql);
+                  // if (CFG.DEBUG) { console.log(sql); }
                   // tx.executeSql(sql, [], function () {
                   var sql = 'CREATE INDEX ' + escapedIndexToRecreate + ' ON ' + escapedStoreNameSQL + '(' + escapedIndexNameSQL + ')';
-                  CFG.DEBUG && console.log(sql);
-                  tx.executeSql(sql, [], resolve, /* eslint-disable no-extra-parens -- TS */
-                  /** @type {SQLStatementErrorCallback} */
+                  if (CFG.DEBUG) {
+                    console.log(sql);
+                  }
+                  tx.executeSql(sql, [], resolve, /** @type {SQLStatementErrorCallback} */
                   function (tx, err) {
                     reject(err);
-                  }
-                  /* eslint-enable no-extra-parens -- TS */);
+                  });
                   // }, function (tx, err) {
                   //    reject(err);
                   // });
                 });
               });
-
               indexCreations.push(new SyncPromise(function (resolve, reject) {
                 var escapedIndexToRecreate = sqlQuote('sk_' + escapedStoreNameSQL.slice(1, -1));
                 // Chrome erring here if not dropped first; Node does not
                 var sql = 'DROP INDEX IF EXISTS ' + escapedIndexToRecreate;
-                CFG.DEBUG && console.log(sql);
+                if (CFG.DEBUG) {
+                  console.log(sql);
+                }
                 tx.executeSql(sql, [], function () {
                   var sql = 'CREATE INDEX ' + escapedIndexToRecreate + ' ON ' + escapedStoreNameSQL + '("key")';
-                  CFG.DEBUG && console.log(sql);
-                  tx.executeSql(sql, [], resolve, /* eslint-disable no-extra-parens -- TS */
-                  /** @type {SQLStatementErrorCallback} */
+                  if (CFG.DEBUG) {
+                    console.log(sql);
+                  }
+                  tx.executeSql(sql, [], resolve, /** @type {SQLStatementErrorCallback} */
                   function (tx, err) {
-                    /* eslint-enable no-extra-parens -- TS */
                     reject(err);
                   });
-                }, /* eslint-disable no-extra-parens -- TS */
-                /** @type {SQLStatementErrorCallback} */
+                }, /** @type {SQLStatementErrorCallback} */
                 function (tx, err) {
-                  /* eslint-enable no-extra-parens -- TS */
                   reject(err);
                 });
               }));
@@ -7810,12 +7896,14 @@
       sql.push('LIMIT', String(count));
     }
     var isCount = opType === 'count';
-    CFG.DEBUG && console.log('Trying to fetch data for Index', sql.join(' '), sqlValues);
+    if (CFG.DEBUG) {
+      console.log('Trying to fetch data for Index', sql.join(' '), sqlValues);
+    }
     tx.executeSql(sql.join(' '), sqlValues, function (tx, data) {
       var records = [];
       var recordCount = 0;
       var decode$1 = isCount ? function () {/* */} : opType === 'key'
-      // eslint-disable-next-line operator-linebreak -- JSDoc
+      // eslint-disable-next-line @stylistic/operator-linebreak -- JSDoc
       ?
       /**
        * @param {{
@@ -7827,7 +7915,7 @@
         // Key.convertValueToKey(record.key); // Already validated before storage
         return _decode(unescapeSQLiteResponse(record.key));
       }
-      // eslint-disable-next-line operator-linebreak -- JSDoc
+      // eslint-disable-next-line @stylistic/operator-linebreak -- JSDoc
       :
       /**
        * @param {{
@@ -7869,13 +7957,12 @@
           if (record) {
             records.push(decode$1(record));
             if (unboundedDisallowed) {
-              return "break";
+              return 1; // break
             }
           }
         };
         for (var i = 0; i < data.rows.length; i++) {
-          var _ret = _loop();
-          if (_ret === "break") break;
+          if (_loop()) break;
         }
       } else {
         for (var _i = 0; _i < data.rows.length; _i++) {
@@ -7925,7 +8012,9 @@
         sql.push('AND (');
         /** @type {import('./Key.js').KeyPathArray} */
         range.forEach(function (innerKey, i) {
-          if (i > 0) sql.push('OR');
+          if (i > 0) {
+            sql.push('OR');
+          }
           sql.push(escapeIndexNameForSQL(index.name), "LIKE ? ESCAPE '^' ");
           sqlValues.push('%' + sqlLIKEEscape( /** @type {string} */_encode(innerKey, index.multiEntry)) + '%');
         });
@@ -8073,20 +8162,24 @@
           me.__pendingName = oldName;
           var sql = 'UPDATE __sys__ SET "name" = ? WHERE "name" = ?';
           var sqlValues = [escapeSQLiteStatement(name), escapeSQLiteStatement(oldName)];
-          CFG.DEBUG && console.log(sql, sqlValues);
+          if (CFG.DEBUG) {
+            console.log(sql, sqlValues);
+          }
           /** @type {import('./IDBTransaction.js').IDBTransactionFull} */
           me.transaction.__addNonRequestToTransactionQueue(function objectStoreClear(tx, args, success, error) {
-            tx.executeSql(sql, sqlValues, function (tx, data) {
+            tx.executeSql(sql, sqlValues, function (tx) {
               // This SQL preserves indexes per https://www.sqlite.org/lang_altertable.html
               var sql = 'ALTER TABLE ' + escapeStoreNameForSQL(oldName) + ' RENAME TO ' + escapeStoreNameForSQL(name);
-              CFG.DEBUG && console.log(sql);
-              tx.executeSql(sql, [], function (tx, data) {
+              if (CFG.DEBUG) {
+                console.log(sql);
+              }
+              tx.executeSql(sql, [], function () {
                 delete me.__pendingName;
                 success();
               });
             }, function (tx, err) {
               error(err);
-              return true;
+              return false;
             });
           });
         }
@@ -8165,15 +8258,19 @@
        * @returns {boolean}
        */
       function error(tx, err) {
-        CFG.DEBUG && console.log(err);
+        if (CFG.DEBUG) {
+          console.log(err);
+        }
         failure(createDOMException('UnknownError', 'Could not create object store "' + storeName + '"', err));
-        return true;
+        return false;
       }
       var escapedStoreNameSQL = escapeStoreNameForSQL(storeName);
       // key INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL UNIQUE
       var sql = ['CREATE TABLE', escapedStoreNameSQL, '(key BLOB', store.autoIncrement ? 'UNIQUE, inc INTEGER PRIMARY KEY AUTOINCREMENT' : 'PRIMARY KEY', ', value BLOB)'].join(' ');
-      CFG.DEBUG && console.log(sql);
-      tx.executeSql(sql, [], function (tx, data) {
+      if (CFG.DEBUG) {
+        console.log(sql);
+      }
+      tx.executeSql(sql, [], function (tx) {
         /**
          * @returns {void}
          */
@@ -8227,9 +8324,11 @@
        * @returns {boolean}
        */
       function error(tx, err) {
-        CFG.DEBUG && console.log(err);
+        if (CFG.DEBUG) {
+          console.log(err);
+        }
         failure(createDOMException('UnknownError', 'Could not delete ObjectStore', err));
-        return true;
+        return false;
       }
       tx.executeSql('SELECT "name" FROM __sys__ WHERE "name" = ?', [escapeSQLiteStatement(store.__currentName)], function (tx, data) {
         if (data.rows.length > 0) {
@@ -8346,6 +8445,7 @@
     if (me.autoIncrement) {
       // If auto-increment and no valid primaryKey found on the keyPath, get and set the new value, and use
       if (key === undefined) {
+        // @ts-expect-error Due to re-exporting `Key.d.ts` file (needed for `node_modules` imports)
         generateKeyForStore(tx, me, function (failure, key, oldCn) {
           if (failure) {
             failCb(createDOMException('ConstraintError', 'The key generator\'s current number has reached the maximum safe integer limit'));
@@ -8359,6 +8459,7 @@
           success(key, oldCn);
         }, failCb);
       } else {
+        // @ts-expect-error Due to re-exporting `Key.d.ts` file (needed for `node_modules` imports)
         possiblyUpdateKeyGenerator(tx, me, key, keyCloneThenSuccess, failCb);
       }
       // Not auto-increment
@@ -8481,13 +8582,15 @@
       sqlEnd.push('?)');
       insertSqlValues.push(escapeSQLiteStatement(encoded));
       var insertSql = sqlStart.join(' ') + sqlEnd.join(' ');
-      CFG.DEBUG && console.log('SQL for adding', insertSql, insertSqlValues);
-      tx.executeSql(insertSql, insertSqlValues, function (tx, data) {
+      if (CFG.DEBUG) {
+        console.log('SQL for adding', insertSql, insertSqlValues);
+      }
+      tx.executeSql(insertSql, insertSqlValues, function () {
         success(clonedKeyOrCurrentNumber);
       }, function (tx, err) {
         // Should occur for `add` operation
         error(createDOMException('ConstraintError', /** @type {string} */err.message, err));
-        return true;
+        return false;
       });
       return undefined;
     })["catch"](function (err) {
@@ -8500,6 +8603,7 @@
         error(err);
       }
       if (typeof oldCn === 'number') {
+        // @ts-expect-error Due to re-exporting `Key.d.ts` file (needed for `node_modules` imports)
         assignCurrentNumber(tx, me, oldCn, fail, fail);
         return null;
       }
@@ -8544,7 +8648,7 @@
    * @this {IDBObjectStoreFull}
    * @returns {import('./IDBRequest.js').IDBRequestFull}
    */
-  IDBObjectStore.prototype.put = function (value /*, key */) {
+  IDBObjectStore.prototype.put = function (value /* , key */) {
     var me = this;
     // eslint-disable-next-line prefer-rest-params
     var key = arguments[1];
@@ -8583,11 +8687,13 @@
     var sql = 'DELETE FROM ' + escapeStoreNameForSQL(me.__currentName) + ' WHERE "key" = ?';
     var encodedKey = /** @type {string} */_encode(key);
     tx.executeSql(sql, [escapeSQLiteStatement(encodedKey)], function (tx, data) {
-      CFG.DEBUG && console.log('Did the row with the', key, 'exist?', data.rowsAffected);
+      if (CFG.DEBUG) {
+        console.log('Did the row with the', key, 'exist?', data.rowsAffected);
+      }
       cb(tx);
     }, function (tx, err) {
       error(err);
-      return true;
+      return false;
     });
   };
 
@@ -8666,46 +8772,51 @@
       sql.push('LIMIT', String(count));
     }
     var sqlStr = sql.join(' ');
-    return (/** @type {import('./IDBTransaction.js').IDBTransactionFull} */me.transaction.__addToTransactionQueue(function objectStoreGet(tx, args, success, error) {
-        CFG.DEBUG && console.log('Fetching', me.__currentName, sqlValues);
-        tx.executeSql(sqlStr, sqlValues, function (tx, data) {
-          CFG.DEBUG && console.log('Fetched data', data);
-          var ret;
-          try {
-            // Opera can't deal with the try-catch here.
-            if (data.rows.length === 0) {
-              if (getAll) {
-                success([]);
-              } else {
-                success();
-              }
-              return;
-            }
-            ret = [];
-            if (getKey) {
-              for (var i = 0; i < data.rows.length; i++) {
-                // Key.convertValueToKey(data.rows.item(i).key); // Already validated before storage
-                ret.push(_decode(unescapeSQLiteResponse(data.rows.item(i).key), false));
-              }
+    return /** @type {import('./IDBTransaction.js').IDBTransactionFull} */me.transaction.__addToTransactionQueue(function objectStoreGet(tx, args, success, error) {
+      if (CFG.DEBUG) {
+        console.log('Fetching', me.__currentName, sqlValues);
+      }
+      tx.executeSql(sqlStr, sqlValues, function (tx, data) {
+        if (CFG.DEBUG) {
+          console.log('Fetched data', data);
+        }
+        var ret;
+        try {
+          // Opera can't deal with the try-catch here.
+          if (data.rows.length === 0) {
+            if (getAll) {
+              success([]);
             } else {
-              for (var _i = 0; _i < data.rows.length; _i++) {
-                ret.push(decode(unescapeSQLiteResponse(data.rows.item(_i).value)));
-              }
+              success();
             }
-            if (!getAll) {
-              ret = ret[0];
+            return;
+          }
+          ret = [];
+          if (getKey) {
+            for (var i = 0; i < data.rows.length; i++) {
+              // Key.convertValueToKey(data.rows.item(i).key); // Already validated before storage
+              ret.push(_decode(unescapeSQLiteResponse(data.rows.item(i).key), false));
+            }
+          } else {
+            for (var _i = 0; _i < data.rows.length; _i++) {
+              ret.push(decode(unescapeSQLiteResponse(data.rows.item(_i).value)));
             }
-          } catch (e) {
-            // If no result is returned, or error occurs when parsing JSON
-            CFG.DEBUG && console.log(e);
           }
-          success(ret);
-        }, function (tx, err) {
-          error(err);
-          return true;
-        });
-      }, undefined, me)
-    );
+          if (!getAll) {
+            ret = ret[0];
+          }
+        } catch (e) {
+          // If no result is returned, or error occurs when parsing JSON
+          if (CFG.DEBUG) {
+            console.log(e);
+          }
+        }
+        success(ret);
+      }, function (tx, err) {
+        error(err);
+        return false;
+      });
+    }, undefined, me);
   };
 
   /**
@@ -8786,21 +8897,23 @@
     var sqlValues = [];
     setSQLForKeyRange(range, sqlQuote('key'), sqlArr, sqlValues);
     var sql = sqlArr.join(' ');
-    return (/** @type {import('./IDBTransaction.js').IDBTransactionFull} */me.transaction.__addToTransactionQueue(function objectStoreDelete(tx, args, success, error) {
-        CFG.DEBUG && console.log('Deleting', me.__currentName, sqlValues);
-        tx.executeSql(sql, sqlValues, function (tx, data) {
-          CFG.DEBUG && console.log('Deleted from database', data.rowsAffected);
-          me.__cursors.forEach(function (cursor) {
-            cursor.__invalidateCache(); // Delete
-          });
-
-          success();
-        }, function (tx, err) {
-          error(err);
-          return true;
+    return /** @type {import('./IDBTransaction.js').IDBTransactionFull} */me.transaction.__addToTransactionQueue(function objectStoreDelete(tx, args, success, error) {
+      if (CFG.DEBUG) {
+        console.log('Deleting', me.__currentName, sqlValues);
+      }
+      tx.executeSql(sql, sqlValues, function (tx, data) {
+        if (CFG.DEBUG) {
+          console.log('Deleted from database', data.rowsAffected);
+        }
+        me.__cursors.forEach(function (cursor) {
+          cursor.__invalidateCache(); // Delete
         });
-      }, undefined, me)
-    );
+        success();
+      }, function (tx, err) {
+        error(err);
+        return false;
+      });
+    }, undefined, me);
   };
 
   /**
@@ -8816,20 +8929,20 @@
     IDBTransaction.__assertActive(me.transaction);
     /** @type {import('./IDBTransaction.js').IDBTransactionFull} */
     me.transaction.__assertWritable();
-    return (/** @type {import('./IDBTransaction.js').IDBTransactionFull} */me.transaction.__addToTransactionQueue(function objectStoreClear(tx, args, success, error) {
-        tx.executeSql('DELETE FROM ' + escapeStoreNameForSQL(me.__currentName), [], function (tx, data) {
-          CFG.DEBUG && console.log('Cleared all records from database', data.rowsAffected);
-          me.__cursors.forEach(function (cursor) {
-            cursor.__invalidateCache(); // Clear
-          });
-
-          success();
-        }, function (tx, err) {
-          error(err);
-          return true;
+    return /** @type {import('./IDBTransaction.js').IDBTransactionFull} */me.transaction.__addToTransactionQueue(function objectStoreClear(tx, args, success, error) {
+      tx.executeSql('DELETE FROM ' + escapeStoreNameForSQL(me.__currentName), [], function (tx, data) {
+        if (CFG.DEBUG) {
+          console.log('Cleared all records from database', data.rowsAffected);
+        }
+        me.__cursors.forEach(function (cursor) {
+          cursor.__invalidateCache(); // Clear
         });
-      }, undefined, me)
-    );
+        success();
+      }, function (tx, err) {
+        error(err);
+        return false;
+      });
+    }, undefined, me);
   };
 
   /**
@@ -9292,7 +9405,6 @@
       this.__setOptions({
         legacyOutputDidListenersThrowFlag: true // Event hook for IndexedB
       });
-
       this.__transactions = [];
 
       /** @type {{[key: string]: IDBObjectStore}} */
@@ -9507,6 +9619,7 @@
     me.close();
     var ct = 0;
     me.__transactions.forEach(function (trans) {
+      // eslint-disable-next-line camelcase -- Clear API
       trans.on__abort = function () {
         ct++;
         if (ct === me.__transactions.length) {
@@ -9818,14 +9931,14 @@
               deleteTables(i + 1);
             }, function () {
               deleteTables(i + 1);
-              return true;
+              return false;
             });
           }
         })(0);
-      }, function (e) {
+      }, function () {
         // __sys__ table does not exist, but that does not mean delete did not happen
         databaseDeleted();
-        return true;
+        return false;
       });
     });
   }
@@ -9851,7 +9964,9 @@
      */
     function sysDbCreateError(tx, err) {
       var er = webSQLErrback( /** @type {SQLError} */err || tx);
-      CFG.DEBUG && console.log('Error in sysdb transaction - when creating dbVersions', err);
+      if (CFG.DEBUG) {
+        console.log('Error in sysdb transaction - when creating dbVersions', err);
+      }
       failure(er);
     }
     if (sysdb) {
@@ -9966,9 +10081,9 @@
      */
     function dbCreateError(tx, err) {
       if (calledDbCreateError) {
-        return true;
+        return false;
       }
-      var er = err ? webSQLErrback(err) : /** @type {Error} */tx;
+      var er = err ? webSQLErrback(err) : ( /** @type {Error} */tx);
       calledDbCreateError = true;
       // Re: why bubbling here (and how cancelable is only really relevant for `window.onerror`) see: https://github.com/w3c/IndexedDB/issues/86
       var evt = createEvent('error', er, {
@@ -9979,7 +10094,7 @@
       req.__error = er;
       req.__result = undefined; // Must be undefined if an error per `result` getter
       req.dispatchEvent(evt);
-      return true;
+      return false;
     }
 
     /**
@@ -10052,7 +10167,6 @@
               // In browser, should auto-commit
               cb(); // eslint-disable-line promise/no-callback-in-promise
             };
-
             sysdb.transaction(function (systx) {
               /**
                * @returns {void}
@@ -10066,7 +10180,7 @@
                 req.__result = connection;
                 connection.__upgradeTransaction = req.__transaction = req.__result.__versionTransaction = IDBTransaction.__createInstance(req.__result, req.__result.objectStoreNames, 'versionchange');
                 req.__done = true;
-                req.transaction.__addNonRequestToTransactionQueue(function onupgradeneeded(tx, args, finished, error) {
+                req.transaction.__addNonRequestToTransactionQueue(function onupgradeneeded(tx, args, finished /* , error */) {
                   req.dispatchEvent(e);
                   if (e.__legacyOutputDidListenersThrowError) {
                     logError('Error', 'An error occurred in an upgradeneeded handler attached to request chain', /** @type {Error} */e.__legacyOutputDidListenersThrowError); // We do nothing else with this error as per spec
@@ -10075,6 +10189,8 @@
                   }
                   finished();
                 });
+
+                // eslint-disable-next-line camelcase -- Clear API
                 req.transaction.on__beforecomplete = function (ev) {
                   connection.__upgradeTransaction = null;
                   /** @type {import('./IDBDatabase.js').IDBDatabaseFull} */
@@ -10084,9 +10200,11 @@
                       ev.complete();
                       req.__transaction = null;
                     });
-                    return true;
+                    return false;
                   });
                 };
+
+                // eslint-disable-next-line camelcase -- Clear API
                 req.transaction.on__preabort = function () {
                   connection.__upgradeTransaction = null;
                   // We ensure any cache is deleted before any request error events fire and try to reopen
@@ -10096,6 +10214,8 @@
                     }
                   }
                 };
+
+                // eslint-disable-next-line camelcase -- Clear API
                 req.transaction.on__abort = function () {
                   req.__transaction = null;
                   // `readyState` and `result` will be reset anyways by `dbCreateError` but we follow spec.
@@ -10109,13 +10229,15 @@
                         cleanupDatabaseResources(me.__openDatabase, name, escapedDatabaseName, dbCreateError.bind(null, err),
                         // @ts-expect-error It's ok
                         reportError || dbCreateError);
-                        return true;
+                        return false;
                       }
                       dbCreateError(err);
-                      return true;
+                      return false;
                     });
                   });
                 };
+
+                // eslint-disable-next-line camelcase -- Clear API
                 req.transaction.on__complete = function () {
                   if ( /** @type {import('./IDBDatabase.js').IDBDatabaseFull} */req.__result.__closePending) {
                     req.__transaction = null;
@@ -10142,7 +10264,6 @@
                   // });
                 };
               }
-
               if (oldVersion === 0) {
                 systx.executeSql('INSERT INTO dbVersions VALUES (?,?)', [sqlSafeName, version], versionSet, dbCreateError);
               } else {
@@ -10223,7 +10344,7 @@
         }, /** @type {SQLStatementErrorCallback} */dbCreateError);
       }, dbCreateError);
     }
-    addRequestToConnectionQueue(req, name, /* origin */undefined, function (req) {
+    addRequestToConnectionQueue(req, name, /* origin */undefined, function () {
       var latestCachedVersion;
       if (useDatabaseCache) {
         if (!(name in websqlDBCache)) {
@@ -10280,7 +10401,6 @@
     } catch (err) {
       throw err; // throw new TypeError('You have supplied a database name which does not match the currently supported configuration, possibly due to a length limit enforced for Node compatibility.');
     }
-
     var useMemoryDatabase = typeof CFG.memoryDatabase === 'string';
     var useDatabaseCache = CFG.cacheDatabaseInstances !== false || useMemoryDatabase;
     var req = IDBOpenDBRequest.__createInstance();
@@ -10308,7 +10428,7 @@
      */
     function dbError(tx, err) {
       if (calledDBError || err === true) {
-        return true;
+        return false;
       }
       var er = webSQLErrback( /** @type {SQLError} */err || tx);
       sysdbFinishedCbDelete(true, function () {
@@ -10323,7 +10443,7 @@
         req.dispatchEvent(e);
         calledDBError = true;
       });
-      return true;
+      return false;
     }
     addRequestToConnectionQueue(req, name, /* origin */undefined, function (req) {
       createSysDB(me.__openDatabase, function () {
@@ -10350,7 +10470,6 @@
             if (useDatabaseCache && name in websqlDBCache) {
               delete websqlDBCache[name]; // New calls will treat as though never existed
             }
-
             delete me.__connections[name];
             completeDatabaseDelete();
           });
@@ -10452,12 +10571,12 @@
        */
       function dbGetDatabaseNamesError(tx, err) {
         if (calledDbCreateError) {
-          return true;
+          return false;
         }
         var er = err ? webSQLErrback( /** @type {SQLError} */err) : tx;
         calledDbCreateError = true;
         reject(er);
-        return true;
+        return false;
       }
       createSysDB(me.__openDatabase, function () {
         sysdb.readTransaction(function (sysReadTx) {
@@ -10772,25 +10891,33 @@
       sql.push('LIMIT', String(recordsToLoad));
     }
     var sqlStr = sql.join(' ');
-    CFG.DEBUG && console.log(sqlStr, sqlValues);
+    if (CFG.DEBUG) {
+      console.log(sqlStr, sqlValues);
+    }
     tx.executeSql(sqlStr, sqlValues, function (tx, data) {
       if (me.__count) {
         success(undefined, data.rows.length, undefined);
       } else if (data.rows.length > 1) {
         me.__prefetchedIndex = 0;
         me.__prefetchedData = data.rows;
-        CFG.DEBUG && console.log('Preloaded ' + me.__prefetchedData.length + ' records for cursor');
+        if (CFG.DEBUG) {
+          console.log('Preloaded ' + me.__prefetchedData.length + ' records for cursor');
+        }
         me.__decode(data.rows.item(0), success);
       } else if (data.rows.length === 1) {
         me.__decode(data.rows.item(0), success);
       } else {
-        CFG.DEBUG && console.log('Reached end of cursors');
+        if (CFG.DEBUG) {
+          console.log('Reached end of cursors');
+        }
         success(undefined, undefined, undefined);
       }
     }, function (tx, err) {
-      CFG.DEBUG && console.log('Could not execute Cursor.continue', sqlStr, sqlValues);
+      if (CFG.DEBUG) {
+        console.log('Could not execute Cursor.continue', sqlStr, sqlValues);
+      }
       error(err);
-      return true;
+      return false;
     });
   };
   var leftBracketRegex = /\[/g;
@@ -10808,7 +10935,9 @@
   IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, error) {
     var me = this;
     if (me.__prefetchedData && me.__prefetchedData.length === me.__prefetchedIndex) {
-      CFG.DEBUG && console.log('Reached end of multiEntry cursor');
+      if (CFG.DEBUG) {
+        console.log('Reached end of multiEntry cursor');
+      }
       success(undefined, undefined, undefined);
       return;
     }
@@ -10860,7 +10989,9 @@
       }
     }
     var sqlStr = sql.join(' ');
-    CFG.DEBUG && console.log(sqlStr, sqlValues);
+    if (CFG.DEBUG) {
+      console.log(sqlStr, sqlValues);
+    }
     tx.executeSql(sqlStr, sqlValues, function (tx, data) {
       if (data.rows.length > 0) {
         if (me.__count) {
@@ -10889,8 +11020,8 @@
                * @type {RowItemNonNull}
                */
               var clone = {
-                matchingKey: /** @type {string} */
-                _encode(matchingKey, true),
+                matchingKey: ( /** @type {string} */
+                _encode(matchingKey, true)),
                 key: _rowItem.key
               };
               clone[me.__keyColumnName] = _rowItem[me.__keyColumnName];
@@ -10932,23 +11063,33 @@
               return this.data[index];
             }
           };
-          CFG.DEBUG && console.log('Preloaded ' + me.__prefetchedData.length + ' records for multiEntry cursor');
+          if (CFG.DEBUG) {
+            console.log('Preloaded ' + me.__prefetchedData.length + ' records for multiEntry cursor');
+          }
           me.__decode(rows[0], success);
         } else if (rows.length === 1) {
-          CFG.DEBUG && console.log('Reached end of multiEntry cursor');
+          if (CFG.DEBUG) {
+            console.log('Reached end of multiEntry cursor');
+          }
           me.__decode(rows[0], success);
         } else {
-          CFG.DEBUG && console.log('Reached end of multiEntry cursor');
+          if (CFG.DEBUG) {
+            console.log('Reached end of multiEntry cursor');
+          }
           success(undefined, undefined, undefined);
         }
       } else {
-        CFG.DEBUG && console.log('Reached end of multiEntry cursor');
+        if (CFG.DEBUG) {
+          console.log('Reached end of multiEntry cursor');
+        }
         success(undefined, undefined, undefined);
       }
     }, function (tx, err) {
-      CFG.DEBUG && console.log('Could not execute Cursor.continue', sqlStr, sqlValues);
+      if (CFG.DEBUG) {
+        console.log('Could not execute Cursor.continue', sqlStr, sqlValues);
+      }
       error(err);
-      return true;
+      return false;
     });
   };
 
@@ -11037,7 +11178,7 @@
     var key = _decode(encKey, me.__multiEntryIndex);
     var val = me.__valueDecoder.decode(encVal);
     var primaryKey = _decode(encPrimaryKey);
-    callback(key, val, primaryKey, encKey /*, encVal, encPrimaryKey */);
+    callback(key, val, primaryKey, encKey /* , encVal, encPrimaryKey */);
   };
 
   /**
@@ -11249,7 +11390,9 @@
    */
   IDBCursor.prototype.update = function (valueToUpdate) {
     var me = this;
-    if (!arguments.length) throw new TypeError('A value must be passed to update()');
+    if (!arguments.length) {
+      throw new TypeError('A value must be passed to update()');
+    }
     IDBTransaction.__assertActive(me.__store.transaction);
     /** @type {import('./IDBTransaction.js').IDBTransactionFull} */
     me.__store.transaction.__assertWritable();
@@ -11303,28 +11446,29 @@
     if (me.__keyOnly) {
       throw createDOMException('InvalidStateError', 'This cursor method cannot be called when the key only flag has been set.');
     }
-    return (/** @type {import('./IDBTransaction.js').IDBTransactionFull} */this.__store.transaction.__addToTransactionQueue(function cursorDelete(tx, args, success, error) {
-        me.__find(undefined, undefined, tx, /** @type {KeySuccess} */
-        function (key, value, primaryKey) {
-          var sql = 'DELETE FROM  ' + escapeStoreNameForSQL(me.__store.__currentName) + ' WHERE "key" = ?';
-          CFG.DEBUG && console.log(sql, key, primaryKey);
-          // Key.convertValueToKey(primaryKey); // Already checked when entered
-          tx.executeSql(sql, [escapeSQLiteStatement( /** @type {string} */_encode(primaryKey))], function (tx, data) {
-            if (data.rowsAffected === 1) {
-              // We don't invalidate the cache (as we don't access it anymore
-              //    and it will set the index off)
-              success(undefined);
-            } else {
-              // @ts-expect-error Apparently ok
-              error('No rows with key found' + key);
-            }
-          }, function (tx, data) {
-            error(data);
-            return true;
-          });
-        }, error);
-      }, undefined, me)
-    );
+    return /** @type {import('./IDBTransaction.js').IDBTransactionFull} */this.__store.transaction.__addToTransactionQueue(function cursorDelete(tx, args, success, error) {
+      me.__find(undefined, undefined, tx, /** @type {KeySuccess} */
+      function (key, value, primaryKey) {
+        var sql = 'DELETE FROM  ' + escapeStoreNameForSQL(me.__store.__currentName) + ' WHERE "key" = ?';
+        if (CFG.DEBUG) {
+          console.log(sql, key, primaryKey);
+        }
+        // Key.convertValueToKey(primaryKey); // Already checked when entered
+        tx.executeSql(sql, [escapeSQLiteStatement( /** @type {string} */_encode(primaryKey))], function (tx, data) {
+          if (data.rowsAffected === 1) {
+            // We don't invalidate the cache (as we don't access it anymore
+            //    and it will set the index off)
+            success(undefined);
+          } else {
+            // @ts-expect-error Apparently ok
+            error('No rows with key found' + key);
+          }
+        }, function (tx, data) {
+          error(data);
+          return false;
+        });
+      }, error);
+    }, undefined, me);
   };
   IDBCursor.prototype[Symbol.toStringTag] = 'IDBCursorPrototype';
   defineReadonlyOuterInterface(IDBCursor.prototype, ['source', 'direction', 'key', 'primaryKey', 'request']);
@@ -11476,10 +11620,7 @@
    * @returns {ShimmedObject}
    */
   function setGlobalVars(idb, initialConfig) {
-    if (initialConfig) {
-      setConfig(initialConfig);
-    }
-    var IDB = idb || globalThis || {};
+    var IDB = globalThis || {};
     /**
      * @typedef {any} AnyClass
      */
@@ -11522,8 +11663,7 @@
             }
           } else {
             var o = _defineAccessor("get", {}, name, function () {
-              return (/** @type {AnyFunction} */ /** @type {PropertyDescriptor} */propDesc.get.call(this)
-              );
+              return /** @type {AnyFunction} */( /** @type {PropertyDescriptor} */propDesc.get).call(this);
             });
             desc = /** @type {PropertyDescriptor} */
             Object.getOwnPropertyDescriptor(o, name);
@@ -11538,7 +11678,9 @@
 
       // @ts-expect-error It's ok
       if (IDB[name] !== value) {
-        typeof console !== 'undefined' && console.warn && console.warn('Unable to shim ' + name);
+        if (typeof console !== 'undefined' && console.warn) {
+          console.warn('Unable to shim ' + name);
+        }
       }
     }
     if (CFG.win.openDatabase !== undefined) {
@@ -11717,8 +11859,7 @@
       IDB.IDBCursor = IDB.IDBCursor || 'webkitIDBCursor' in IDB && IDB.webkitIDBCursor;
       IDB.IDBKeyRange = IDB.IDBKeyRange || 'webkitIDBKeyRange' in IDB && IDB.webkitIDBKeyRange;
     }
-    return (/** @type {ShimmedObject} */IDB
-    );
+    return /** @type {ShimmedObject} */IDB;
   }
 
   /* eslint-env browser, worker */