indexeddbshim 17.2.1 → 17.3.0

package/src/IDBVersionChangeEvent.js

@@ -4,30 +4,41 @@ import * as util from './util.js';
 const readonlyProperties = ['oldVersion', 'newVersion'];
 
 /**
- * Babel apparently having a problem adding `hasInstance` to a class,
- * so we are redefining as a function.
- * @class
- * @param {string} type
+ * @typedef {number} Integer
  */
-function IDBVersionChangeEvent (type /* , eventInitDict */) { // eventInitDict is a IDBVersionChangeEventInit (but is not defined as a global)
-    // @ts-expect-error It's passing only one!
-    ShimEvent.call(this, type);
-    this[Symbol.toStringTag] = 'IDBVersionChangeEvent';
-    this.toString = function () {
-        return '[object IDBVersionChangeEvent]';
-    };
-    // eslint-disable-next-line prefer-rest-params -- API
-    this.__eventInitDict = arguments[1] || {};
-}
-
-// @ts-expect-error It's ok
-IDBVersionChangeEvent.prototype = Object.create(ShimEvent.prototype);
 
-IDBVersionChangeEvent.prototype[Symbol.toStringTag] = 'IDBVersionChangeEventPrototype';
+/**
+ * @typedef {globalThis.Event & {
+ *   __eventInitDict: {oldVersion?: Integer, newVersion?: Integer|null}
+ * }} IDBVersionChangeEventFull
+ */
 
 /**
- * @typedef {number} Integer
+ * `extends ShimEvent` via a real `class`, now that `Event` (`ShimEvent`)
+ *   is itself a real, constructible class in `eventtargeter` -- the old
+ *   `ShimEvent.call(this, type)` + `Object.create(ShimEvent.prototype)`
+ *   pattern this used to use is illegal for a real class constructor
+ *   (only callable via `new`/`super()`).
  */
