indexeddbshim 12.0.0 → 13.0.0-pre.1

package/src/Key.js

@@ -4,12 +4,57 @@ import cmp from './cmp.js';
 import CFG from './CFG.js';
 
 /**
- * @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}}
  */
 const keyTypeToEncodedChar = {
     invalid: 100,
@@ -19,15 +64,17 @@ const keyTypeToEncodedChar = {
     binary: 500,
     array: 600
 };
-const keyTypes = Object.keys(keyTypeToEncodedChar);
+const keyTypes = /** @type {(KeyType|"invalid")[]} */ (Object.keys(keyTypeToEncodedChar));
 keyTypes.forEach((k) => {
-    keyTypeToEncodedChar[k] = String.fromCodePoint(keyTypeToEncodedChar[k]);
+    keyTypeToEncodedChar[k] = String.fromCodePoint(
+        /** @type {number} */ (keyTypeToEncodedChar[k])
+    );
 });
 
 const encodedCharToKeyType = keyTypes.reduce((o, k) => {
     o[keyTypeToEncodedChar[k]] = k;
     return o;
-}, {});
+}, /** @type {{[key: string]: KeyType|"invalid"}} */ ({}));
 
 /**
  * The sign values for numbers, ordered from least to greatest.
@@ -40,12 +87,24 @@ const encodedCharToKeyType = keyTypes.reduce((o, k) => {
  */
 const signValues = ['negativeInfinity', 'bigNegative', 'smallNegative', 'smallPositive', 'bigPositive', 'positiveInfinity'];
 
