indexeddbshim 12.0.0 → 13.0.0

package/dist/indexeddbshim-Key.js

@@ -1,4 +1,4 @@
-/*! indexeddbshim - v11.0.0 - 4/29/2023 */
+/*! indexeddbshim - v13.0.0 - 12/7/2023 */
 
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
@@ -6,41 +6,41 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.IDBKeyUtils = {}));
 })(this, (function (exports) { 'use strict';
 
-  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;
+  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) {
+          if (Object(t) !== t) return;
+          f = !1;
+        } 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 _typeof(obj) {
+  function _typeof(o) {
     "@babel/helpers - typeof";
 
-    return _typeof = "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(obj);
+    return _typeof = "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(o);
   }
   function _slicedToArray(arr, i) {
     return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
@@ -128,8 +128,73 @@
     };
   }
 
+  /* eslint-disable jsdoc/valid-types -- https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/147 */
+  /**
+   * @typedef {T[keyof T]} ValueOf<T>
+   * @template T
+   */
+  /* eslint-enable jsdoc/valid-types -- https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/147 */
+
+  /**
+   * @typedef {{unlink: (path: string, cb: import('fs').NoParamCallback) => void}} FSApi
+   */
+
+  /**
+   * @typedef {{
+   *   DEBUG: boolean,
+   *   cacheDatabaseInstances: boolean,
+   *   autoName: boolean,
+   *   fullIDLSupport: boolean,
+   *   checkOrigin: boolean,
+   *   cursorPreloadPackSize: number,
+   *   UnicodeIDStart: string,
+   *   UnicodeIDContinue: string,
+   *   registerSCA: (
+   *     preset: import('typeson').Preset
+   *   ) => import('typeson').Preset,
+   *   avoidAutoShim: boolean,
+   *   win: {
+   *     openDatabase: (name: string, version: string, displayName: string, estimatedSize: number) => import('websql-configurable').default
+   *   },
+   *   DEFAULT_DB_SIZE: number,
+   *   useSQLiteIndexes: boolean,
+   *   fs: FSApi,
+   *   addNonIDBGlobals: boolean,
+   *   replaceNonIDBGlobals: boolean,
+   *   escapeDatabaseName: (name: string) => string,
+   *   unescapeDatabaseName: (name: string) => string,
+   *   databaseCharacterEscapeList: string|false,
+   *   databaseNameLengthLimit: number|false,
+   *   escapeNFDForDatabaseNames: boolean,
+   *   addSQLiteExtension: boolean,
+   *   memoryDatabase: string,
+   *   deleteDatabaseFiles: boolean,
+   *   databaseBasePath: string,
+   *   sysDatabaseBasePath: string,
+   *   sqlBusyTimeout: number,
+   *   sqlTrace: () => void,
+   *   sqlProfile: () => void,
+   *   createIndexes: boolean
+   * }} ConfigValues
+   */
+
+  /**
+   * @typedef {ValueOf<ConfigValues>} ConfigValue
+   */
+
+  /** @type {{[key: string]: ConfigValue}} */
   var map = {};
-  var CFG = {};
+  var CFG = /** @type {ConfigValues} */{};
+
+  /**
+   * @typedef {keyof ConfigValues} KeyofConfigValues
+   */
+
+  /**
+   * @typedef {KeyofConfigValues[]} Config
+   */
+
+  /** @type {Config} */
   [
   // Boolean for verbose reporting
   'DEBUG',
@@ -240,8 +305,14 @@
   //   defaults to `true`
   'addSQLiteExtension',
   // Various types of in-memory databases that can auto-delete
-  ['memoryDatabase', function (val) {
-    if (!/^(?::memory:|file::memory:(\?(?:[\0-"\$-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?(#(?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?)?$/.test(val)) {
+  ['memoryDatabase',
+  /**
+   * @param {string} val
+   * @throws {TypeError}
+   * @returns {void}
+   */
+  function (val) {
+    if (!/^(?::memory:|file::memory:(\?(?:[\0-"\$-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?(#(?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?)?$/.test( /** @type {string} */val)) {
       throw new TypeError('`memoryDatabase` must be the empty string, ":memory:", or a ' + '"file::memory:[?queryString][#hash] URL".');
     }
   }],
@@ -254,8 +325,11 @@
   // Defaults to 1000
   'sqlTrace',
   // Callback not used by default
-  'sqlProfile' // Callback not used by default
-  ].forEach(function (prop) {
+  'sqlProfile',
+  // Callback not used by default
+
+  'createIndexes'].forEach(function (prop) {
+    /** @type {(val: any) => void} */
     var validator;
     if (Array.isArray(prop)) {
       var _prop = prop;
@@ -283,10 +357,25 @@
    * @returns {DOMException}
    */
   function createNativeDOMException(name, message) {
+    // @ts-expect-error It's ok
     return new DOMException.prototype.constructor(message, name || 'DOMException');
   }
 
   // From web-platform-tests testharness.js name_code_map (though not in new spec)
+
+  /**
+   * @typedef {"IndexSizeError"|"HierarchyRequestError"|"WrongDocumentError"|
+   * "InvalidCharacterError"|"NoModificationAllowedError"|"NotFoundError"|
+   * "NotSupportedError"|"InUseAttributeError"|"InvalidStateError"|
+   * "SyntaxError"|"InvalidModificationError"|"NamespaceError"|
+   * "InvalidAccessError"|"TypeMismatchError"|"SecurityError"|
+   * "NetworkError"|"AbortError"|"URLMismatchError"|"QuotaExceededError"|
+   * "TimeoutError"|"InvalidNodeTypeError"|"DataCloneError"|"EncodingError"|
+   * "NotReadableError"|"UnknownError"|"ConstraintError"|"DataError"|
+   * "TransactionInactiveError"|"ReadOnlyError"|"VersionError"|
+   * "OperationError"|"NotAllowedError"} Code
+   */
+
   var codes = {
     IndexSizeError: 1,
     HierarchyRequestError: 3,
@@ -321,6 +410,18 @@
     OperationError: 0,
     NotAllowedError: 0
   };
+
+  /**
+   * @typedef {"INDEX_SIZE_ERR"|"DOMSTRING_SIZE_ERR"|"HIERARCHY_REQUEST_ERR"|
+   * "WRONG_DOCUMENT_ERR"|"INVALID_CHARACTER_ERR"|"NO_DATA_ALLOWED_ERR"|
+   * "NO_MODIFICATION_ALLOWED_ERR"|"NOT_FOUND_ERR"|"NOT_SUPPORTED_ERR"|
+   * "INUSE_ATTRIBUTE_ERR"|"INVALID_STATE_ERR"|"SYNTAX_ERR"|
+   * "INVALID_MODIFICATION_ERR"|"NAMESPACE_ERR"|"INVALID_ACCESS_ERR"|
+   * "VALIDATION_ERR"|"TYPE_MISMATCH_ERR"|"SECURITY_ERR"|"NETWORK_ERR"|
+   * "ABORT_ERR"|"URL_MISMATCH_ERR"|"QUOTA_EXCEEDED_ERR"|"TIMEOUT_ERR"|
+   * "INVALID_NODE_TYPE_ERR"|"DATA_CLONE_ERR"} LegacyCode
+   */
+
   var legacyCodes = {
     INDEX_SIZE_ERR: 1,
     DOMSTRING_SIZE_ERR: 2,
@@ -351,13 +452,18 @@
 
   /**
    *
-   * @returns {DOMException}
+   * @returns {typeof DOMException}
    */
   function createNonNativeDOMExceptionClass() {
+    /**
+     * @param {string|undefined} message
+     * @param {Code|LegacyCode} name
+     * @returns {void}
+     */
     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[name] : legacyCodes[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
@@ -388,17 +494,30 @@
     // Necessary for W3C tests which complains if `DOMException` has properties on its "own" prototype
 
     // class DummyDOMException extends Error {}; // Sometimes causing problems in Node
-    // eslint-disable-next-line func-name-matching
+    /* eslint-disable func-name-matching */
+    /**
+     * @class
+     */
     var DummyDOMException = function DOMException() {/* */};
+    /* eslint-enable func-name-matching */
     DummyDOMException.prototype = Object.create(Error.prototype); // Intended for subclassing
+    /** @type {const} */
     ['name', 'message'].forEach(function (prop) {
       Object.defineProperty(DummyDOMException.prototype, prop, {
         enumerable: true,
+        /**
+         * @this {DOMException}
+         * @returns {string}
+         */
         get: function get() {
-          if (!(this instanceof DOMException || this instanceof DummyDOMException || this instanceof Error)) {
+          if (!(this instanceof DOMException ||
+          // @ts-expect-error Just checking
+          this instanceof DummyDOMException ||
+          // @ts-expect-error Just checking
+          this instanceof Error)) {
             throw new TypeError('Illegal invocation');
           }
-          return this['_' + prop];
+          return this[prop === 'name' ? '_name' : '_message'];
         }
       });
     });
@@ -410,12 +529,16 @@
         throw new TypeError('Illegal invocation');
       }
     });
+    // @ts-expect-error It's ok
     DOMException.prototype = new DummyDOMException();
     DOMException.prototype[Symbol.toStringTag] = 'DOMExceptionPrototype';
     Object.defineProperty(DOMException, 'prototype', {
       writable: false
     });
-    Object.keys(codes).forEach(function (codeName) {
+    var keys = Object.keys(codes);
+
+    /** @type {(keyof codes)[]} */
+    keys.forEach(function (codeName) {
       Object.defineProperty(DOMException.prototype, codeName, {
         enumerable: true,
         configurable: false,
@@ -427,6 +550,7 @@
         value: codes[codeName]
       });
     });
+    /** @type {(keyof legacyCodes)[]} */
     Object.keys(legacyCodes).forEach(function (codeName) {
       Object.defineProperty(DOMException.prototype, codeName, {
         enumerable: true,
@@ -445,6 +569,8 @@
       enumerable: false,
       value: DOMException
     });
+
+    // @ts-expect-error We don't need all its properties
     return DOMException;
   }
   var ShimNonNativeDOMException = createNonNativeDOMExceptionClass();
@@ -459,23 +585,38 @@
     return new ShimNonNativeDOMException(message, name);
   }
 
+  /**
+   * @typedef {{
+   *   message: string|DOMString
+   * }} ErrorLike
+   */
+
   /**
    * Logs detailed error information to the console.
    * @param {string} name
    * @param {string} message
-   * @param {string|Error|null} error
+   * @param {string|ErrorLike|boolean|null} [error]
    * @returns {void}
    */
   function logError(name, message, error) {
     if (CFG.DEBUG) {
-      if (error && error.message) {
-        error = error.message;
-      }
+      var msg = error && _typeof(error) === 'object' && error.message ? error.message : ( /** @type {string} */error);
       var method = typeof console.error === 'function' ? 'error' : 'log';
-      console[method](name + ': ' + message + '. ' + (error || ''));
-      console.trace && console.trace();
+      console[method](name + ': ' + message + '. ' + (msg || ''));
+      if (console.trace) {
+        console.trace();
+      }
     }
   }
+
+  /**
+   * @typedef {any} ArbitraryValue
+   */
+
+  /**
+   * @param {ArbitraryValue} obj
+   * @returns {boolean}
+   */
   function isErrorOrDOMErrorOrDOMException(obj) {
     return obj && _typeof(obj) === 'object' &&
     // We don't use util.isObj here as mutual dependency causing problems in Babel with browser
@@ -492,17 +633,43 @@
       useNativeDOMException = true;
     }
   } catch (e) {}
-  var createDOMException = useNativeDOMException ? function (name, message, error) {
+  var createDOMException = useNativeDOMException
+  // eslint-disable-next-line @stylistic/operator-linebreak -- Need JSDoc
+  ?
+  /**
+  * @param {string} name
+  * @param {string} message
+  * @param {ErrorLike} [error]
+  * @returns {DOMException}
+  */
+  function (name, message, error) {
     logError(name, message, error);
     return createNativeDOMException(name, message);
-  } : function (name, message, error) {
+  }
+  // eslint-disable-next-line @stylistic/operator-linebreak -- Need JSDoc
+  :
+  /**
+  * @param {string} name
+  * @param {string} message
+  * @param {ErrorLike} [error]
+  * @returns {Error}
+  */
+  function (name, message, error) {
     logError(name, message, error);
     return createNonNativeDOMException(name, message);
   };
 
+  /**
+   * @typedef {number} Integer
+   */
+
+  /**
+   * @param {string} arg
+   * @returns {string}
+   */
   function escapeUnmatchedSurrogates(arg) {
     // http://stackoverflow.com/a/6701665/271577
-    return arg.replace(/((?:[\uD800-\uDBFF](?![\uDC00-\uDFFF])))(?!(?:(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]))|(^|(?:[\0-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]))((?:(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]))/g, function (_, unmatchedHighSurrogate, precedingLow, unmatchedLowSurrogate) {
+    return arg.replaceAll(/((?:[\uD800-\uDBFF](?![\uDC00-\uDFFF])))(?!(?:(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]))|(^|(?:[\0-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]))((?:(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]))/g, function (_, unmatchedHighSurrogate, precedingLow, unmatchedLowSurrogate) {
       // Could add a corresponding surrogate for compatibility with `node-sqlite3`: http://bugs.python.org/issue12569 and http://stackoverflow.com/a/6701665/271577
       //   but Chrome having problems
       if (unmatchedHighSurrogate) {
@@ -512,41 +679,80 @@
     });
   }
 
-  // The escaping of unmatched surrogates was needed by Chrome but not Node
+  /**
+   * The escaping of unmatched surrogates was needed by Chrome but not Node.
+   * @param {string} arg
+   * @returns {string}
+   */
   function escapeSQLiteStatement(arg) {
-    return escapeUnmatchedSurrogates(arg.replace(/\^/g, '^^').replace(/\0/g, '^0'));
+    return escapeUnmatchedSurrogates(arg.replaceAll('^', '^^').replaceAll('\0', '^0'));
   }
+
+  /**
+   *
+   * @param {AnyValue} obj
+   * @returns {obj is object}
+   */
   function isObj(obj) {
-    return obj && _typeof(obj) === 'object';
+    return obj !== null && _typeof(obj) === 'object';
   }
+
+  /**
+   *
+   * @param {object} obj
+   * @returns {boolean}
+   */
   function isDate(obj) {
-    return isObj(obj) && typeof obj.getDate === 'function';
+    return isObj(obj) && 'getDate' in obj && typeof obj.getDate === 'function';
   }
+
+  /**
+   *
+   * @param {object} obj
+   * @returns {boolean}
+   */
   function isBlob(obj) {
-    return isObj(obj) && typeof obj.size === 'number' && typeof obj.slice === 'function' && !('lastModified' in obj);
+    return isObj(obj) && 'size' in obj && typeof obj.size === 'number' && 'slice' in obj && typeof obj.slice === 'function' && !('lastModified' in obj);
   }
+
+  /**
+   *
+   * @param {object} obj
+   * @returns {boolean}
+   */
   function isFile(obj) {
-    return isObj(obj) && typeof obj.name === 'string' && typeof obj.slice === 'function' && 'lastModified' in obj;
+    return isObj(obj) && 'name' in obj && typeof obj.name === 'string' && 'slice' in obj && typeof obj.slice === 'function' && 'lastModified' in obj;
   }
+
+  /**
+   *
+   * @param {AnyValue} obj
+   * @returns {boolean}
+   */
   function isBinary(obj) {
-    return isObj(obj) && typeof obj.byteLength === 'number' && (typeof obj.slice === 'function' ||
+    return isObj(obj) && 'byteLength' in obj && typeof obj.byteLength === 'number' && ('slice' in obj && typeof obj.slice === 'function' ||
     // `TypedArray` (view on buffer) or `ArrayBuffer`
-    typeof obj.getFloat64 === 'function' // `DataView` (view on buffer)
+    'getFloat64' in obj && typeof obj.getFloat64 === 'function' // `DataView` (view on buffer)
     );
   }
+
+  /**
+   * @param {AnyValue} v
+   * @returns {v is null|undefined}
+   */
   function isNullish(v) {
     return v === null || v === undefined;
   }
 
   /**
    * Compares two keys.
-   * @param first
-   * @param second
-   * @returns {number}
+   * @param {import('./Key.js').Key} first
+   * @param {import('./Key.js').Key} second
+   * @returns {0|1|-1}
    */
   function cmp(first, second) {
-    var encodedKey1 = _encode(first);
-    var encodedKey2 = _encode(second);
+    var encodedKey1 = /** @type {string} */_encode(first);
+    var encodedKey2 = /** @type {string} */_encode(second);
     var result = encodedKey1 > encodedKey2 ? 1 : encodedKey1 === encodedKey2 ? 0 : -1;
     if (CFG.DEBUG) {
       // verify that the keys encoded correctly
@@ -574,12 +780,57 @@
   }
 
   /**
-   * @module Key
+   * @typedef {NodeJS.TypedArray|DataView} ArrayBufferView
+   */
+
+  /**
+   * @typedef {ArrayBufferView|ArrayBuffer} BufferSource
+   */
+
+  /**
+   * @typedef {"number"|"date"|"string"|"binary"|"array"} KeyType
+   */
+
+  /**
+   * @typedef {any} Value
+   */
+
+  /**
+   * @typedef {any} Key
+   * @todo Specify possible value more precisely
+   */
+
+  /**
+   * @typedef {KeyPath[]} KeyPathArray
+   */
+  /**
+   * @typedef {string|KeyPathArray} KeyPath
+   */
+
+  /**
+  * @typedef {object} KeyValueObject
+  * @property {KeyType|"NaN"|"null"|"undefined"|"boolean"|"object"|"symbol"|
+  *   "function"|"bigint"} type If not `KeyType`, indicates invalid value
+  * @property {Value} [value]
+  * @property {boolean} [invalid]
+  * @property {string} [message]
+  * @todo Specify acceptable `value` more precisely
+  */
+
+  /**
+   * @typedef {number|string|Date|ArrayBuffer} ValueTypePrimitive
+   */
+  /**
+   * @typedef {ValueType[]} ValueTypeArray
+   */
+  /**
+   * @typedef {ValueTypePrimitive|ValueTypeArray} ValueType
    */
 
   /**
    * Encodes the keys based on their types. This is required to maintain collations
    * We leave space for future keys.
+   * @type {{[key: string]: Integer|string}}
    */
   var keyTypeToEncodedChar = {
     invalid: 100,
@@ -589,14 +840,14 @@
     binary: 500,
     array: 600
   };
-  var keyTypes = Object.keys(keyTypeToEncodedChar);
+  var keyTypes = /** @type {(KeyType|"invalid")[]} */Object.keys(keyTypeToEncodedChar);
   keyTypes.forEach(function (k) {
-    keyTypeToEncodedChar[k] = String.fromCodePoint(keyTypeToEncodedChar[k]);
+    keyTypeToEncodedChar[k] = String.fromCodePoint( /** @type {number} */keyTypeToEncodedChar[k]);
   });
   var encodedCharToKeyType = keyTypes.reduce(function (o, k) {
     o[keyTypeToEncodedChar[k]] = k;
     return o;
-  }, {});
+  }, /** @type {{[key: string]: KeyType|"invalid"}} */{});
 
   /**
    * The sign values for numbers, ordered from least to greatest.
@@ -608,12 +859,23 @@
    *  - "positiveInfinity": Sorts above all other values.
    */
   var signValues = ['negativeInfinity', 'bigNegative', 'smallNegative', 'smallPositive', 'bigPositive', 'positiveInfinity'];
+
+  /**
+   * @typedef {any} AnyValue
+   */
+
   var types = {
     invalid: {
-      encode: function encode(key) {
+      /**
+       * @returns {string}
+       */
+      encode: function encode() {
         return keyTypeToEncodedChar.invalid + '-';
       },
-      decode: function decode(key) {
+      /**
+       * @returns {undefined}
+       */
+      decode: function decode() {
         return undefined;
       }
     },
@@ -630,6 +892,10 @@
     number: {
       // The encode step checks for six numeric cases and generates 14-digit encoded
       // sign-exponent-mantissa strings.
+      /**
+       * @param {number} key
+       * @returns {string}
+       */
       encode: function encode(key) {
         var key32 = key === Number.MIN_VALUE
         // Mocha test `IDBFactory/cmp-spec.js` exposed problem for some
@@ -685,6 +951,10 @@
       // The decode step must interpret the sign, reflip values encoded as the 32's complements,
       // apply signs to the exponent and mantissa, do the base-32 power operation, and return
       // the original JavaScript number values.
+      /**
+       * @param {string} key
+       * @returns {number}
+       */
       decode: function decode(key) {
         var sign = Number(key.slice(2, 3));
         var exponent = key.slice(3, 5);
@@ -721,18 +991,28 @@
     // This effectively doubles the size of every string, but it ensures that when two arrays of strings are compared,
     // the indexes of each string's characters line up with each other.
     string: {
+      /**
+       * @param {string} key
+       * @param {boolean} [inArray]
+       * @returns {string}
+       */
       encode: function encode(key, inArray) {
         if (inArray) {
           // prepend each character with a dash, and append a space to the end
-          key = key.replace(/((?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]))/g, '-$1') + ' ';
+          key = key.replaceAll(/((?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]))/g, '-$1') + ' ';
         }
         return keyTypeToEncodedChar.string + '-' + key;
       },
+      /**
+       * @param {string} key
+       * @param {boolean} [inArray]
+       * @returns {string}
+       */
       decode: function decode(key, inArray) {
         key = key.slice(2);
         if (inArray) {
           // remove the space at the end, and the dash before each character
-          key = key.slice(0, -1).replace(/\x2D((?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]))/g, '$1');
+          key = key.slice(0, -1).replaceAll(/\x2D((?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]))/g, '$1');
         }
         return key;
       }
@@ -741,6 +1021,10 @@
     // An extra, value is added to each array during encoding to make
     //  empty arrays sort correctly.
     array: {
+      /**
+       * @param {ValueTypeArray} key
+       * @returns {string}
+       */
       encode: function encode(key) {
         var encoded = [];
         var _iterator = _createForOfIteratorHelper(key.entries()),
@@ -761,6 +1045,10 @@
         encoded.push(keyTypeToEncodedChar.invalid + '-'); // append an extra item, so empty arrays sort correctly
         return keyTypeToEncodedChar.array + '-' + JSON.stringify(encoded);
       },
+      /**
+       * @param {string} key
+       * @returns {ValueTypeArray}
+       */
       decode: function decode(key) {
         var decoded = JSON.parse(key.slice(2));
         decoded.pop(); // remove the extra item
@@ -774,21 +1062,37 @@
     },
     // Dates are encoded as ISO 8601 strings, in UTC time zone.
     date: {
+      /**
+       * @param {Date} key
+       * @returns {string}
+       */
       encode: function encode(key) {
         return keyTypeToEncodedChar.date + '-' + key.toJSON();
       },
+      /**
+       * @param {string} key
+       * @returns {Date}
+       */
       decode: function decode(key) {
         return new Date(key.slice(2));
       }
     },
     binary: {
       // `ArrayBuffer`/Views on buffers (`TypedArray` or `DataView`)
+      /**
+       * @param {BufferSource} key
+       * @returns {string}
+       */
       encode: function encode(key) {
         return keyTypeToEncodedChar.binary + '-' + (key.byteLength ? _toConsumableArray(getCopyBytesHeldByBufferSource(key)).map(function (b) {
           return String(b).padStart(3, '0');
         }) // e.g., '255,005,254,000,001,033'
         : '');
       },
+      /**
+       * @param {string} key
+       * @returns {ArrayBuffer}
+       */
       decode: function decode(key) {
         // Set the entries in buffer's [[ArrayBufferData]] to those in `value`
         var k = key.slice(2);
@@ -809,8 +1113,8 @@
    * @returns {string}
    */
   function padBase32Exponent(n) {
-    n = n.toString(32);
-    return n.length === 1 ? '0' + n : n;
+    var exp = n.toString(32);
+    return exp.length === 1 ? '0' + exp : exp;
   }
 
   /**
@@ -857,24 +1161,28 @@
    * @returns {number}
    */
   function pow32(mantissa, exponent) {
-    exponent = Number.parseInt(exponent, 32);
-    if (exponent < 0) {
-      return roundToPrecision(Number.parseInt(mantissa, 32) * Math.pow(32, exponent - 10));
+    var exp = Number.parseInt(exponent, 32);
+    if (exp < 0) {
+      return roundToPrecision(Number.parseInt(mantissa, 32) * Math.pow(32, exp - 10));
     }
-    if (exponent < 11) {
-      var whole = mantissa.slice(0, exponent);
-      whole = Number.parseInt(whole, 32);
-      var fraction = mantissa.slice(exponent);
-      fraction = Number.parseInt(fraction, 32) * Math.pow(32, exponent - 11);
-      return roundToPrecision(whole + fraction);
+    if (exp < 11) {
+      var whole = mantissa.slice(0, exp);
+      var wholeNum = Number.parseInt(whole, 32);
+      var fraction = mantissa.slice(exp);
+      var fractionNum = Number.parseInt(fraction, 32) * Math.pow(32, exp - 11);
+      return roundToPrecision(wholeNum + fractionNum);
     }
-    var expansion = mantissa + zeros(exponent - 11);
+    var expansion = mantissa + zeros(exp - 11);
     return Number.parseInt(expansion, 32);
   }
 
+  /**
+   * @typedef {number} Float
+   */
+
   /**
    * @param {Float} num
-   * @param {Float} [precision=16]
+   * @param {Float} [precision]
    * @returns {Float}
    */
   function roundToPrecision(num) {
@@ -901,27 +1209,29 @@
   }
 
   /**
-  * @typedef {"number"|"date"|"string"|"binary"|"array"} module:Key.KeyType
-  */
-
-  /**
-   * @param key
-   * @returns {module:Key.KeyType}
+   * @param {Key} key
+   * @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(key);
-    return ['string', 'number'].includes(keyType) ? keyType : 'invalid';
+    return ['string', 'number'].includes(keyType) ? ( /** @type {"string"|"number"} */keyType) : 'invalid';
   }
 
   /**
    * Keys must be strings, numbers (besides `NaN`), Dates (if value is not
    *   `NaN`), binary objects or Arrays.
-   * @param input The key input
-   * @param {?(Array)} [seen] An array of already seen keys
-   * @returns {module:Key.keyValueObject}
+   * @param {Value} input The key input
+   * @param {Value[]|null|undefined} [seen] An array of already seen keys
+   * @returns {KeyValueObject}
    */
   function convertValueToKey(input, seen) {
     return convertValueToKeyValueDecoded(input, seen, false, true);
@@ -929,8 +1239,8 @@
 
   /**
   * Currently not in use.
-  * @param input
-  * @returns {module:Key.keyValueObject}
+  * @param {Value} input
+  * @returns {KeyValueObject}
   */
   function convertValueToMultiEntryKey(input) {
     return convertValueToKeyValueDecoded(input, null, true, true);
@@ -938,7 +1248,7 @@
 
   /**
    *
-   * @param O
+   * @param {BufferSource} O
    * @throws {TypeError}
    * @see https://heycam.github.io/webidl/#ref-for-dfn-get-buffer-source-copy-2
    * @returns {Uint8Array}
@@ -959,29 +1269,23 @@
     }
     // const octets = new Uint8Array(input);
     // const octets = types.binary.decode(types.binary.encode(input));
-    return new Uint8Array(O.buffer || O, offset, length);
+    return new Uint8Array(
+    // Should allow DataView
+    /** @type {ArrayBuffer} */
+    'buffer' in O && O.buffer || O, offset, length);
   }
 
-  /**
-  * @typedef {PlainObject} module:Key.keyValueObject
-  * @property {module:Key.KeyType|"NaN"} type
-  * @property {*} [value]
-  * @property {boolean} [invalid]
-  * @property {string} [message]
-  * @todo Specify acceptable `value` more precisely
-  */
-
   /**
   * Shortcut utility to avoid returning full keys from `convertValueToKey`
   *   and subsequent need to process in calling code unless `fullKeys` is
   *   set; may throw.
-  * @param {module:Key.Key} input
-  * @param {?(Array)} [seen]
+  * @param {Value} input
+  * @param {Value[]|null} [seen]
   * @param {boolean} [multiEntry]
   * @param {boolean} [fullKeys]
   * @throws {TypeError} See `getCopyBytesHeldByBufferSource`
   * @todo Document other allowable `input`
-  * @returns {module:Key.keyValueObject}
+  * @returns {KeyValueObject}
   */
   function convertValueToKeyValueDecoded(input, seen, multiEntry, fullKeys) {
     seen = seen || [];
@@ -1016,18 +1320,18 @@
               value: 0
             };
           }
-          return ret;
+          return /** @type {{type: KeyType; value: Value}} */ret;
         }
       case 'string':
         {
-          return ret;
+          return /** @type {{type: KeyType; value: Value}} */ret;
         }
       case 'binary':
         {
           // May throw (if detached)
           // Get a copy of the bytes held by the buffer source
           // https://heycam.github.io/webidl/#ref-for-dfn-get-buffer-source-copy-2
-          var octets = getCopyBytesHeldByBufferSource(input);
+          var octets = getCopyBytesHeldByBufferSource( /** @type {BufferSource} */input);
           return {
             type: 'binary',
             value: octets
@@ -1036,52 +1340,56 @@
       case 'array':
         {
           // May throw (from binary)
-          var len = input.length;
+          var arr = /** @type {Array<any>} */input;
+          var len = arr.length;
           seen.push(input);
+
+          /** @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.prototype.hasOwnProperty.call(input, i)) {
-              return {
-                v: {
-                  type: type,
-                  invalid: true,
-                  message: 'Does not have own index property'
-                }
-              };
-            }
-            try {
-              var entry = input[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(_ret) === "object") return _ret.v;
+            _ret = _loop();
+            if (_ret === 0) continue;
+            if (_ret) return _ret.v;
           }
           return {
             type: type,
@@ -1090,13 +1398,14 @@
         }
       case 'date':
         {
-          if (!Number.isNaN(input.getTime())) {
+          var date = /** @type {Date} */input;
+          if (!Number.isNaN(date.getTime())) {
             return fullKeys ? {
               type: type,
-              value: input.getTime()
+              value: date.getTime()
             } : {
               type: type,
-              value: new Date(input.getTime())
+              value: new Date(date.getTime())
             };
           }
           return {
@@ -1110,7 +1419,7 @@
       default:
         {
           // Other `typeof` types which are not valid keys:
-          //    'undefined', 'boolean', 'object' (including `null`), 'symbol', 'function
+          //    'undefined', 'boolean', 'object' (including `null`), 'symbol', 'function'
           var _type = input === null ? 'null' : _typeof(input); // Convert `null` for convenience of consumers in reporting errors
           return {
             type: _type,
@@ -1121,16 +1430,11 @@
     }
   }
 
-  /**
-  * @typedef {*} module:Key.Key
-  * @todo Specify possible value more precisely
-  */
-
   /**
    *
-   * @param {module:Key.Key} key
-   * @param {boolean} fullKeys
-   * @returns {module:Key.keyValueObject}
+   * @param {Key} key
+   * @param {boolean} [fullKeys]
+   * @returns {KeyValueObject}
    * @todo Document other allowable `key`?
    */
   function convertValueToMultiEntryKeyDecoded(key, fullKeys) {
@@ -1139,10 +1443,10 @@
 
   /**
   * An internal utility.
-  * @param input
-  * @param {boolean} seen
+  * @param {Value} input
+  * @param {Value[]|null|undefined} [seen]
   * @throws {DOMException} `DataError`
-  * @returns {module:Key.keyValueObject}
+  * @returns {KeyValueObject}
   */
   function convertValueToKeyRethrowingAndIfInvalid(input, seen) {
     var key = convertValueToKey(input, seen);
@@ -1154,10 +1458,10 @@
 
   /**
    *
-   * @param value
-   * @param keyPath
+   * @param {Value} value
+   * @param {KeyPath} keyPath
    * @param {boolean} multiEntry
-   * @returns {module:Key.keyValueObject|module:Key.KeyPathEvaluateValue}
+   * @returns {KeyValueObject|KeyPathEvaluateValue}
    * @todo Document other possible return?
    */
   function extractKeyFromValueUsingKeyPath(value, keyPath, multiEntry) {
@@ -1165,10 +1469,10 @@
   }
   /**
   * Not currently in use.
-  * @param value
-  * @param keyPath
+  * @param {Value} value
+  * @param {KeyPath} keyPath
   * @param {boolean} multiEntry
-  * @returns {module:Key.KeyPathEvaluateValue}
+  * @returns {KeyPathEvaluateValue}
   */
   function evaluateKeyPathOnValue(value, keyPath, multiEntry) {
     return evaluateKeyPathOnValueToDecodedValue(value, keyPath);
@@ -1177,11 +1481,11 @@
   /**
   * May throw, return `{failure: true}` (e.g., non-object on keyPath resolution)
   *    or `{invalid: true}` (e.g., `NaN`).
-  * @param value
-  * @param keyPath
-  * @param {boolean} multiEntry
-  * @param {boolean} fullKeys
-  * @returns {module:Key.keyValueObject|module:Key.KeyPathEvaluateValue}
+  * @param {Value} value
+  * @param {KeyPath} keyPath
+  * @param {boolean} [multiEntry]
+  * @param {boolean} [fullKeys]
+  * @returns {KeyValueObject|KeyPathEvaluateValue}
   * @todo Document other possible return?
   */
   function extractKeyValueDecodedFromValueUsingKeyPath(value, keyPath, multiEntry, fullKeys) {
@@ -1196,26 +1500,37 @@
   }
 
   /**
-  * @typedef {PlainObject} module:Key.KeyPathEvaluateFailure
-  * @property {boolean} failure
-  */
+   * Unused?
+   * @typedef {object} KeyPathEvaluateFailure
+   * @property {boolean} failure
+   */
 
   /**
-  * @typedef {PlainObject} module:Key.KeyPathEvaluateValue
-  * @property {undefined|array|string} value
-  */
+   * @typedef {KeyPathEvaluateValueValue[]} KeyPathEvaluateValueValueArray
+   */
+
+  /**
+   * @typedef {undefined|number|string|Date|object|KeyPathEvaluateValueValueArray} KeyPathEvaluateValueValue
+   */
+
+  /**
+   * @typedef {object} KeyPathEvaluateValue
+   * @property {KeyPathEvaluateValueValue} [value]
+   * @property {boolean} [failure]
+   */
 
   /**
    * Returns the value of an inline key based on a key path (wrapped in an
    *   object with key `value`) or `{failure: true}`
-   * @param {object} value
-   * @param {string|array} keyPath
-   * @param {boolean} multiEntry
+   * @param {Value} value
+   * @param {KeyPath} keyPath
+   * @param {boolean} [multiEntry]
    * @param {boolean} [fullKeys]
-   * @returns {module:Key.KeyPathEvaluateValue}
+   * @returns {KeyPathEvaluateValue}
    */
   function evaluateKeyPathOnValueToDecodedValue(value, keyPath, multiEntry, fullKeys) {
     if (Array.isArray(keyPath)) {
+      /** @type {KeyPathEvaluateValueValueArray} */
       var result = [];
       return keyPath.some(function (item) {
         var key = evaluateKeyPathOnValueToDecodedValue(value, item);
@@ -1236,30 +1551,30 @@
       };
     }
     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)) {
         switch (idntfr) {
           case 'size':
           case 'type':
-            value = value[idntfr];
+            value = /** @type {Blob} */value[idntfr];
             break;
         }
       } else if (isFile(value)) {
         switch (idntfr) {
           case 'name':
           case 'lastModified':
-            value = value[idntfr];
+            value = /** @type {File} */value[idntfr];
             break;
           case 'lastModifiedDate':
-            value = new Date(value.lastModified);
+            value = new Date( /** @type {File} */value.lastModified);
             break;
         }
-      } else if (!isObj(value) || !Object.prototype.hasOwnProperty.call(value, idntfr)) {
+      } else if (!isObj(value) || !Object.hasOwn(value, idntfr)) {
         return true;
       } else {
-        value = value[idntfr];
+        value = /** @type {{[key: string]: KeyPathEvaluateValueValue}} */value[idntfr];
         return value === undefined;
       }
       return false;
@@ -1272,8 +1587,8 @@
 
   /**
    * Sets the inline key value.
-   * @param {object} value
-   * @param {*} key
+   * @param {{[key: string]: AnyValue}} value
+   * @param {Key} key
    * @param {string} keyPath
    * @returns {void}
    */
@@ -1281,19 +1596,19 @@
     var identifiers = keyPath.split('.');
     var last = identifiers.pop();
     identifiers.forEach(function (identifier) {
-      var hop = Object.prototype.hasOwnProperty.call(value, identifier);
+      var hop = Object.hasOwn(value, identifier);
       if (!hop) {
         value[identifier] = {};
       }
       value = value[identifier];
     });
-    value[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
   }
 
   /**
    *
-   * @param value
-   * @param keyPath
+   * @param {Value} value
+   * @param {string} keyPath
    * @see https://github.com/w3c/IndexedDB/pull/146
    * @returns {boolean}
    */
@@ -1308,11 +1623,11 @@
         if (!isObj(value)) {
           return false;
         }
-        var hop = Object.prototype.hasOwnProperty.call(value, identifier);
+        var hop = Object.hasOwn(value, identifier);
         if (!hop) {
           return true;
         }
-        value = value[identifier];
+        value = /** @type {{[key: string]: Value}} */value[identifier];
       }
     } catch (err) {
       _iterator3.e(err);
@@ -1324,9 +1639,9 @@
 
   /**
    *
-   * @param {module:Key.Key} key
-   * @param {IDBKeyRange} range
-   * @param {boolean} checkCached
+   * @param {Key} key
+   * @param {import('./IDBKeyRange.js').IDBKeyRangeFull} range
+   * @param {boolean} [checkCached]
    * @returns {boolean}
    */
   function isKeyInRange(key, range, checkCached) {
@@ -1335,21 +1650,11 @@
     var encodedKey = _encode(key, true);
     var lower = checkCached ? range.__lowerCached : _encode(range.lower, true);
     var upper = checkCached ? range.__upperCached : _encode(range.upper, true);
-    if (range.lower !== undefined) {
-      if (range.lowerOpen && encodedKey > lower) {
-        lowerMatch = true;
-      }
-      if (!range.lowerOpen && encodedKey >= lower) {
-        lowerMatch = true;
-      }
+    if (!lowerMatch && (range.lowerOpen && encodedKey !== null && lower !== null && encodedKey > lower || !range.lowerOpen && (!encodedKey && !lower || encodedKey !== null && lower !== null && encodedKey >= lower))) {
+      lowerMatch = true;
     }
-    if (range.upper !== undefined) {
-      if (range.upperOpen && encodedKey < upper) {
-        upperMatch = true;
-      }
-      if (!range.upperOpen && encodedKey <= upper) {
-        upperMatch = true;
-      }
+    if (!upperMatch && (range.upperOpen && encodedKey !== null && upper !== null && encodedKey < upper || !range.upperOpen && (!encodedKey && !upper || encodedKey !== null && upper !== null && encodedKey <= upper))) {
+      upperMatch = true;
     }
     return lowerMatch && upperMatch;
   }
@@ -1370,9 +1675,9 @@
 
   /**
    *
-   * @param {module:Key.Key} keyEntry
-   * @param {IDBKeyRange} range
-   * @returns {module:Key.Key[]}
+   * @param {Key} keyEntry
+   * @param {import('./IDBKeyRange.js').IDBKeyRangeFull|undefined} range
+   * @returns {Key[]}
    */
   function findMultiEntryMatches(keyEntry, range) {
     var matches = [];
@@ -1411,15 +1716,11 @@
     return matches;
   }
 
-  /**
-  * @typedef {number|string|Date|ArrayBuffer|module:Key.ValueTypes[]} module:Key.ValueTypes
-  */
-
   /**
   * Not currently in use but keeping for spec parity.
-  * @param {module:Key.Key} key
+  * @param {Key} key
   * @throws {Error} Upon a "bad key"
-  * @returns {module:Key.ValueTypes}
+  * @returns {ValueType}
   */
   function convertKeyToValue(key) {
     var type = key.type,
@@ -1463,8 +1764,8 @@
 
   /**
    *
-   * @param {module:Key.Key} key
-   * @param {boolean} inArray
+   * @param {Key} key
+   * @param {boolean} [inArray]
    * @returns {string|null}
    */
   function _encode(key, inArray) {
@@ -1473,15 +1774,16 @@
       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);
   }
 
   /**
    *
-   * @param {module:Key.Key} key
-   * @param {boolean} inArray
+   * @param {Key} key
+   * @param {boolean} [inArray]
    * @throws {Error} Invalid number
-   * @returns {undefined|module:Key.ValueTypes}
+   * @returns {undefined|ValueType}
    */
   function _decode(key, inArray) {
     if (typeof key !== 'string') {
@@ -1492,9 +1794,9 @@
 
   /**
    *
-   * @param {module:Key.Key} key
-   * @param {boolean} inArray
-   * @returns {undefined|module:Key.ValueTypes}
+   * @param {Key} key
+   * @param {boolean} [inArray]
+   * @returns {undefined|ValueType}
    */
   function roundTrip(key, inArray) {
     return _decode(_encode(key, inArray), inArray);
@@ -1502,30 +1804,25 @@
   var MAX_ALLOWED_CURRENT_NUMBER = 9007199254740992; // 2 ^ 53 (Also equal to `Number.MAX_SAFE_INTEGER + 1`)
 
   /**
-   * @external WebSQLTransaction
+   * @typedef {number} Integer
    */
 
-  /**
-  * @typedef {IDBObjectStore} IDBObjectStoreWithCurrentName
-  * @property {string} __currentName
-  */
-
   /**
    * @callback CurrentNumberCallback
-   * @param {Integer} The current number
+   * @param {Integer} cn The current number
    * @returns {void}
    */
 
   /**
   * @callback SQLFailureCallback
-  * @param {DOMException} exception
+  * @param {DOMException|Error} exception
   * @returns {void}
   */
 
   /**
    *
-   * @param {external:WebSQLTransaction} tx
-   * @param {IDBObjectStoreWithCurrentName} store
+   * @param {SQLTransaction} tx
+   * @param {import('./IDBObjectStore.js').IDBObjectStoreFull} store
    * @param {CurrentNumberCallback} func
    * @param {SQLFailureCallback} sqlFailCb
    * @returns {void}
@@ -1539,13 +1836,14 @@
       }
     }, function (tx, error) {
       sqlFailCb(createDOMException('DataError', 'Could not get the auto increment value for key', error));
+      return false;
     });
   }
 
   /**
    *
-   * @param {external:WebSQLTransaction} tx
-   * @param {IDBObjectStoreWithCurrentName} store
+   * @param {SQLTransaction} tx
+   * @param {import('./IDBObjectStore.js').IDBObjectStoreFull} store
    * @param {Integer} num
    * @param {CurrentNumberCallback} successCb
    * @param {SQLFailureCallback} failCb
@@ -1554,11 +1852,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 false;
     });
   }
 
@@ -1566,8 +1867,8 @@
    * Bump up the auto-inc counter if the key path-resolved value is valid
    *   (greater than old value and >=1) OR if a manually passed in key is
    *   valid (numeric and >= 1) and >= any primaryKey.
-   * @param {external:WebSQLTransaction} tx
-   * @param {IDBObjectStoreWithCurrentName} store
+   * @param {SQLTransaction} tx
+   * @param {import('./IDBObjectStore.js').IDBObjectStoreFull} store
    * @param {Integer} num
    * @param {CurrentNumberCallback} successCb
    * @param {SQLFailureCallback} failCb
@@ -1589,8 +1890,8 @@
 
   /**
    *
-   * @param {external:WebSQLTransaction} tx
-   * @param {IDBObjectStoreWithCurrentName} store
+   * @param {SQLTransaction} tx
+   * @param {import('./IDBObjectStore.js').IDBObjectStoreFull} store
    * @param {KeyForStoreCallback} cb
    * @param {SQLFailureCallback} sqlFailCb
    * @returns {void}
@@ -1616,10 +1917,10 @@
   //     so we do not return a key
   /**
    *
-   * @param {external:WebSQLTransaction} tx
-   * @param {IDBObjectStoreWithCurrentName} store
-   * @param {*|Integer} key
-   * @param {CurrentNumberCallback|void} successCb
+   * @param {SQLTransaction} tx
+   * @param {import('./IDBObjectStore.js').IDBObjectStoreFull} store
+   * @param {import('./Key.js').Key} key
+   * @param {(num?: Integer) => void} successCb
    * @param {SQLFailureCallback} sqlFailCb
    * @returns {void}
    */