+class IDBVersionChangeEvent extends ShimEvent {
+    /**
+     * @param {string} type
+     */
+    constructor (type /* , eventInitDict */) { // eventInitDict is a IDBVersionChangeEventInit (but is not defined as a global)
+        super(type);
+        const me = /** @type {IDBVersionChangeEventFull} */ (/** @type {unknown} */ (this));
+        // @ts-expect-error It's ok
+        me[Symbol.toStringTag] = 'IDBVersionChangeEvent';
+        me.toString = function () {
+            return '[object IDBVersionChangeEvent]';
+        };
+        // eslint-disable-next-line prefer-rest-params -- API
+        me.__eventInitDict = arguments[1] || {};
+    }
+}
+
+// @ts-expect-error Not part of the class body itself
+IDBVersionChangeEvent.prototype[Symbol.toStringTag] = 'IDBVersionChangeEventPrototype';
 
 /* eslint-disable unicorn/no-top-level-side-effects -- Would be good */
 readonlyProperties.forEach((prop) => {
@@ -40,7 +51,10 @@ readonlyProperties.forEach((prop) => {
             if (!(this instanceof IDBVersionChangeEvent)) {
                 throw new TypeError('Illegal invocation');
             }
-            return (this.__eventInitDict && this.__eventInitDict[prop]) || (prop === 'oldVersion' ? 0 : null);
+            const me = /** @type {IDBVersionChangeEventFull} */ (/** @type {unknown} */ (this));
+            return (me.__eventInitDict && me.__eventInitDict[
+                /** @type {keyof IDBVersionChangeEventFull['__eventInitDict']} */ (prop)
+            ]) || (prop === 'oldVersion' ? 0 : null);
         }
     };
     const desc = /** @type {PropertyDescriptor} */ (
@@ -64,16 +78,9 @@ Object.defineProperty(IDBVersionChangeEvent, Symbol.hasInstance, {
         'defaultPrevented' in obj && typeof obj.defaultPrevented === 'boolean'
 });
 
-Object.defineProperty(IDBVersionChangeEvent.prototype, 'constructor', {
-    enumerable: false,
-    writable: true,
-    configurable: true,
-    value: IDBVersionChangeEvent
-});
-
-Object.defineProperty(IDBVersionChangeEvent, 'prototype', {
-    writable: false
-});
+// A real class's own `.prototype` (and its `.constructor` back-reference)
+//   is already set up correctly and non-writable/non-configurable per
+//   spec, so no explicit setup is needed here.
 /* eslint-enable unicorn/no-top-level-side-effects -- Would be good */
 
 export default IDBVersionChangeEvent;

package/src/Key.js

@@ -15,6 +15,10 @@ import CFG from './CFG.js';
  * @typedef {"number"|"date"|"string"|"binary"|"array"} KeyType
  */
 
+/**
+ * @typedef {import('websql-configurable/lib/websql/WebSQLTransaction.js').default} WebSQLTransaction
+ */
+
 /**
  * @typedef {any} Value
  */
@@ -553,12 +557,22 @@ function convertValueToKeyValueDecoded (input, seen, multiEntry, fullKeys) {
         return /** @type {{type: KeyType; value: Value}} */ (ret);
     } case 'string': {
         return /** @type {{type: KeyType; value: Value}} */ (ret);
-    } case 'binary': { // May throw (if detached)
+    } case 'binary': {
         // 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(
-            /** @type {BufferSource} */ (input)
-        );
+        // A detached buffer/view can't be read -- the engine itself throws
+        //   (e.g. "Cannot perform Construct on a detached ArrayBuffer")
+        //   rather than us being able to detect this up front, so treat any
+        //   such failure the same as any other invalid key rather than
+        //   letting that native error escape uncaught.
+        let octets;
+        try {
+            octets = getCopyBytesHeldByBufferSource(
+                /** @type {BufferSource} */ (input)
+            );
+        } catch {
+            return {type, invalid: true, message: 'Could not read the buffer source (it may be detached)'};
+        }
         return {type: 'binary', value: octets};
     } case 'array': { // May throw (from binary)
         const arr = /** @type {Array<any>} */ (input);
@@ -992,7 +1006,7 @@ const MAX_ALLOWED_CURRENT_NUMBER = 9007199254740992; // 2 ^ 53 (Also equal to `N
 
 /**
  *
- * @param {SQLTransaction} tx
+ * @param {WebSQLTransaction} tx
  * @param {import('./IDBObjectStore.js').IDBObjectStoreFull} store
  * @param {CurrentNumberCallback} func
  * @param {SQLFailureCallback} sqlFailCb
@@ -1005,7 +1019,7 @@ function getCurrentNumber (tx, store, func, sqlFailCb) {
         if (data.rows.length !== 1) {
             func(1);
         } else {
-            func(data.rows.item(0).currNum);
+            func(/** @type {{currNum: number}} */ (data.rows.item(0)).currNum);
         }
     }, function (tx, error) {
         sqlFailCb(createDOMException(
@@ -1019,7 +1033,7 @@ function getCurrentNumber (tx, store, func, sqlFailCb) {
 
 /**
  *
- * @param {SQLTransaction} tx
+ * @param {WebSQLTransaction} tx
  * @param {import('./IDBObjectStore.js').IDBObjectStoreFull} store
  * @param {Integer} num
  * @param {CurrentNumberCallback} successCb
@@ -1042,7 +1056,7 @@ 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 {SQLTransaction} tx
+ * @param {WebSQLTransaction} tx
  * @param {import('./IDBObjectStore.js').IDBObjectStoreFull} store
  * @param {Integer} num
  * @param {CurrentNumberCallback} successCb
@@ -1050,14 +1064,18 @@ function assignCurrentNumber (tx, store, num, successCb, failCb) {
  * @returns {void}
  */
 function setCurrentNumber (tx, store, num, successCb, failCb) {
-    num = 1 + (num === MAX_ALLOWED_CURRENT_NUMBER
-        // Since incrementing by one will have no effect in JavaScript on this
-        // unsafe max, we represent the max as a number incremented by two.
-        // The getting of the current number is never returned to the user and
-        // is only used in safe comparisons, so it is safe for us to represent
-        // it in this manner
-        ? num + 1
-        : num);
+    // Since incrementing by one has no effect in JavaScript on this unsafe
+    //   max (`MAX_ALLOWED_CURRENT_NUMBER + 1 === MAX_ALLOWED_CURRENT_NUMBER`
+    //   in IEEE 754 double precision), we represent the max as a number
+    //   incremented by two instead -- computed as a single `+ 2` rather
+    //   than two chained `+ 1`s, as the latter *also* rounds back to the
+    //   original value (each addition independently hits the same
+    //   unrepresentable `+ 1` and rounds down, so the two `+ 1`s don't
+    //   compose into a `+ 2`).
+    //   The getting of the current number is never returned to the user and
+    //   is only used in safe comparisons, so it is safe for us to represent
+    //   it in this manner
+    num += num === MAX_ALLOWED_CURRENT_NUMBER ? 2 : 1;
     return assignCurrentNumber(tx, store, num, successCb, failCb);
 }
 
@@ -1071,7 +1089,7 @@ function setCurrentNumber (tx, store, num, successCb, failCb) {
 
 /**
  *
- * @param {SQLTransaction} tx
+ * @param {WebSQLTransaction} tx
  * @param {import('./IDBObjectStore.js').IDBObjectStoreFull} store
  * @param {KeyForStoreCallback} cb
  * @param {SQLFailureCallback} sqlFailCb
@@ -1101,7 +1119,7 @@ function generateKeyForStore (tx, store, cb, sqlFailCb) {
 //     so we do not return a key
 /**
  *
- * @param {SQLTransaction} tx
+ * @param {WebSQLTransaction} tx
  * @param {import('./IDBObjectStore.js').IDBObjectStoreFull} store
  * @param {Key} key
  * @param {(num?: Integer) => void} successCb

package/src/Sca.js

@@ -73,4 +73,25 @@ function clone (val) {
     return decode(encode(val));
 }
 
-export {encode, decode, clone, register};
+/**
+ * Per spec, a transaction must appear inactive to any code that runs
+ *   reentrantly *during* the structured clone of a value passed to
+ *   `add()`/`put()`/`IDBCursor#update()` (e.g. a getter on the value being
+ *   stored) -- even though the transaction is otherwise active for the
+ *   duration of that same call. `__active` is restored in a `finally` so a
+ *   `DataCloneError` (or any other throw from `clone()`) can't leave the
+ *   transaction permanently stuck inactive.
+ * @param {{__active: boolean}} transaction
+ * @param {AnyValue} val
+ * @returns {AnyValue}
+ */
+function cloneWithInactiveTransaction (transaction, val) {
+    transaction.__active = false;
+    try {
+        return clone(val);
+    } finally {
+        transaction.__active = true;
+    }
+}
+
+export {encode, decode, clone, cloneWithInactiveTransaction, register};

package/src/browser-UnicodeIdentifiers.js

@@ -5,7 +5,9 @@ import * as UnicodeIdentifiers from './UnicodeIdentifiers.js';
 import setGlobalVars from './setGlobalVars.js';
 import CFG from './CFG.js';
 
-CFG.win = typeof window !== 'undefined' ? window : self; // For Web Workers
+CFG.win = /** @type {import('./CFG.js').ConfigValues['win']} */ (
+    /** @type {unknown} */ (typeof window !== 'undefined' ? window : self)
+); // For Web Workers
 
 setGlobalVars();
 // END: Same code as in browser.js

package/src/browser-noninvasive.js

@@ -4,7 +4,9 @@ import {UnicodeIDStart, UnicodeIDContinue} from './UnicodeIdentifiers.js';
 import setGlobalVars from './setGlobalVars.js';
 import CFG from './CFG.js';
 
-CFG.win = typeof window !== 'undefined' ? window : self; // For Web Workers
+CFG.win = /** @type {import('./CFG.js').ConfigValues['win']} */ (
+    /** @type {unknown} */ (typeof window !== 'undefined' ? window : self)
+); // For Web Workers
 // END: Same code as in browser.js
 
 CFG.UnicodeIDStart = UnicodeIDStart;

package/src/browser.js

@@ -1,5 +1,7 @@
 import setGlobalVars from './setGlobalVars.js';
 import CFG from './CFG.js';
 
-CFG.win = typeof window !== 'undefined' ? window : self; // For Web Workers
+CFG.win = /** @type {import('./CFG.js').ConfigValues['win']} */ (
+    /** @type {unknown} */ (typeof window !== 'undefined' ? window : self)
+); // For Web Workers
 setGlobalVars();

package/src/node-UnicodeIdentifiers.js

@@ -9,7 +9,7 @@ CFG.win = {openDatabase: nodeWebSQL};
 
 /**
  * @param {import('./setGlobalVars.js').ShimmedObject} idb
- * @param {import('./CFG.js').default} initialConfig
+ * @param {Partial<import('./CFG.js').ConfigValues>} initialConfig
  * @returns {import('./setGlobalVars.js').ShimmedObject|Window}
  */
 const __setGlobalVars = function (idb, initialConfig = {}) {

package/src/node.js

@@ -8,7 +8,7 @@ CFG.win = {openDatabase: nodeWebSQL};
 
 /**
  * @param {import('./setGlobalVars.js').ShimmedObject} idb
- * @param {import('./CFG.js').default} initialConfig
+ * @param {Partial<import('./CFG.js').ConfigValues>} initialConfig
  * @returns {import('./setGlobalVars.js').ShimmedObject|Window}
  */
 const __setGlobalVars = function (idb, initialConfig = {}) {

package/src/nodeSQLiteDatabase.js

@@ -30,12 +30,34 @@ const READ_ONLY_ERROR = new Error(
  * @typedef {((sql: string) => void)|undefined} SQLTraceCallback
  */
 
+// Two separate `better-sqlite3` connections (i.e., two separate
+//   `SQLiteDatabase` instances) can legitimately point at the same
+//   underlying file at once -- e.g. an old, about-to-close IndexedDB
+//   connection and a newly-opened one during an upgrade. `PRAGMA
+//   busy_timeout` can't safely arbitrate between them here: it blocks the
+//   single JS thread synchronously while it retries, but the lock holder's
+//   own release is itself scheduled via `setTimeout` below, which can never
+//   fire while that retry loop is blocking the same thread -- so instead of
+//   waiting, the second connection's write just fails with "database is
+//   locked". Serialize writes per file path instead, so a second
+//   connection's `BEGIN` waits for the first connection's transaction to
+//   actually finish rather than colliding with it.
+/** @type {Map<string, {_db: any, _qFilePath: string}>} */
+const fileLockOwners = new Map();
+/** @type {Map<string, (() => void)[]>} */
+const fileLockWaiters = new Map();
+const beginRe = /^\s*BEGIN\b/iu;
+const endRe = /^\s*(END|COMMIT|ROLLBACK)\b/iu;
+
 /**
+ * @class
  * @param {string} name
  * @param {{busyTimeout?: number, trace?: (sql: string) => void, profile?: SQLProfileCallback}} [opts]
+ * @this {{_db: any, _qFilePath: string}}
  * @returns {void}
  */
 function SQLiteDatabase (name, opts = {}) {
+    this._qFilePath = name;
     /** @type {import('better-sqlite3').Database} */
     const db = new Database(name);
 
@@ -130,6 +152,22 @@ function runNonSelect (db, sql, args) {
  * @returns {void}
  */
 SQLiteDatabase.prototype.exec = function exec (queries, readOnly, callback) {
+    // `:memory:` (SQLite/`better-sqlite3`'s own sentinel for an isolated,
+    //   non-shared in-memory database) can never actually collide with a
+    //   different connection -- each `new Database(':memory:')` call is
+    //   already fully independent -- so there is nothing to serialize.
+    const filePath = this._qFilePath === ':memory:' ? null : this._qFilePath;
+    if (filePath && queries[0] && beginRe.test(queries[0].sql)) {
+        const owner = fileLockOwners.get(filePath);
+        if (owner && owner !== this) {
+            const waiters = fileLockWaiters.get(filePath) || [];
+            waiters.push(() => this.exec(queries, readOnly, callback));
+            fileLockWaiters.set(filePath, waiters);
+            return;
+        }
+        fileLockOwners.set(filePath, this);
+    }
+
     const db = this._db._db;
     const len = queries.length;
     const results = Array.from({length: len});
@@ -166,9 +204,36 @@ SQLiteDatabase.prototype.exec = function exec (queries, readOnly, callback) {
             }
         }
     }
-    queueMicrotask(() => {
+    // A real timer (not `queueMicrotask`) so this yields to the macrotask
+    //   queue: code that synchronously issues a new request from within
+    //   each request's callback (e.g. to keep a transaction alive) would
+    //   otherwise chain microtask to microtask forever, starving out any
+    //   `setTimeout`-based code (including IndexedDB's own internal request
+    //   scheduling) that never gets a turn to run.
+    setTimeout(() => {
+        // Release the file lock (if held) and hand it to the next waiting
+        //   connection, if any, only once this transaction has genuinely
+        //   finished -- and only here, on its own turn, so a resumed
+        //   waiter's own `exec` call can't run reentrantly inside this one.
+        // Checked across the whole batch, not just `queries[0]`: when a
+        //   transaction's `BEGIN` and its later `ROLLBACK`/`COMMIT` are both
+        //   queued synchronously before `websql-configurable`'s async flush
+        //   gets a turn to run (e.g. an immediate `transaction.abort()`
+        //   inside `onupgradeneeded`), they arrive coalesced into a single
+        //   batch/`exec()` call, with the terminal statement anywhere but
+        //   first -- so only checking `queries[0]` would acquire the lock
+        //   and never see the matching release, deadlocking every later
+        //   connection to the same file.
+        if (filePath && queries.some((q) => endRe.test(q.sql))) {
+            fileLockOwners.delete(filePath);
+            const waiters = fileLockWaiters.get(filePath);
+            const nextWaitingExec = waiters && waiters.shift();
+            if (nextWaitingExec) {
+                nextWaitingExec();
+            }
+        }
         callback(null, results);
-    });
+    }, 0);
 };
 
 export default SQLiteDatabase;

package/src/nodeWebSQL.js

@@ -2,11 +2,31 @@ import customOpenDatabase from 'websql-configurable/custom/index.js';
 import SQLiteDatabase from './nodeSQLiteDatabase.js';
 import CFG from './CFG.js';
 
+/**
+ * @typedef {{
+ *   _db: any,
+ *   exec: typeof SQLiteDatabase['prototype']['exec']
+ * }} SQLiteDatabaseInstance
+ */
+
+/**
+ * `websql-configurable`'s `customOpenDatabase` always calls this via `new`
+ *   (see its `custom.js`: `new SQLiteDatabase(dbName, sqliteOpts)`), so this
+ *   is typed with a construct signature even though `wrappedSQLiteDatabase`
+ *   below is written as a plain function -- that's a deliberate, working JS
+ *   idiom (a plain function invoked with `new` that explicitly `return`s an
+ *   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
+ */
+
 /**
  * @param {string} name
- * @returns {SQLiteDatabase}
+ * @returns {SQLiteDatabaseInstance}
  */
 function wrappedSQLiteDatabase (name) {
+    // @ts-ignore It's ok; needed under some TS versions
     const db = new SQLiteDatabase(name, {});
     if (CFG.sqlBusyTimeout) {
         db._db.configure('busyTimeout', /** @type {number} */ (CFG.sqlBusyTimeout)); // Default is 1000
@@ -20,5 +40,5 @@ function wrappedSQLiteDatabase (name) {
     return db;
 }
 
-const nodeWebSQL = customOpenDatabase(wrappedSQLiteDatabase, {});
+const nodeWebSQL = customOpenDatabase(/** @type {SQLiteDatabaseConstructor} */ (/** @type {unknown} */ (wrappedSQLiteDatabase)), {});
 export default nodeWebSQL;

package/src/setGlobalVars.js

@@ -1,6 +1,6 @@
-import {setPrototypeOfCustomEvent} from 'eventtargeter';
 import shimIDBVersionChangeEvent from './IDBVersionChangeEvent.js';
 import {IDBCursor as shimIDBCursor, IDBCursorWithValue as shimIDBCursorWithValue} from './IDBCursor.js';
+import shimIDBRecord from './IDBRecord.js';
 import {IDBRequest as shimIDBRequest, IDBOpenDBRequest as shimIDBOpenDBRequest} from './IDBRequest.js';
 import {createDOMException, ShimDOMException} from './DOMException.js';
 import {shimIndexedDB, IDBFactory, setFS} from './IDBFactory.js';
@@ -104,7 +104,7 @@ function setConfig (prop, val) {
 /**
  *
  * @param {ShimmedObject} [idb]
- * @param {import('./CFG.js').ConfigValues} [initialConfig]
+ * @param {Partial<import('./CFG.js').ConfigValues>} [initialConfig]
  * @returns {ShimmedObject}
  */
 function setGlobalVars (idb, initialConfig) {
@@ -249,6 +249,7 @@ function setGlobalVars (idb, initialConfig) {
                     ['IDBTransaction', shimIDBTransaction],
                     ['IDBCursor', shimIDBCursor],
                     ['IDBCursorWithValue', shimIDBCursorWithValue],
+                    ['IDBRecord', shimIDBRecord],
                     ['IDBKeyRange', shimIDBKeyRange],
                     ['IDBRequest', shimIDBRequest],
                     ['IDBOpenDBRequest', shimIDBOpenDBRequest],
@@ -275,7 +276,6 @@ function setGlobalVars (idb, initialConfig) {
                     Object.setPrototypeOf(shimIDBVersionChangeEvent, ShimEvent);
                     Object.setPrototypeOf(ShimDOMException, Error);
                     Object.setPrototypeOf(ShimDOMException.prototype, Error.prototype);
-                    setPrototypeOfCustomEvent();
                 }
                 if (IDB.indexedDB && !IDB.indexedDB.toString().includes('[native code]')) {
                     if (CFG.addNonIDBGlobals) {
@@ -296,9 +296,9 @@ function setGlobalVars (idb, initialConfig) {
             }
         };
 
-        IDB.shimIndexedDB.__debug = function (val) {
+        IDB.shimIndexedDB.__debug = /** @type {(val: boolean) => void} */ (function (val) {
             CFG.DEBUG = val;
-        };
+        });
         IDB.shimIndexedDB.__setConfig = setConfig;
 
         /** @type {GetConfig} */

package/src/util.js

@@ -377,7 +377,6 @@ function defineListenerProperties (obj, listeners) {
             },
             /**
              * @param {AnyValue} val
-             * @returns {void}
              */
             set [listener] (val) {
                 obj['__' + listener] = val;
@@ -434,6 +433,34 @@ function defineReadonlyProperties (obj, props, getter = null) {
     });
 }
 
+/**
+ * `X.prototype.method = function (...) {}` (an assignment to a
+ * `MemberExpression`, as used throughout this codebase for IDB
+ * interface operations) does not get its `name` inferred by the
+ * engine the way object-literal method shorthand or a plain variable
+ * assignment would, so it is left as `''`. Per Web IDL, an operation's
+ * function object must have its `name` set to the operation's
+ * identifier, so call this once all of an interface's own-property
+ * operations have been assigned onto its prototype (or, for static
+ * operations, onto the constructor itself) to patch any still-empty
+ * names in place.
+ * @param {object} obj
+ * @returns {void}
+ */
+function setOperationNames (obj) {
+    Object.getOwnPropertyNames(obj).forEach((key) => {
+        if (key === 'constructor') {
+            return;
+        }
+        const desc = /** @type {PropertyDescriptor} */ (
+            Object.getOwnPropertyDescriptor(obj, key)
+        );
+        if (typeof desc.value === 'function' && desc.value.name === '') {
+            Object.defineProperty(desc.value, 'name', {value: key, configurable: true});
+        }
+    });
+}
+
 /**
  *
  * @param {string} item
@@ -615,6 +642,7 @@ export {escapeSQLiteStatement, unescapeSQLiteResponse,
     isObj, isDate, isBlob, isRegExp, isFile, isBinary, isIterable,
     defineOuterInterface, defineReadonlyOuterInterface,
     defineListenerProperties, defineReadonlyProperties,
+    setOperationNames,
     isValidKeyPath, enforceRange,
     convertToDOMString, convertToSequenceDOMString,
     isNullish, runContinuationSafely};

package/typings/shimIndexedDB.d.ts

@@ -1,4 +1,4 @@
-declare var shimIndexedDB: import('../src/IDBFactory.js').IDBFactory & WindowDatabase & {
+declare var shimIndexedDB: import('../src/IDBFactory.js').IDBFactoryFull & WindowDatabase & {
     __useShim: () => void
     __debug: (val: boolean) => void
     __setConfig: (prop: string, val: import('../src/CFG.js').ConfigValue) => void