+/**
+ * @typedef {any} AnyValue
+ */
+
 const types = {
     invalid: {
-        encode (key) {
+        /**
+         * @param {AnyValue} _key
+         * @returns {string}
+         */
+        encode (_key) {
             return keyTypeToEncodedChar.invalid + '-';
         },
-        decode (key) {
+        /**
+         * @param {string} _key
+         * @returns {undefined}
+         */
+        decode (_key) {
             return undefined;
         }
     },
@@ -63,6 +122,10 @@ const types = {
     number: {
         // The encode step checks for six numeric cases and generates 14-digit encoded
         // sign-exponent-mantissa strings.
+        /**
+         * @param {number} key
+         * @returns {string}
+         */
         encode (key) {
             let key32 = key === Number.MIN_VALUE
                 // Mocha test `IDBFactory/cmp-spec.js` exposed problem for some
@@ -128,6 +191,10 @@ const types = {
         // 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 (key) {
             const sign = Number(key.slice(2, 3));
             let exponent = key.slice(3, 5);
@@ -166,18 +233,28 @@ const types = {
     // 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 (key, inArray) {
             if (inArray) {
                 // prepend each character with a dash, and append a space to the end
-                key = key.replace(/(.)/gu, '-$1') + ' ';
+                key = key.replaceAll(/(.)/gu, '-$1') + ' ';
             }
             return keyTypeToEncodedChar.string + '-' + key;
         },
+        /**
+         * @param {string} key
+         * @param {boolean} [inArray]
+         * @returns {string}
+         */
         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(/-(.)/gu, '$1');
+                key = key.slice(0, -1).replaceAll(/-(.)/gu, '$1');
             }
             return key;
         }
@@ -187,6 +264,10 @@ const types = {
     // An extra, value is added to each array during encoding to make
     //  empty arrays sort correctly.
     array: {
+        /**
+         * @param {ValueTypeArray} key
+         * @returns {string}
+         */
         encode (key) {
             const encoded = [];
             for (const [i, item] of key.entries()) {
@@ -196,6 +277,10 @@ const types = {
             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 (key) {
             const decoded = JSON.parse(key.slice(2));
             decoded.pop(); // remove the extra item
@@ -210,15 +295,27 @@ const types = {
 
     // Dates are encoded as ISO 8601 strings, in UTC time zone.
     date: {
+        /**
+         * @param {Date} key
+         * @returns {string}
+         */
         encode (key) {
             return keyTypeToEncodedChar.date + '-' + key.toJSON();
         },
+        /**
+         * @param {string} key
+         * @returns {Date}
+         */
         decode (key) {
             return new Date(key.slice(2));
         }
     },
     binary: {
         // `ArrayBuffer`/Views on buffers (`TypedArray` or `DataView`)
+        /**
+         * @param {BufferSource} key
+         * @returns {string}
+         */
         encode (key) {
             return keyTypeToEncodedChar.binary + '-' + (key.byteLength
                 ? [...getCopyBytesHeldByBufferSource(key)].map(
@@ -226,6 +323,10 @@ const types = {
                 ) // e.g., '255,005,254,000,001,033'
                 : '');
         },
+        /**
+         * @param {string} key
+         * @returns {ArrayBuffer}
+         */
         decode (key) {
             // Set the entries in buffer's [[ArrayBufferData]] to those in `value`
             const k = key.slice(2);
@@ -244,8 +345,8 @@ const types = {
  * @returns {string}
  */
 function padBase32Exponent (n) {
-    n = n.toString(32);
-    return (n.length === 1) ? '0' + n : n;
+    const exp = n.toString(32);
+    return (exp.length === 1) ? '0' + exp : exp;
 }
 
 /**
@@ -283,26 +384,30 @@ function flipBase32 (encoded) {
  * @returns {number}
  */
 function pow32 (mantissa, exponent) {
-    exponent = Number.parseInt(exponent, 32);
-    if (exponent < 0) {
+    const exp = Number.parseInt(exponent, 32);
+    if (exp < 0) {
         return roundToPrecision(
-            Number.parseInt(mantissa, 32) * (32 ** (exponent - 10))
+            Number.parseInt(mantissa, 32) * (32 ** (exp - 10))
         );
     }
-    if (exponent < 11) {
-        let whole = mantissa.slice(0, exponent);
-        whole = Number.parseInt(whole, 32);
-        let fraction = mantissa.slice(exponent);
-        fraction = Number.parseInt(fraction, 32) * (32 ** (exponent - 11));
-        return roundToPrecision(whole + fraction);
+    if (exp < 11) {
+        const whole = mantissa.slice(0, exp);
+        const wholeNum = Number.parseInt(whole, 32);
+        const fraction = mantissa.slice(exp);
+        const fractionNum = Number.parseInt(fraction, 32) * (32 ** (exp - 11));
+        return roundToPrecision(wholeNum + fractionNum);
     }
-    const expansion = mantissa + zeros(exponent - 11);
+    const 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, precision = 16) {
@@ -328,27 +433,25 @@ function negate (s) {
 }
 
 /**
-* @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 (util.isDate(key)) return 'date';
     if (util.isBinary(key)) return 'binary';
     const 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);
@@ -356,8 +459,8 @@ function convertValueToKey (input, seen) {
 
 /**
 * Currently not in use.
-* @param input
-* @returns {module:Key.keyValueObject}
+* @param {Value} input
+* @returns {KeyValueObject}
 */
 function convertValueToMultiEntryKey (input) {
     return convertValueToKeyValueDecoded(input, null, true, true);
@@ -365,7 +468,7 @@ function convertValueToMultiEntryKey (input) {
 
 /**
  *
- * @param O
+ * @param {BufferSource} O
  * @throws {TypeError}
  * @see https://heycam.github.io/webidl/#ref-for-dfn-get-buffer-source-copy-2
  * @returns {Uint8Array}
@@ -387,29 +490,26 @@ function getCopyBytesHeldByBufferSource (O) {
     }
     // 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 || [];
@@ -434,24 +534,29 @@ function convertValueToKeyValueDecoded (input, seen, multiEntry, fullKeys) {
         if (Object.is(input, -0)) {
             return {type, 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
-        const octets = getCopyBytesHeldByBufferSource(input);
+        const octets = getCopyBytesHeldByBufferSource(
+            /** @type {BufferSource} */ (input)
+        );
         return {type: 'binary', value: octets};
     } case 'array': { // May throw (from binary)
-        const len = input.length;
+        const arr = /** @type {Array<any>} */ (input);
+        const len = arr.length;
         seen.push(input);
+
+        /** @type {(KeyValueObject|Value)[]} */
         const keys = [];
         for (let i = 0; i < len; i++) { // We cannot iterate here with array extras as we must ensure sparse arrays are invalidated
-            if (!multiEntry && !Object.prototype.hasOwnProperty.call(input, i)) {
+            if (!multiEntry && !Object.hasOwn(arr, i)) {
                 return {type, invalid: true, message: 'Does not have own index property'};
             }
             try {
-                const entry = input[i];
+                const entry = arr[i];
                 const key = convertValueToKeyValueDecoded(entry, seen, false, fullKeys); // Though steps do not list rethrowing, the next is returnifabrupt when not multiEntry
                 if (key.invalid) {
                     if (multiEntry) {
@@ -473,32 +578,28 @@ function convertValueToKeyValueDecoded (input, seen, multiEntry, fullKeys) {
         }
         return {type, value: keys};
     } case 'date': {
-        if (!Number.isNaN(input.getTime())) {
+        const date = /** @type {Date} */ (input);
+        if (!Number.isNaN(date.getTime())) {
             return fullKeys
-                ? {type, value: input.getTime()}
-                : {type, value: new Date(input.getTime())};
+                ? {type, value: date.getTime()}
+                : {type, value: new Date(date.getTime())};
         }
         return {type, invalid: true, message: 'Not a valid date'};
         // Falls through
     } case 'invalid': default: {
         // Other `typeof` types which are not valid keys:
-        //    'undefined', 'boolean', 'object' (including `null`), 'symbol', 'function
+        //    'undefined', 'boolean', 'object' (including `null`), 'symbol', 'function'
         const type = input === null ? 'null' : typeof input; // Convert `null` for convenience of consumers in reporting errors
         return {type, invalid: true, message: 'Not a valid key; type ' + type};
     }
     }
 }
 
-/**
-* @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) {
@@ -507,10 +608,10 @@ function convertValueToMultiEntryKeyDecoded (key, fullKeys) {
 
 /**
 * 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) {
     const key = convertValueToKey(input, seen);
@@ -522,10 +623,10 @@ function convertValueToKeyRethrowingAndIfInvalid (input, seen) {
 
 /**
  *
- * @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) {
@@ -533,10 +634,10 @@ function extractKeyFromValueUsingKeyPath (value, keyPath, multiEntry) {
 }
 /**
 * 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, multiEntry, true);
@@ -545,11 +646,11 @@ function evaluateKeyPathOnValue (value, keyPath, multiEntry) {
 /**
 * 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) {
@@ -564,26 +665,37 @@ function extractKeyValueDecodedFromValueUsingKeyPath (value, keyPath, multiEntry
 }
 
 /**
-* @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} */
         const result = [];
         return keyPath.some((item) => {
             const key = evaluateKeyPathOnValueToDecodedValue(value, item, multiEntry, fullKeys);
@@ -608,22 +720,24 @@ function evaluateKeyPathOnValueToDecodedValue (value, keyPath, multiEntry, fullK
         } else if (util.isBlob(value)) {
             switch (idntfr) {
             case 'size': case 'type':
-                value = value[idntfr];
+                value = /** @type {Blob} */ (value)[idntfr];
                 break;
             }
         } else if (util.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 (!util.isObj(value) || !Object.prototype.hasOwnProperty.call(value, idntfr)) {
+        } else if (!util.isObj(value) || !Object.hasOwn(value, idntfr)) {
             return true;
         } else {
-            value = value[idntfr];
+            value = /** @type {{[key: string]: KeyPathEvaluateValueValue}} */ (
+                value
+            )[idntfr];
             return value === undefined;
         }
         return false;
@@ -634,8 +748,8 @@ function evaluateKeyPathOnValueToDecodedValue (value, keyPath, multiEntry, fullK
 
 /**
  * Sets the inline key value.
- * @param {object} value
- * @param {*} key
+ * @param {{[key: string]: AnyValue}} value
+ * @param {Key} key
  * @param {string} keyPath
  * @returns {void}
  */
@@ -643,19 +757,19 @@ function injectKeyIntoValueUsingKeyPath (value, key, keyPath) {
     const identifiers = keyPath.split('.');
     const last = identifiers.pop();
     identifiers.forEach((identifier) => {
-        const hop = Object.prototype.hasOwnProperty.call(value, identifier);
+        const 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}
  */
@@ -666,20 +780,20 @@ function checkKeyCouldBeInjectedIntoValue (value, keyPath) {
         if (!util.isObj(value)) {
             return false;
         }
-        const hop = Object.prototype.hasOwnProperty.call(value, identifier);
+        const hop = Object.hasOwn(value, identifier);
         if (!hop) {
             return true;
         }
-        value = value[identifier];
+        value = /** @type {{[key: string]: Value}} */ (value)[identifier];
     }
     return util.isObj(value);
 }
 
 /**
  *
- * @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) {
@@ -689,21 +803,25 @@ function isKeyInRange (key, range, checkCached) {
     const lower = checkCached ? range.__lowerCached : encode(range.lower, true);
     const 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;
@@ -726,9 +844,9 @@ function isMultiEntryMatch (encodedEntry, encodedKey) {
 
 /**
  *
- * @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) {
     const matches = [];
@@ -760,15 +878,11 @@ function findMultiEntryMatches (keyEntry, range) {
     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) {
     const {type, value} = key;
@@ -801,8 +915,8 @@ function convertKeyToValue (key) {
 
 /**
  *
- * @param {module:Key.Key} key
- * @param {boolean} inArray
+ * @param {Key} key
+ * @param {boolean} [inArray]
  * @returns {string|null}
  */
 function encode (key, inArray) {
@@ -816,10 +930,10 @@ function 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') {
@@ -830,9 +944,9 @@ function decode (key, inArray) {
 
 /**
  *
- * @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);
@@ -841,30 +955,25 @@ function roundTrip (key, inArray) {
 const 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}
@@ -884,13 +993,14 @@ function getCurrentNumber (tx, store, func, sqlFailCb) {
             'Could not get the auto increment value for key',
             error
         ));
+        return true;
     });
 }
 
 /**
  *
- * @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
@@ -904,6 +1014,7 @@ function assignCurrentNumber (tx, store, num, successCb, failCb) {
         successCb(num);
     }, function (tx, err) {
         failCb(createDOMException('UnknownError', 'Could not set the auto increment value for key', err));
+        return true;
     });
 }
 
@@ -911,8 +1022,8 @@ function assignCurrentNumber (tx, store, num, successCb, failCb) {
  * 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
@@ -935,8 +1046,8 @@ function setCurrentNumber (tx, store, num, successCb, failCb) {
 
 /**
  *
- * @param {external:WebSQLTransaction} tx
- * @param {IDBObjectStoreWithCurrentName} store
+ * @param {SQLTransaction} tx
+ * @param {import('./IDBObjectStore.js').IDBObjectStoreFull} store
  * @param {KeyForStoreCallback} cb
  * @param {SQLFailureCallback} sqlFailCb
  * @returns {void}
@@ -965,10 +1076,10 @@ function generateKeyForStore (tx, store, cb, sqlFailCb) {
 //     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}
  */