indexeddbshim 18.0.0 → 19.0.0

package/src/IDBFactory.js

@@ -645,7 +645,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
                     let sysdbFinishedCb = function (systx, err, cb) {
                         if (err) {
                             /**
-                             * @param {any} [errorToShow]
+                             * @param {unknown} [errorToShow]
                              * @returns {void}
                              */
                             const manualRevert = function (errorToShow) {
@@ -679,7 +679,10 @@ IDBFactory.prototype.open = function (name /* , version */) {
                                     },
                                     function () {
                                         isRevertingSysdb = false;
-                                        cb(errorToShow || reportError); // eslint-disable-line promise/no-callback-in-promise -- Convenient
+                                        // eslint-disable-next-line promise/no-callback-in-promise -- Convenient
+                                        cb(/** @type {(Error & {code?: number})|undefined} */ (
+                                            errorToShow || reportError
+                                        ));
                                     }
                                 );
                             };
@@ -718,14 +721,14 @@ IDBFactory.prototype.open = function (name /* , version */) {
                                 new IDBVersionChangeEvent('upgradeneeded', {oldVersion, newVersion: version})
                             );
                             req.__result = connection;
-                            connection.__upgradeTransaction = req.__transaction = req.__result.__versionTransaction = IDBTransaction.__createInstance(req.__result, req.__result.objectStoreNames, 'versionchange');
+                            connection.__upgradeTransaction = req.__transaction = connection.__versionTransaction = IDBTransaction.__createInstance(connection, connection.objectStoreNames, 'versionchange');
                             req.__done = true;
 
                             req.transaction.__addNonRequestToTransactionQueue(
                                 /**
                                  * @param {import('websql-configurable/lib/websql/WebSQLTransaction.js').default} tx
-                                 * @param {any[]} args
-                                 * @param {(result?: any, req?: import('./IDBRequest.js').IDBRequestFull) => void} finished
+                                 * @param {unknown[]} args
+                                 * @param {(result?: unknown, req?: import('./IDBRequest.js').IDBRequestFull) => void} finished
                                  * @returns {void}
                                  */
                                 function onupgradeneeded (tx, args, finished /* , error */) {

package/src/IDBIndex.js

@@ -68,7 +68,7 @@ const IDBIndexAlias = IDBIndex;
  *   __keyPath: import('./Key.js').KeyPath,
  *   __recreated?: boolean,
  *   __fetchIndexData: (
- *     range: any,
+ *     range: Query,
  *     opType: "value"|"key"|"count",
  *     nullDisallowed: boolean,
  *     count?: number
@@ -497,7 +497,7 @@ IDBIndex.__updateIndexList = function (store, tx, success, failure) {
 };
 
 /**
- * @typedef {any|IDBKeyRange} Query
+ * @typedef {import('./Key.js').Value|IDBKeyRange} Query
  */
 
 /**
@@ -766,7 +766,7 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
                             })
                         );
                         SyncPromise.all(indexCreations).then(finish).catch(
-                            /** @type {(reason: any) => PromiseLike<never>} */
+                            /** @type {(reason: unknown) => PromiseLike<never>} */
                             (error)
                         ).catch((err) => {
                             console.log('Index rename error');
@@ -779,14 +779,10 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
     });
 };
 
-/**
- * @typedef {any} AnyValue
- */
-
 /* eslint-disable unicorn/no-top-level-side-effects -- Would be good */
 Object.defineProperty(IDBIndex, Symbol.hasInstance, {
     /**
-     * @param {AnyValue} obj
+     * @param {unknown} obj
      * @returns {boolean}
      */
     value: (obj) => util.isObj(obj) &&
@@ -819,7 +815,9 @@ Object.defineProperty(IDBIndex, 'prototype', {
  * @param {string[]} sqlValues
  * @param {WebSQLTransaction} tx
  * @param {null|undefined} args
- * @param {(result: number|undefined|[]|AnyValue|AnyValue[]) => void} success
+ * @param {(
+ *   result: number|undefined|[]|import('./Key.js').Value|import('./Key.js').Value[]
+ * ) => void} success
  * @param {(tx: WebSQLTransaction, err: (Error & {code?: number})) => void} error
  * @returns {void}
  */
@@ -859,7 +857,7 @@ function executeFetchIndexData (
                  * @param {{
                  *   value: string
                  * }} record
-                 * @returns {AnyValue}
+                 * @returns {import('./Key.js').Value}
                  */
                 (record) => { // when opType is value
                     return Sca.decode(util.unescapeSQLiteResponse(record.value));
@@ -874,9 +872,9 @@ function executeFetchIndexData (
                 );
                 let record;
                 if (hasKey && (
-                    (multiChecks && range.some(
+                    (multiChecks && /** @type {import('./Key.js').ValueType[]} */ (range).some(
                         /**
-                         * @param {string} check
+                         * @param {import('./Key.js').ValueType} check
                          * @returns {boolean}
                          */
                         (check) => rowKey.includes(check)

package/src/IDBKeyRange.js

@@ -27,8 +27,8 @@ function IDBKeyRange () {
 const IDBKeyRangeAlias = IDBKeyRange;
 
 /**
- * @param {import('./Key.js').Key|null} lower
- * @param {import('./Key.js').Key|null} upper
+ * @param {import('./Key.js').Value} lower
+ * @param {import('./Key.js').Value} upper
  * @param {boolean} lowerOpen
  * @param {boolean} upperOpen
  * @returns {import('./IDBKeyRange.js').IDBKeyRangeFull}
@@ -238,10 +238,11 @@ function setSQLForKeyRange (
 function convertValueToKeyRange (value, nullDisallowed) {
     if (util.instanceOf(value, IDBKeyRange)) {
         // We still need to validate IDBKeyRange-like objects (the above check is based on loose duck-typing)
-        if (value.toString() !== '[object IDBKeyRange]') {
-            return IDBKeyRange.__createInstance(value.lower, value.upper, value.lowerOpen, value.upperOpen);
+        const range = /** @type {IDBKeyRangeFull} */ (value);
+        if (range.toString() !== '[object IDBKeyRange]') {
+            return IDBKeyRange.__createInstance(range.lower, range.upper, range.lowerOpen, range.upperOpen);
         }
-        return value;
+        return range;
     }
     if (util.isNullish(value)) {
         if (nullDisallowed) {

package/src/IDBObjectStore.js

@@ -60,14 +60,14 @@ const IDBObjectStoreAlias = IDBObjectStore;
  *   __idbdb: import('./IDBDatabase.js').IDBDatabaseFull,
  *   __validateKeyAndValueAndCloneValue: (
  *     value: import('./Key.js').Value,
- *     key: import('./Key.js').Key,
+ *     key: import('./Key.js').Key|undefined,
  *     cursorUpdate: boolean
  *   ) => KeyValueArray,
  *   __deriveKey: (
  *     tx: WebSQLTransaction,
  *     value: import('./Key.js').Value,
- *     key: import('./Key.js').Key,
- *     success: (key: import('./Key.js').Key, cn?: Integer) => void,
+ *     key: import('./Key.js').Key|undefined,
+ *     success: (key: import('./Key.js').Value, cn?: Integer) => void,
  *     failCb: import('./Key.js').SQLFailureCallback
  *   ) => void,
  *   __checkIndexConstraints: (
@@ -399,7 +399,7 @@ IDBObjectStore.__deleteObjectStore = function (db, store) {
 };
 
 /**
- * @typedef {[import('./Key.js').Key, import('./Key.js').Value]} KeyValueArray
+ * @typedef {[import('./Key.js').Key|undefined, import('./Key.js').Value]} KeyValueArray
  */
 
 // Todo: Although we may end up needing to do cloning genuinely asynchronously (for Blobs and FileLists),
@@ -414,7 +414,7 @@ IDBObjectStore.__deleteObjectStore = function (db, store) {
  * Determines whether the given inline or out-of-line key is valid,
  *   according to the object store's schema.
  * @param {import('./Key.js').Value} value Used for inline keys
- * @param {import('./Key.js').Key} key Used for out-of-line keys
+ * @param {import('./Key.js').Key|undefined} key Used for out-of-line keys
  * @param {boolean} cursorUpdate
  * @throws {DOMException}
  * @this {IDBObjectStoreFull}
@@ -433,11 +433,11 @@ IDBObjectStore.prototype.__validateKeyAndValueAndCloneValue = function (value, k
             /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (me.transaction),
             value
         );
-        key = Key.extractKeyValueDecodedFromValueUsingKeyPath(clonedValue, me.keyPath); // May throw so "rethrow"
-        if (key.invalid) {
+        const extractedKey = Key.extractKeyValueDecodedFromValueUsingKeyPath(clonedValue, me.keyPath); // May throw so "rethrow"
+        if ('invalid' in extractedKey && extractedKey.invalid) {
             throw createDOMException('DataError', 'KeyPath was specified, but key was invalid.');
         }
-        if (key.failure) {
+        if ('failure' in extractedKey && extractedKey.failure) {
             if (!cursorUpdate) {
                 if (!me.autoIncrement) {
                     throw createDOMException('DataError', 'Could not evaluate a key from keyPath and there is no key generator');
@@ -452,14 +452,13 @@ IDBObjectStore.prototype.__validateKeyAndValueAndCloneValue = function (value, k
             throw createDOMException('DataError', 'Could not evaluate a key from keyPath');
         }
         // An `IDBCursor.update` call will also throw if not equal to the cursor’s effective key
-        return [key.value, clonedValue];
+        return [(/** @type {import('./Key.js').Key} */ (extractedKey.value)), clonedValue];
     }
     if (key === undefined) {
         if (!me.autoIncrement) {
             throw createDOMException('DataError', 'The object store uses out-of-line keys and has no key generator and the key parameter was not provided.');
         }
         // A key will be generated
-        key = undefined;
     } else {
         Key.convertValueToKeyRethrowingAndIfInvalid(key);
     }
@@ -477,8 +476,8 @@ IDBObjectStore.prototype.__validateKeyAndValueAndCloneValue = function (value, k
  *   a keyPath leading to a valid but non-numeric or < 1 key).
  * @param {WebSQLTransaction} tx
  * @param {import('./Key.js').Value} value
- * @param {import('./Key.js').Key} key
- * @param {(key: import('./Key.js').Key, cn?: Integer) => void} success
+ * @param {import('./Key.js').Key|undefined} key
+ * @param {(key: import('./Key.js').Value, cn?: Integer) => void} success
  * @param {import('./Key.js').SQLFailureCallback} failCb
  * @this {IDBObjectStoreFull}
  * @returns {void}
@@ -492,9 +491,8 @@ IDBObjectStore.prototype.__deriveKey = function (tx, value, key, success, failCb
      * @returns {void}
      */
     function keyCloneThenSuccess (oldCn) { // We want to return the original key, so we don't need to accept an argument here
-        Sca.encode(key, function (key) {
-            key = Sca.decode(key);
-            success(key, oldCn);
+        Sca.encode(key, function (encodedKey) {
+            success(Sca.decode(encodedKey), oldCn);
         });
     }
 
@@ -510,7 +508,9 @@ IDBObjectStore.prototype.__deriveKey = function (tx, value, key, success, failCb
                     // Should not throw now as checked earlier
                     // Todo: Could this not be an array here?
                     Key.injectKeyIntoValueUsingKeyPath(
-                        value, key, /** @type {string} */ (me.keyPath)
+                        /** @type {{[key: string]: import('./Key.js').Value}} */ (value),
+                        /** @type {import('./Key.js').Key} */ (key),
+                        /** @type {string} */ (me.keyPath)
                     );
                 }
                 success(key, oldCn);
@@ -571,15 +571,17 @@ IDBObjectStore.prototype.__checkIndexConstraints = function (tx, value, excludeK
                 resolve(undefined);
                 return;
             }
-            indexKey = indexKey.value;
-            if (indexKey === undefined) {
+            const indexKeyValue = indexKey.value;
+            if (indexKeyValue === undefined) {
                 resolve(undefined);
                 return;
             }
-            const multiCheck = index.multiEntry && Array.isArray(indexKey);
-            const fetchArgs = buildFetchIndexDataSQL(true, index, indexKey, 'key', multiCheck);
+            const multiCheck = index.multiEntry && Array.isArray(indexKeyValue);
+            const fetchArgs = buildFetchIndexDataSQL(true, index, indexKeyValue, 'key', multiCheck);
             executeFetchIndexData(null, ...fetchArgs, tx, null, function success (key) {
-                if (key === undefined || (excludeKey !== undefined && cmp(key, excludeKey) === 0)) {
+                if (key === undefined || (excludeKey !== undefined && cmp(
+                    /** @type {import('./Key.js').Key} */ (key), excludeKey
+                ) === 0)) {
                     resolve(undefined);
                     return;
                 }
@@ -662,22 +664,22 @@ IDBObjectStore.prototype.__insertData = function (tx, encoded, value, clonedKeyO
                 resolve(undefined);
                 return;
             }
-            indexKey = indexKey.value;
+            const indexKeyValue = indexKey.value;
             /**
              * @param {import('./IDBIndex.js').IDBIndexFull} index
              * @returns {void}
              */
             function setIndexInfo (index) {
-                if (indexKey === undefined) {
+                if (indexKeyValue === undefined) {
                     return;
                 }
                 paramMap[index.__currentName] = /** @type {string} */ (
-                    Key.encode(indexKey, index.multiEntry)
+                    Key.encode(indexKeyValue, index.multiEntry)
                 );
             }
             if (index.unique) {
-                const multiCheck = index.multiEntry && Array.isArray(indexKey);
-                const fetchArgs = buildFetchIndexDataSQL(true, index, indexKey, 'key', multiCheck);
+                const multiCheck = index.multiEntry && Array.isArray(indexKeyValue);
+                const fetchArgs = buildFetchIndexDataSQL(true, index, indexKeyValue, 'key', multiCheck);
                 executeFetchIndexData(null, ...fetchArgs, tx, null, function success (key) {
                     if (key === undefined) {
                         setIndexInfo(index);
@@ -854,7 +856,10 @@ IDBObjectStore.__storingRecordObjectStore = function (request, store, invalidate
     /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
         store.transaction
     ).__pushToQueue(request, function (tx, args, success, error) {
-        store.__deriveKey(tx, value, key, function (clonedKeyOrCurrentNumber, oldCn) {
+        store.__deriveKey(tx, value, key, function (clonedKeyOrCurrentNumberRaw, oldCn) {
+            const clonedKeyOrCurrentNumber = /** @type {import('./Key.js').Key|Integer} */ (
+                clonedKeyOrCurrentNumberRaw
+            );
             Sca.encode(value, function (encoded) {
                 /**
                  * @param {WebSQLTransaction} tx

package/src/IDBRequest.js

@@ -20,7 +20,7 @@ function IDBRequest () {
  * @typedef {IDBRequest & EventTarget & import('eventtargeter').EventTargetInstance & {
  *   transaction: import('./IDBTransaction.js').IDBTransactionFull,
  *   __done: boolean,
- *   __result: import('./IDBDatabase.js').IDBDatabaseFull|undefined,
+ *   __result: unknown,
  *   __error: null|DOMException|Error,
  *   __source: null|import('./IDBDatabase.js').IDBDatabaseFull|
  *     import('./IDBObjectStore.js').IDBObjectStoreFull|

package/src/IDBTransaction.js

@@ -19,7 +19,7 @@ const readonlyProperties = ['objectStoreNames', 'mode', 'durability', 'db', 'err
 /**
  * @typedef {{
  *   op: SQLCallback,
- *   args: any[],
+ *   args: unknown[],
  *   req: import('./IDBRequest.js').IDBRequestFull|null
  * }} RequestInfo
  */
@@ -71,17 +71,17 @@ const readonlyProperties = ['objectStoreNames', 'mode', 'durability', 'db', 'err
  *   __pushToQueue: (
  *     request: import('./IDBRequest.js').IDBRequestFull|null,
  *     callback: SQLCallback,
- *     args?: any[]
+ *     args?: unknown[]
  *   ) => void,
  *   __assertActive: () => void,
  *   commit: () => void,
  *   __addNonRequestToTransactionQueue: (
  *     callback: SQLCallback,
- *     args?: any[]
+ *     args?: unknown[]
  *   ) => void
  *   __addToTransactionQueue: (
  *     callback: SQLCallback,
- *     args: any[]|undefined,
+ *     args: unknown[]|undefined,
  *     source: import('./IDBDatabase.js').IDBDatabaseFull|
  *       import('./IDBObjectStore.js').IDBObjectStoreFull|
  *       import('./IDBIndex.js').IDBIndexFull|
@@ -281,7 +281,7 @@ IDBTransaction.prototype.__executeRequests = function () {
                 i = -1;
 
             /**
-             * @typedef {any} IDBRequestResult
+             * @typedef {unknown} IDBRequestResult
              */
 
             /**
@@ -710,8 +710,8 @@ IDBTransaction.prototype.__createRequest = function (source) {
 /**
  * @typedef {(
  *   tx: import('websql-configurable/lib/websql/WebSQLTransaction.js').default,
- *   args: any[],
- *   success: (result?: any, req?: import('./IDBRequest.js').IDBRequestFull) => void,
+ *   args: unknown[],
+ *   success: (result?: unknown, req?: import('./IDBRequest.js').IDBRequestFull) => void,
  *   error: (
  *     tx: import('websql-configurable/lib/websql/WebSQLTransaction.js').default|Error|DOMException,
  *     err?: Error & {code?: number}
@@ -723,7 +723,7 @@ IDBTransaction.prototype.__createRequest = function (source) {
 /**
  * Adds a callback function to the transaction queue.
  * @param {SQLCallback} callback
- * @param {any[]} args
+ * @param {unknown[]} args
  * @param {import('./IDBDatabase.js').IDBDatabaseFull|
  *   import('./IDBObjectStore.js').IDBObjectStoreFull|
  *   import('./IDBIndex.js').IDBIndexFull} source
@@ -740,7 +740,7 @@ IDBTransaction.prototype.__addToTransactionQueue = function (callback, args, sou
  * Adds a callback function to the transaction queue without generating a
  *   request.
  * @param {SQLCallback} callback
- * @param {any[]} args
+ * @param {unknown[]} args
  * @this {IDBTransactionFull}
  * @returns {void}
  */
@@ -752,7 +752,7 @@ IDBTransaction.prototype.__addNonRequestToTransactionQueue = function (callback,
  * Adds an IDBRequest to the transaction queue.
  * @param {import('./IDBRequest.js').IDBRequestFull|null} request
  * @param {SQLCallback} callback
- * @param {any[]} args
+ * @param {unknown[]} args
  * @this {IDBTransactionFull}
  * @returns {void}
  */
@@ -923,7 +923,7 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
                 q.req.__error = createDOMException('AbortError', 'A request was aborted (an unfinished request).');
                 const reqEvt = createEvent('error', q.req.__error, {bubbles: true, cancelable: true});
                 return new SyncPromise(
-                    /** @type {(resolve: (value?: any) => void) => void} */
+                    /** @type {(resolve: (value?: unknown) => void) => void} */
                     (resolve) => {
                         setTimeout(() => {
                             if (!q.req) { // TS guard

package/src/IDBVersionChangeEvent.js

@@ -66,12 +66,9 @@ readonlyProperties.forEach((prop) => {
 });
 
 Object.defineProperty(IDBVersionChangeEvent, Symbol.hasInstance, {
-    /**
-     * @typedef {any} AnyValue
-     */
     value:
         /**
-         * @param {AnyValue} obj
+         * @param {unknown} obj
          * @returns {boolean}
          */
         (obj) => util.isObj(obj) && 'oldVersion' in obj &&

package/src/Key.js

@@ -39,12 +39,11 @@ import CFG from './CFG.js';
  */
 
 /**
- * @typedef {any} Value
+ * @typedef {unknown} Value
  */
 
 /**
- * @typedef {any} Key
- * @todo Specify possible value more precisely
+ * @typedef {IDBValidKey} Key
  */
 
 /**
@@ -113,15 +112,11 @@ const encodedCharToKeyType = keyTypes.reduce((o, k) => {
  */
 const signValues = ['negativeInfinity', 'bigNegative', 'smallNegative', 'smallPositive', 'bigPositive', 'positiveInfinity'];
 
-/**
- * @typedef {any} AnyValue
- */
-
 /**
  * @type {{
  *   [key: string]: {
- *     encode: (param: any, inArray?: boolean) => string,
- *     decode: (param: string, inArray?: boolean) => any
+ *     encode(param: unknown, inArray?: boolean): string,
+ *     decode(param: string, inArray?: boolean): ValueType|undefined
  *   }
  * }}
  */
@@ -473,7 +468,7 @@ function negate (s) {
 }
 
 /**
- * @param {Key} key
+ * @param {Value} key
  * @returns {KeyType|"invalid"}
  */
 function getKeyType (key) {
@@ -595,7 +590,7 @@ function convertValueToKeyValueDecoded (input, seen, multiEntry, fullKeys) {
         }
         return {type: 'binary', value: octets};
     } case 'array': { // May throw (from binary)
-        const arr = /** @type {Array<any>} */ (input);
+        const arr = /** @type {unknown[]} */ (input);
         const len = arr.length;
         safePush(seen, input);
 
@@ -615,8 +610,12 @@ function convertValueToKeyValueDecoded (input, seen, multiEntry, fullKeys) {
                     return {type, invalid: true, message: 'Bad array entry value-to-key conversion'};
                 }
                 if (!multiEntry ||
-                    (!fullKeys && keys.every((k) => cmp(k, key.value) !== 0)) ||
-                    (fullKeys && keys.every((k) => cmp(k, key) !== 0))
+                    (!fullKeys && keys.every((k) => cmp(
+                        /** @type {Key} */ (k), /** @type {Key} */ (key.value)
+                    ) !== 0)) ||
+                    (fullKeys && keys.every((k) => cmp(
+                        /** @type {Key} */ (k), /** @type {Key} */ (/** @type {unknown} */ (key))
+                    ) !== 0))
                 ) {
                     safePush(keys, fullKeys ? key : key.value);
                 }
@@ -647,7 +646,7 @@ function convertValueToKeyValueDecoded (input, seen, multiEntry, fullKeys) {
 
 /**
  *
- * @param {Key} key
+ * @param {Value} key
  * @param {boolean} [fullKeys]
  * @returns {KeyValueObject}
  * @todo Document other allowable `key`?
@@ -759,7 +758,7 @@ function evaluateKeyPathOnValueToDecodedValue (value, keyPath, multiEntry, fullK
             : {value: result};
     }
     if (keyPath === '') {
-        return {value};
+        return {value: /** @type {KeyPathEvaluateValueValue} */ (value)};
     }
     const identifiers = keyPath.split('.');
     return identifiers.some((idntfr) => {
@@ -797,12 +796,12 @@ function evaluateKeyPathOnValueToDecodedValue (value, keyPath, multiEntry, fullK
         return false;
     })
         ? {failure: true}
-        : {value};
+        : {value: /** @type {KeyPathEvaluateValueValue} */ (value)};
 }
 
 /**
  * Sets the inline key value.
- * @param {{[key: string]: AnyValue}} value
+ * @param {{[key: string]: Value}} value
  * @param {Key} key
  * @param {string} keyPath
  * @returns {void}
@@ -815,7 +814,7 @@ function injectKeyIntoValueUsingKeyPath (value, key, keyPath) {
         if (!hop) {
             Object.defineProperty(value, identifier, {value: {}, enumerable: true, writable: true, configurable: true});
         }
-        value = value[identifier];
+        value = /** @type {{[key: string]: Value}} */ (value[identifier]);
     });
     Object.defineProperty(value, /** @type {string} */ (last), {value: key, enumerable: true, writable: true, configurable: true}); // key is already a `keyValue` in our processing so no need to convert
 }
@@ -903,7 +902,7 @@ function isMultiEntryMatch (encodedEntry, encodedKey) {
  * @returns {Key[]}
  */
 function findMultiEntryMatches (keyEntry, range) {
-    /** @type {unknown[]} */
+    /** @type {Key[]} */
     const matches = [];
 
     if (Array.isArray(keyEntry)) {
@@ -935,7 +934,7 @@ function findMultiEntryMatches (keyEntry, range) {
 
 /**
  * Not currently in use but keeping for spec parity.
- * @param {Key} key
+ * @param {KeyValueObject} key
  * @throws {Error} Upon a "bad key"
  * @returns {ValueType}
  */
@@ -943,35 +942,37 @@ function convertKeyToValue (key) {
     const {type, value} = key;
     switch (type) {
     case 'number': case 'string': {
-        return value;
+        return /** @type {number|string} */ (value);
     } case 'array': {
         /** @type {ValueType[]} */
         const array = [];
-        const len = value.length;
+        const arrValue = /** @type {KeyValueObject[]} */ (value);
+        const len = arrValue.length;
         let index = 0;
         while (index < len) {
-            const entry = convertKeyToValue(value[index]);
+            const entry = convertKeyToValue(arrValue[index]);
             setArrayValue(array, index, entry);
             index++;
         }
         return array;
     } case 'date': {
-        return new Date(value);
+        return new Date(/** @type {number} */ (value));
     } case 'binary': {
-        const len = value.length;
+        const binValue = /** @type {Uint8Array} */ (value);
+        const len = binValue.length;
         const buffer = new ArrayBuffer(len);
         // Set the entries in buffer's [[ArrayBufferData]] to those in `value`
-        const uint8 = new Uint8Array(buffer, value.byteOffset || 0, value.byteLength);
-        uint8.set(value);
+        const uint8 = new Uint8Array(buffer, binValue.byteOffset || 0, binValue.byteLength);
+        uint8.set(binValue);
         return buffer;
-    } case 'invalid': default:
+    } default:
         throw new Error('Bad key');
     }
 }
 
 /**
  *
- * @param {Key} key
+ * @param {Value} key
  * @param {boolean} [inArray]
  * @returns {string|null}
  */
@@ -986,7 +987,7 @@ function encode (key, inArray) {
 
 /**
  *
- * @param {Key} key
+ * @param {string|null} key
  * @param {boolean} [inArray]
  * @throws {Error} Invalid number
  * @returns {undefined|ValueType}
@@ -1000,7 +1001,7 @@ function decode (key, inArray) {
 
 /**
  *
- * @param {Key} key
+ * @param {Value} key
  * @param {boolean} [inArray]
  * @returns {undefined|ValueType}
  */

package/src/Sca.js

@@ -102,7 +102,7 @@ function encode (obj, func) {
 }
 
 /**
- * @typedef {any} AnyValue
+ * @typedef {import('./Key.js').Value} AnyValue
  */
 
 /**

package/src/cmp.js

@@ -3,8 +3,8 @@ import {encode as keyEncode, decode as keyDecode} from './Key.js';
 
 /**
  * Compares two keys.
- * @param {import('./Key.js').Key} first
- * @param {import('./Key.js').Key} second
+ * @param {import('./Key.js').Key|null|undefined} first
+ * @param {import('./Key.js').Key|null|undefined} second
  * @returns {0|1|-1}
  */
 function cmp (first, second) {

package/src/nodeWebSQL.js

@@ -4,7 +4,7 @@ import CFG from './CFG.js';
 
 /**
  * @typedef {{
- *   _db: any,
+ *   _db: unknown,
  *   exec: typeof SQLiteDatabase['prototype']['exec']
  * }} SQLiteDatabaseInstance
  */
@@ -18,7 +18,10 @@ import CFG from './CFG.js';
  *   object yields that object as the `new` expression's result, overriding
  *   the default "return `this`" behavior), not something TypeScript can
  *   verify structurally.
- * @typedef {new (name: string, opts?: any) => SQLiteDatabaseInstance} SQLiteDatabaseConstructor
+ * @typedef {new (
+ *   name: string,
+ *   opts?: import('websql-configurable/lib/sqlite/SQLiteDatabase.js').SQLiteDatabaseOptions
+ * ) => SQLiteDatabaseInstance} SQLiteDatabaseConstructor
  */
 
 /**