indexeddbshim 18.0.0 → 19.0.0

package/dist/indexeddbshim-UnicodeIdentifiers-node.cjs

@@ -1,4 +1,4 @@
-/*! indexeddbshim - v18.0.0 - 9/3/2026 */
+/*! indexeddbshim - v19.0.0 - 9/3/2026 */
 
 'use strict';
 
@@ -1545,7 +1545,7 @@ val => {
 // Callback not used by default
 // Defaults to true except in Node builds where we can preserve literal NUL with better-sqlite3
 'escapeNULForSQLiteStatements', 'sqlMemoryQuota', 'createIndexes'].forEach(prop => {
-  /** @type {(val: any) => void} */
+  /** @type {(val: ConfigValue) => void} */
   let validator;
   if (Array.isArray(prop)) {
     [prop, validator] = prop;
@@ -1765,9 +1765,11 @@ function joinPath(base, name) {
   return base.replace(/[/\\]+$/u, '') + sep + name;
 }
 
+/* eslint-disable jsdoc/valid-types -- Bug */
 /**
- * @typedef {Function} AnyClass
+ * @typedef {{[Symbol.hasInstance]: (value: unknown) => boolean}} AnyClass
  */
+/* eslint-enable jsdoc/valid-types -- Bug */
 
 // Babel doesn't seem to provide a means of using the `instanceof` operator with Symbol.hasInstance (yet?)
 /**
@@ -1791,7 +1793,7 @@ function isObj(obj) {
 
 /**
  *
- * @param {object} obj
+ * @param {AnyValue} obj
  * @returns {boolean}
  */
 function isDate(obj) {
@@ -1800,7 +1802,7 @@ function isDate(obj) {
 
 /**
  *
- * @param {object} obj
+ * @param {AnyValue} obj
  * @returns {boolean}
  */
 function isBlob(obj) {
@@ -1809,7 +1811,7 @@ function isBlob(obj) {
 
 /**
  *
- * @param {object} obj
+ * @param {AnyValue} obj
  * @returns {boolean}
  */
 function isFile(obj) {
@@ -1831,7 +1833,7 @@ function isBinary(obj) {
 /**
  *
  * @param {AnyValue} obj
- * @returns {boolean}
+ * @returns {obj is Iterable<unknown>}
  */
 function isIterable(obj) {
   return isObj(obj) &&
@@ -1883,9 +1885,7 @@ function defineReadonlyOuterInterface(obj, props) {
 
 /**
  *
- * @param {object & {
- *   [key: string]: any
- * }} obj
+ * @param {object} obj
  * @param {string[]} listeners
  * @returns {void}
  */
@@ -1894,13 +1894,13 @@ function defineListenerProperties(obj, listeners) {
   listeners.forEach(listener => {
     const o = {
       get [listener]() {
-        return obj['__' + listener];
+        return Reflect.get(obj, '__' + listener);
       },
       /**
        * @param {AnyValue} val
        */
       set [listener](val) {
-        obj['__' + listener] = val;
+        Reflect.set(obj, '__' + listener, val);
       }
     };
     const desc = /** @type {PropertyDescriptor} */
@@ -1910,7 +1910,7 @@ function defineListenerProperties(obj, listeners) {
     Object.defineProperty(obj, listener, desc);
   });
   listeners.forEach(l => {
-    obj[l] = null;
+    Reflect.set(obj, l, null);
   });
 }
 
@@ -1919,7 +1919,7 @@ function defineListenerProperties(obj, listeners) {
  * @param {object} obj
  * @param {string|string[]} props
  * @param {null|{
- *   [key: string]: any
+ *   [key: string]: unknown
  * }} getter
  * @returns {void}
  */
@@ -2056,7 +2056,7 @@ function enforceRange(number, type) {
 }
 
 /**
- * @typedef {any} AnyValue
+ * @typedef {unknown} AnyValue
  */
 
 /**
@@ -2074,8 +2074,11 @@ function convertToDOMString(v, treatNullAs) {
  */
 function ToString(o) {
   // Todo: See `es-abstract/es7`
-  // `String()` will not throw with Symbols
-  return '' + o; // eslint-disable-line no-implicit-coercion -- Need to throw with symbols
+  // `String()` will not throw with Symbols, but the unchecked `+ ''`
+  //   coercion deliberately does (Web IDL requires converting a symbol
+  //   to `DOMString` to throw a `TypeError`); the assertion only tells
+  //   the compiler to allow the coercion it cannot model.
+  return '' + (/** @type {string} */o); // eslint-disable-line no-implicit-coercion -- Need to throw with symbols
 }
 
 /**
@@ -2182,12 +2185,9 @@ function createEvent(type, debug, evInit) {
 // We don't add within polyfill repo as might not always be the desired implementation
 Object.defineProperty(ShimEvent, Symbol.hasInstance, {
   /* eslint-enable unicorn/no-top-level-side-effects -- Would be good */
-  /**
-   * @typedef {any} AnyValue
-   */
   value:
   /**
-   * @param {AnyValue} obj
+   * @param {unknown} obj
    * @returns {boolean}
    */
   obj => isObj(obj) && 'target' in obj && 'bubbles' in obj && typeof obj.bubbles === 'boolean'
@@ -2255,12 +2255,9 @@ readonlyProperties$7.forEach(prop => {
   Object.defineProperty(IDBVersionChangeEvent.prototype, prop, desc);
 });
 Object.defineProperty(IDBVersionChangeEvent, Symbol.hasInstance, {
-  /**
-   * @typedef {any} AnyValue
-   */
   value:
   /**
-   * @param {AnyValue} obj
+   * @param {unknown} obj
    * @returns {boolean}
    */
   obj => isObj(obj) && 'oldVersion' in obj && 'defaultPrevented' in obj && typeof obj.defaultPrevented === 'boolean'
@@ -2540,25 +2537,20 @@ function logError(name, message, error) {
 }
 
 /**
- * @typedef {any} ArbitraryValue
- */
-
-/**
- * @param {ArbitraryValue} obj
+ * @param {unknown} 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
-  typeof obj.name === 'string';
+  return typeof obj === 'object' && obj !== null && 'name' in obj && typeof obj.name === 'string';
 }
 
 /**
  * Finds the error argument.  This is useful because some WebSQL callbacks
  * pass the error as the first argument, and some pass it as the second
  * argument.
- * @param {(Error|{message?: string, name?: string}|any)[]} args
- * @returns {Error|DOMException|undefined}
+ * @param {unknown[]} args
+ * @returns {unknown}
  */
 function findError(args) {
   let err;
@@ -2570,7 +2562,7 @@ function findError(args) {
       if (isErrorOrDOMErrorOrDOMException(arg)) {
         return arg;
       }
-      if (arg && typeof arg.message === 'string') {
+      if (typeof arg === 'object' && arg !== null && 'message' in arg && typeof arg.message === 'string') {
         err = arg;
       }
     }
@@ -2690,7 +2682,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|
@@ -3146,8 +3138,8 @@ class SyncPromise {
 
 /**
  * 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) {
@@ -3221,12 +3213,11 @@ const safePush = (arr, val) => setArrayValue(arr, arr.length, val);
  */
 
 /**
- * @typedef {any} Value
+ * @typedef {unknown} Value
  */
 
 /**
- * @typedef {any} Key
- * @todo Specify possible value more precisely
+ * @typedef {IDBValidKey} Key
  */
 
 /**
@@ -3293,15 +3284,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
  *   }
  * }}
  */
@@ -3633,7 +3620,7 @@ function negate(s) {
 }
 
 /**
- * @param {Key} key
+ * @param {Value} key
  * @returns {KeyType|"invalid"}
  */
 function getKeyType(key) {
@@ -3777,7 +3764,7 @@ function convertValueToKeyValueDecoded(input, seen, multiEntry, fullKeys) {
     case 'array':
       {
         // May throw (from binary)
-        const arr = /** @type {Array<any>} */input;
+        const arr = /** @type {unknown[]} */input;
         const len = arr.length;
         safePush(seen, input);
 
@@ -3805,7 +3792,7 @@ function convertValueToKeyValueDecoded(input, seen, multiEntry, fullKeys) {
                 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)) {
+            if (!multiEntry || !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);
             }
           } catch (err) {
@@ -3855,7 +3842,7 @@ function convertValueToKeyValueDecoded(input, seen, multiEntry, fullKeys) {
 
 /**
  *
- * @param {Key} key
+ * @param {Value} key
  * @param {boolean} [fullKeys]
  * @returns {KeyValueObject}
  * @todo Document other allowable `key`?
@@ -3970,7 +3957,7 @@ function evaluateKeyPathOnValueToDecodedValue(value, keyPath, multiEntry, fullKe
   }
   if (keyPath === '') {
     return {
-      value
+      value: (/** @type {KeyPathEvaluateValueValue} */value)
     };
   }
   const identifiers = keyPath.split('.');
@@ -4004,13 +3991,13 @@ function evaluateKeyPathOnValueToDecodedValue(value, keyPath, multiEntry, fullKe
   }) ? {
     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}
@@ -4028,7 +4015,7 @@ function injectKeyIntoValueUsingKeyPath(value, key, keyPath) {
         configurable: true
       });
     }
-    value = value[identifier];
+    value = /** @type {{[key: string]: Value}} */value[identifier];
   });
   Object.defineProperty(value, /** @type {string} */last, {
     value: key,
@@ -4104,7 +4091,7 @@ function isMultiEntryMatch(encodedEntry, encodedKey) {
  * @returns {Key[]}
  */
 function findMultiEntryMatches(keyEntry, range) {
-  /** @type {unknown[]} */
+  /** @type {Key[]} */
   const matches = [];
   if (Array.isArray(keyEntry)) {
     for (let key of keyEntry) {
@@ -4134,7 +4121,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}
  */
@@ -4147,16 +4134,17 @@ function convertKeyToValue(key) {
     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++;
         }
@@ -4164,18 +4152,18 @@ function convertKeyToValue(key) {
       }
     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:
       throw new Error('Bad key');
   }
@@ -4183,7 +4171,7 @@ function convertKeyToValue(key) {
 
 /**
  *
- * @param {Key} key
+ * @param {Value} key
  * @param {boolean} [inArray]
  * @returns {string|null}
  */
@@ -4198,7 +4186,7 @@ function encode$1(key, inArray) {
 
 /**
  *
- * @param {Key} key
+ * @param {string|null} key
  * @param {boolean} [inArray]
  * @throws {Error} Invalid number
  * @returns {undefined|ValueType}
@@ -4212,7 +4200,7 @@ function decode$1(key, inArray) {
 
 /**
  *
- * @param {Key} key
+ * @param {Value} key
  * @param {boolean} [inArray]
  * @returns {undefined|ValueType}
  */
@@ -4430,8 +4418,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}
@@ -4634,10 +4622,11 @@ function setSQLForKeyRange(range, quotedKeyColumnName, sql, sqlValues, addAnd, c
 function convertValueToKeyRange(value, nullDisallowed) {
   if (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 (isNullish(value)) {
     if (nullDisallowed) {
@@ -4664,7 +4653,7 @@ function convertValueToKeyRange(value, nullDisallowed) {
  *   clone: () => DOMStringListFull,
  *   contains: (str: string) => boolean,
  *   indexOf: (str: string) => Integer,
- *   splice: (index: Integer, howmany: Integer, ...args: any) => void
+ *   splice: (index: Integer, howmany: Integer, ...args: string[]) => void
  *   length: Integer
  * }} DOMStringListFull
  */
@@ -4781,9 +4770,10 @@ DOMStringList.prototype = {
   },
   /**
    * @this {DOMStringListFull}
-   * @param {(value: string, i: Integer, arr: string[]) => any[]} cb
+   * @template T
+   * @param {(value: string, i: Integer, arr: string[]) => T} cb
    * @param {object} thisArg
-   * @returns {any[]}
+   * @returns {T[]}
    */
   map(cb, thisArg) {
     // eslint-disable-next-line unicorn/no-array-callback-reference, unicorn/no-array-method-this-argument -- Convenient
@@ -4808,10 +4798,7 @@ DOMStringList.prototype = {
     this.sortList();
   },
   /**
-   * @typedef {any} AnyArgs
-   */
-  /**
-   * @param {[index: Integer, howmany: Integer, ...args: any]} args
+   * @param {[index: Integer, howmany: Integer, ...args: string[]]} args
    * @this {DOMStringListFull}
    * @returns {void}
    */
@@ -4845,12 +4832,9 @@ DOMStringList.prototype = {
 };
 
 /* eslint-disable unicorn/no-top-level-side-effects -- Would be good */
-/**
- * @typedef {any} AnyValue
- */
 Object.defineProperty(DOMStringList, Symbol.hasInstance, {
   /**
-   * @param {AnyValue} obj
+   * @param {unknown} obj
    * @returns {boolean}
    */
   value(obj) {
@@ -4931,7 +4915,7 @@ const readonlyProperties$4 = ['objectStoreNames', 'mode', 'durability', 'db', 'e
 /**
  * @typedef {{
  *   op: SQLCallback,
- *   args: any[],
+ *   args: unknown[],
  *   req: import('./IDBRequest.js').IDBRequestFull|null
  * }} RequestInfo
  */
@@ -4983,17 +4967,17 @@ const readonlyProperties$4 = ['objectStoreNames', 'mode', 'durability', 'db', 'e
  *   __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|
@@ -5193,7 +5177,7 @@ IDBTransaction.prototype.__executeRequests = function () {
       i = -1;
 
     /**
-     * @typedef {any} IDBRequestResult
+     * @typedef {unknown} IDBRequestResult
      */
 
     /**
@@ -5624,8 +5608,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}
@@ -5637,7 +5621,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
@@ -5654,7 +5638,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}
  */
@@ -5666,7 +5650,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}
  */
@@ -5835,7 +5819,7 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
           bubbles: true,
           cancelable: true
         });
-        return new SyncPromise(/** @type {(resolve: (value?: any) => void) => void} */
+        return new SyncPromise(/** @type {(resolve: (value?: unknown) => void) => void} */
         resolve => {
           setTimeout(() => {
             if (!q.req) {
@@ -7650,7 +7634,7 @@ function encode(obj, func) {
 }
 
 /**
- * @typedef {any} AnyValue
+ * @typedef {import('./Key.js').Value} AnyValue
  */
 
 /**
@@ -7760,7 +7744,7 @@ const IDBIndexAlias = IDBIndex;
  *   __keyPath: import('./Key.js').KeyPath,
  *   __recreated?: boolean,
  *   __fetchIndexData: (
- *     range: any,
+ *     range: Query,
  *     opType: "value"|"key"|"count",
  *     nullDisallowed: boolean,
  *     count?: number
@@ -8136,7 +8120,7 @@ IDBIndex.__updateIndexList = function (store, tx, success, failure) {
 };
 
 /**
- * @typedef {any|IDBKeyRange} Query
+ * @typedef {import('./Key.js').Value|IDBKeyRange} Query
  */
 
 /**
@@ -8409,7 +8393,7 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
                 reject(err);
               });
             }));
-            SyncPromise.all(indexCreations).then(finish).catch(/** @type {(reason: any) => PromiseLike<never>} */
+            SyncPromise.all(indexCreations).then(finish).catch(/** @type {(reason: unknown) => PromiseLike<never>} */
             error).catch(err => {
               console.log('Index rename error');
               throw err;
@@ -8421,14 +8405,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 => isObj(obj) && 'openCursor' in obj && typeof obj.openCursor === 'function' && 'multiEntry' in obj && typeof obj.multiEntry === 'boolean'
@@ -8454,7 +8434,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}
  */
@@ -8491,7 +8473,7 @@ function executeFetchIndexData(count, unboundedDisallowed, index, hasKey, range,
      * @param {{
      *   value: string
      * }} record
-     * @returns {AnyValue}
+     * @returns {import('./Key.js').Value}
      */
     record => {
       // when opType is value
@@ -8505,9 +8487,9 @@ function executeFetchIndexData(count, unboundedDisallowed, index, hasKey, range,
         const rowKey = /** @type {import('./Key.js').ValueTypeArray} */
         decode$1(row[escapedIndexNameForKeyCol]);
         let record;
-        if (hasKey && (multiChecks && range.some(
+        if (hasKey && (multiChecks && /** @type {import('./Key.js').ValueType[]} */range.some(
         /**
-         * @param {string} check
+         * @param {import('./Key.js').ValueType} check
          * @returns {boolean}
          */
         check => rowKey.includes(check)) ||
@@ -8653,14 +8635,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: (
@@ -8971,7 +8953,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),
@@ -8986,7 +8968,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}
@@ -9002,11 +8984,11 @@ IDBObjectStore.prototype.__validateKeyAndValueAndCloneValue = function (value, k
     //   occurs sync; then can make cloning and this method without callbacks (except where ok
     //   to be async)
     const clonedValue = cloneWithInactiveTransaction(/** @type {import('./IDBTransaction.js').IDBTransactionFull} */me.transaction, value);
-    key = extractKeyValueDecodedFromValueUsingKeyPath(clonedValue, me.keyPath); // May throw so "rethrow"
-    if (key.invalid) {
+    const extractedKey = 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');
@@ -9021,14 +9003,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 {
     convertValueToKeyRethrowingAndIfInvalid(key);
   }
@@ -9043,8 +9024,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}
@@ -9059,9 +9040,8 @@ IDBObjectStore.prototype.__deriveKey = function (tx, value, key, success, failCb
    */
   function keyCloneThenSuccess(oldCn) {
     // We want to return the original key, so we don't need to accept an argument here
-    encode(key, function (key) {
-      key = decode(key);
-      success(key, oldCn);
+    encode(key, function (encodedKey) {
+      success(decode(encodedKey), oldCn);
     });
   }
   if (me.autoIncrement) {
@@ -9075,7 +9055,7 @@ IDBObjectStore.prototype.__deriveKey = function (tx, value, key, success, failCb
         if (me.keyPath !== null) {
           // Should not throw now as checked earlier
           // Todo: Could this not be an array here?
-          injectKeyIntoValueUsingKeyPath(value, key, /** @type {string} */me.keyPath);
+          injectKeyIntoValueUsingKeyPath(/** @type {{[key: string]: import('./Key.js').Value}} */value, /** @type {import('./Key.js').Key} */key, /** @type {string} */me.keyPath);
         }
         success(key, oldCn);
       }, failCb);
@@ -9132,15 +9112,15 @@ 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;
         }
@@ -9213,21 +9193,21 @@ 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} */
-        encode$1(indexKey, index.multiEntry);
+        encode$1(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);
@@ -9386,7 +9366,9 @@ IDBObjectStore.__storingRecordObjectStore = function (request, store, invalidate
   const key = arguments[5];
   /** @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;
       encode(value, function (encoded) {
         /**
          * @param {WebSQLTransaction} tx
@@ -10763,7 +10745,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) {
@@ -10787,7 +10769,9 @@ IDBFactory.prototype.open = function (name /* , version */) {
                   cb(sqlErr); // eslint-disable-line promise/no-callback-in-promise -- Convenient
                 }, 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);
                 });
               };
               try {
@@ -10820,13 +10804,13 @@ IDBFactory.prototype.open = function (name /* , version */) {
                 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 */) {
@@ -11533,16 +11517,16 @@ const cursorDirections = ['next', 'prev', 'nextunique', 'prevunique'];
 
 /**
  * @typedef {IDBCursor & {
- *   primaryKey: import('./Key.js').Key,
- *   key:  import('./Key.js').Key,
+ *   primaryKey: import('./Key.js').Key|null|undefined,
+ *   key:  import('./Key.js').Key|null|undefined,
  *   direction: string,
  *   source: import('./IDBObjectStore.js').IDBObjectStoreFull|
  *     import('./IDBIndex.js').IDBIndexFull,
  *   __request: import('./IDBRequest.js').IDBRequestFull,
  *   __advanceCount: Integer|undefined,
  *   __indexSource: boolean,
- *   __key: import('./Key.js').Key,
- *   __primaryKey: import('./Key.js').Key,
+ *   __key: import('./Key.js').Key|null|undefined,
+ *   __primaryKey: import('./Key.js').Key|null|undefined,
  *   __value: import('./Key.js').Value,
  *   __store: import('./IDBObjectStore.js').IDBObjectStoreFull,
  *   __range: import('./IDBKeyRange.js').IDBKeyRangeFull|undefined,
@@ -11550,13 +11534,13 @@ const cursorDirections = ['next', 'prev', 'nextunique', 'prevunique'];
  *   __valueColumnName: string,
  *   __keyOnly: boolean,
  *   __valueDecoder: {
- *     decode: (str: string) => any,
+ *     decode: (str: string) => import('./Key.js').Value,
  *   },
  *   __count: boolean,
  *   __prefetchedIndex: Integer,
  *   __prefetchedData: null|{
  *     length: number;
- *     item(index: number): any;
+ *     item(index: number): unknown;
  *   }|{
  *     data: RowItemNonNull[],
  *     length: Integer,
@@ -11571,7 +11555,14 @@ const cursorDirections = ['next', 'prev', 'nextunique', 'prevunique'];
  *   __multiEntryExhausted: boolean,
  *   __invalidateCache: () => void,
  *   __gotValue: boolean,
- *   __find: (...args: any[]) => void,
+ *   __find: (
+ *     key: import('./Key.js').Key|undefined,
+ *     primaryKey: import('./Key.js').Key|undefined,
+ *     tx: WebSQLTransaction,
+ *     success: KeySuccess,
+ *     error: FindError,
+ *     recordsToLoad?: Integer
+ *   ) => void,
  *   __findBasic: (
  *     key: import('./Key.js').Key|undefined,
  *     primaryKey: import('./Key.js').Key|undefined,
@@ -11592,17 +11583,17 @@ const cursorDirections = ['next', 'prev', 'nextunique', 'prevunique'];
  *   __decode: (
  *     rowItem: RowItemNonNull,
  *     callback: (
- *       key: import('./Key.js').Key,
+ *       key: import('./Key.js').Key|undefined,
  *       val: import('./Key.js').Value,
- *       primaryKey: import('./Key.js').Key,
+ *       primaryKey: import('./Key.js').Key|undefined,
  *       encKey?: string
  *     ) => void
  *   ) => void,
  *   __sourceOrEffectiveObjStoreDeleted: () => void,
  *   __continue: (key?: import('./Key.js').Key, advanceContinue?: boolean) => void,
  *   __continueFinish: (
- *     key: import('./Key.js').Key,
- *     primaryKey: import('./Key.js').Key,
+ *     key: import('./Key.js').Key|undefined,
+ *     primaryKey: import('./Key.js').Key|undefined,
  *     advanceState: boolean
  *   ) => void
  * }} IDBCursorFull
@@ -11635,7 +11626,7 @@ const IDBCursorAlias = IDBCursor;
  *   import('./IDBIndex.js').IDBIndexFull} source
  * @param {string} keyColumnName
  * @param {string} valueColumnName
- * @param {boolean} count
+ * @param {boolean} [count]
  * @this {IDBCursorFull}
  * @returns {void}
  */
@@ -11676,7 +11667,7 @@ IDBCursor.__super = function IDBCursor(query, direction, store, source, keyColum
   this.__valueColumnName = valueColumnName;
   this.__keyOnly = valueColumnName === 'key';
   this.__valueDecoder = this.__keyOnly ? Key : Sca;
-  this.__count = count;
+  this.__count = Boolean(count);
   this.__prefetchedIndex = -1;
   this.__continuationKey = undefined;
   this.__continuationPrimaryKey = undefined;
@@ -11695,25 +11686,36 @@ IDBCursor.__super = function IDBCursor(query, direction, store, source, keyColum
 
 /**
  *
- * @param {...any} args
+ * @param {IDBKeyRange} query
+ * @param {string} direction
+ * @param {import('./IDBObjectStore.js').IDBObjectStoreFull} store
+ * @param {import('./IDBObjectStore.js').IDBObjectStoreFull|
+ *   import('./IDBIndex.js').IDBIndexFull} source
+ * @param {string} keyColumnName
+ * @param {string} valueColumnName
+ * @param {boolean} [count]
  * @returns {IDBCursorFull}
  */
-IDBCursor.__createInstance = function (...args) {
+IDBCursor.__createInstance = function (query, direction, store, source, keyColumnName, valueColumnName, count) {
   const IDBCursor = IDBCursorAlias.__super;
   IDBCursor.prototype = IDBCursorAlias.prototype;
 
   // @ts-expect-error It's ok
-  return new IDBCursor(...args);
+  return new IDBCursor(query, direction, store, source, keyColumnName, valueColumnName, count);
 };
 
 /**
  *
- * @param {...any} args
+ * @param {import('./Key.js').Key|undefined} key
+ * @param {import('./Key.js').Key|undefined} primaryKey
+ * @param {WebSQLTransaction} tx
+ * @param {KeySuccess} success
+ * @param {FindError} error
+ * @param {Integer} [recordsToLoad]
  * @this {IDBCursorFull}
  * @returns {void}
  */
-IDBCursor.prototype.__find = function (...args /* key, tx, success, error, recordsToLoad */) {
-  const [key, primaryKey, tx, success, error, recordsToLoad] = args;
+IDBCursor.prototype.__find = function (key, primaryKey, tx, success, error, recordsToLoad) {
   if (this.__multiEntryIndex) {
     this.__findMultiEntry(key, primaryKey, tx, success, error, recordsToLoad);
   } else {
@@ -11723,9 +11725,9 @@ IDBCursor.prototype.__find = function (...args /* key, tx, success, error, recor
 
 /**
  * @typedef {(
- *   k: import('./Key.js').Key,
+ *   k: import('./Key.js').Key|undefined,
  *   val: import('./Key.js').Value,
- *   primKey: import('./Key.js').Key
+ *   primKey: import('./Key.js').Key|undefined
  * ) => void} KeySuccess
  */
 
@@ -11822,7 +11824,7 @@ IDBCursor.prototype.__findBasic = function (key, primaryKey, tx, success, error,
       me.__prefetchedIndex = 0;
       me.__prefetchedData = data.rows;
       if (CFG.DEBUG) {
-        console.log('Preloaded ' + me.__prefetchedData.length + ' records for cursor');
+        console.log('Preloaded ' + data.rows.length + ' records for cursor');
       }
       me.__decode(/** @type {RowItemNonNull} */data.rows.item(0), success);
     } else if (data.rows.length === 1) {
@@ -11946,7 +11948,7 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
         for (let i = 0; i < data.rows.length; i++) {
           const rowItem = /** @type {RowItemNonNull} */data.rows.item(i);
           const rowKey = decode$1(rowItem[me.__keyColumnName], true);
-          const matches = findMultiEntryMatches(rowKey, me.__range);
+          const matches = findMultiEntryMatches(/** @type {import('./Key.js').Key} */rowKey, me.__range);
           ct += matches.length;
         }
         success(undefined, ct, undefined);
@@ -11966,7 +11968,7 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
       for (let i = 0; i < data.rows.length; i++) {
         const rowItem = /** @type {RowItemNonNull} */data.rows.item(i);
         const rowKey = decode$1(rowItem[me.__keyColumnName], true);
-        const matches = findMultiEntryMatches(rowKey, me.__range);
+        const matches = findMultiEntryMatches(/** @type {import('./Key.js').Key} */rowKey, me.__range);
         for (const matchingKey of matches) {
           /**
            * @type {RowItemNonNull}
@@ -12040,11 +12042,11 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
 };
 
 /**
- * @typedef {any} StructuredCloneValue
+ * @typedef {import('./Key.js').Value} StructuredCloneValue
  */
 
 /**
- * @typedef {any} IndexedDBKey
+ * @typedef {import('./Key.js').Key} IndexedDBKey
  */
 
 /**
@@ -12056,9 +12058,9 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
 
 /**
  * @callback SuccessCallback
- * @param {IndexedDBKey} key
+ * @param {IndexedDBKey|undefined} key
  * @param {StructuredCloneValue} value
- * @param {IndexedDBKey} primaryKey
+ * @param {IndexedDBKey|undefined} primaryKey
  * @returns {void}
  */
 
@@ -12098,9 +12100,9 @@ IDBCursor.prototype.__onsuccess = function (success) {
  *
  * @param {RowItemNonNull} rowItem
  * @param {(
- *   key: import('./Key.js').Key,
+ *   key: import('./Key.js').Key|undefined,
  *   val: import('./Key.js').Value,
- *   primaryKey: import('./Key.js').Key,
+ *   primaryKey: import('./Key.js').Key|undefined,
  *   encKey?: string
  * ) => void} callback
  * @this {IDBCursorFull}
@@ -12175,8 +12177,8 @@ IDBCursor.prototype.__continue = function (key, advanceContinue) {
 
 /**
  *
- * @param {import('./Key.js').Key} key
- * @param {import('./Key.js').Key} primaryKey
+ * @param {import('./Key.js').Key|undefined} key
+ * @param {import('./Key.js').Key|undefined} primaryKey
  * @param {boolean} advanceState
  * @this {IDBCursorFull}
  * @returns {void}
@@ -12190,9 +12192,9 @@ IDBCursor.prototype.__continueFinish = function (key, primaryKey, advanceState)
   /** @type {import('./IDBTransaction.js').IDBTransactionFull} */
   me.__store.transaction.__pushToQueue(me.__request, function cursorContinue(tx, args, success, error, executeNextRequest) {
     /**
-     * @param {import('./Key.js').Key} k
+     * @param {import('./Key.js').Key|undefined} k
      * @param {import('./Key.js').Value} val
-     * @param {import('./Key.js').Key} primKey
+     * @param {import('./Key.js').Key|undefined} primKey
      * @returns {void}
      */
     function triggerSuccess(k, val, primKey) {
@@ -12236,7 +12238,7 @@ IDBCursor.prototype.__continueFinish = function (key, primaryKey, advanceState)
       // We have pre-loaded data for the cursor
       me.__prefetchedIndex++;
       if (me.__prefetchedIndex < me.__prefetchedData.length) {
-        me.__decode(me.__prefetchedData.item(me.__prefetchedIndex), function (k, val, primKey, encKey) {
+        me.__decode(/** @type {RowItemNonNull} */me.__prefetchedData.item(me.__prefetchedIndex), function (k, val, primKey, encKey) {
           /**
            * @returns {void}
            */
@@ -12371,12 +12373,18 @@ IDBCursor.prototype.advance = function (count) {
 };
 
 /**
- * @typedef {any} AnyValue
+ * The `{query, count, direction}` options shape shared by
+ *   `getAll`/`getAllKeys`/`getAllRecords`.
+ * @typedef {{
+ *   query?: import('./Key.js').Value,
+ *   count?: Integer,
+ *   direction?: string
+ * }} GetAllOptions
  */
 
 /**
  *
- * @param {AnyValue} valueToUpdate
+ * @param {import('./Key.js').Value} valueToUpdate
  * @this {IDBCursorFull}
  * @returns {IDBRequest}
  */
@@ -12499,16 +12507,22 @@ Object.defineProperty(IDBCursorWithValue.prototype, 'constructor', {
 const IDBCursorWithValueAlias = IDBCursorWithValue;
 /**
  *
- * @param {...any} args
+ * @param {IDBKeyRange} query
+ * @param {string} direction
+ * @param {import('./IDBObjectStore.js').IDBObjectStoreFull} store
+ * @param {import('./IDBObjectStore.js').IDBObjectStoreFull|
+ *   import('./IDBIndex.js').IDBIndexFull} source
+ * @param {string} keyColumnName
+ * @param {string} valueColumnName
+ * @param {boolean} [count]
  * @returns {IDBCursorWithValueFull}
  */
-IDBCursorWithValue.__createInstance = function (...args) {
+IDBCursorWithValue.__createInstance = function (query, direction, store, source, keyColumnName, valueColumnName, count) {
   /**
    * @class
    * @this {IDBCursorWithValueFull}
    */
   function IDBCursorWithValue() {
-    const [query, direction, store, source, keyColumnName, valueColumnName, count] = args;
     IDBCursor.__super.call(this, query, direction, store, source, keyColumnName, valueColumnName, count);
     // @ts-expect-error It's ok
     this[Symbol.toStringTag] = 'IDBCursorWithValue';
@@ -12531,16 +12545,20 @@ Object.defineProperty(IDBCursorWithValue, 'prototype', {
 /**
  * Validates `direction` and fills in defaults for the `{query, count,
  *   direction}` shape shared by `getAll`/`getAllKeys`/`getAllRecords`.
- * @param {AnyValue} options
+ * @param {unknown} options
  * @throws {TypeError}
- * @returns {{query: AnyValue, count: Integer|undefined, direction: string}}
+ * @returns {{
+ *   query: import('./Key.js').Value|undefined,
+ *   count: Integer|undefined,
+ *   direction: string
+ * }}
  */
 function normalizeGetAllOptions(options) {
   const {
     query,
     count,
     direction = 'next'
-  } = /** @type {AnyValue} */options ?? {};
+  } = /** @type {GetAllOptions} */options ?? {};
   if (!cursorDirections.includes(direction)) {
     throw new TypeError('`' + direction + '` is not a valid direction');
   }
@@ -12565,7 +12583,11 @@ function normalizeGetAllOptions(options) {
  *   first argument wins regardless of how many arguments were actually passed.
  * @param {IArguments} args
  * @throws {TypeError}
- * @returns {{query: AnyValue, count: Integer|undefined, direction: string}}
+ * @returns {{
+ *   query: import('./Key.js').Value|undefined,
+ *   count: Integer|undefined,
+ *   direction: string
+ * }}
  */
 function parseGetAllArgs(args) {
   const arg0 = args[0];
@@ -12586,7 +12608,11 @@ function parseGetAllArgs(args) {
  *   form to disambiguate against.
  * @param {IArguments} args
  * @throws {TypeError}
- * @returns {{query: AnyValue, count: Integer|undefined, direction: string}}
+ * @returns {{
+ *   query: import('./Key.js').Value|undefined,
+ *   count: Integer|undefined,
+ *   direction: string
+ * }}
  */
 function parseGetAllRecordsArgs(args) {
   return normalizeGetAllOptions(args[0]);
@@ -12693,7 +12719,7 @@ function collectAll(source, query, count, direction, mode) {
     value: direction
   });
   return tx.__addToTransactionQueue(function collectAllOp(sqlTx, args, success, error) {
-    /** @type {AnyValue[]} */
+    /** @type {unknown[]} */
     const results = [];
     const recordsToLoad = count || CFG.cursorPreloadPackSize || 100;
 
@@ -12733,7 +12759,7 @@ function collectAll(source, query, count, direction, mode) {
       if (state.__prefetchedData) {
         state.__prefetchedIndex++;
         if (state.__prefetchedIndex < state.__prefetchedData.length) {
-          IDBCursor.prototype.__decode.call(state, state.__prefetchedData.item(state.__prefetchedIndex),
+          IDBCursor.prototype.__decode.call(state, /** @type {RowItemNonNull} */state.__prefetchedData.item(state.__prefetchedIndex),
           /**
            * @param {import('./Key.js').Key} k
            * @param {import('./Key.js').Value} val
@@ -12763,15 +12789,11 @@ function collectAll(source, query, count, direction, mode) {
   }, undefined, source);
 }
 
-/**
- * @typedef {any} AnyValue
- */
-
 /**
  * @callback SetConfig
  * @param {import('./CFG.js').KeyofConfigValues|
  *   Partial<import('./CFG.js').ConfigValues>} prop
- * @param {AnyValue} [val]
+ * @param {import('./CFG.js').ConfigValue} [val]
  * @throws {Error}
  * @returns {void}
  */
@@ -12856,18 +12878,9 @@ function setGlobalVars(idb, initialConfig) {
   }
   const IDB = /** @type {ShimmedObject & {[key: string]: unknown}} */
   /** @type {unknown} */idb || globalThis || {};
-  /**
-   * @typedef {any} AnyClass
-   */
-  /**
-   * @typedef {any} AnyValue
-   */
-  /**
-   * @typedef {Function} AnyFunction
-   */
   /**
    * @param {string} name
-   * @param {AnyClass} value
+   * @param {unknown} value
    * @param {PropertyDescriptor & {
    *   shimNS?: object
    * }|undefined} [propDesc]
@@ -12896,10 +12909,10 @@ function setGlobalVars(idb, initialConfig) {
         } else {
           const o = {
             /**
-             * @returns {AnyValue}
+             * @returns {unknown}
              */
             get [name]() {
-              return /** @type {AnyFunction} */(/** @type {PropertyDescriptor} */propDesc.get).call(this);
+              return /** @type {() => unknown} */(/** @type {PropertyDescriptor} */propDesc.get).call(this);
             }
           };
           desc = /** @type {PropertyDescriptor} */
@@ -12973,7 +12986,7 @@ function setGlobalVars(idb, initialConfig) {
             return shimIndexedDB;
           }
         });
-        /** @type {[string, any][]} */
+        /** @type {[string, unknown][]} */
         [['IDBFactory', shimIDBFactory], ['IDBDatabase', IDBDatabase], ['IDBObjectStore', IDBObjectStore], ['IDBIndex', IDBIndex], ['IDBTransaction', IDBTransaction], ['IDBCursor', IDBCursor], ['IDBCursorWithValue', IDBCursorWithValue], ['IDBRecord', IDBRecord], ['IDBKeyRange', IDBKeyRange], ['IDBRequest', IDBRequest], ['IDBOpenDBRequest', IDBOpenDBRequest], ['IDBVersionChangeEvent', IDBVersionChangeEvent]].forEach(([prop, obj]) => {
           shim(prop, obj, {
             enumerable: false,
@@ -13060,7 +13073,7 @@ function setGlobalVars(idb, initialConfig) {
     IDB.shimIndexedDB = /** @type {ShimIndexedDB} */{};
     /** @type {const} */
     ['__useShim', '__debug', '__setConfig', '__getConfig', '__setUnicodeIdentifiers'].forEach(prop => {
-      /** @type {ShimIndexedDB} */IDB.shimIndexedDB[prop] = /** @type {() => any} */function () {
+      /** @type {{[key: string]: () => void}} */(/** @type {unknown} */IDB.shimIndexedDB)[prop] = function () {
         console.warn('This browser does not have WebSQL to shim.');
       };
     });
@@ -13111,7 +13124,7 @@ function setGlobalVars(idb, initialConfig) {
 
 /**
  * @typedef {{
- *   _db: any,
+ *   _db: unknown,
  *   exec: typeof SQLiteDatabase['prototype']['exec']
  * }} SQLiteDatabaseInstance
  */
@@ -13125,7 +13138,10 @@ function setGlobalVars(idb, initialConfig) {
  *   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
  */
 
 /**