dexie 4.4.1 → 4.4.2

package/dist/modern/dexie.mjs

@@ -4,17 +4,20 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 4.4.1, Wed Mar 25 2026
+ * Version 4.4.2, Tue Mar 31 2026
  *
  * https://dexie.org
  *
  * Apache License Version 2.0, January 2004, http://www.apache.org/licenses/
  */
  
-const _global = typeof globalThis !== 'undefined' ? globalThis :
-    typeof self !== 'undefined' ? self :
-        typeof window !== 'undefined' ? window :
-            global;
+const _global = typeof globalThis !== 'undefined'
+    ? globalThis
+    : typeof self !== 'undefined'
+        ? self
+        : typeof window !== 'undefined'
+            ? window
+            : global;
 
 const keys = Object.keys;
 const isArray = Array.isArray;
@@ -37,32 +40,38 @@ function hasOwn(obj, prop) {
 function props(proto, extension) {
     if (typeof extension === 'function')
         extension = extension(getProto(proto));
-    (typeof Reflect === "undefined" ? keys : Reflect.ownKeys)(extension).forEach(key => {
+    (typeof Reflect === 'undefined' ? keys : Reflect.ownKeys)(extension).forEach((key) => {
         setProp(proto, key, extension[key]);
     });
 }
 const defineProperty = Object.defineProperty;
 function setProp(obj, prop, functionOrGetSet, options) {
-    defineProperty(obj, prop, extend(functionOrGetSet && hasOwn(functionOrGetSet, "get") && typeof functionOrGetSet.get === 'function' ?
-        { get: functionOrGetSet.get, set: functionOrGetSet.set, configurable: true } :
-        { value: functionOrGetSet, configurable: true, writable: true }, options));
+    defineProperty(obj, prop, extend(functionOrGetSet &&
+        hasOwn(functionOrGetSet, 'get') &&
+        typeof functionOrGetSet.get === 'function'
+        ? {
+            get: functionOrGetSet.get,
+            set: functionOrGetSet.set,
+            configurable: true,
+        }
+        : { value: functionOrGetSet, configurable: true, writable: true }, options));
 }
 function derive(Child) {
     return {
         from: function (Parent) {
             Child.prototype = Object.create(Parent.prototype);
-            setProp(Child.prototype, "constructor", Child);
+            setProp(Child.prototype, 'constructor', Child);
             return {
-                extend: props.bind(null, Child.prototype)
+                extend: props.bind(null, Child.prototype),
             };
-        }
+        },
     };
 }
 const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
 function getPropertyDescriptor(obj, prop) {
     const pd = getOwnPropertyDescriptor(obj, prop);
     let proto;
-    return pd || (proto = getProto(obj)) && getPropertyDescriptor(proto, prop);
+    return pd || ((proto = getProto(obj)) && getPropertyDescriptor(proto, prop));
 }
 const _slice = [].slice;
 function slice(args, start, end) {
@@ -73,7 +82,7 @@ function override(origFunc, overridedFactory) {
 }
 function assert(b) {
     if (!b)
-        throw new Error("Assertion Failed");
+        throw new Error('Assertion Failed');
 }
 function asap$1(fn) {
     if (_global.setImmediate)
@@ -105,7 +114,9 @@ function getByKeyPath(obj, keyPath) {
     var period = keyPath.indexOf('.');
     if (period !== -1) {
         var innerObj = obj[keyPath.substr(0, period)];
-        return innerObj == null ? undefined : getByKeyPath(innerObj, keyPath.substr(period + 1));
+        return innerObj == null
+            ? undefined
+            : getByKeyPath(innerObj, keyPath.substr(period + 1));
     }
     return undefined;
 }
@@ -125,7 +136,7 @@ function setByKeyPath(obj, keyPath, value) {
         if (period !== -1) {
             var currentKeyPath = keyPath.substr(0, period);
             var remainingKeyPath = keyPath.substr(period + 1);
-            if (remainingKeyPath === "")
+            if (remainingKeyPath === '')
                 if (value === undefined) {
                     if (isArray(obj) && !isNaN(parseInt(currentKeyPath)))
                         obj.splice(currentKeyPath, 1);
@@ -137,7 +148,7 @@ function setByKeyPath(obj, keyPath, value) {
             else {
                 var innerObj = obj[currentKeyPath];
                 if (!innerObj || !hasOwn(obj, currentKeyPath))
-                    innerObj = (obj[currentKeyPath] = {});
+                    innerObj = obj[currentKeyPath] = {};
                 setByKeyPath(innerObj, remainingKeyPath, value);
             }
         }
@@ -173,15 +184,20 @@ const concat = [].concat;
 function flatten(a) {
     return concat.apply([], a);
 }
-const intrinsicTypeNames = "BigUint64Array,BigInt64Array,Array,Boolean,String,Date,RegExp,Blob,File,FileList,FileSystemFileHandle,FileSystemDirectoryHandle,ArrayBuffer,DataView,Uint8ClampedArray,ImageBitmap,ImageData,Map,Set,CryptoKey"
-    .split(',').concat(flatten([8, 16, 32, 64].map(num => ["Int", "Uint", "Float"].map(t => t + num + "Array")))).filter(t => _global[t]);
-const intrinsicTypes = new Set(intrinsicTypeNames.map(t => _global[t]));
+const intrinsicTypeNames = 'BigUint64Array,BigInt64Array,Array,Boolean,String,Date,RegExp,Blob,File,FileList,FileSystemFileHandle,FileSystemDirectoryHandle,ArrayBuffer,DataView,Uint8ClampedArray,ImageBitmap,ImageData,Map,Set,CryptoKey'
+    .split(',')
+    .concat(flatten([8, 16, 32, 64].map((num) => ['Int', 'Uint', 'Float'].map((t) => t + num + 'Array'))))
+    .filter((t) => _global[t]);
+const intrinsicTypes = new Set(intrinsicTypeNames.map((t) => _global[t]));
 function cloneSimpleObjectTree(o) {
     const rv = {};
     for (const k in o)
         if (hasOwn(o, k)) {
             const v = o[k];
-            rv[k] = !v || typeof v !== 'object' || intrinsicTypes.has(v.constructor) ? v : cloneSimpleObjectTree(v);
+            rv[k] =
+                !v || typeof v !== 'object' || intrinsicTypes.has(v.constructor)
+                    ? v
+                    : cloneSimpleObjectTree(v);
         }
     return rv;
 }
@@ -224,13 +240,15 @@ const { toString } = {};
 function toStringTag(o) {
     return toString.call(o).slice(8, -1);
 }
-const iteratorSymbol = typeof Symbol !== 'undefined' ?
-    Symbol.iterator :
-    '@@iterator';
-const getIteratorOf = typeof iteratorSymbol === "symbol" ? function (x) {
-    var i;
-    return x != null && (i = x[iteratorSymbol]) && i.apply(x);
-} : function () { return null; };
+const iteratorSymbol = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';
+const getIteratorOf = typeof iteratorSymbol === 'symbol'
+    ? function (x) {
+        var i;
+        return x != null && (i = x[iteratorSymbol]) && i.apply(x);
+    }
+    : function () {
+        return null;
+    };
 function delArrayItem(a, x) {
     const i = a.indexOf(x);
     if (i >= 0)
@@ -247,7 +265,7 @@ function getArrayOf(arrayLike) {
             return [arrayLike];
         if ((it = getIteratorOf(arrayLike))) {
             a = [];
-            while ((x = it.next()), !x.done)
+            while (((x = it.next()), !x.done))
                 a.push(x.value);
             return a;
         }
@@ -288,7 +306,7 @@ var dexieErrorNames = [
     'Internal',
     'DatabaseClosed',
     'PrematureCommit',
-    'ForeignAwait'
+    'ForeignAwait',
 ];
 var idbDomErrorNames = [
     'Unknown',
@@ -304,28 +322,34 @@ var idbDomErrorNames = [
     'Timeout',
     'QuotaExceeded',
     'Syntax',
-    'DataClone'
+    'DataClone',
 ];
 var errorList = dexieErrorNames.concat(idbDomErrorNames);
 var defaultTexts = {
-    VersionChanged: "Database version changed by other database connection",
-    DatabaseClosed: "Database has been closed",
-    Abort: "Transaction aborted",
-    TransactionInactive: "Transaction has already completed or failed",
-    MissingAPI: "IndexedDB API missing. Please visit https://tinyurl.com/y2uuvskb"
+    VersionChanged: 'Database version changed by other database connection',
+    DatabaseClosed: 'Database has been closed',
+    Abort: 'Transaction aborted',
+    TransactionInactive: 'Transaction has already completed or failed',
+    MissingAPI: 'IndexedDB API missing. Please visit https://tinyurl.com/y2uuvskb',
 };
 function DexieError(name, msg) {
     this.name = name;
     this.message = msg;
 }
-derive(DexieError).from(Error).extend({
-    toString: function () { return this.name + ": " + this.message; }
+derive(DexieError)
+    .from(Error)
+    .extend({
+    toString: function () {
+        return this.name + ': ' + this.message;
+    },
 });
 function getMultiErrorMessage(msg, failures) {
-    return msg + ". Errors: " + Object.keys(failures)
-        .map(key => failures[key].toString())
-        .filter((v, i, s) => s.indexOf(v) === i)
-        .join('\n');
+    return (msg +
+        '. Errors: ' +
+        Object.keys(failures)
+            .map((key) => failures[key].toString())
+            .filter((v, i, s) => s.indexOf(v) === i)
+            .join('\n'));
 }
 function ModifyError(msg, failures, successCount, failedKeys) {
     this.failures = failures;
@@ -335,16 +359,16 @@ function ModifyError(msg, failures, successCount, failedKeys) {
 }
 derive(ModifyError).from(DexieError);
 function BulkError(msg, failures) {
-    this.name = "BulkError";
-    this.failures = Object.keys(failures).map(pos => failures[pos]);
+    this.name = 'BulkError';
+    this.failures = Object.keys(failures).map((pos) => failures[pos]);
     this.failuresByPos = failures;
     this.message = getMultiErrorMessage(msg, this.failures);
 }
 derive(BulkError).from(DexieError);
-var errnames = errorList.reduce((obj, name) => (obj[name] = name + "Error", obj), {});
+var errnames = errorList.reduce((obj, name) => ((obj[name] = name + 'Error'), obj), {});
 const BaseException = DexieError;
 var exceptions = errorList.reduce((obj, name) => {
-    var fullName = name + "Error";
+    var fullName = name + 'Error';
     function DexieError(msgOrInner, inner) {
         this.name = fullName;
         if (!msgOrInner) {
@@ -368,23 +392,30 @@ exceptions.Syntax = SyntaxError;
 exceptions.Type = TypeError;
 exceptions.Range = RangeError;
 var exceptionMap = idbDomErrorNames.reduce((obj, name) => {
-    obj[name + "Error"] = exceptions[name];
+    obj[name + 'Error'] = exceptions[name];
     return obj;
 }, {});
 function mapError(domError, message) {
-    if (!domError || domError instanceof DexieError || domError instanceof TypeError || domError instanceof SyntaxError || !domError.name || !exceptionMap[domError.name])
+    if (!domError ||
+        domError instanceof DexieError ||
+        domError instanceof TypeError ||
+        domError instanceof SyntaxError ||
+        !domError.name ||
+        !exceptionMap[domError.name])
         return domError;
     var rv = new exceptionMap[domError.name](message || domError.message, domError);
-    if ("stack" in domError) {
-        setProp(rv, "stack", { get: function () {
+    if ('stack' in domError) {
+        setProp(rv, 'stack', {
+            get: function () {
                 return this.inner.stack;
-            } });
+            },
+        });
     }
     return rv;
 }
 var fullNameExceptions = errorList.reduce((obj, name) => {
-    if (["Syntax", "Type", "Range"].indexOf(name) === -1)
-        obj[name + "Error"] = exceptions[name];
+    if (['Syntax', 'Type', 'Range'].indexOf(name) === -1)
+        obj[name + 'Error'] = exceptions[name];
     return obj;
 }, {});
 fullNameExceptions.ModifyError = ModifyError;
@@ -392,7 +423,9 @@ fullNameExceptions.DexieError = DexieError;
 fullNameExceptions.BulkError = BulkError;
 
 function nop() { }
-function mirror(val) { return val; }
+function mirror(val) {
+    return val;
+}
 function pureFunctionChain(f1, f2) {
     if (f1 == null || f1 === mirror)
         return f2;
@@ -419,7 +452,9 @@ function hookCreatingChain(f1, f2) {
         this.onerror = null;
         var res2 = f2.apply(this, arguments);
         if (onsuccess)
-            this.onsuccess = this.onsuccess ? callBoth(onsuccess, this.onsuccess) : onsuccess;
+            this.onsuccess = this.onsuccess
+                ? callBoth(onsuccess, this.onsuccess)
+                : onsuccess;
         if (onerror)
             this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror;
         return res2 !== undefined ? res2 : res;
@@ -435,7 +470,9 @@ function hookDeletingChain(f1, f2) {
         this.onsuccess = this.onerror = null;
         f2.apply(this, arguments);
         if (onsuccess)
-            this.onsuccess = this.onsuccess ? callBoth(onsuccess, this.onsuccess) : onsuccess;
+            this.onsuccess = this.onsuccess
+                ? callBoth(onsuccess, this.onsuccess)
+                : onsuccess;
         if (onerror)
             this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror;
     };
@@ -452,12 +489,16 @@ function hookUpdatingChain(f1, f2) {
         this.onerror = null;
         var res2 = f2.apply(this, arguments);
         if (onsuccess)
-            this.onsuccess = this.onsuccess ? callBoth(onsuccess, this.onsuccess) : onsuccess;
+            this.onsuccess = this.onsuccess
+                ? callBoth(onsuccess, this.onsuccess)
+                : onsuccess;
         if (onerror)
             this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror;
-        return res === undefined ?
-            (res2 === undefined ? undefined : res2) :
-            (extend(res, res2));
+        return res === undefined
+            ? res2 === undefined
+                ? undefined
+                : res2
+            : extend(res, res2);
     };
 }
 function reverseStoppableEventChain(f1, f2) {
@@ -493,18 +534,14 @@ function setDebug(value, filter) {
 }
 
 var INTERNAL = {};
-const ZONE_ECHO_LIMIT = 100, [resolvedNativePromise, nativePromiseProto, resolvedGlobalPromise] = typeof Promise === 'undefined' ?
-    [] :
-    (() => {
+const ZONE_ECHO_LIMIT = 100, [resolvedNativePromise, nativePromiseProto, resolvedGlobalPromise] = typeof Promise === 'undefined'
+    ? []
+    : (() => {
         let globalP = Promise.resolve();
         if (typeof crypto === 'undefined' || !crypto.subtle)
             return [globalP, getProto(globalP), globalP];
-        const nativeP = crypto.subtle.digest("SHA-512", new Uint8Array([0]));
-        return [
-            nativeP,
-            getProto(nativeP),
-            globalP
-        ];
+        const nativeP = crypto.subtle.digest('SHA-512', new Uint8Array([0]));
+        return [nativeP, getProto(nativeP), globalP];
     })(), nativePromiseThen = nativePromiseProto && nativePromiseProto.then;
 const NativePromise = resolvedNativePromise && resolvedNativePromise.constructor;
 const patchGlobalPromise = !!resolvedGlobalPromise;
@@ -531,7 +568,7 @@ var globalPSD = {
     onunhandled: nop,
     pgp: false,
     env: {},
-    finalize: nop
+    finalize: nop,
 };
 var PSD = globalPSD;
 var microtickQueue = [];
@@ -574,15 +611,15 @@ const thenProp = {
         return then;
     },
     set: function (value) {
-        setProp(this, 'then', value && value.prototype === INTERNAL ?
-            thenProp :
-            {
+        setProp(this, 'then', value && value.prototype === INTERNAL
+            ? thenProp
+            : {
                 get: function () {
                     return value;
                 },
-                set: thenProp.set
+                set: thenProp.set,
             });
-    }
+    },
 };
 props(DexiePromise.prototype, {
     then: thenProp,
@@ -593,25 +630,27 @@ props(DexiePromise.prototype, {
         if (arguments.length === 1)
             return this.then(null, onRejected);
         var type = arguments[0], handler = arguments[1];
-        return typeof type === 'function' ? this.then(null, err =>
-        err instanceof type ? handler(err) : PromiseReject(err))
-            : this.then(null, err =>
+        return typeof type === 'function'
+            ? this.then(null, (err) =>
+            err instanceof type ? handler(err) : PromiseReject(err))
+            : this.then(null, (err) =>
             err && err.name === type ? handler(err) : PromiseReject(err));
     },
     finally: function (onFinally) {
-        return this.then(value => {
+        return this.then((value) => {
             return DexiePromise.resolve(onFinally()).then(() => value);
-        }, err => {
+        }, (err) => {
             return DexiePromise.resolve(onFinally()).then(() => PromiseReject(err));
         });
     },
     timeout: function (ms, msg) {
-        return ms < Infinity ?
-            new DexiePromise((resolve, reject) => {
+        return ms < Infinity
+            ? new DexiePromise((resolve, reject) => {
                 var handle = setTimeout(() => reject(new exceptions.Timeout(msg)), ms);
                 this.then(resolve, reject).finally(clearTimeout.bind(null, handle));
-            }) : this;
-    }
+            })
+            : this;
+    },
 });
 if (typeof Symbol !== 'undefined' && Symbol.toStringTag)
     setProp(DexiePromise.prototype, Symbol.toStringTag, 'Dexie.Promise');
@@ -625,20 +664,21 @@ function Listener(onFulfilled, onRejected, resolve, reject, zone) {
 }
 props(DexiePromise, {
     all: function () {
-        var values = getArrayOf.apply(null, arguments)
+        var values = getArrayOf
+            .apply(null, arguments)
             .map(onPossibleParallellAsync);
         return new DexiePromise(function (resolve, reject) {
             if (values.length === 0)
                 resolve([]);
             var remaining = values.length;
-            values.forEach((a, i) => DexiePromise.resolve(a).then(x => {
+            values.forEach((a, i) => DexiePromise.resolve(a).then((x) => {
                 values[i] = x;
                 if (!--remaining)
                     resolve(values);
             }, reject));
         });
     },
-    resolve: value => {
+    resolve: (value) => {
         if (value instanceof DexiePromise)
             return value;
         if (value && typeof value.then === 'function')
@@ -650,25 +690,31 @@ props(DexiePromise, {
     },
     reject: PromiseReject,
     race: function () {
-        var values = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
+        var values = getArrayOf
+            .apply(null, arguments)
+            .map(onPossibleParallellAsync);
         return new DexiePromise((resolve, reject) => {
-            values.map(value => DexiePromise.resolve(value).then(resolve, reject));
+            values.map((value) => DexiePromise.resolve(value).then(resolve, reject));
         });
     },
     PSD: {
         get: () => PSD,
-        set: value => PSD = value
+        set: (value) => (PSD = value),
     },
     totalEchoes: { get: () => totalEchoes },
     newPSD: newScope,
     usePSD: usePSD,
     scheduler: {
         get: () => asap,
-        set: value => { asap = value; }
+        set: (value) => {
+            asap = value;
+        },
     },
     rejectionMapper: {
         get: () => rejectionMapper,
-        set: value => { rejectionMapper = value; }
+        set: (value) => {
+            rejectionMapper = value;
+        },
     },
     follow: (fn, zoneProps) => {
         return new DexiePromise((resolve, reject) => {
@@ -678,36 +724,43 @@ props(DexiePromise, {
                 psd.onunhandled = reject;
                 psd.finalize = callBoth(function () {
                     run_at_end_of_this_or_next_physical_tick(() => {
-                        this.unhandleds.length === 0 ? resolve() : reject(this.unhandleds[0]);
+                        this.unhandleds.length === 0
+                            ? resolve()
+                            : reject(this.unhandleds[0]);
                     });
                 }, psd.finalize);
                 fn();
             }, zoneProps, resolve, reject);
         });
-    }
+    },
 });
 if (NativePromise) {
     if (NativePromise.allSettled)
-        setProp(DexiePromise, "allSettled", function () {
-            const possiblePromises = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
-            return new DexiePromise(resolve => {
+        setProp(DexiePromise, 'allSettled', function () {
+            const possiblePromises = getArrayOf
+                .apply(null, arguments)
+                .map(onPossibleParallellAsync);
+            return new DexiePromise((resolve) => {
                 if (possiblePromises.length === 0)
                     resolve([]);
                 let remaining = possiblePromises.length;
                 const results = new Array(remaining);
-                possiblePromises.forEach((p, i) => DexiePromise.resolve(p).then(value => results[i] = { status: "fulfilled", value }, reason => results[i] = { status: "rejected", reason })
+                possiblePromises.forEach((p, i) => DexiePromise.resolve(p)
+                    .then((value) => (results[i] = { status: 'fulfilled', value }), (reason) => (results[i] = { status: 'rejected', reason }))
                     .then(() => --remaining || resolve(results)));
             });
         });
     if (NativePromise.any && typeof AggregateError !== 'undefined')
-        setProp(DexiePromise, "any", function () {
-            const possiblePromises = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
+        setProp(DexiePromise, 'any', function () {
+            const possiblePromises = getArrayOf
+                .apply(null, arguments)
+                .map(onPossibleParallellAsync);
             return new DexiePromise((resolve, reject) => {
                 if (possiblePromises.length === 0)
                     reject(new AggregateError([]));
                 let remaining = possiblePromises.length;
                 const failures = new Array(remaining);
-                possiblePromises.forEach((p, i) => DexiePromise.resolve(p).then(value => resolve(value), failure => {
+                possiblePromises.forEach((p, i) => DexiePromise.resolve(p).then((value) => resolve(value), (failure) => {
                     failures[i] = failure;
                     if (!--remaining)
                         reject(new AggregateError(failures));
@@ -719,7 +772,7 @@ if (NativePromise) {
 }
 function executePromiseTask(promise, fn) {
     try {
-        fn(value => {
+        fn((value) => {
             if (promise._state !== null)
                 return;
             if (value === promise)
@@ -727,9 +780,9 @@ function executePromiseTask(promise, fn) {
             var shouldExecuteTick = promise._lib && beginMicroTickScope();
             if (value && typeof value.then === 'function') {
                 executePromiseTask(promise, (resolve, reject) => {
-                    value instanceof DexiePromise ?
-                        value._then(resolve, reject) :
-                        value.then(resolve, reject);
+                    value instanceof DexiePromise
+                        ? value._then(resolve, reject)
+                        : value.then(resolve, reject);
                 });
             }
             else {
@@ -792,7 +845,10 @@ function callListener(cb, promise, listener) {
         var ret, value = promise._value;
         if (!promise._state && rejectingErrors.length)
             rejectingErrors = [];
-        ret = debug && promise._consoleTask ? promise._consoleTask.run(() => cb(value)) : cb(value);
+        ret =
+            debug && promise._consoleTask
+                ? promise._consoleTask.run(() => cb(value))
+                : cb(value);
         if (!promise._state && rejectingErrors.indexOf(value) === -1) {
             markErrorAsHandled(promise);
         }
@@ -837,7 +893,7 @@ function endMicroTickScope() {
 function finalizePhysicalTick() {
     var unhandledErrs = unhandledErrors;
     unhandledErrors = [];
-    unhandledErrs.forEach(p => {
+    unhandledErrs.forEach((p) => {
         p._PSD.onunhandled.call(null, p._value, p);
     });
     var finalizers = tickFinalizers.slice(0);
@@ -858,7 +914,7 @@ function run_at_end_of_this_or_next_physical_tick(fn) {
     }, []);
 }
 function addPossiblyUnhandledError(promise) {
-    if (!unhandledErrors.some(p => p._value === promise._value))
+    if (!unhandledErrors.some((p) => p._value === promise._value))
         unhandledErrors.push(promise);
 }
 function markErrorAsHandled(promise) {
@@ -903,16 +959,22 @@ function newScope(fn, props, a1, a2) {
     psd.global = false;
     psd.id = ++zone_id_counter;
     globalPSD.env;
-    psd.env = patchGlobalPromise ? {
-        Promise: DexiePromise,
-        PromiseProp: { value: DexiePromise, configurable: true, writable: true },
-        all: DexiePromise.all,
-        race: DexiePromise.race,
-        allSettled: DexiePromise.allSettled,
-        any: DexiePromise.any,
-        resolve: DexiePromise.resolve,
-        reject: DexiePromise.reject,
-    } : {};
+    psd.env = patchGlobalPromise
+        ? {
+            Promise: DexiePromise,
+            PromiseProp: {
+                value: DexiePromise,
+                configurable: true,
+                writable: true,
+            },
+            all: DexiePromise.all,
+            race: DexiePromise.race,
+            allSettled: DexiePromise.allSettled,
+            any: DexiePromise.any,
+            resolve: DexiePromise.resolve,
+            reject: DexiePromise.reject,
+        }
+        : {};
     if (props)
         extend(psd, props);
     ++parent.ref;
@@ -943,12 +1005,14 @@ if (('' + nativePromiseThen).indexOf('[native code]') === -1) {
     incrementExpectedAwaits = decrementExpectedAwaits = nop;
 }
 function onPossibleParallellAsync(possiblePromise) {
-    if (task.echoes && possiblePromise && possiblePromise.constructor === NativePromise) {
+    if (task.echoes &&
+        possiblePromise &&
+        possiblePromise.constructor === NativePromise) {
         incrementExpectedAwaits();
-        return possiblePromise.then(x => {
+        return possiblePromise.then((x) => {
             decrementExpectedAwaits();
             return x;
-        }, e => {
+        }, (e) => {
             decrementExpectedAwaits();
             return rejection(e);
         });
@@ -970,7 +1034,9 @@ function zoneLeaveEcho() {
 }
 function switchToZone(targetZone, bEnteringZone) {
     var currentZone = PSD;
-    if (bEnteringZone ? task.echoes && (!zoneEchoes++ || targetZone !== PSD) : zoneEchoes && (!--zoneEchoes || targetZone !== PSD)) {
+    if (bEnteringZone
+        ? task.echoes && (!zoneEchoes++ || targetZone !== PSD)
+        : zoneEchoes && (!--zoneEchoes || targetZone !== PSD)) {
         queueMicrotask(bEnteringZone ? zoneEnterEcho.bind(null, targetZone) : zoneLeaveEcho);
     }
     if (targetZone === PSD)
@@ -996,16 +1062,18 @@ function switchToZone(targetZone, bEnteringZone) {
 }
 function snapShot() {
     var GlobalPromise = _global.Promise;
-    return patchGlobalPromise ? {
-        Promise: GlobalPromise,
-        PromiseProp: Object.getOwnPropertyDescriptor(_global, "Promise"),
-        all: GlobalPromise.all,
-        race: GlobalPromise.race,
-        allSettled: GlobalPromise.allSettled,
-        any: GlobalPromise.any,
-        resolve: GlobalPromise.resolve,
-        reject: GlobalPromise.reject,
-    } : {};
+    return patchGlobalPromise
+        ? {
+            Promise: GlobalPromise,
+            PromiseProp: Object.getOwnPropertyDescriptor(_global, 'Promise'),
+            all: GlobalPromise.all,
+            race: GlobalPromise.race,
+            allSettled: GlobalPromise.allSettled,
+            any: GlobalPromise.any,
+            resolve: GlobalPromise.resolve,
+            reject: GlobalPromise.reject,
+        }
+        : {};
 }
 function usePSD(psd, fn, a1, a2, a3) {
     var outerScope = PSD;
@@ -1018,20 +1086,22 @@ function usePSD(psd, fn, a1, a2, a3) {
     }
 }
 function nativeAwaitCompatibleWrap(fn, zone, possibleAwait, cleanup) {
-    return typeof fn !== 'function' ? fn : function () {
-        var outerZone = PSD;
-        if (possibleAwait)
-            incrementExpectedAwaits();
-        switchToZone(zone, true);
-        try {
-            return fn.apply(this, arguments);
-        }
-        finally {
-            switchToZone(outerZone, false);
-            if (cleanup)
-                queueMicrotask(decrementExpectedAwaits);
-        }
-    };
+    return typeof fn !== 'function'
+        ? fn
+        : function () {
+            var outerZone = PSD;
+            if (possibleAwait)
+                incrementExpectedAwaits();
+            switchToZone(zone, true);
+            try {
+                return fn.apply(this, arguments);
+            }
+            finally {
+                switchToZone(outerZone, false);
+                if (cleanup)
+                    queueMicrotask(decrementExpectedAwaits);
+            }
+        };
 }
 function execInGlobalContext(cb) {
     if (Promise === NativePromise && task.echoes === 0) {
@@ -1049,7 +1119,7 @@ function execInGlobalContext(cb) {
 var rejection = DexiePromise.reject;
 
 function tempTransaction(db, mode, storeNames, fn) {
-    if (!db.idbdb || (!db._state.openComplete && (!PSD.letThrough && !db._vip))) {
+    if (!db.idbdb || (!db._state.openComplete && !PSD.letThrough && !db._vip)) {
         if (db._state.openComplete) {
             return rejection(new exceptions.DatabaseClosed(db._state.dbOpenError));
         }
@@ -1067,45 +1137,53 @@ function tempTransaction(db, mode, storeNames, fn) {
             db._state.PR1398_maxLoop = 3;
         }
         catch (ex) {
-            if (ex.name === errnames.InvalidState && db.isOpen() && --db._state.PR1398_maxLoop > 0) {
+            if (ex.name === errnames.InvalidState &&
+                db.isOpen() &&
+                --db._state.PR1398_maxLoop > 0) {
                 console.warn('Dexie: Need to reopen db');
                 db.close({ disableAutoOpen: false });
                 return db.open().then(() => tempTransaction(db, mode, storeNames, fn));
             }
             return rejection(ex);
         }
-        return trans._promise(mode, (resolve, reject) => {
+        return trans
+            ._promise(mode, (resolve, reject) => {
             return newScope(() => {
                 PSD.trans = trans;
                 return fn(resolve, reject, trans);
             });
-        }).then(result => {
+        })
+            .then((result) => {
             if (mode === 'readwrite')
                 try {
                     trans.idbtrans.commit();
                 }
                 catch { }
-            return mode === 'readonly' ? result : trans._completion.then(() => result);
+            return mode === 'readonly'
+                ? result
+                : trans._completion.then(() => result);
         });
     }
 }
 
-const DEXIE_VERSION = '4.4.1';
+const DEXIE_VERSION = '4.4.2';
 const maxString = String.fromCharCode(65535);
 const minKey = -Infinity;
-const INVALID_KEY_ARGUMENT = "Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>.";
-const STRING_EXPECTED = "String expected.";
+const INVALID_KEY_ARGUMENT = 'Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>.';
+const STRING_EXPECTED = 'String expected.';
 const DEFAULT_MAX_CONNECTIONS = 1000;
 const DBNAMES_DB = '__dbnames';
 const READONLY = 'readonly';
 const READWRITE = 'readwrite';
 
 function combine(filter1, filter2) {
-    return filter1 ?
-        filter2 ?
-            function () { return filter1.apply(this, arguments) && filter2.apply(this, arguments); } :
-            filter1 :
-        filter2;
+    return filter1
+        ? filter2
+            ? function () {
+                return (filter1.apply(this, arguments) && filter2.apply(this, arguments));
+            }
+            : filter1
+        : filter2;
 }
 
 const AnyRange = {
@@ -1113,13 +1191,13 @@ const AnyRange = {
     lower: -Infinity,
     lowerOpen: false,
     upper: [[]],
-    upperOpen: false
+    upperOpen: false,
 };
 
 function workaroundForUndefinedPrimKey(keyPath) {
-    return typeof keyPath === "string" && !/\./.test(keyPath)
+    return typeof keyPath === 'string' && !/\./.test(keyPath)
         ? (obj) => {
-            if (obj[keyPath] === undefined && (keyPath in obj)) {
+            if (obj[keyPath] === undefined && keyPath in obj) {
                 obj = deepClone(obj);
                 delete obj[keyPath];
             }
@@ -1221,7 +1299,7 @@ function builtInDeletionTrigger(table, keys, res) {
 
 class PropModification {
     execute(value) {
-        const spec = this["@@propmod"];
+        const spec = this['@@propmod'];
         if (spec.add !== undefined) {
             const term = spec.add;
             if (isArray(term)) {
@@ -1242,7 +1320,9 @@ class PropModification {
         if (spec.remove !== undefined) {
             const subtrahend = spec.remove;
             if (isArray(subtrahend)) {
-                return isArray(value) ? value.filter(item => !subtrahend.includes(item)).sort() : [];
+                return isArray(value)
+                    ? value.filter((item) => !subtrahend.includes(item)).sort()
+                    : [];
             }
             if (typeof subtrahend === 'number')
                 return Number(value) - subtrahend;
@@ -1257,13 +1337,15 @@ class PropModification {
             throw new TypeError(`Invalid subtrahend ${subtrahend}`);
         }
         const prefixToReplace = spec.replacePrefix?.[0];
-        if (prefixToReplace && typeof value === 'string' && value.startsWith(prefixToReplace)) {
+        if (prefixToReplace &&
+            typeof value === 'string' &&
+            value.startsWith(prefixToReplace)) {
             return spec.replacePrefix[1] + value.substring(prefixToReplace.length);
         }
         return value;
     }
     constructor(spec) {
-        this["@@propmod"] = spec;
+        this['@@propmod'] = spec;
     }
 }
 
@@ -1291,22 +1373,25 @@ class Table {
     _trans(mode, fn, writeLocked) {
         const trans = this._tx || PSD.trans;
         const tableName = this.name;
-        const task = debug && typeof console !== 'undefined' && console.createTask && console.createTask(`Dexie: ${mode === 'readonly' ? 'read' : 'write'} ${this.name}`);
+        const task = debug &&
+            typeof console !== 'undefined' &&
+            console.createTask &&
+            console.createTask(`Dexie: ${mode === 'readonly' ? 'read' : 'write'} ${this.name}`);
         function checkTableInTransaction(resolve, reject, trans) {
             if (!trans.schema[tableName])
-                throw new exceptions.NotFound("Table " + tableName + " not part of transaction");
+                throw new exceptions.NotFound('Table ' + tableName + ' not part of transaction');
             return fn(trans.idbtrans, trans);
         }
         const wasRootExec = beginMicroTickScope();
         try {
-            let p = trans && trans.db._novip === this.db._novip ?
-                trans === PSD.trans ?
-                    trans._promise(mode, checkTableInTransaction, writeLocked) :
-                    newScope(() => trans._promise(mode, checkTableInTransaction, writeLocked), { trans: trans, transless: PSD.transless || PSD }) :
-                tempTransaction(this.db, mode, [this.name], checkTableInTransaction);
+            let p = trans && trans.db._novip === this.db._novip
+                ? trans === PSD.trans
+                    ? trans._promise(mode, checkTableInTransaction, writeLocked)
+                    : newScope(() => trans._promise(mode, checkTableInTransaction, writeLocked), { trans: trans, transless: PSD.transless || PSD })
+                : tempTransaction(this.db, mode, [this.name], checkTableInTransaction);
             if (task) {
                 p._consoleTask = task;
-                p = p.catch(err => {
+                p = p.catch((err) => {
                     console.trace(err);
                     return rejection(err);
                 });
@@ -1324,8 +1409,9 @@ class Table {
         if (keyOrCrit == null)
             return rejection(new exceptions.Type(`Invalid argument to Table.get()`));
         return this._trans('readonly', (trans) => {
-            return this.core.get({ trans, key: keyOrCrit })
-                .then(res => this.hook.reading.fire(res));
+            return this.core
+                .get({ trans, key: keyOrCrit })
+                .then((res) => this.hook.reading.fire(res));
         }).then(cb);
     }
     where(indexOrCrit) {
@@ -1335,12 +1421,12 @@ class Table {
             return new this.db.WhereClause(this, `[${indexOrCrit.join('+')}]`);
         const keyPaths = keys(indexOrCrit);
         if (keyPaths.length === 1)
-            return this
-                .where(keyPaths[0])
-                .equals(indexOrCrit[keyPaths[0]]);
-        const compoundIndex = this.schema.indexes.concat(this.schema.primKey).filter(ix => {
+            return this.where(keyPaths[0]).equals(indexOrCrit[keyPaths[0]]);
+        const compoundIndex = this.schema.indexes
+            .concat(this.schema.primKey)
+            .filter((ix) => {
             if (ix.compound &&
-                keyPaths.every(keyPath => ix.keyPath.indexOf(keyPath) >= 0)) {
+                keyPaths.every((keyPath) => ix.keyPath.indexOf(keyPath) >= 0)) {
                 for (let i = 0; i < keyPaths.length; ++i) {
                     if (keyPaths.indexOf(ix.keyPath[i]) === -1)
                         return false;
@@ -1348,12 +1434,11 @@ class Table {
                 return true;
             }
             return false;
-        }).sort((a, b) => a.keyPath.length - b.keyPath.length)[0];
+        })
+            .sort((a, b) => a.keyPath.length - b.keyPath.length)[0];
         if (compoundIndex && this.db._maxKey !== maxString) {
             const keyPathsInValidOrder = compoundIndex.keyPath.slice(0, keyPaths.length);
-            return this
-                .where(keyPathsInValidOrder)
-                .equals(keyPathsInValidOrder.map(kp => indexOrCrit[kp]));
+            return this.where(keyPathsInValidOrder).equals(keyPathsInValidOrder.map((kp) => indexOrCrit[kp]));
         }
         if (!compoundIndex && debug)
             console.warn(`The query ${JSON.stringify(indexOrCrit)} on ${this.name} would benefit from a ` +
@@ -1367,21 +1452,24 @@ class Table {
             const value = indexOrCrit[keyPath];
             return [
                 prevIndex || index,
-                prevIndex || !index ?
-                    combine(prevFilterFn, index && index.multi ?
-                        x => {
+                prevIndex || !index
+                    ? combine(prevFilterFn, index && index.multi
+                        ? (x) => {
                             const prop = getByKeyPath(x, keyPath);
-                            return isArray(prop) && prop.some(item => equals(value, item));
-                        } : x => equals(value, getByKeyPath(x, keyPath)))
-                    : prevFilterFn
+                            return (isArray(prop) &&
+                                prop.some((item) => equals(value, item)));
+                        }
+                        : (x) => equals(value, getByKeyPath(x, keyPath)))
+                    : prevFilterFn,
             ];
         }, [null, null]);
-        return idx ?
-            this.where(idx.name).equals(indexOrCrit[idx.keyPath])
-                .filter(filterFunction) :
-            compoundIndex ?
-                this.filter(filterFunction) :
-                this.where(keyPaths).equals('');
+        return idx
+            ? this.where(idx.name)
+                .equals(indexOrCrit[idx.keyPath])
+                .filter(filterFunction)
+            : compoundIndex
+                ? this.filter(filterFunction)
+                : this.where(keyPaths).equals('');
     }
     filter(filterFunction) {
         return this.toCollection().and(filterFunction);
@@ -1405,9 +1493,7 @@ class Table {
         return new this.db.Collection(new this.db.WhereClause(this));
     }
     orderBy(index) {
-        return new this.db.Collection(new this.db.WhereClause(this, isArray(index) ?
-            `[${index.join('+')}]` :
-            index));
+        return new this.db.Collection(new this.db.WhereClause(this, isArray(index) ? `[${index.join('+')}]` : index));
     }
     reverse() {
         return this.toCollection().reverse();
@@ -1417,13 +1503,17 @@ class Table {
         this.schema.mappedClass = constructor;
         if (constructor.prototype instanceof Entity) {
             constructor = class extends constructor {
-                get db() { return db; }
-                table() { return tableName; }
+                get db() {
+                    return db;
+                }
+                table() {
+                    return tableName;
+                }
             };
         }
         const inheritedProps = new Set();
         for (let proto = constructor.prototype; proto; proto = getProto(proto)) {
-            Object.getOwnPropertyNames(proto).forEach(propName => inheritedProps.add(propName));
+            Object.getOwnPropertyNames(proto).forEach((propName) => inheritedProps.add(propName));
         }
         const readHook = (obj) => {
             if (!obj)
@@ -1441,7 +1531,7 @@ class Table {
             this.hook.reading.unsubscribe(this.schema.readHook);
         }
         this.schema.readHook = readHook;
-        this.hook("reading", readHook);
+        this.hook('reading', readHook);
         return constructor;
     }
     defineClass() {
@@ -1456,10 +1546,16 @@ class Table {
         if (keyPath && auto) {
             objToAdd = workaroundForUndefinedPrimKey(keyPath)(obj);
         }
-        return this._trans('readwrite', trans => {
-            return this.core.mutate({ trans, type: 'add', keys: key != null ? [key] : null, values: [objToAdd] });
-        }).then(res => res.numFailures ? DexiePromise.reject(res.failures[0]) : res.lastResult)
-            .then(lastResult => {
+        return this._trans('readwrite', (trans) => {
+            return this.core.mutate({
+                trans,
+                type: 'add',
+                keys: key != null ? [key] : null,
+                values: [objToAdd],
+            });
+        })
+            .then((res) => res.numFailures ? DexiePromise.reject(res.failures[0]) : res.lastResult)
+            .then((lastResult) => {
             if (keyPath) {
                 try {
                     setByKeyPath(obj, keyPath, lastResult);
@@ -1471,20 +1567,22 @@ class Table {
     }
     upsert(key, modifications) {
         const { keyPath } = this.schema.primKey;
-        return this._trans('readwrite', trans => {
-            return this.core.get({ trans, key }).then(existing => {
+        return this._trans('readwrite', (trans) => {
+            return this.core.get({ trans, key }).then((existing) => {
                 const obj = existing ?? {};
                 applyUpdateSpec(obj, modifications);
                 if (keyPath)
                     setByKeyPath(obj, keyPath, key);
-                return this.core.mutate({
+                return this.core
+                    .mutate({
                     trans,
                     type: 'put',
                     values: [obj],
                     keys: [key],
                     upsert: true,
-                    updates: { keys: [key], changeSpecs: [modifications] }
-                }).then(res => res.numFailures ? DexiePromise.reject(res.failures[0]) : !!existing);
+                    updates: { keys: [key], changeSpecs: [modifications] },
+                })
+                    .then((res) => res.numFailures ? DexiePromise.reject(res.failures[0]) : !!existing);
             });
         });
     }
@@ -1492,11 +1590,11 @@ class Table {
         if (typeof keyOrObject === 'object' && !isArray(keyOrObject)) {
             const key = getByKeyPath(keyOrObject, this.schema.primKey.keyPath);
             if (key === undefined)
-                return rejection(new exceptions.InvalidArgument("Given object does not contain its primary key"));
-            return this.where(":id").equals(key).modify(modifications);
+                return rejection(new exceptions.InvalidArgument('Given object does not contain its primary key'));
+            return this.where(':id').equals(key).modify(modifications);
         }
         else {
-            return this.where(":id").equals(keyOrObject).modify(modifications);
+            return this.where(':id').equals(keyOrObject).modify(modifications);
         }
     }
     put(obj, key) {
@@ -1505,9 +1603,14 @@ class Table {
         if (keyPath && auto) {
             objToAdd = workaroundForUndefinedPrimKey(keyPath)(obj);
         }
-        return this._trans('readwrite', trans => this.core.mutate({ trans, type: 'put', values: [objToAdd], keys: key != null ? [key] : null }))
-            .then(res => res.numFailures ? DexiePromise.reject(res.failures[0]) : res.lastResult)
-            .then(lastResult => {
+        return this._trans('readwrite', (trans) => this.core.mutate({
+            trans,
+            type: 'put',
+            values: [objToAdd],
+            keys: key != null ? [key] : null,
+        }))
+            .then((res) => res.numFailures ? DexiePromise.reject(res.failures[0]) : res.lastResult)
+            .then((lastResult) => {
             if (keyPath) {
                 try {
                     setByKeyPath(obj, keyPath, lastResult);
@@ -1518,38 +1621,49 @@ class Table {
         });
     }
     delete(key) {
-        return this._trans('readwrite', trans => this.core.mutate({ trans, type: 'delete', keys: [key] })
-            .then(res => builtInDeletionTrigger(this, [key], res))
-            .then(res => res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined));
+        return this._trans('readwrite', (trans) => this.core
+            .mutate({ trans, type: 'delete', keys: [key] })
+            .then((res) => builtInDeletionTrigger(this, [key], res))
+            .then((res) => res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined));
     }
     clear() {
-        return this._trans('readwrite', trans => this.core.mutate({ trans, type: 'deleteRange', range: AnyRange })
-            .then(res => builtInDeletionTrigger(this, null, res)))
-            .then(res => res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined);
+        return this._trans('readwrite', (trans) => this.core
+            .mutate({ trans, type: 'deleteRange', range: AnyRange })
+            .then((res) => builtInDeletionTrigger(this, null, res))).then((res) => res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined);
     }
     bulkGet(keys) {
-        return this._trans('readonly', trans => {
-            return this.core.getMany({
+        return this._trans('readonly', (trans) => {
+            return this.core
+                .getMany({
                 keys,
-                trans
-            }).then(result => result.map(res => this.hook.reading.fire(res)));
+                trans,
+            })
+                .then((result) => result.map((res) => this.hook.reading.fire(res)));
         });
     }
     bulkAdd(objects, keysOrOptions, options) {
         const keys = Array.isArray(keysOrOptions) ? keysOrOptions : undefined;
-        options = options || (keys ? undefined : keysOrOptions);
+        options =
+            options || (keys ? undefined : keysOrOptions);
         const wantResults = options ? options.allKeys : undefined;
-        return this._trans('readwrite', trans => {
+        return this._trans('readwrite', (trans) => {
             const { auto, keyPath } = this.schema.primKey;
             if (keyPath && keys)
-                throw new exceptions.InvalidArgument("bulkAdd(): keys argument invalid on tables with inbound keys");
+                throw new exceptions.InvalidArgument('bulkAdd(): keys argument invalid on tables with inbound keys');
             if (keys && keys.length !== objects.length)
-                throw new exceptions.InvalidArgument("Arguments objects and keys must have the same length");
+                throw new exceptions.InvalidArgument('Arguments objects and keys must have the same length');
             const numObjects = objects.length;
-            let objectsToAdd = keyPath && auto ?
-                objects.map(workaroundForUndefinedPrimKey(keyPath)) :
-                objects;
-            return this.core.mutate({ trans, type: 'add', keys: keys, values: objectsToAdd, wantResults })
+            let objectsToAdd = keyPath && auto
+                ? objects.map(workaroundForUndefinedPrimKey(keyPath))
+                : objects;
+            return this.core
+                .mutate({
+                trans,
+                type: 'add',
+                keys: keys,
+                values: objectsToAdd,
+                wantResults,
+            })
                 .then(({ numFailures, results, lastResult, failures }) => {
                 const result = wantResults ? results : lastResult;
                 if (numFailures === 0)
@@ -1560,19 +1674,27 @@ class Table {
     }
     bulkPut(objects, keysOrOptions, options) {
         const keys = Array.isArray(keysOrOptions) ? keysOrOptions : undefined;
-        options = options || (keys ? undefined : keysOrOptions);
+        options =
+            options || (keys ? undefined : keysOrOptions);
         const wantResults = options ? options.allKeys : undefined;
-        return this._trans('readwrite', trans => {
+        return this._trans('readwrite', (trans) => {
             const { auto, keyPath } = this.schema.primKey;
             if (keyPath && keys)
-                throw new exceptions.InvalidArgument("bulkPut(): keys argument invalid on tables with inbound keys");
+                throw new exceptions.InvalidArgument('bulkPut(): keys argument invalid on tables with inbound keys');
             if (keys && keys.length !== objects.length)
-                throw new exceptions.InvalidArgument("Arguments objects and keys must have the same length");
+                throw new exceptions.InvalidArgument('Arguments objects and keys must have the same length');
             const numObjects = objects.length;
-            let objectsToPut = keyPath && auto ?
-                objects.map(workaroundForUndefinedPrimKey(keyPath)) :
-                objects;
-            return this.core.mutate({ trans, type: 'put', keys: keys, values: objectsToPut, wantResults })
+            let objectsToPut = keyPath && auto
+                ? objects.map(workaroundForUndefinedPrimKey(keyPath))
+                : objects;
+            return this.core
+                .mutate({
+                trans,
+                type: 'put',
+                keys: keys,
+                values: objectsToPut,
+                wantResults,
+            })
                 .then(({ numFailures, results, lastResult, failures }) => {
                 const result = wantResults ? results : lastResult;
                 if (numFailures === 0)
@@ -1618,8 +1740,8 @@ class Table {
                     values: resultObjs,
                     updates: {
                         keys,
-                        changeSpecs
-                    }
+                        changeSpecs,
+                    },
                 })
                     .then(({ numFailures, failures }) => {
                     if (numFailures === 0)
@@ -1639,9 +1761,10 @@ class Table {
     }
     bulkDelete(keys) {
         const numKeys = keys.length;
-        return this._trans('readwrite', trans => {
-            return this.core.mutate({ trans, type: 'delete', keys: keys })
-                .then(res => builtInDeletionTrigger(this, keys, res));
+        return this._trans('readwrite', (trans) => {
+            return this.core
+                .mutate({ trans, type: 'delete', keys: keys })
+                .then((res) => builtInDeletionTrigger(this, keys, res));
         }).then(({ numFailures, lastResult, failures }) => {
             if (numFailures === 0)
                 return lastResult;
@@ -1660,7 +1783,7 @@ function Events(ctx) {
             evs[eventName].subscribe.apply(null, args);
             return ctx;
         }
-        else if (typeof (eventName) === 'string') {
+        else if (typeof eventName === 'string') {
             return evs[eventName];
         }
     };
@@ -1686,9 +1809,11 @@ function Events(ctx) {
                 }
             },
             unsubscribe: function (cb) {
-                context.subscribers = context.subscribers.filter(function (fn) { return fn !== cb; });
+                context.subscribers = context.subscribers.filter(function (fn) {
+                    return fn !== cb;
+                });
                 context.fire = context.subscribers.reduce(chainFunction, defaultFunction);
-            }
+            },
         };
         evs[eventName] = rv[eventName] = context;
         return context;
@@ -1712,7 +1837,7 @@ function Events(ctx) {
                 });
             }
             else
-                throw new exceptions.InvalidArgument("Invalid event config");
+                throw new exceptions.InvalidArgument('Invalid event config');
         });
     }
 }
@@ -1728,18 +1853,20 @@ function createTableConstructor(db) {
         this._tx = trans;
         this.name = name;
         this.schema = tableSchema;
-        this.hook = db._allTables[name] ? db._allTables[name].hook : Events(null, {
-            "creating": [hookCreatingChain, nop],
-            "reading": [pureFunctionChain, mirror],
-            "updating": [hookUpdatingChain, nop],
-            "deleting": [hookDeletingChain, nop]
-        });
+        this.hook = db._allTables[name]
+            ? db._allTables[name].hook
+            : Events(null, {
+                creating: [hookCreatingChain, nop],
+                reading: [pureFunctionChain, mirror],
+                updating: [hookUpdatingChain, nop],
+                deleting: [hookDeletingChain, nop],
+            });
     });
 }
 
 function isPlainKeyRange(ctx, ignoreLimitFilter) {
-    return !(ctx.filter || ctx.algorithm || ctx.or) &&
-        (ignoreLimitFilter ? ctx.justLimit : !ctx.replayFilter);
+    return (!(ctx.filter || ctx.algorithm || ctx.or) &&
+        (ignoreLimitFilter ? ctx.justLimit : !ctx.replayFilter));
 }
 function addFilter(ctx, fn) {
     ctx.filter = combine(ctx.filter, fn);
@@ -1757,7 +1884,11 @@ function getIndexOrStore(ctx, coreSchema) {
         return coreSchema.primaryKey;
     const index = coreSchema.getIndexByKeyPath(ctx.index);
     if (!index)
-        throw new exceptions.Schema("KeyPath " + ctx.index + " on object store " + coreSchema.name + " is not indexed");
+        throw new exceptions.Schema('KeyPath ' +
+            ctx.index +
+            ' on object store ' +
+            coreSchema.name +
+            ' is not indexed');
     return index;
 }
 function openCursor(ctx, coreTable, trans) {
@@ -1769,19 +1900,22 @@ function openCursor(ctx, coreTable, trans) {
         unique: !!ctx.unique,
         query: {
             index,
-            range: ctx.range
-        }
+            range: ctx.range,
+        },
     });
 }
 function iter(ctx, fn, coreTrans, coreTable) {
-    const filter = ctx.replayFilter ? combine(ctx.filter, ctx.replayFilter()) : ctx.filter;
+    const filter = ctx.replayFilter
+        ? combine(ctx.filter, ctx.replayFilter())
+        : ctx.filter;
     if (!ctx.or) {
         return iterate(openCursor(ctx, coreTable, coreTrans), combine(ctx.algorithm, filter), fn, !ctx.keysOnly && ctx.valueMapper);
     }
     else {
         const set = {};
         const union = (item, cursor, advance) => {
-            if (!filter || filter(cursor, advance, result => cursor.stop(result), err => cursor.fail(err))) {
+            if (!filter ||
+                filter(cursor, advance, (result) => cursor.stop(result), (err) => cursor.fail(err))) {
                 var primaryKey = cursor.primaryKey;
                 var key = '' + primaryKey;
                 if (key === '[object ArrayBuffer]')
@@ -1794,19 +1928,26 @@ function iter(ctx, fn, coreTrans, coreTable) {
         };
         return Promise.all([
             ctx.or._iterate(union, coreTrans),
-            iterate(openCursor(ctx, coreTable, coreTrans), ctx.algorithm, union, !ctx.keysOnly && ctx.valueMapper)
+            iterate(openCursor(ctx, coreTable, coreTrans), ctx.algorithm, union, !ctx.keysOnly && ctx.valueMapper),
         ]);
     }
 }
 function iterate(cursorPromise, filter, fn, valueMapper) {
     var mappedFn = valueMapper ? (x, c, a) => fn(valueMapper(x), c, a) : fn;
     var wrappedFn = wrap(mappedFn);
-    return cursorPromise.then(cursor => {
+    return cursorPromise.then((cursor) => {
         if (cursor) {
             return cursor.start(() => {
                 var c = () => cursor.continue();
-                if (!filter || filter(cursor, advancer => c = advancer, val => { cursor.stop(val); c = nop; }, e => { cursor.fail(e); c = nop; }))
-                    wrappedFn(cursor.value, cursor, advancer => c = advancer);
+                if (!filter ||
+                    filter(cursor, (advancer) => (c = advancer), (val) => {
+                        cursor.stop(val);
+                        c = nop;
+                    }, (e) => {
+                        cursor.fail(e);
+                        c = nop;
+                    }))
+                    wrappedFn(cursor.value, cursor, (advancer) => (c = advancer));
                 c();
             });
         }
@@ -1816,15 +1957,15 @@ function iterate(cursorPromise, filter, fn, valueMapper) {
 class Collection {
     _read(fn, cb) {
         var ctx = this._ctx;
-        return ctx.error ?
-            ctx.table._trans(null, rejection.bind(null, ctx.error)) :
-            ctx.table._trans('readonly', fn).then(cb);
+        return ctx.error
+            ? ctx.table._trans(null, rejection.bind(null, ctx.error))
+            : ctx.table._trans('readonly', fn).then(cb);
     }
     _write(fn) {
         var ctx = this._ctx;
-        return ctx.error ?
-            ctx.table._trans(null, rejection.bind(null, ctx.error)) :
-            ctx.table._trans('readwrite', fn, "locked");
+        return ctx.error
+            ? ctx.table._trans(null, rejection.bind(null, ctx.error))
+            : ctx.table._trans('readwrite', fn, 'locked');
     }
     _addAlgorithm(fn) {
         var ctx = this._ctx;
@@ -1846,25 +1987,29 @@ class Collection {
     }
     each(fn) {
         var ctx = this._ctx;
-        return this._read(trans => iter(ctx, fn, trans, ctx.table.core));
+        return this._read((trans) => iter(ctx, fn, trans, ctx.table.core));
     }
     count(cb) {
-        return this._read(trans => {
+        return this._read((trans) => {
             const ctx = this._ctx;
             const coreTable = ctx.table.core;
             if (isPlainKeyRange(ctx, true)) {
-                return coreTable.count({
+                return coreTable
+                    .count({
                     trans,
                     query: {
                         index: getIndexOrStore(ctx, coreTable.schema),
-                        range: ctx.range
-                    }
-                }).then(count => Math.min(count, ctx.limit));
+                        range: ctx.range,
+                    },
+                })
+                    .then((count) => Math.min(count, ctx.limit));
             }
             else {
                 var count = 0;
-                return iter(ctx, () => { ++count; return false; }, trans, coreTable)
-                    .then(() => count);
+                return iter(ctx, () => {
+                    ++count;
+                    return false;
+                }, trans, coreTable).then(() => count);
             }
         }).then(cb);
     }
@@ -1875,7 +2020,7 @@ class Collection {
                 return getval(obj[parts[i]], i - 1);
             return obj[lastPart];
         }
-        var order = this._ctx.dir === "next" ? 1 : -1;
+        var order = this._ctx.dir === 'next' ? 1 : -1;
         function sorter(a, b) {
             var aVal = getval(a, lastIndex), bVal = getval(b, lastIndex);
             return cmp(aVal, bVal) * order;
@@ -1885,25 +2030,27 @@ class Collection {
         }).then(cb);
     }
     toArray(cb) {
-        return this._read(trans => {
+        return this._read((trans) => {
             var ctx = this._ctx;
             if (isPlainKeyRange(ctx, true) && ctx.limit > 0) {
                 const { valueMapper } = ctx;
                 const index = getIndexOrStore(ctx, ctx.table.core.schema);
-                return ctx.table.core.query({
+                return ctx.table.core
+                    .query({
                     trans,
                     limit: ctx.limit,
                     values: true,
                     direction: ctx.dir === 'prev' ? 'prev' : undefined,
                     query: {
                         index,
-                        range: ctx.range
-                    }
-                }).then(({ result }) => valueMapper ? result.map(valueMapper) : result);
+                        range: ctx.range,
+                    },
+                })
+                    .then(({ result }) => valueMapper ? result.map(valueMapper) : result);
             }
             else {
                 const a = [];
-                return iter(ctx, item => a.push(item), trans, ctx.table.core).then(() => a);
+                return iter(ctx, (item) => a.push(item), trans, ctx.table.core).then(() => a);
             }
         }, cb);
     }
@@ -1933,7 +2080,7 @@ class Collection {
         else {
             addReplayFilter(ctx, () => {
                 var offsetLeft = offset;
-                return () => (--offsetLeft < 0);
+                return () => --offsetLeft < 0;
             });
         }
         return this;
@@ -1963,7 +2110,11 @@ class Collection {
         return this;
     }
     first(cb) {
-        return this.limit(1).toArray(function (a) { return a[0]; }).then(cb);
+        return this.limit(1)
+            .toArray(function (a) {
+            return a[0];
+        })
+            .then(cb);
     }
     last(cb) {
         return this.reverse().first(cb);
@@ -1982,7 +2133,7 @@ class Collection {
         return new this.db.WhereClause(this._ctx.table, indexName, this);
     }
     reverse() {
-        this._ctx.dir = (this._ctx.dir === "prev" ? "next" : "prev");
+        this._ctx.dir = this._ctx.dir === 'prev' ? 'next' : 'prev';
         if (this._ondirectionchange)
             this._ondirectionchange(this._ctx.dir);
         return this;
@@ -1993,16 +2144,20 @@ class Collection {
     eachKey(cb) {
         var ctx = this._ctx;
         ctx.keysOnly = !ctx.isMatch;
-        return this.each(function (val, cursor) { cb(cursor.key, cursor); });
+        return this.each(function (val, cursor) {
+            cb(cursor.key, cursor);
+        });
     }
     eachUniqueKey(cb) {
-        this._ctx.unique = "unique";
+        this._ctx.unique = 'unique';
         return this.eachKey(cb);
     }
     eachPrimaryKey(cb) {
         var ctx = this._ctx;
         ctx.keysOnly = !ctx.isMatch;
-        return this.each(function (val, cursor) { cb(cursor.primaryKey, cursor); });
+        return this.each(function (val, cursor) {
+            cb(cursor.primaryKey, cursor);
+        });
     }
     keys(cb) {
         var ctx = this._ctx;
@@ -2010,14 +2165,16 @@ class Collection {
         var a = [];
         return this.each(function (item, cursor) {
             a.push(cursor.key);
-        }).then(function () {
+        })
+            .then(function () {
             return a;
-        }).then(cb);
+        })
+            .then(cb);
     }
     primaryKeys(cb) {
         var ctx = this._ctx;
         if (isPlainKeyRange(ctx, true) && ctx.limit > 0) {
-            return this._read(trans => {
+            return this._read((trans) => {
                 var index = getIndexOrStore(ctx, ctx.table.core.schema);
                 return ctx.table.core.query({
                     trans,
@@ -2026,25 +2183,33 @@ class Collection {
                     direction: ctx.dir === 'prev' ? 'prev' : undefined,
                     query: {
                         index,
-                        range: ctx.range
-                    }
+                        range: ctx.range,
+                    },
                 });
-            }).then(({ result }) => result).then(cb);
+            })
+                .then(({ result }) => result)
+                .then(cb);
         }
         ctx.keysOnly = !ctx.isMatch;
         var a = [];
         return this.each(function (item, cursor) {
             a.push(cursor.primaryKey);
-        }).then(function () {
+        })
+            .then(function () {
             return a;
-        }).then(cb);
+        })
+            .then(cb);
     }
     uniqueKeys(cb) {
-        this._ctx.unique = "unique";
+        this._ctx.unique = 'unique';
         return this.keys(cb);
     }
     firstKey(cb) {
-        return this.limit(1).keys(function (a) { return a[0]; }).then(cb);
+        return this.limit(1)
+            .keys(function (a) {
+            return a[0];
+        })
+            .then(cb);
     }
     lastKey(cb) {
         return this.reverse().firstKey(cb);
@@ -2064,13 +2229,13 @@ class Collection {
     }
     modify(changes) {
         var ctx = this._ctx;
-        return this._write(trans => {
+        return this._write((trans) => {
             var modifyer;
             if (typeof changes === 'function') {
                 modifyer = changes;
             }
             else {
-                modifyer = item => applyUpdateSpec(item, changes);
+                modifyer = (item) => applyUpdateSpec(item, changes);
             }
             const coreTable = ctx.table.core;
             const { outbound, extractKey } = coreTable.schema.primaryKey;
@@ -2078,7 +2243,8 @@ class Collection {
             const modifyChunkSize = this.db._options.modifyChunkSize;
             if (modifyChunkSize) {
                 if (typeof modifyChunkSize == 'object') {
-                    limit = modifyChunkSize[coreTable.name] || modifyChunkSize['*'] || 200;
+                    limit =
+                        modifyChunkSize[coreTable.name] || modifyChunkSize['*'] || 200;
                 }
                 else {
                     limit = modifyChunkSize;
@@ -2095,21 +2261,25 @@ class Collection {
                 }
             };
             const isUnconditionalDelete = changes === deleteCallback;
-            return this.clone().primaryKeys().then(keys => {
+            return this.clone()
+                .primaryKeys()
+                .then((keys) => {
                 const criteria = isPlainKeyRange(ctx) &&
                     ctx.limit === Infinity &&
                     (typeof changes !== 'function' || isUnconditionalDelete) && {
                     index: ctx.index,
-                    range: ctx.range
+                    range: ctx.range,
                 };
                 const nextChunk = (offset) => {
                     const count = Math.min(limit, keys.length - offset);
                     const keysInChunk = keys.slice(offset, offset + count);
-                    return (isUnconditionalDelete ? Promise.resolve([]) : coreTable.getMany({
-                        trans,
-                        keys: keysInChunk,
-                        cache: "immutable"
-                    })).then(values => {
+                    return (isUnconditionalDelete
+                        ? Promise.resolve([])
+                        : coreTable.getMany({
+                            trans,
+                            keys: keysInChunk,
+                            cache: 'immutable',
+                        })).then((values) => {
                         const addValues = [];
                         const putValues = [];
                         const putKeys = outbound ? [] : null;
@@ -2119,13 +2289,14 @@ class Collection {
                                 const origValue = values[i];
                                 const ctx = {
                                     value: deepClone(origValue),
-                                    primKey: keys[offset + i]
+                                    primKey: keys[offset + i],
                                 };
                                 if (modifyer.call(ctx, ctx.value, ctx) !== false) {
                                     if (ctx.value == null) {
                                         deleteKeys.push(keys[offset + i]);
                                     }
-                                    else if (!outbound && cmp(extractKey(origValue), extractKey(ctx.value)) !== 0) {
+                                    else if (!outbound &&
+                                        cmp(extractKey(origValue), extractKey(ctx.value)) !== 0) {
                                         deleteKeys.push(keys[offset + i]);
                                         addValues.push(ctx.value);
                                     }
@@ -2137,38 +2308,47 @@ class Collection {
                                 }
                             }
                         return Promise.resolve(addValues.length > 0 &&
-                            coreTable.mutate({ trans, type: 'add', values: addValues })
-                                .then(res => {
+                            coreTable
+                                .mutate({ trans, type: 'add', values: addValues })
+                                .then((res) => {
                                 for (let pos in res.failures) {
                                     deleteKeys.splice(parseInt(pos), 1);
                                 }
                                 applyMutateResult(addValues.length, res);
-                            })).then(() => (putValues.length > 0 || (criteria && typeof changes === 'object')) &&
-                            coreTable.mutate({
+                            }))
+                            .then(() => (putValues.length > 0 ||
+                            (criteria && typeof changes === 'object')) &&
+                            coreTable
+                                .mutate({
                                 trans,
                                 type: 'put',
                                 keys: putKeys,
                                 values: putValues,
                                 criteria,
-                                changeSpec: typeof changes !== 'function'
-                                    && changes,
-                                isAdditionalChunk: offset > 0
-                            }).then(res => applyMutateResult(putValues.length, res))).then(() => (deleteKeys.length > 0 || (criteria && isUnconditionalDelete)) &&
-                            coreTable.mutate({
+                                changeSpec: typeof changes !== 'function' && changes,
+                                isAdditionalChunk: offset > 0,
+                            })
+                                .then((res) => applyMutateResult(putValues.length, res)))
+                            .then(() => (deleteKeys.length > 0 ||
+                            (criteria && isUnconditionalDelete)) &&
+                            coreTable
+                                .mutate({
                                 trans,
                                 type: 'delete',
                                 keys: deleteKeys,
                                 criteria,
-                                isAdditionalChunk: offset > 0
-                            }).then(res => builtInDeletionTrigger(ctx.table, deleteKeys, res))
-                                .then(res => applyMutateResult(deleteKeys.length, res))).then(() => {
-                            return keys.length > offset + count && nextChunk(offset + limit);
+                                isAdditionalChunk: offset > 0,
+                            })
+                                .then((res) => builtInDeletionTrigger(ctx.table, deleteKeys, res))
+                                .then((res) => applyMutateResult(deleteKeys.length, res)))
+                            .then(() => {
+                            return (keys.length > offset + count && nextChunk(offset + limit));
                         });
                     });
                 };
                 return nextChunk(0).then(() => {
                     if (totalFailures.length > 0)
-                        throw new ModifyError("Error modifying one or more objects", totalFailures, successCount, failedKeys);
+                        throw new ModifyError('Error modifying one or more objects', totalFailures, successCount, failedKeys);
                     return keys.length;
                 });
             });
@@ -2180,14 +2360,17 @@ class Collection {
             !ctx.table.schema.yProps &&
             (ctx.isPrimKey || range.type === 3 ))
          {
-            return this._write(trans => {
+            return this._write((trans) => {
                 const { primaryKey } = ctx.table.core.schema;
                 const coreRange = range;
-                return ctx.table.core.count({ trans, query: { index: primaryKey, range: coreRange } }).then(count => {
-                    return ctx.table.core.mutate({ trans, type: 'deleteRange', range: coreRange })
+                return ctx.table.core
+                    .count({ trans, query: { index: primaryKey, range: coreRange } })
+                    .then((count) => {
+                    return ctx.table.core
+                        .mutate({ trans, type: 'deleteRange', range: coreRange })
                         .then(({ failures, numFailures }) => {
                         if (numFailures)
-                            throw new ModifyError("Could not delete some values", Object.keys(failures).map(pos => failures[pos]), count - numFailures);
+                            throw new ModifyError('Could not delete some values', Object.keys(failures).map((pos) => failures[pos]), count - numFailures);
                         return count - numFailures;
                     });
                 });
@@ -2196,7 +2379,7 @@ class Collection {
         return this.modify(deleteCallback);
     }
 }
-const deleteCallback = (value, ctx) => ctx.value = null;
+const deleteCallback = (value, ctx) => (ctx.value = null);
 
 function createCollectionConstructor(db) {
     return makeClassConstructor(Collection.prototype, function Collection(whereClause, keyRangeGenerator) {
@@ -2215,11 +2398,13 @@ function createCollectionConstructor(db) {
         this._ctx = {
             table: table,
             index: whereCtx.index,
-            isPrimKey: (!whereCtx.index || (table.schema.primKey.keyPath && whereCtx.index === table.schema.primKey.name)),
+            isPrimKey: !whereCtx.index ||
+                (table.schema.primKey.keyPath &&
+                    whereCtx.index === table.schema.primKey.name),
             range: keyRange,
             keysOnly: false,
-            dir: "next",
-            unique: "",
+            dir: 'next',
+            unique: '',
             algorithm: null,
             filter: null,
             replayFilter: null,
@@ -2229,7 +2414,7 @@ function createCollectionConstructor(db) {
             limit: Infinity,
             error: error,
             or: whereCtx.or,
-            valueMapper: readingHook !== mirror ? readingHook : null
+            valueMapper: readingHook !== mirror ? readingHook : null,
         };
     });
 }
@@ -2242,24 +2427,24 @@ function simpleCompareReverse(a, b) {
 }
 
 function fail(collectionOrWhereClause, err, T) {
-    var collection = collectionOrWhereClause instanceof WhereClause ?
-        new collectionOrWhereClause.Collection(collectionOrWhereClause) :
-        collectionOrWhereClause;
+    var collection = collectionOrWhereClause instanceof WhereClause
+        ? new collectionOrWhereClause.Collection(collectionOrWhereClause)
+        : collectionOrWhereClause;
     collection._ctx.error = T ? new T(err) : new TypeError(err);
     return collection;
 }
 function emptyCollection(whereClause) {
-    return new whereClause.Collection(whereClause, () => rangeEqual("")).limit(0);
+    return new whereClause.Collection(whereClause, () => rangeEqual('')).limit(0);
 }
 function upperFactory(dir) {
-    return dir === "next" ?
-        (s) => s.toUpperCase() :
-        (s) => s.toLowerCase();
+    return dir === 'next'
+        ? (s) => s.toUpperCase()
+        : (s) => s.toLowerCase();
 }
 function lowerFactory(dir) {
-    return dir === "next" ?
-        (s) => s.toLowerCase() :
-        (s) => s.toUpperCase();
+    return dir === 'next'
+        ? (s) => s.toLowerCase()
+        : (s) => s.toUpperCase();
 }
 function nextCasing(key, lowerKey, upperNeedle, lowerNeedle, cmp, dir) {
     var length = Math.min(key.length, lowerNeedle.length);
@@ -2278,32 +2463,40 @@ function nextCasing(key, lowerKey, upperNeedle, lowerNeedle, cmp, dir) {
         if (cmp(key[i], lwrKeyChar) < 0)
             llp = i;
     }
-    if (length < lowerNeedle.length && dir === "next")
+    if (length < lowerNeedle.length && dir === 'next')
         return key + upperNeedle.substr(key.length);
-    if (length < key.length && dir === "prev")
+    if (length < key.length && dir === 'prev')
         return key.substr(0, upperNeedle.length);
-    return (llp < 0 ? null : key.substr(0, llp) + lowerNeedle[llp] + upperNeedle.substr(llp + 1));
+    return llp < 0
+        ? null
+        : key.substr(0, llp) + lowerNeedle[llp] + upperNeedle.substr(llp + 1);
 }
 function addIgnoreCaseAlgorithm(whereClause, match, needles, suffix) {
     var upper, lower, compare, upperNeedles, lowerNeedles, direction, nextKeySuffix, needlesLen = needles.length;
-    if (!needles.every(s => typeof s === 'string')) {
+    if (!needles.every((s) => typeof s === 'string')) {
         return fail(whereClause, STRING_EXPECTED);
     }
     function initDirection(dir) {
         upper = upperFactory(dir);
         lower = lowerFactory(dir);
-        compare = (dir === "next" ? simpleCompare : simpleCompareReverse);
-        var needleBounds = needles.map(function (needle) {
+        compare = dir === 'next' ? simpleCompare : simpleCompareReverse;
+        var needleBounds = needles
+            .map(function (needle) {
             return { lower: lower(needle), upper: upper(needle) };
-        }).sort(function (a, b) {
+        })
+            .sort(function (a, b) {
             return compare(a.lower, b.lower);
         });
-        upperNeedles = needleBounds.map(function (nb) { return nb.upper; });
-        lowerNeedles = needleBounds.map(function (nb) { return nb.lower; });
+        upperNeedles = needleBounds.map(function (nb) {
+            return nb.upper;
+        });
+        lowerNeedles = needleBounds.map(function (nb) {
+            return nb.lower;
+        });
         direction = dir;
-        nextKeySuffix = (dir === "next" ? "" : suffix);
+        nextKeySuffix = dir === 'next' ? '' : suffix;
     }
-    initDirection("next");
+    initDirection('next');
     var c = new whereClause.Collection(whereClause, () => createRange(upperNeedles[0], lowerNeedles[needlesLen - 1] + suffix));
     c._ondirectionchange = function (direction) {
         initDirection(direction);
@@ -2323,12 +2516,15 @@ function addIgnoreCaseAlgorithm(whereClause, match, needles, suffix) {
                 var casing = nextCasing(key, lowerKey, upperNeedles[i], lowerNeedles[i], compare, direction);
                 if (casing === null && lowestPossibleCasing === null)
                     firstPossibleNeedle = i + 1;
-                else if (lowestPossibleCasing === null || compare(lowestPossibleCasing, casing) > 0) {
+                else if (lowestPossibleCasing === null ||
+                    compare(lowestPossibleCasing, casing) > 0) {
                     lowestPossibleCasing = casing;
                 }
             }
             if (lowestPossibleCasing !== null) {
-                advance(function () { cursor.continue(lowestPossibleCasing + nextKeySuffix); });
+                advance(function () {
+                    cursor.continue(lowestPossibleCasing + nextKeySuffix);
+                });
             }
             else {
                 advance(resolve);
@@ -2344,14 +2540,14 @@ function createRange(lower, upper, lowerOpen, upperOpen) {
         lower,
         upper,
         lowerOpen,
-        upperOpen
+        upperOpen,
     };
 }
 function rangeEqual(value) {
     return {
         type: 1 ,
         lower: value,
-        upper: value
+        upper: value,
     };
 }
 
@@ -2363,8 +2559,10 @@ class WhereClause {
         includeLower = includeLower !== false;
         includeUpper = includeUpper === true;
         try {
-            if ((this._cmp(lower, upper) > 0) ||
-                (this._cmp(lower, upper) === 0 && (includeLower || includeUpper) && !(includeLower && includeUpper)))
+            if (this._cmp(lower, upper) > 0 ||
+                (this._cmp(lower, upper) === 0 &&
+                    (includeLower || includeUpper) &&
+                    !(includeLower && includeUpper)))
                 return emptyCollection(this);
             return new this.Collection(this, () => createRange(lower, upper, !includeLower, !includeUpper));
         }
@@ -2403,24 +2601,24 @@ class WhereClause {
         return this.between(str, str + maxString, true, true);
     }
     startsWithIgnoreCase(str) {
-        if (str === "")
+        if (str === '')
             return this.startsWith(str);
         return addIgnoreCaseAlgorithm(this, (x, a) => x.indexOf(a[0]) === 0, [str], maxString);
     }
     equalsIgnoreCase(str) {
-        return addIgnoreCaseAlgorithm(this, (x, a) => x === a[0], [str], "");
+        return addIgnoreCaseAlgorithm(this, (x, a) => x === a[0], [str], '');
     }
     anyOfIgnoreCase() {
         var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
         if (set.length === 0)
             return emptyCollection(this);
-        return addIgnoreCaseAlgorithm(this, (x, a) => a.indexOf(x) !== -1, set, "");
+        return addIgnoreCaseAlgorithm(this, (x, a) => a.indexOf(x) !== -1, set, '');
     }
     startsWithAnyOfIgnoreCase() {
         var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
         if (set.length === 0)
             return emptyCollection(this);
-        return addIgnoreCaseAlgorithm(this, (x, a) => a.some(n => x.indexOf(n) === 0), set, maxString);
+        return addIgnoreCaseAlgorithm(this, (x, a) => a.some((n) => x.indexOf(n) === 0), set, maxString);
     }
     anyOf() {
         const set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
@@ -2434,10 +2632,8 @@ class WhereClause {
         if (set.length === 0)
             return emptyCollection(this);
         const c = new this.Collection(this, () => createRange(set[0], set[set.length - 1]));
-        c._ondirectionchange = direction => {
-            compare = (direction === "next" ?
-                this._ascending :
-                this._descending);
+        c._ondirectionchange = (direction) => {
+            compare = direction === 'next' ? this._ascending : this._descending;
             set.sort(compare);
         };
         let i = 0;
@@ -2454,14 +2650,19 @@ class WhereClause {
                 return true;
             }
             else {
-                advance(() => { cursor.continue(set[i]); });
+                advance(() => {
+                    cursor.continue(set[i]);
+                });
                 return false;
             }
         });
         return c;
     }
     notEqual(value) {
-        return this.inAnyRange([[minKey, value], [value, this.db._maxKey]], { includeLowers: false, includeUppers: false });
+        return this.inAnyRange([
+            [minKey, value],
+            [value, this.db._maxKey],
+        ], { includeLowers: false, includeUppers: false });
     }
     noneOf() {
         const set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
@@ -2473,20 +2674,21 @@ class WhereClause {
         catch (e) {
             return fail(this, INVALID_KEY_ARGUMENT);
         }
-        const ranges = set.reduce((res, val) => res ?
-            res.concat([[res[res.length - 1][1], val]]) :
-            [[minKey, val]], null);
+        const ranges = set.reduce((res, val) => res ? res.concat([[res[res.length - 1][1], val]]) : [[minKey, val]], null);
         ranges.push([set[set.length - 1], this.db._maxKey]);
-        return this.inAnyRange(ranges, { includeLowers: false, includeUppers: false });
+        return this.inAnyRange(ranges, {
+            includeLowers: false,
+            includeUppers: false,
+        });
     }
     inAnyRange(ranges, options) {
         const cmp = this._cmp, ascending = this._ascending, descending = this._descending, min = this._min, max = this._max;
         if (ranges.length === 0)
             return emptyCollection(this);
-        if (!ranges.every(range => range[0] !== undefined &&
+        if (!ranges.every((range) => range[0] !== undefined &&
             range[1] !== undefined &&
             ascending(range[0], range[1]) <= 0)) {
-            return fail(this, "First argument to inAnyRange() must be an Array of two-value Arrays [lower,upper] where upper must not be lower than lower", exceptions.InvalidArgument);
+            return fail(this, 'First argument to inAnyRange() must be an Array of two-value Arrays [lower,upper] where upper must not be lower than lower', exceptions.InvalidArgument);
         }
         const includeLowers = !options || options.includeLowers !== false;
         const includeUppers = options && options.includeUppers === true;
@@ -2505,7 +2707,9 @@ class WhereClause {
             return ranges;
         }
         let sortDirection = ascending;
-        function rangeSorter(a, b) { return sortDirection(a[0], b[0]); }
+        function rangeSorter(a, b) {
+            return sortDirection(a[0], b[0]);
+        }
         let set;
         try {
             set = ranges.reduce(addRange, []);
@@ -2515,19 +2719,19 @@ class WhereClause {
             return fail(this, INVALID_KEY_ARGUMENT);
         }
         let rangePos = 0;
-        const keyIsBeyondCurrentEntry = includeUppers ?
-            key => ascending(key, set[rangePos][1]) > 0 :
-            key => ascending(key, set[rangePos][1]) >= 0;
-        const keyIsBeforeCurrentEntry = includeLowers ?
-            key => descending(key, set[rangePos][0]) > 0 :
-            key => descending(key, set[rangePos][0]) >= 0;
+        const keyIsBeyondCurrentEntry = includeUppers
+            ? (key) => ascending(key, set[rangePos][1]) > 0
+            : (key) => ascending(key, set[rangePos][1]) >= 0;
+        const keyIsBeforeCurrentEntry = includeLowers
+            ? (key) => descending(key, set[rangePos][0]) > 0
+            : (key) => descending(key, set[rangePos][0]) >= 0;
         function keyWithinCurrentRange(key) {
             return !keyIsBeyondCurrentEntry(key) && !keyIsBeforeCurrentEntry(key);
         }
         let checkKey = keyIsBeyondCurrentEntry;
         const c = new this.Collection(this, () => createRange(set[0][0], set[set.length - 1][1], !includeLowers, !includeUppers));
-        c._ondirectionchange = direction => {
-            if (direction === "next") {
+        c._ondirectionchange = (direction) => {
+            if (direction === 'next') {
                 checkKey = keyIsBeyondCurrentEntry;
                 sortDirection = ascending;
             }
@@ -2549,7 +2753,8 @@ class WhereClause {
             if (keyWithinCurrentRange(key)) {
                 return true;
             }
-            else if (this._cmp(key, set[rangePos][1]) === 0 || this._cmp(key, set[rangePos][0]) === 0) {
+            else if (this._cmp(key, set[rangePos][1]) === 0 ||
+                this._cmp(key, set[rangePos][0]) === 0) {
                 return false;
             }
             else {
@@ -2566,8 +2771,8 @@ class WhereClause {
     }
     startsWithAnyOf() {
         const set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
-        if (!set.every(s => typeof s === 'string')) {
-            return fail(this, "startsWithAnyOf() only works with strings");
+        if (!set.every((s) => typeof s === 'string')) {
+            return fail(this, 'startsWithAnyOf() only works with strings');
         }
         if (set.length === 0)
             return emptyCollection(this);
@@ -2580,13 +2785,13 @@ function createWhereClauseConstructor(db) {
         this.db = db;
         this._ctx = {
             table: table,
-            index: index === ":id" ? null : index,
-            or: orCollection
+            index: index === ':id' ? null : index,
+            or: orCollection,
         };
         this._cmp = this._ascending = cmp;
         this._descending = (a, b) => cmp(b, a);
-        this._max = (a, b) => cmp(a, b) > 0 ? a : b;
-        this._min = (a, b) => cmp(a, b) < 0 ? a : b;
+        this._max = (a, b) => (cmp(a, b) > 0 ? a : b);
+        this._min = (a, b) => (cmp(a, b) < 0 ? a : b);
         this._IDBKeyRange = db._deps.IDBKeyRange;
         if (!this._IDBKeyRange)
             throw new exceptions.MissingAPI();
@@ -2645,9 +2850,9 @@ class Transaction {
         assert(!this.idbtrans);
         if (!idbtrans && !idbdb) {
             switch (dbOpenError && dbOpenError.name) {
-                case "DatabaseClosedError":
+                case 'DatabaseClosedError':
                     throw new exceptions.DatabaseClosed(dbOpenError);
-                case "MissingAPIError":
+                case 'MissingAPIError':
                     throw new exceptions.MissingAPI(dbOpenError.message, dbOpenError);
                 default:
                     throw new exceptions.OpenFailed(dbOpenError);
@@ -2656,39 +2861,45 @@ class Transaction {
         if (!this.active)
             throw new exceptions.TransactionInactive();
         assert(this._completion._state === null);
-        idbtrans = this.idbtrans = idbtrans ||
-            (this.db.core
-                ? this.db.core.transaction(this.storeNames, this.mode, { durability: this.chromeTransactionDurability })
-                : idbdb.transaction(this.storeNames, this.mode, { durability: this.chromeTransactionDurability }));
-        idbtrans.onerror = wrap(ev => {
+        idbtrans = this.idbtrans =
+            idbtrans ||
+                (this.db.core
+                    ? this.db.core.transaction(this.storeNames, this.mode, { durability: this.chromeTransactionDurability })
+                    : idbdb.transaction(this.storeNames, this.mode, {
+                        durability: this.chromeTransactionDurability,
+                    }));
+        idbtrans.onerror = wrap((ev) => {
             preventDefault(ev);
             this._reject(idbtrans.error);
         });
-        idbtrans.onabort = wrap(ev => {
+        idbtrans.onabort = wrap((ev) => {
             preventDefault(ev);
             this.active && this._reject(new exceptions.Abort(idbtrans.error));
             this.active = false;
-            this.on("abort").fire(ev);
+            this.on('abort').fire(ev);
         });
         idbtrans.oncomplete = wrap(() => {
             this.active = false;
             this._resolve();
             if ('mutatedParts' in idbtrans) {
-                globalEvents.storagemutated.fire(idbtrans["mutatedParts"]);
+                globalEvents.storagemutated.fire(idbtrans['mutatedParts']);
             }
         });
         return this;
     }
     _promise(mode, fn, bWriteLock) {
         if (mode === 'readwrite' && this.mode !== 'readwrite')
-            return rejection(new exceptions.ReadOnly("Transaction is readonly"));
+            return rejection(new exceptions.ReadOnly('Transaction is readonly'));
         if (!this.active)
             return rejection(new exceptions.TransactionInactive());
         if (this._locked()) {
             return new DexiePromise((resolve, reject) => {
-                this._blockedFuncs.push([() => {
+                this._blockedFuncs.push([
+                    () => {
                         this._promise(mode, fn, bWriteLock).then(resolve, reject);
-                    }, PSD]);
+                    },
+                    PSD,
+                ]);
             });
         }
         else if (bWriteLock) {
@@ -2730,14 +2941,16 @@ class Transaction {
             (function spin() {
                 ++root._spinCount;
                 while (root._waitingQueue.length)
-                    (root._waitingQueue.shift())();
+                    root._waitingQueue.shift()();
                 if (root._waitingFor)
                     store.get(-Infinity).onsuccess = spin;
-            }());
+            })();
         }
         var currentWaitPromise = root._waitingFor;
         return new DexiePromise((resolve, reject) => {
-            promise.then(res => root._waitingQueue.push(wrap(resolve.bind(null, res))), err => root._waitingQueue.push(wrap(reject.bind(null, err)))).finally(() => {
+            promise
+                .then((res) => root._waitingQueue.push(wrap(resolve.bind(null, res))), (err) => root._waitingQueue.push(wrap(reject.bind(null, err))))
+                .finally(() => {
                 if (root._waitingFor === currentWaitPromise) {
                     root._waitingFor = null;
                 }
@@ -2753,12 +2966,12 @@ class Transaction {
         }
     }
     table(tableName) {
-        const memoizedTables = (this._memoizedTables || (this._memoizedTables = {}));
+        const memoizedTables = this._memoizedTables || (this._memoizedTables = {});
         if (hasOwn(memoizedTables, tableName))
             return memoizedTables[tableName];
         const tableSchema = this.schema[tableName];
         if (!tableSchema) {
-            throw new exceptions.NotFound("Table " + tableName + " not part of transaction");
+            throw new exceptions.NotFound('Table ' + tableName + ' not part of transaction');
         }
         const transactionBoundTable = new this.db.Table(tableName, tableSchema, this);
         transactionBoundTable.core = this.db.core.table(tableName);
@@ -2770,10 +2983,10 @@ class Transaction {
 function createTransactionConstructor(db) {
     return makeClassConstructor(Transaction.prototype, function Transaction(mode, storeNames, dbschema, chromeTransactionDurability, parent) {
         if (mode !== 'readonly')
-            storeNames.forEach(storeName => {
+            storeNames.forEach((storeName) => {
                 const yProps = dbschema[storeName]?.yProps;
                 if (yProps)
-                    storeNames = storeNames.concat(yProps.map(p => p.updatesTable));
+                    storeNames = storeNames.concat(yProps.map((p) => p.updatesTable));
             });
         this.db = db;
         this.mode = mode;
@@ -2781,7 +2994,7 @@ function createTransactionConstructor(db) {
         this.schema = dbschema;
         this.chromeTransactionDurability = chromeTransactionDurability;
         this.idbtrans = null;
-        this.on = Events(this, "complete", "error", "abort");
+        this.on = Events(this, 'complete', 'error', 'abort');
         this.parent = parent || null;
         this.active = true;
         this._reculock = 0;
@@ -2798,13 +3011,13 @@ function createTransactionConstructor(db) {
         this._completion.then(() => {
             this.active = false;
             this.on.complete.fire();
-        }, e => {
+        }, (e) => {
             var wasActive = this.active;
             this.active = false;
             this.on.error.fire(e);
-            this.parent ?
-                this.parent._reject(e) :
-                wasActive && this.idbtrans && this.idbtrans.abort();
+            this.parent
+                ? this.parent._reject(e)
+                : wasActive && this.idbtrans && this.idbtrans.abort();
             return rejection(e);
         });
     });
@@ -2818,14 +3031,19 @@ function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey
         multi,
         auto,
         compound,
-        src: (unique && !isPrimKey ? '&' : '') + (multi ? '*' : '') + (auto ? "++" : "") + nameFromKeyPath(keyPath),
-        type
+        src: (unique && !isPrimKey ? '&' : '') +
+            (multi ? '*' : '') +
+            (auto ? '++' : '') +
+            nameFromKeyPath(keyPath),
+        type,
     };
 }
 function nameFromKeyPath(keyPath) {
-    return typeof keyPath === 'string' ?
-        keyPath :
-        keyPath ? ('[' + [].join.call(keyPath, '+') + ']') : "";
+    return typeof keyPath === 'string'
+        ? keyPath
+        : keyPath
+            ? '[' + [].join.call(keyPath, '+') + ']'
+            : '';
 }
 
 function createTableSchema(name, primKey, indexes) {
@@ -2861,16 +3079,16 @@ function getKeyExtractor(keyPath) {
         return getSinglePathKeyExtractor(keyPath);
     }
     else {
-        return obj => getByKeyPath(obj, keyPath);
+        return (obj) => getByKeyPath(obj, keyPath);
     }
 }
 function getSinglePathKeyExtractor(keyPath) {
     const split = keyPath.split('.');
     if (split.length === 1) {
-        return obj => obj[keyPath];
+        return (obj) => obj[keyPath];
     }
     else {
-        return obj => getByKeyPath(obj, keyPath);
+        return (obj) => getByKeyPath(obj, keyPath);
     }
 }
 
@@ -2879,22 +3097,22 @@ function arrayify(arrayLike) {
 }
 let _id_counter = 0;
 function getKeyPathAlias(keyPath) {
-    return keyPath == null ?
-        ":id" :
-        typeof keyPath === 'string' ?
-            keyPath :
-            `[${keyPath.join('+')}]`;
+    return keyPath == null
+        ? ':id'
+        : typeof keyPath === 'string'
+            ? keyPath
+            : `[${keyPath.join('+')}]`;
 }
 function createDBCore(db, IdbKeyRange, tmpTrans) {
     function extractSchema(db, trans) {
         const tables = arrayify(db.objectStoreNames);
-        const tempStore = tables.length > 0
-            ? trans.objectStore(tables[0])
-            : {};
+        const tempStore = tables.length > 0 ? trans.objectStore(tables[0]) : {};
         return {
             schema: {
                 name: db.name,
-                tables: tables.map(table => trans.objectStore(table)).map(store => {
+                tables: tables
+                    .map((table) => trans.objectStore(table))
+                    .map((store) => {
                     const { keyPath, autoIncrement } = store;
                     const compound = isArray(keyPath);
                     const outbound = keyPath == null;
@@ -2909,10 +3127,11 @@ function createDBCore(db, IdbKeyRange, tmpTrans) {
                             keyPath,
                             autoIncrement,
                             unique: true,
-                            extractKey: getKeyExtractor(keyPath)
+                            extractKey: getKeyExtractor(keyPath),
                         },
-                        indexes: arrayify(store.indexNames).map(indexName => store.index(indexName))
-                            .map(index => {
+                        indexes: arrayify(store.indexNames)
+                            .map((indexName) => store.index(indexName))
+                            .map((index) => {
                             const { name, unique, multiEntry, keyPath } = index;
                             const compound = isArray(keyPath);
                             const result = {
@@ -2921,40 +3140,42 @@ function createDBCore(db, IdbKeyRange, tmpTrans) {
                                 keyPath,
                                 unique,
                                 multiEntry,
-                                extractKey: getKeyExtractor(keyPath)
+                                extractKey: getKeyExtractor(keyPath),
                             };
                             indexByKeyPath[getKeyPathAlias(keyPath)] = result;
                             return result;
                         }),
-                        getIndexByKeyPath: (keyPath) => indexByKeyPath[getKeyPathAlias(keyPath)]
+                        getIndexByKeyPath: (keyPath) => indexByKeyPath[getKeyPathAlias(keyPath)],
                     };
-                    indexByKeyPath[":id"] = result.primaryKey;
+                    indexByKeyPath[':id'] = result.primaryKey;
                     if (keyPath != null) {
                         indexByKeyPath[getKeyPathAlias(keyPath)] = result.primaryKey;
                     }
                     return result;
-                })
+                }),
             },
-            hasGetAll: tables.length > 0 && ('getAll' in tempStore) &&
-                !(typeof navigator !== 'undefined' && /Safari/.test(navigator.userAgent) &&
+            hasGetAll: tables.length > 0 &&
+                'getAll' in tempStore &&
+                !(typeof navigator !== 'undefined' &&
+                    /Safari/.test(navigator.userAgent) &&
                     !/(Chrome\/|Edge\/)/.test(navigator.userAgent) &&
                     [].concat(navigator.userAgent.match(/Safari\/(\d*)/))[1] < 604),
-            hasIdb3Features: 'getAllRecords' in tempStore
+            hasIdb3Features: 'getAllRecords' in tempStore,
         };
     }
     function makeIDBKeyRange(range) {
         if (range.type === 3 )
             return null;
         if (range.type === 4 )
-            throw new Error("Cannot convert never type to IDBKeyRange");
+            throw new Error('Cannot convert never type to IDBKeyRange');
         const { lower, upper, lowerOpen, upperOpen } = range;
-        const idbRange = lower === undefined ?
-            upper === undefined ?
-                null :
-                IdbKeyRange.upperBound(upper, !!upperOpen) :
-            upper === undefined ?
-                IdbKeyRange.lowerBound(lower, !!lowerOpen) :
-                IdbKeyRange.bound(lower, upper, !!lowerOpen, !!upperOpen);
+        const idbRange = lower === undefined
+            ? upper === undefined
+                ? null
+                : IdbKeyRange.upperBound(upper, !!upperOpen)
+            : upper === undefined
+                ? IdbKeyRange.lowerBound(lower, !!lowerOpen)
+                : IdbKeyRange.bound(lower, upper, !!lowerOpen, !!upperOpen);
         return idbRange;
     }
     function createDbCoreTable(tableSchema) {
@@ -2964,89 +3185,97 @@ function createDBCore(db, IdbKeyRange, tmpTrans) {
                 resolve = wrap(resolve);
                 const store = trans.objectStore(tableName);
                 const outbound = store.keyPath == null;
-                const isAddOrPut = type === "put" || type === "add";
+                const isAddOrPut = type === 'put' || type === 'add';
                 if (!isAddOrPut && type !== 'delete' && type !== 'deleteRange')
-                    throw new Error("Invalid operation type: " + type);
+                    throw new Error('Invalid operation type: ' + type);
                 const { length } = keys || values || { length: 1 };
                 if (keys && values && keys.length !== values.length) {
-                    throw new Error("Given keys array must have same length as given values array.");
+                    throw new Error('Given keys array must have same length as given values array.');
                 }
                 if (length === 0)
-                    return resolve({ numFailures: 0, failures: {}, results: [], lastResult: undefined });
+                    return resolve({
+                        numFailures: 0,
+                        failures: {},
+                        results: [],
+                        lastResult: undefined,
+                    });
                 let req;
                 const reqs = [];
                 const failures = [];
                 let numFailures = 0;
-                const errorHandler = event => {
+                const errorHandler = (event) => {
                     ++numFailures;
                     preventDefault(event);
                 };
                 if (type === 'deleteRange') {
                     if (range.type === 4 )
-                        return resolve({ numFailures, failures, results: [], lastResult: undefined });
+                        return resolve({
+                            numFailures,
+                            failures,
+                            results: [],
+                            lastResult: undefined,
+                        });
                     if (range.type === 3 )
-                        reqs.push(req = store.clear());
+                        reqs.push((req = store.clear()));
                     else
-                        reqs.push(req = store.delete(makeIDBKeyRange(range)));
+                        reqs.push((req = store.delete(makeIDBKeyRange(range))));
                 }
                 else {
-                    const [args1, args2] = isAddOrPut ?
-                        outbound ?
-                            [values, keys] :
-                            [values, null] :
-                        [keys, null];
+                    const [args1, args2] = isAddOrPut
+                        ? outbound
+                            ? [values, keys]
+                            : [values, null]
+                        : [keys, null];
                     if (isAddOrPut) {
                         for (let i = 0; i < length; ++i) {
-                            reqs.push(req = (args2 && args2[i] !== undefined ?
-                                store[type](args1[i], args2[i]) :
-                                store[type](args1[i])));
+                            reqs.push((req = (args2 && args2[i] !== undefined
+                                ? store[type](args1[i], args2[i])
+                                : store[type](args1[i]))));
                             req.onerror = errorHandler;
                         }
                     }
                     else {
                         for (let i = 0; i < length; ++i) {
-                            reqs.push(req = store[type](args1[i]));
+                            reqs.push((req = store[type](args1[i])));
                             req.onerror = errorHandler;
                         }
                     }
                 }
-                const done = event => {
+                const done = (event) => {
                     const lastResult = event.target.result;
                     reqs.forEach((req, i) => req.error != null && (failures[i] = req.error));
                     resolve({
                         numFailures,
                         failures,
-                        results: type === "delete" ? keys : reqs.map(req => req.result),
-                        lastResult
+                        results: type === 'delete' ? keys : reqs.map((req) => req.result),
+                        lastResult,
                     });
                 };
-                req.onerror = event => {
+                req.onerror = (event) => {
                     errorHandler(event);
                     done(event);
                 };
                 req.onsuccess = done;
             });
         }
-        function openCursor({ trans, values, query, reverse, unique }) {
+        function openCursor({ trans, values, query, reverse, unique, }) {
             return new Promise((resolve, reject) => {
                 resolve = wrap(resolve);
                 const { index, range } = query;
                 const store = trans.objectStore(tableName);
-                const source = index.isPrimaryKey ?
-                    store :
-                    store.index(index.name);
-                const direction = reverse ?
-                    unique ?
-                        "prevunique" :
-                        "prev" :
-                    unique ?
-                        "nextunique" :
-                        "next";
-                const req = values || !('openKeyCursor' in source) ?
-                    source.openCursor(makeIDBKeyRange(range), direction) :
-                    source.openKeyCursor(makeIDBKeyRange(range), direction);
+                const source = index.isPrimaryKey ? store : store.index(index.name);
+                const direction = reverse
+                    ? unique
+                        ? 'prevunique'
+                        : 'prev'
+                    : unique
+                        ? 'nextunique'
+                        : 'next';
+                const req = values || !('openKeyCursor' in source)
+                    ? source.openCursor(makeIDBKeyRange(range), direction)
+                    : source.openKeyCursor(makeIDBKeyRange(range), direction);
                 req.onerror = eventRejectHandler(reject);
-                req.onsuccess = wrap(ev => {
+                req.onsuccess = wrap((ev) => {
                     const cursor = req.result;
                     if (!cursor) {
                         resolve(null);
@@ -3059,10 +3288,18 @@ function createDBCore(db, IdbKeyRange, tmpTrans) {
                     if (_cursorContinuePrimaryKey)
                         _cursorContinuePrimaryKey = _cursorContinuePrimaryKey.bind(cursor);
                     const _cursorAdvance = cursor.advance.bind(cursor);
-                    const doThrowCursorIsNotStarted = () => { throw new Error("Cursor not started"); };
-                    const doThrowCursorIsStopped = () => { throw new Error("Cursor not stopped"); };
+                    const doThrowCursorIsNotStarted = () => {
+                        throw new Error('Cursor not started');
+                    };
+                    const doThrowCursorIsStopped = () => {
+                        throw new Error('Cursor not stopped');
+                    };
                     cursor.trans = trans;
-                    cursor.stop = cursor.continue = cursor.continuePrimaryKey = cursor.advance = doThrowCursorIsNotStarted;
+                    cursor.stop =
+                        cursor.continue =
+                            cursor.continuePrimaryKey =
+                                cursor.advance =
+                                    doThrowCursorIsNotStarted;
                     cursor.fail = wrap(reject);
                     cursor.next = function () {
                         let gotOne = 1;
@@ -3073,8 +3310,12 @@ function createDBCore(db, IdbKeyRange, tmpTrans) {
                             resolveIteration = wrap(resolveIteration);
                             req.onerror = eventRejectHandler(rejectIteration);
                             cursor.fail = rejectIteration;
-                            cursor.stop = value => {
-                                cursor.stop = cursor.continue = cursor.continuePrimaryKey = cursor.advance = doThrowCursorIsStopped;
+                            cursor.stop = (value) => {
+                                cursor.stop =
+                                    cursor.continue =
+                                        cursor.continuePrimaryKey =
+                                            cursor.advance =
+                                                doThrowCursorIsStopped;
                                 resolveIteration(value);
                             };
                         });
@@ -3089,11 +3330,13 @@ function createDBCore(db, IdbKeyRange, tmpTrans) {
                             }
                             else {
                                 cursor.done = true;
-                                cursor.start = () => { throw new Error("Cursor behind last entry"); };
+                                cursor.start = () => {
+                                    throw new Error('Cursor behind last entry');
+                                };
                                 cursor.stop();
                             }
                         };
-                        req.onsuccess = wrap(ev => {
+                        req.onsuccess = wrap((ev) => {
                             req.onsuccess = guardedCallback;
                             guardedCallback();
                         });
@@ -3124,26 +3367,26 @@ function createDBCore(db, IdbKeyRange, tmpTrans) {
                         const options = {
                             query: idbKeyRange,
                             count: nonInfinitLimit,
-                            direction
+                            direction,
                         };
-                        const req = values ?
-                            source.getAll(options) :
-                            source.getAllKeys(options);
-                        req.onsuccess = event => resolve({ result: event.target.result });
+                        const req = values
+                            ? source.getAll(options)
+                            : source.getAllKeys(options);
+                        req.onsuccess = (event) => resolve({ result: event.target.result });
                         req.onerror = eventRejectHandler(reject);
                     }
                     else if (hasGetAll && direction === 'next') {
-                        const req = values ?
-                            source.getAll(idbKeyRange, nonInfinitLimit) :
-                            source.getAllKeys(idbKeyRange, nonInfinitLimit);
+                        const req = values
+                            ? source.getAll(idbKeyRange, nonInfinitLimit)
+                            : source.getAllKeys(idbKeyRange, nonInfinitLimit);
                         req.onsuccess = (event) => resolve({ result: event.target.result });
                         req.onerror = eventRejectHandler(reject);
                     }
                     else {
                         let count = 0;
-                        const req = values || !('openKeyCursor' in source) ?
-                            source.openCursor(idbKeyRange, direction) :
-                            source.openKeyCursor(idbKeyRange, direction);
+                        const req = values || !('openKeyCursor' in source)
+                            ? source.openCursor(idbKeyRange, direction)
+                            : source.openKeyCursor(idbKeyRange, direction);
                         const result = [];
                         req.onsuccess = () => {
                             const cursor = req.result;
@@ -3172,7 +3415,7 @@ function createDBCore(db, IdbKeyRange, tmpTrans) {
                     let keyCount = 0;
                     let callbackCount = 0;
                     let req;
-                    const successHandler = event => {
+                    const successHandler = (event) => {
                         const req = event.target;
                         if ((result[req._pos] = req.result) != null)
                             ;
@@ -3199,7 +3442,7 @@ function createDBCore(db, IdbKeyRange, tmpTrans) {
                     resolve = wrap(resolve);
                     const store = trans.objectStore(tableName);
                     const req = store.get(key);
-                    req.onsuccess = event => resolve(event.target.result);
+                    req.onsuccess = (event) => resolve(event.target.result);
                     req.onerror = eventRejectHandler(reject);
                 });
             },
@@ -3212,18 +3455,18 @@ function createDBCore(db, IdbKeyRange, tmpTrans) {
                     const source = index.isPrimaryKey ? store : store.index(index.name);
                     const idbKeyRange = makeIDBKeyRange(range);
                     const req = idbKeyRange ? source.count(idbKeyRange) : source.count();
-                    req.onsuccess = wrap(ev => resolve(ev.target.result));
+                    req.onsuccess = wrap((ev) => resolve(ev.target.result));
                     req.onerror = eventRejectHandler(reject);
                 });
-            }
+            },
         };
     }
     const { schema, hasGetAll, hasIdb3Features } = extractSchema(db, tmpTrans);
-    const tables = schema.tables.map(tableSchema => createDbCoreTable(tableSchema));
+    const tables = schema.tables.map((tableSchema) => createDbCoreTable(tableSchema));
     const tableMap = {};
-    tables.forEach(table => tableMap[table.name] = table);
+    tables.forEach((table) => (tableMap[table.name] = table));
     return {
-        stack: "dbcore",
+        stack: 'dbcore',
         transaction: db.transaction.bind(db),
         table(name) {
             const result = tableMap[name];
@@ -3233,7 +3476,7 @@ function createDBCore(db, IdbKeyRange, tmpTrans) {
         },
         MIN_KEY: -Infinity,
         MAX_KEY: getMaxKey(IdbKeyRange),
-        schema
+        schema,
     };
 }
 
@@ -3243,16 +3486,16 @@ function createMiddlewareStack(stackImpl, middlewares) {
 function createMiddlewareStacks(middlewares, idbdb, { IDBKeyRange, indexedDB }, tmpTrans) {
     const dbcore = createMiddlewareStack(createDBCore(idbdb, IDBKeyRange, tmpTrans), middlewares.dbcore);
     return {
-        dbcore
+        dbcore,
     };
 }
 function generateMiddlewareStacks(db, tmpTrans) {
     const idbdb = tmpTrans.db;
     const stacks = createMiddlewareStacks(db._middlewares, idbdb, db._deps, tmpTrans);
     db.core = stacks.dbcore;
-    db.tables.forEach(table => {
+    db.tables.forEach((table) => {
         const tableName = table.name;
-        if (db.core.schema.tables.some(tbl => tbl.name === tableName)) {
+        if (db.core.schema.tables.some((tbl) => tbl.name === tableName)) {
             table.core = db.core.table(tableName);
             if (db[tableName] instanceof db.Table) {
                 db[tableName].core = table.core;
@@ -3262,17 +3505,24 @@ function generateMiddlewareStacks(db, tmpTrans) {
 }
 
 function setApiOnPlace(db, objs, tableNames, dbschema) {
-    tableNames.forEach(tableName => {
+    tableNames.forEach((tableName) => {
         const schema = dbschema[tableName];
-        objs.forEach(obj => {
+        objs.forEach((obj) => {
             const propDesc = getPropertyDescriptor(obj, tableName);
-            if (!propDesc || ("value" in propDesc && propDesc.value === undefined)) {
+            if (!propDesc || ('value' in propDesc && propDesc.value === undefined)) {
                 if (obj === db.Transaction.prototype || obj instanceof db.Transaction) {
                     setProp(obj, tableName, {
-                        get() { return this.table(tableName); },
+                        get() {
+                            return this.table(tableName);
+                        },
                         set(value) {
-                            defineProperty(this, tableName, { value, writable: true, configurable: true, enumerable: true });
-                        }
+                            defineProperty(this, tableName, {
+                                value,
+                                writable: true,
+                                configurable: true,
+                                enumerable: true,
+                            });
+                        },
                     });
                 }
                 else {
@@ -3283,7 +3533,7 @@ function setApiOnPlace(db, objs, tableNames, dbschema) {
     });
 }
 function removeTablesApi(db, objs) {
-    objs.forEach(obj => {
+    objs.forEach((obj) => {
         for (let key in obj) {
             if (obj[key] instanceof db.Table)
                 delete obj[key];
@@ -3295,8 +3545,9 @@ function lowerVersionFirst(a, b) {
 }
 function runUpgraders(db, oldVersion, idbUpgradeTrans, reject) {
     const globalSchema = db._dbSchema;
-    if (idbUpgradeTrans.objectStoreNames.contains('$meta') && !globalSchema.$meta) {
-        globalSchema.$meta = createTableSchema("$meta", parseIndexSyntax("")[0], []);
+    if (idbUpgradeTrans.objectStoreNames.contains('$meta') &&
+        !globalSchema.$meta) {
+        globalSchema.$meta = createTableSchema('$meta', parseIndexSyntax('')[0], []);
         db._storeNames.push('$meta');
     }
     const trans = db._createTransaction('readwrite', db._storeNames, globalSchema);
@@ -3308,7 +3559,7 @@ function runUpgraders(db, oldVersion, idbUpgradeTrans, reject) {
         PSD.trans = trans;
         PSD.transless = transless;
         if (oldVersion === 0) {
-            keys(globalSchema).forEach(tableName => {
+            keys(globalSchema).forEach((tableName) => {
                 createTable(idbUpgradeTrans, tableName, globalSchema[tableName].primKey, globalSchema[tableName].indexes);
             });
             generateMiddlewareStacks(db, idbUpgradeTrans);
@@ -3317,15 +3568,18 @@ function runUpgraders(db, oldVersion, idbUpgradeTrans, reject) {
         else {
             generateMiddlewareStacks(db, idbUpgradeTrans);
             return getExistingVersion(db, trans, oldVersion)
-                .then(oldVersion => updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans))
+                .then((oldVersion) => updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans))
                 .catch(rejectTransaction);
         }
     });
 }
 function patchCurrentVersion(db, idbUpgradeTrans) {
     createMissingTables(db._dbSchema, idbUpgradeTrans);
-    if (idbUpgradeTrans.db.version % 10 === 0 && !idbUpgradeTrans.objectStoreNames.contains('$meta')) {
-        idbUpgradeTrans.db.createObjectStore('$meta').add(Math.ceil((idbUpgradeTrans.db.version / 10) - 1), 'version');
+    if (idbUpgradeTrans.db.version % 10 === 0 &&
+        !idbUpgradeTrans.objectStoreNames.contains('$meta')) {
+        idbUpgradeTrans.db
+            .createObjectStore('$meta')
+            .add(Math.ceil(idbUpgradeTrans.db.version / 10 - 1), 'version');
     }
     const globalSchema = buildGlobalSchema(db, db.idbdb, idbUpgradeTrans);
     adjustToExistingIndexNames(db, db._dbSchema, idbUpgradeTrans);
@@ -3336,7 +3590,7 @@ function patchCurrentVersion(db, idbUpgradeTrans) {
             return;
         }
         const store = idbUpgradeTrans.objectStore(tableChange.name);
-        tableChange.add.forEach(idx => {
+        tableChange.add.forEach((idx) => {
             if (debug)
                 console.debug(`Dexie upgrade patch: Creating missing index ${tableChange.name}.${idx.src}`);
             addIndex(store, idx);
@@ -3345,7 +3599,10 @@ function patchCurrentVersion(db, idbUpgradeTrans) {
 }
 function getExistingVersion(db, trans, oldVersion) {
     if (trans.storeNames.includes('$meta')) {
-        return trans.table('$meta').get('version').then(metaVersion => {
+        return trans
+            .table('$meta')
+            .get('version')
+            .then((metaVersion) => {
             return metaVersion != null ? metaVersion : oldVersion;
         });
     }
@@ -3356,12 +3613,12 @@ function getExistingVersion(db, trans, oldVersion) {
 function updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans) {
     const queue = [];
     const versions = db._versions;
-    let globalSchema = db._dbSchema = buildGlobalSchema(db, db.idbdb, idbUpgradeTrans);
-    const versToRun = versions.filter(v => v._cfg.version >= oldVersion);
+    let globalSchema = (db._dbSchema = buildGlobalSchema(db, db.idbdb, idbUpgradeTrans));
+    const versToRun = versions.filter((v) => v._cfg.version >= oldVersion);
     if (versToRun.length === 0) {
         return DexiePromise.resolve();
     }
-    versToRun.forEach(version => {
+    versToRun.forEach((version) => {
         queue.push(() => {
             const oldSchema = globalSchema;
             const newSchema = version._cfg.dbschema;
@@ -3369,21 +3626,21 @@ function updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans) {
             adjustToExistingIndexNames(db, newSchema, idbUpgradeTrans);
             globalSchema = db._dbSchema = newSchema;
             const diff = getSchemaDiff(oldSchema, newSchema);
-            diff.add.forEach(tuple => {
+            diff.add.forEach((tuple) => {
                 createTable(idbUpgradeTrans, tuple[0], tuple[1].primKey, tuple[1].indexes);
             });
-            diff.change.forEach(change => {
+            diff.change.forEach((change) => {
                 if (change.recreate) {
-                    throw new exceptions.Upgrade("Not yet support for changing primary key");
+                    throw new exceptions.Upgrade('Not yet support for changing primary key');
                 }
                 else {
                     const store = idbUpgradeTrans.objectStore(change.name);
-                    change.add.forEach(idx => addIndex(store, idx));
-                    change.change.forEach(idx => {
+                    change.add.forEach((idx) => addIndex(store, idx));
+                    change.change.forEach((idx) => {
                         store.deleteIndex(idx.name);
                         addIndex(store, idx);
                     });
-                    change.del.forEach(idxName => store.deleteIndex(idxName));
+                    change.del.forEach((idxName) => store.deleteIndex(idxName));
                 }
             });
             const contentUpgrade = version._cfg.contentUpgrade;
@@ -3391,7 +3648,7 @@ function updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans) {
                 generateMiddlewareStacks(db, idbUpgradeTrans);
                 trans._memoizedTables = {};
                 let upgradeSchema = shallowClone(newSchema);
-                diff.del.forEach(table => {
+                diff.del.forEach((table) => {
                     upgradeSchema[table] = oldSchema[table];
                 });
                 removeTablesApi(db, [db.Transaction.prototype]);
@@ -3411,23 +3668,24 @@ function updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans) {
                         }
                     }
                 });
-                return (returnValue && typeof returnValue.then === 'function' ?
-                    DexiePromise.resolve(returnValue) : promiseFollowed.then(() => returnValue));
+                return returnValue && typeof returnValue.then === 'function'
+                    ? DexiePromise.resolve(returnValue)
+                    : promiseFollowed.then(() => returnValue);
             }
         });
-        queue.push(idbtrans => {
+        queue.push((idbtrans) => {
             const newSchema = version._cfg.dbschema;
             deleteRemovedTables(newSchema, idbtrans);
             removeTablesApi(db, [db.Transaction.prototype]);
             setApiOnPlace(db, [db.Transaction.prototype], db._storeNames, db._dbSchema);
             trans.schema = db._dbSchema;
         });
-        queue.push(idbtrans => {
+        queue.push((idbtrans) => {
             if (db.idbdb.objectStoreNames.contains('$meta')) {
                 if (Math.ceil(db.idbdb.version / 10) === version._cfg.version) {
                     db.idbdb.deleteObjectStore('$meta');
                     delete db._dbSchema.$meta;
-                    db._storeNames = db._storeNames.filter(name => name !== '$meta');
+                    db._storeNames = db._storeNames.filter((name) => name !== '$meta');
                 }
                 else {
                     idbtrans.objectStore('$meta').put(version._cfg.version, 'version');
@@ -3436,8 +3694,9 @@ function updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans) {
         });
     });
     function runQueue() {
-        return queue.length ? DexiePromise.resolve(queue.shift()(trans.idbtrans)).then(runQueue) :
-            DexiePromise.resolve();
+        return queue.length
+            ? DexiePromise.resolve(queue.shift()(trans.idbtrans)).then(runQueue)
+            : DexiePromise.resolve();
     }
     return runQueue().then(() => {
         createMissingTables(globalSchema, idbUpgradeTrans);
@@ -3447,7 +3706,7 @@ function getSchemaDiff(oldSchema, newSchema) {
     const diff = {
         del: [],
         add: [],
-        change: []
+        change: [],
     };
     let table;
     for (table in oldSchema) {
@@ -3466,11 +3725,12 @@ function getSchemaDiff(oldSchema, newSchema) {
                 recreate: false,
                 del: [],
                 add: [],
-                change: []
+                change: [],
             };
-            if ((
-            '' + (oldDef.primKey.keyPath || '')) !== ('' + (newDef.primKey.keyPath || '')) ||
-                (oldDef.primKey.auto !== newDef.primKey.auto)) {
+            if (
+            '' + (oldDef.primKey.keyPath || '') !==
+                '' + (newDef.primKey.keyPath || '') ||
+                oldDef.primKey.auto !== newDef.primKey.auto) {
                 change.recreate = true;
                 diff.change.push(change);
             }
@@ -3489,7 +3749,9 @@ function getSchemaDiff(oldSchema, newSchema) {
                     else if (oldIdx.src !== newIdx.src)
                         change.change.push(newIdx);
                 }
-                if (change.del.length > 0 || change.add.length > 0 || change.change.length > 0) {
+                if (change.del.length > 0 ||
+                    change.add.length > 0 ||
+                    change.change.length > 0) {
                     diff.change.push(change);
                 }
             }
@@ -3498,14 +3760,14 @@ function getSchemaDiff(oldSchema, newSchema) {
     return diff;
 }
 function createTable(idbtrans, tableName, primKey, indexes) {
-    const store = idbtrans.db.createObjectStore(tableName, primKey.keyPath ?
-        { keyPath: primKey.keyPath, autoIncrement: primKey.auto } :
-        { autoIncrement: primKey.auto });
-    indexes.forEach(idx => addIndex(store, idx));
+    const store = idbtrans.db.createObjectStore(tableName, primKey.keyPath
+        ? { keyPath: primKey.keyPath, autoIncrement: primKey.auto }
+        : { autoIncrement: primKey.auto });
+    indexes.forEach((idx) => addIndex(store, idx));
     return store;
 }
 function createMissingTables(newSchema, idbtrans) {
-    keys(newSchema).forEach(tableName => {
+    keys(newSchema).forEach((tableName) => {
         if (!idbtrans.db.objectStoreNames.contains(tableName)) {
             if (debug)
                 console.debug('Dexie: Creating missing table', tableName);
@@ -3514,23 +3776,28 @@ function createMissingTables(newSchema, idbtrans) {
     });
 }
 function deleteRemovedTables(newSchema, idbtrans) {
-    [].slice.call(idbtrans.db.objectStoreNames).forEach(storeName => newSchema[storeName] == null && idbtrans.db.deleteObjectStore(storeName));
+    [].slice
+        .call(idbtrans.db.objectStoreNames)
+        .forEach((storeName) => newSchema[storeName] == null && idbtrans.db.deleteObjectStore(storeName));
 }
 function addIndex(store, idx) {
-    store.createIndex(idx.name, idx.keyPath, { unique: idx.unique, multiEntry: idx.multi });
+    store.createIndex(idx.name, idx.keyPath, {
+        unique: idx.unique,
+        multiEntry: idx.multi,
+    });
 }
 function buildGlobalSchema(db, idbdb, tmpTrans) {
     const globalSchema = {};
     const dbStoreNames = slice(idbdb.objectStoreNames, 0);
-    dbStoreNames.forEach(storeName => {
+    dbStoreNames.forEach((storeName) => {
         const store = tmpTrans.objectStore(storeName);
         let keyPath = store.keyPath;
-        const primKey = createIndexSpec(nameFromKeyPath(keyPath), keyPath || "", true, false, !!store.autoIncrement, keyPath && typeof keyPath !== "string", true);
+        const primKey = createIndexSpec(nameFromKeyPath(keyPath), keyPath || '', true, false, !!store.autoIncrement, keyPath && typeof keyPath !== 'string', true);
         const indexes = [];
         for (let j = 0; j < store.indexNames.length; ++j) {
             const idbindex = store.index(store.indexNames[j]);
             keyPath = idbindex.keyPath;
-            var index = createIndexSpec(idbindex.name, keyPath, !!idbindex.unique, !!idbindex.multiEntry, false, keyPath && typeof keyPath !== "string", false);
+            var index = createIndexSpec(idbindex.name, keyPath, !!idbindex.unique, !!idbindex.multiEntry, false, keyPath && typeof keyPath !== 'string', false);
             indexes.push(index);
         }
         globalSchema[storeName] = createTableSchema(storeName, primKey, indexes);
@@ -3539,14 +3806,15 @@ function buildGlobalSchema(db, idbdb, tmpTrans) {
 }
 function readGlobalSchema(db, idbdb, tmpTrans) {
     db.verno = idbdb.version / 10;
-    const globalSchema = db._dbSchema = buildGlobalSchema(db, idbdb, tmpTrans);
+    const globalSchema = (db._dbSchema = buildGlobalSchema(db, idbdb, tmpTrans));
     db._storeNames = slice(idbdb.objectStoreNames, 0);
     setApiOnPlace(db, [db._allTables], keys(globalSchema), globalSchema);
 }
 function verifyInstalledSchema(db, tmpTrans) {
     const installedSchema = buildGlobalSchema(db, db.idbdb, tmpTrans);
     const diff = getSchemaDiff(installedSchema, db._dbSchema);
-    return !(diff.add.length || diff.change.some(ch => ch.add.length || ch.change.length));
+    return !(diff.add.length ||
+        diff.change.some((ch) => ch.add.length || ch.change.length));
 }
 function adjustToExistingIndexNames(db, schema, idbtrans) {
     const storeNames = idbtrans.db.objectStoreNames;
@@ -3557,7 +3825,9 @@ function adjustToExistingIndexNames(db, schema, idbtrans) {
         for (let j = 0; j < store.indexNames.length; ++j) {
             const indexName = store.indexNames[j];
             const keyPath = store.index(indexName).keyPath;
-            const dexieName = typeof keyPath === 'string' ? keyPath : "[" + slice(keyPath).join('+') + "]";
+            const dexieName = typeof keyPath === 'string'
+                ? keyPath
+                : '[' + slice(keyPath).join('+') + ']';
             if (schema[storeName]) {
                 const indexSpec = schema[storeName].idxByName[dexieName];
                 if (indexSpec) {
@@ -3568,9 +3838,11 @@ function adjustToExistingIndexNames(db, schema, idbtrans) {
             }
         }
     }
-    if (typeof navigator !== 'undefined' && /Safari/.test(navigator.userAgent) &&
+    if (typeof navigator !== 'undefined' &&
+        /Safari/.test(navigator.userAgent) &&
         !/(Chrome\/|Edge\/)/.test(navigator.userAgent) &&
-        _global.WorkerGlobalScope && _global instanceof _global.WorkerGlobalScope &&
+        _global.WorkerGlobalScope &&
+        _global instanceof _global.WorkerGlobalScope &&
         [].concat(navigator.userAgent.match(/Safari\/(\d*)/))[1] < 604) {
         db._hasGetAll = false;
     }
@@ -3580,8 +3852,10 @@ function parseIndexSyntax(primKeyAndIndexes) {
         const typeSplit = index.split(':');
         const type = typeSplit[1]?.trim();
         index = typeSplit[0].trim();
-        const name = index.replace(/([&*]|\+\+)/g, "");
-        const keyPath = /^\[/.test(name) ? name.match(/^\[(.*)\]$/)[1].split('+') : name;
+        const name = index.replace(/([&*]|\+\+)/g, '');
+        const keyPath = /^\[/.test(name)
+            ? name.match(/^\[(.*)\]$/)[1].split('+')
+            : name;
         return createIndexSpec(name, keyPath || null, /\&/.test(index), /\*/.test(index), /\+\+/.test(index), isArray(keyPath), indexNum === 0, type);
     });
 }
@@ -3648,21 +3922,22 @@ function createVersionConstructor(db) {
             storesSource: null,
             dbschema: {},
             tables: {},
-            contentUpgrade: null
+            contentUpgrade: null,
         };
     });
 }
 
 const connections = createConnectionsManager();
 function createConnectionsManager() {
-    if (typeof FinalizationRegistry !== 'undefined' && typeof WeakRef !== 'undefined') {
+    if (typeof FinalizationRegistry !== 'undefined' &&
+        typeof WeakRef !== 'undefined') {
         const _refs = new Set();
         const _registry = new FinalizationRegistry((ref) => {
             _refs.delete(ref);
         });
         const toArray = () => {
             return Array.from(_refs)
-                .map(ref => ref.deref())
+                .map((ref) => ref.deref())
                 .filter((db) => db !== undefined);
         };
         const add = (db) => {
@@ -3711,19 +3986,19 @@ function createConnectionsManager() {
 }
 
 function getDbNamesTable(indexedDB, IDBKeyRange) {
-    let dbNamesDB = indexedDB["_dbNamesDB"];
+    let dbNamesDB = indexedDB['_dbNamesDB'];
     if (!dbNamesDB) {
-        dbNamesDB = indexedDB["_dbNamesDB"] = new Dexie$1(DBNAMES_DB, {
+        dbNamesDB = indexedDB['_dbNamesDB'] = new Dexie$1(DBNAMES_DB, {
             addons: [],
             indexedDB,
             IDBKeyRange,
         });
-        dbNamesDB.version(1).stores({ dbnames: "name" });
+        dbNamesDB.version(1).stores({ dbnames: 'name' });
     }
-    return dbNamesDB.table("dbnames");
+    return dbNamesDB.table('dbnames');
 }
 function hasDatabasesNative(indexedDB) {
-    return indexedDB && typeof indexedDB.databases === "function";
+    return indexedDB && typeof indexedDB.databases === 'function';
 }
 function getDatabaseNames({ indexedDB, IDBKeyRange, }) {
     return hasDatabasesNative(indexedDB)
@@ -3765,15 +4040,17 @@ function idbReady() {
 }
 
 function isEmptyRange(node) {
-    return !("from" in node);
+    return !('from' in node);
 }
 const RangeSet = function (fromOrTree, to) {
     if (this) {
-        extend(this, arguments.length ? { d: 1, from: fromOrTree, to: arguments.length > 1 ? to : fromOrTree } : { d: 0 });
+        extend(this, arguments.length
+            ? { d: 1, from: fromOrTree, to: arguments.length > 1 ? to : fromOrTree }
+            : { d: 0 });
     }
     else {
         const rv = new RangeSet();
-        if (fromOrTree && ("d" in fromOrTree)) {
+        if (fromOrTree && 'd' in fromOrTree) {
             extend(rv, fromOrTree);
         }
         return rv;
@@ -3789,7 +4066,7 @@ props(RangeSet.prototype, {
         return this;
     },
     addKeys(keys) {
-        keys.forEach(key => addRange(this, key, key));
+        keys.forEach((key) => addRange(this, key, key));
         return this;
     },
     hasKey(key) {
@@ -3798,7 +4075,7 @@ props(RangeSet.prototype, {
     },
     [iteratorSymbol]() {
         return getRangeSetIterator(this);
-    }
+    },
 });
 function addRange(target, from, to) {
     const diff = cmp(from, to);
@@ -3841,7 +4118,7 @@ function addRange(target, from, to) {
     }
 }
 function mergeRanges(target, newSet) {
-    function _addRangeSet(target, { from, to, l, r }) {
+    function _addRangeSet(target, { from, to, l, r, }) {
         addRange(target, from, to);
         if (l)
             _addRangeSet(target, l);
@@ -3870,7 +4147,9 @@ function rangesOverlap(rangeSet1, rangeSet2) {
     return false;
 }
 function getRangeSetIterator(node) {
-    let state = isEmptyRange(node) ? null : { s: 0, n: node };
+    let state = isEmptyRange(node)
+        ? null
+        : { s: 0, n: node };
     return {
         next(key) {
             const keyProvided = arguments.length > 0;
@@ -3906,9 +4185,9 @@ function getRangeSetIterator(node) {
 }
 function rebalance(target) {
     const diff = (target.r?.d || 0) - (target.l?.d || 0);
-    const r = diff > 1 ? "r" : diff < -1 ? "l" : "";
+    const r = diff > 1 ? 'r' : diff < -1 ? 'l' : '';
     if (r) {
-        const l = r === "r" ? "l" : "r";
+        const l = r === 'r' ? 'l' : 'r';
         const rootClone = { ...target };
         const oldRootRight = target[r];
         target.from = oldRootRight.from;
@@ -3925,7 +4204,7 @@ function computeDepth({ r, l }) {
 }
 
 function extendObservabilitySet(target, newSet) {
-    keys(newSet).forEach(part => {
+    keys(newSet).forEach((part) => {
         if (target[part])
             mergeRanges(target[part], newSet[part]);
         else
@@ -3935,7 +4214,9 @@ function extendObservabilitySet(target, newSet) {
 }
 
 function obsSetsOverlap(os1, os2) {
-    return os1.all || os2.all || Object.keys(os1).some((key) => os2[key] && rangesOverlap(os2[key], os1[key]));
+    return (os1.all ||
+        os2.all ||
+        Object.keys(os1).some((key) => os2[key] && rangesOverlap(os2[key], os1[key])));
 }
 
 const cache = {};
@@ -4000,9 +4281,7 @@ function dexieOpen(db) {
     const state = db._state;
     const { indexedDB } = db._deps;
     if (state.isBeingOpened || db.idbdb)
-        return state.dbReadyPromise.then(() => state.dbOpenError ?
-            rejection(state.dbOpenError) :
-            db);
+        return state.dbReadyPromise.then(() => state.dbOpenError ? rejection(state.dbOpenError) : db);
     state.isBeingOpened = true;
     state.dbOpenError = null;
     state.openComplete = false;
@@ -4020,14 +4299,14 @@ function dexieOpen(db) {
         if (!indexedDB)
             throw new exceptions.MissingAPI();
         const dbName = db.name;
-        const req = state.autoSchema || !nativeVerToOpen ?
-            indexedDB.open(dbName) :
-            indexedDB.open(dbName, nativeVerToOpen);
+        const req = state.autoSchema || !nativeVerToOpen
+            ? indexedDB.open(dbName)
+            : indexedDB.open(dbName, nativeVerToOpen);
         if (!req)
             throw new exceptions.MissingAPI();
         req.onerror = eventRejectHandler(reject);
         req.onblocked = wrap(db._fireOnBlocked);
-        req.onupgradeneeded = wrap(e => {
+        req.onupgradeneeded = wrap((e) => {
             upgradeTransaction = req.transaction;
             if (state.autoSchema && !db._options.allowEmptyDB) {
                 req.onerror = preventDefault;
@@ -4051,7 +4330,7 @@ function dexieOpen(db) {
         }, reject);
         req.onsuccess = wrap(() => {
             upgradeTransaction = null;
-            const idbdb = db.idbdb = req.result;
+            const idbdb = (db.idbdb = req.result);
             const objectStoreNames = slice(idbdb.objectStoreNames);
             if (objectStoreNames.length > 0)
                 try {
@@ -4073,9 +4352,9 @@ function dexieOpen(db) {
                 catch (e) {
                 }
             connections.add(db);
-            idbdb.onversionchange = wrap(ev => {
+            idbdb.onversionchange = wrap((ev) => {
                 state.vcFired = true;
-                db.on("versionchange").fire(ev);
+                db.on('versionchange').fire(ev);
             });
             idbdb.onclose = wrap(() => {
                 db.close({ disableAutoOpen: false });
@@ -4084,16 +4363,16 @@ function dexieOpen(db) {
                 _onDatabaseCreated(db._deps, dbName);
             resolve();
         }, reject);
-    }).catch(err => {
+    }).catch((err) => {
         switch (err?.name) {
-            case "UnknownError":
+            case 'UnknownError':
                 if (state.PR1398_maxLoop > 0) {
                     state.PR1398_maxLoop--;
                     console.warn('Dexie: Workaround for Chrome UnknownError on open()');
                     return tryOpenDB();
                 }
                 break;
-            case "VersionError":
+            case 'VersionError':
                 if (nativeVerToOpen > 0) {
                     nativeVerToOpen = 0;
                     return tryOpenDB();
@@ -4104,8 +4383,11 @@ function dexieOpen(db) {
     });
     return DexiePromise.race([
         openCanceller,
-        (typeof navigator === 'undefined' ? DexiePromise.resolve() : idbReady()).then(tryOpenDB)
-    ]).then(() => {
+        (typeof navigator === 'undefined'
+            ? DexiePromise.resolve()
+            : idbReady()).then(tryOpenDB),
+    ])
+        .then(() => {
         throwIfCancelled();
         state.onReadyBeingFired = [];
         return DexiePromise.resolve(vip(() => db.on.ready.fire(db.vip))).then(function fireRemainders() {
@@ -4115,12 +4397,14 @@ function dexieOpen(db) {
                 return DexiePromise.resolve(vip(() => remainders(db.vip))).then(fireRemainders);
             }
         });
-    }).finally(() => {
+    })
+        .finally(() => {
         if (state.openCanceller === openCanceller) {
             state.onReadyBeingFired = null;
             state.isBeingOpened = false;
         }
-    }).catch(err => {
+    })
+        .catch((err) => {
         state.dbOpenError = err;
         try {
             upgradeTransaction && upgradeTransaction.abort();
@@ -4130,16 +4414,19 @@ function dexieOpen(db) {
             db._close();
         }
         return rejection(err);
-    }).finally(() => {
+    })
+        .finally(() => {
         state.openComplete = true;
         resolveDbReady();
-    }).then(() => {
+    })
+        .then(() => {
         if (wasCreated) {
             const everything = {};
-            db.tables.forEach(table => {
-                table.schema.indexes.forEach(idx => {
+            db.tables.forEach((table) => {
+                table.schema.indexes.forEach((idx) => {
                     if (idx.name)
-                        everything[`idb://${db.name}/${table.name}/${idx.name}`] = new RangeSet(-Infinity, [[[]]]);
+                        everything[`idb://${db.name}/${table.name}/${idx.name}`] =
+                            new RangeSet(-Infinity, [[[]]]);
                 });
                 everything[`idb://${db.name}/${table.name}/`] = everything[`idb://${db.name}/${table.name}/:dels`] = new RangeSet(-Infinity, [[[]]]);
             });
@@ -4151,14 +4438,17 @@ function dexieOpen(db) {
 }
 
 function awaitIterator(iterator) {
-    var callNext = result => iterator.next(result), doThrow = error => iterator.throw(error), onSuccess = step(callNext), onError = step(doThrow);
+    var callNext = (result) => iterator.next(result), doThrow = (error) => iterator.throw(error), onSuccess = step(callNext), onError = step(doThrow);
     function step(getNext) {
         return (val) => {
             var next = getNext(val), value = next.value;
-            return next.done ? value :
-                (!value || typeof value.then !== 'function' ?
-                    isArray(value) ? Promise.all(value).then(onSuccess, onError) : onSuccess(value) :
-                    value.then(onSuccess, onError));
+            return next.done
+                ? value
+                : !value || typeof value.then !== 'function'
+                    ? isArray(value)
+                        ? Promise.all(value).then(onSuccess, onError)
+                        : onSuccess(value)
+                    : value.then(onSuccess, onError);
         };
     }
     return step(callNext)();
@@ -4167,7 +4457,7 @@ function awaitIterator(iterator) {
 function extractTransactionArgs(mode, _tableArgs_, scopeFunc) {
     var i = arguments.length;
     if (i < 2)
-        throw new exceptions.InvalidArgument("Too few arguments");
+        throw new exceptions.InvalidArgument('Too few arguments');
     var args = new Array(i - 1);
     while (--i)
         args[i - 1] = arguments[i];
@@ -4182,7 +4472,7 @@ function enterTransactionScope(db, mode, storeNames, parentTransaction, scopeFun
         trans.explicit = true;
         const zoneProps = {
             trans: trans,
-            transless: transless
+            transless: transless,
         };
         if (parentTransaction) {
             trans.idbtrans = parentTransaction.idbtrans;
@@ -4194,10 +4484,14 @@ function enterTransactionScope(db, mode, storeNames, parentTransaction, scopeFun
                 db._state.PR1398_maxLoop = 3;
             }
             catch (ex) {
-                if (ex.name === errnames.InvalidState && db.isOpen() && --db._state.PR1398_maxLoop > 0) {
+                if (ex.name === errnames.InvalidState &&
+                    db.isOpen() &&
+                    --db._state.PR1398_maxLoop > 0) {
                     console.warn('Dexie: Need to reopen db');
                     db.close({ disableAutoOpen: false });
-                    return db.open().then(() => enterTransactionScope(db, mode, storeNames, null, scopeFunc));
+                    return db
+                        .open()
+                        .then(() => enterTransactionScope(db, mode, storeNames, null, scopeFunc));
                 }
                 return rejection(ex);
             }
@@ -4214,20 +4508,25 @@ function enterTransactionScope(db, mode, storeNames, parentTransaction, scopeFun
                     var decrementor = decrementExpectedAwaits.bind(null, null);
                     returnValue.then(decrementor, decrementor);
                 }
-                else if (typeof returnValue.next === 'function' && typeof returnValue.throw === 'function') {
+                else if (typeof returnValue.next === 'function' &&
+                    typeof returnValue.throw === 'function') {
                     returnValue = awaitIterator(returnValue);
                 }
             }
         }, zoneProps);
-        return (returnValue && typeof returnValue.then === 'function' ?
-            DexiePromise.resolve(returnValue).then(x => trans.active ?
-                x
-                : rejection(new exceptions.PrematureCommit("Transaction committed too early. See http://bit.ly/2kdckMn")))
-            : promiseFollowed.then(() => returnValue)).then(x => {
+        return (returnValue && typeof returnValue.then === 'function'
+            ?
+                DexiePromise.resolve(returnValue).then((x) => trans.active
+                    ? x
+                    : rejection(new exceptions.PrematureCommit('Transaction committed too early. See http://bit.ly/2kdckMn')))
+            :
+                promiseFollowed.then(() => returnValue))
+            .then((x) => {
             if (parentTransaction)
                 trans._resolve();
             return trans._completion.then(() => x);
-        }).catch(e => {
+        })
+            .catch((e) => {
             trans._reject(e);
             return rejection(e);
         });
@@ -4250,8 +4549,13 @@ function createVirtualIndexMiddleware(down) {
             const allVirtualIndexes = [];
             function addVirtualIndexes(keyPath, keyTail, lowLevelIndex) {
                 const keyPathAlias = getKeyPathAlias(keyPath);
-                const indexList = (indexLookup[keyPathAlias] = indexLookup[keyPathAlias] || []);
-                const keyLength = keyPath == null ? 0 : typeof keyPath === 'string' ? 1 : keyPath.length;
+                const indexList = (indexLookup[keyPathAlias] =
+                    indexLookup[keyPathAlias] || []);
+                const keyLength = keyPath == null
+                    ? 0
+                    : typeof keyPath === 'string'
+                        ? 1
+                        : keyPath.length;
                 const isVirtual = keyTail > 0;
                 const virtualIndex = {
                     ...lowLevelIndex,
@@ -4263,23 +4567,23 @@ function createVirtualIndexMiddleware(down) {
                     keyTail,
                     keyLength,
                     extractKey: getKeyExtractor(keyPath),
-                    unique: !isVirtual && lowLevelIndex.unique
+                    unique: !isVirtual && lowLevelIndex.unique,
                 };
                 indexList.push(virtualIndex);
                 if (!virtualIndex.isPrimaryKey) {
                     allVirtualIndexes.push(virtualIndex);
                 }
                 if (keyLength > 1) {
-                    const virtualKeyPath = keyLength === 2 ?
-                        keyPath[0] :
-                        keyPath.slice(0, keyLength - 1);
+                    const virtualKeyPath = keyLength === 2
+                        ? keyPath[0]
+                        : keyPath.slice(0, keyLength - 1);
                     addVirtualIndexes(virtualKeyPath, keyTail + 1, lowLevelIndex);
                 }
                 indexList.sort((a, b) => a.keyTail - b.keyTail);
                 return virtualIndex;
             }
             const primaryKey = addVirtualIndexes(schema.primaryKey.keyPath, 0, schema.primaryKey);
-            indexLookup[":id"] = [primaryKey];
+            indexLookup[':id'] = [primaryKey];
             for (const index of schema.indexes) {
                 addVirtualIndexes(index.keyPath, 0, index);
             }
@@ -4289,24 +4593,26 @@ function createVirtualIndexMiddleware(down) {
             }
             function translateRange(range, keyTail) {
                 return {
-                    type: range.type === 1  ?
-                        2  :
-                        range.type,
+                    type: range.type === 1
+                        ? 2
+                        : range.type,
                     lower: pad(range.lower, range.lowerOpen ? down.MAX_KEY : down.MIN_KEY, keyTail),
                     lowerOpen: true,
                     upper: pad(range.upper, range.upperOpen ? down.MIN_KEY : down.MAX_KEY, keyTail),
-                    upperOpen: true
+                    upperOpen: true,
                 };
             }
             function translateRequest(req) {
                 const index = req.query.index;
-                return index.isVirtual ? {
-                    ...req,
-                    query: {
-                        index: index.lowLevelIndex,
-                        range: translateRange(req.query.range, index.keyTail)
+                return index.isVirtual
+                    ? {
+                        ...req,
+                        query: {
+                            index: index.lowLevelIndex,
+                            range: translateRange(req.query.range, index.keyTail),
+                        },
                     }
-                } : req;
+                    : req;
             }
             const result = {
                 ...table,
@@ -4314,7 +4620,7 @@ function createVirtualIndexMiddleware(down) {
                     ...schema,
                     primaryKey,
                     indexes: allVirtualIndexes,
-                    getIndexByKeyPath: findBestIndex
+                    getIndexByKeyPath: findBestIndex,
                 },
                 count(req) {
                     return table.count(translateRequest(req));
@@ -4323,61 +4629,62 @@ function createVirtualIndexMiddleware(down) {
                     return table.query(translateRequest(req));
                 },
                 openCursor(req) {
-                    const { keyTail, isVirtual, keyLength } = req.query.index;
+                    const { keyTail, isVirtual, keyLength } = req.query
+                        .index;
                     if (!isVirtual)
                         return table.openCursor(req);
                     function createVirtualCursor(cursor) {
                         function _continue(key) {
-                            key != null ?
-                                cursor.continue(pad(key, req.reverse ? down.MAX_KEY : down.MIN_KEY, keyTail)) :
-                                req.unique ?
-                                    cursor.continue(cursor.key.slice(0, keyLength)
-                                        .concat(req.reverse
-                                        ? down.MIN_KEY
-                                        : down.MAX_KEY, keyTail)) :
-                                    cursor.continue();
+                            key != null
+                                ? cursor.continue(pad(key, req.reverse ? down.MAX_KEY : down.MIN_KEY, keyTail))
+                                : req.unique
+                                    ? cursor.continue(cursor.key
+                                        .slice(0, keyLength)
+                                        .concat(req.reverse ? down.MIN_KEY : down.MAX_KEY, keyTail))
+                                    : cursor.continue();
                         }
                         const virtualCursor = Object.create(cursor, {
                             continue: { value: _continue },
                             continuePrimaryKey: {
                                 value(key, primaryKey) {
                                     cursor.continuePrimaryKey(pad(key, down.MAX_KEY, keyTail), primaryKey);
-                                }
+                                },
                             },
                             primaryKey: {
                                 get() {
                                     return cursor.primaryKey;
-                                }
+                                },
                             },
                             key: {
                                 get() {
                                     const key = cursor.key;
-                                    return keyLength === 1 ?
-                                        key[0] :
-                                        key.slice(0, keyLength);
-                                }
+                                    return keyLength === 1
+                                        ? key[0]
+                                        : key.slice(0, keyLength);
+                                },
                             },
                             value: {
                                 get() {
                                     return cursor.value;
-                                }
-                            }
+                                },
+                            },
                         });
                         return virtualCursor;
                     }
-                    return table.openCursor(translateRequest(req))
-                        .then(cursor => cursor && createVirtualCursor(cursor));
-                }
+                    return table
+                        .openCursor(translateRequest(req))
+                        .then((cursor) => cursor && createVirtualCursor(cursor));
+                },
             };
             return result;
-        }
+        },
     };
 }
 const virtualIndexMiddleware = {
-    stack: "dbcore",
-    name: "VirtualIndexMiddleware",
+    stack: 'dbcore',
+    name: 'VirtualIndexMiddleware',
     level: 1,
-    create: createVirtualIndexMiddleware
+    create: createVirtualIndexMiddleware,
 };
 
 function getObjectDiff(a, b, rv, prfx) {
@@ -4421,8 +4728,8 @@ function getEffectiveKeys(primaryKey, req) {
 }
 
 const hooksMiddleware = {
-    stack: "dbcore",
-    name: "HooksMiddleware",
+    stack: 'dbcore',
+    name: 'HooksMiddleware',
     level: 2,
     create: (downCore) => ({
         ...downCore,
@@ -4457,22 +4764,24 @@ const hooksMiddleware = {
                         const dxTrans = PSD.trans;
                         const keys = req.keys || getEffectiveKeys(primaryKey, req);
                         if (!keys)
-                            throw new Error("Keys missing");
-                        req = req.type === 'add' || req.type === 'put' ?
-                            { ...req, keys } :
-                            { ...req };
+                            throw new Error('Keys missing');
+                        req =
+                            req.type === 'add' || req.type === 'put'
+                                ? { ...req, keys }
+                                : { ...req };
                         if (req.type !== 'delete')
                             req.values = [...req.values];
                         if (req.keys)
                             req.keys = [...req.keys];
-                        return getExistingValues(downTable, req, keys).then(existingValues => {
+                        return getExistingValues(downTable, req, keys).then((existingValues) => {
                             const contexts = keys.map((key, i) => {
                                 const existingValue = existingValues[i];
                                 const ctx = { onerror: null, onsuccess: null };
                                 if (req.type === 'delete') {
                                     deleting.fire.call(ctx, key, existingValue, dxTrans);
                                 }
-                                else if (req.type === 'add' || existingValue === undefined) {
+                                else if (req.type === 'add' ||
+                                    existingValue === undefined) {
                                     const generatedPrimaryKey = creating.fire.call(ctx, key, req.values[i], dxTrans);
                                     if (key == null && generatedPrimaryKey != null) {
                                         key = generatedPrimaryKey;
@@ -4487,9 +4796,10 @@ const hooksMiddleware = {
                                     const additionalChanges = updating.fire.call(ctx, objectDiff, key, existingValue, dxTrans);
                                     if (additionalChanges) {
                                         const requestedValue = req.values[i];
-                                        Object.keys(additionalChanges).forEach(keyPath => {
+                                        Object.keys(additionalChanges).forEach((keyPath) => {
                                             if (hasOwn(requestedValue, keyPath)) {
-                                                requestedValue[keyPath] = additionalChanges[keyPath];
+                                                requestedValue[keyPath] =
+                                                    additionalChanges[keyPath];
                                             }
                                             else {
                                                 setByKeyPath(requestedValue, keyPath, additionalChanges[keyPath]);
@@ -4499,7 +4809,9 @@ const hooksMiddleware = {
                                 }
                                 return ctx;
                             });
-                            return downTable.mutate(req).then(({ failures, results, numFailures, lastResult }) => {
+                            return downTable
+                                .mutate(req)
+                                .then(({ failures, results, numFailures, lastResult }) => {
                                 for (let i = 0; i < keys.length; ++i) {
                                     const primKey = results ? results[i] : keys[i];
                                     const ctx = contexts[i];
@@ -4507,15 +4819,17 @@ const hooksMiddleware = {
                                         ctx.onerror && ctx.onerror(failures[i]);
                                     }
                                     else {
-                                        ctx.onsuccess && ctx.onsuccess(req.type === 'put' && existingValues[i] ?
-                                            req.values[i] :
-                                            primKey
-                                        );
+                                        ctx.onsuccess &&
+                                            ctx.onsuccess(req.type === 'put' && existingValues[i]
+                                                ? req.values[i]
+                                                : primKey
+                                            );
                                     }
                                 }
                                 return { failures, results, numFailures, lastResult };
-                            }).catch(error => {
-                                contexts.forEach(ctx => ctx.onerror && ctx.onerror(error));
+                            })
+                                .catch((error) => {
+                                contexts.forEach((ctx) => ctx.onerror && ctx.onerror(error));
                                 return Promise.reject(error);
                             });
                         });
@@ -4524,30 +4838,52 @@ const hooksMiddleware = {
                         return deleteNextChunk(req.trans, req.range, 10000);
                     }
                     function deleteNextChunk(trans, range, limit) {
-                        return downTable.query({ trans, values: false, query: { index: primaryKey, range }, limit })
+                        return downTable
+                            .query({
+                            trans,
+                            values: false,
+                            query: { index: primaryKey, range },
+                            limit,
+                        })
                             .then(({ result }) => {
-                            return addPutOrDelete({ type: 'delete', keys: result, trans }).then(res => {
+                            return addPutOrDelete({
+                                type: 'delete',
+                                keys: result,
+                                trans,
+                            }).then((res) => {
                                 if (res.numFailures > 0)
                                     return Promise.reject(res.failures[0]);
                                 if (result.length < limit) {
-                                    return { failures: [], numFailures: 0, lastResult: undefined };
+                                    return {
+                                        failures: [],
+                                        numFailures: 0,
+                                        lastResult: undefined,
+                                    };
                                 }
                                 else {
-                                    return deleteNextChunk(trans, { ...range, lower: result[result.length - 1], lowerOpen: true }, limit);
+                                    return deleteNextChunk(trans, {
+                                        ...range,
+                                        lower: result[result.length - 1],
+                                        lowerOpen: true,
+                                    }, limit);
                                 }
                             });
                         });
                     }
-                }
+                },
             };
             return tableMiddleware;
         },
-    })
+    }),
 };
 function getExistingValues(table, req, effectiveKeys) {
-    return req.type === "add"
+    return req.type === 'add'
         ? Promise.resolve([])
-        : table.getMany({ trans: req.trans, keys: effectiveKeys, cache: "immutable" });
+        : table.getMany({
+            trans: req.trans,
+            keys: effectiveKeys,
+            cache: 'immutable',
+        });
 }
 
 function getFromTransactionCache(keys, cache, clone) {
@@ -4570,7 +4906,7 @@ function getFromTransactionCache(keys, cache, clone) {
     }
 }
 const cacheExistingValuesMiddleware = {
-    stack: "dbcore",
+    stack: 'dbcore',
     level: -1,
     create: (core) => {
         return {
@@ -4582,21 +4918,21 @@ const cacheExistingValuesMiddleware = {
                         if (!req.cache) {
                             return table.getMany(req);
                         }
-                        const cachedResult = getFromTransactionCache(req.keys, req.trans["_cache"], req.cache === "clone");
+                        const cachedResult = getFromTransactionCache(req.keys, req.trans['_cache'], req.cache === 'clone');
                         if (cachedResult) {
                             return DexiePromise.resolve(cachedResult);
                         }
                         return table.getMany(req).then((res) => {
-                            req.trans["_cache"] = {
+                            req.trans['_cache'] = {
                                 keys: req.keys,
-                                values: req.cache === "clone" ? deepClone(res) : res,
+                                values: req.cache === 'clone' ? deepClone(res) : res,
                             };
                             return res;
                         });
                     },
                     mutate: (req) => {
-                        if (req.type !== "add")
-                            req.trans["_cache"] = null;
+                        if (req.type !== 'add')
+                            req.trans['_cache'] = null;
                         return table.mutate(req);
                     },
                 };
@@ -4629,9 +4965,9 @@ function isCachableRequest(type, req) {
 }
 
 const observabilityMiddleware = {
-    stack: "dbcore",
+    stack: 'dbcore',
     level: 0,
-    name: "Observability",
+    name: 'Observability',
     create: (core) => {
         const dbName = core.schema.name;
         const FULL_RANGE = new RangeSet(core.MIN_KEY, core.MAX_KEY);
@@ -4648,7 +4984,9 @@ const observabilityMiddleware = {
                 const { schema } = table;
                 const { primaryKey, indexes } = schema;
                 const { extractKey, outbound } = primaryKey;
-                const indexesWithAutoIncPK = primaryKey.autoIncrement && indexes.filter((index) => index.compound && index.keyPath.includes(primaryKey.keyPath));
+                const indexesWithAutoIncPK = primaryKey.autoIncrement &&
+                    indexes.filter((index) => index.compound &&
+                        index.keyPath.includes(primaryKey.keyPath));
                 const tableClone = {
                     ...table,
                     mutate: (req) => {
@@ -4659,20 +4997,25 @@ const observabilityMiddleware = {
                             return (mutatedParts[part] ||
                                 (mutatedParts[part] = new RangeSet()));
                         };
-                        const pkRangeSet = getRangeSet("");
-                        const delsRangeSet = getRangeSet(":dels");
+                        const pkRangeSet = getRangeSet('');
+                        const delsRangeSet = getRangeSet(':dels');
                         const { type } = req;
-                        let [keys, newObjs] = req.type === "deleteRange"
+                        let [keys, newObjs] = req.type === 'deleteRange'
                             ? [req.range]
-                            : req.type === "delete"
+                            : req.type === 'delete'
                                 ? [req.keys]
                                 : req.values.length < 50
-                                    ? [getEffectiveKeys(primaryKey, req).filter(id => id), req.values]
+                                    ? [
+                                        getEffectiveKeys(primaryKey, req).filter((id) => id),
+                                        req.values,
+                                    ]
                                     : [];
-                        const oldCache = req.trans["_cache"];
+                        const oldCache = req.trans['_cache'];
                         if (isArray(keys)) {
                             pkRangeSet.addKeys(keys);
-                            const oldObjs = type === 'delete' || keys.length === newObjs.length ? getFromTransactionCache(keys, oldCache) : null;
+                            const oldObjs = type === 'delete' || keys.length === newObjs.length
+                                ? getFromTransactionCache(keys, oldCache)
+                                : null;
                             if (!oldObjs) {
                                 delsRangeSet.addKeys(keys);
                             }
@@ -4683,7 +5026,7 @@ const observabilityMiddleware = {
                         else if (keys) {
                             const range = {
                                 from: keys.lower ?? core.MIN_KEY,
-                                to: keys.upper ?? core.MAX_KEY
+                                to: keys.upper ?? core.MAX_KEY,
                             };
                             delsRangeSet.add(range);
                             pkRangeSet.add(range);
@@ -4691,15 +5034,15 @@ const observabilityMiddleware = {
                         else {
                             pkRangeSet.add(FULL_RANGE);
                             delsRangeSet.add(FULL_RANGE);
-                            schema.indexes.forEach(idx => getRangeSet(idx.name).add(FULL_RANGE));
+                            schema.indexes.forEach((idx) => getRangeSet(idx.name).add(FULL_RANGE));
                         }
                         return table.mutate(req).then((res) => {
                             if (keys && (req.type === 'add' || req.type === 'put')) {
                                 pkRangeSet.addKeys(res.results);
                                 if (indexesWithAutoIncPK) {
-                                    indexesWithAutoIncPK.forEach(idx => {
-                                        const idxVals = req.values.map(v => idx.extractKey(v));
-                                        const pkPos = idx.keyPath.findIndex(prop => prop === primaryKey.keyPath);
+                                    indexesWithAutoIncPK.forEach((idx) => {
+                                        const idxVals = req.values.map((v) => idx.extractKey(v));
+                                        const pkPos = idx.keyPath.findIndex((prop) => prop === primaryKey.keyPath);
                                         for (let i = 0, len = res.results.length; i < len; ++i) {
                                             idxVals[i][pkPos] = res.results[i];
                                         }
@@ -4727,9 +5070,10 @@ const observabilityMiddleware = {
                     tableClone[method] = function (req) {
                         const { subscr } = PSD;
                         const isLiveQuery = !!subscr;
-                        let cachable = isCachableContext(PSD, table) && isCachableRequest(method, req);
+                        let cachable = isCachableContext(PSD, table) &&
+                            isCachableRequest(method, req);
                         const obsSet = cachable
-                            ? req.obsSet = {}
+                            ? (req.obsSet = {})
                             : subscr;
                         if (isLiveQuery) {
                             const getRangeSet = (indexName) => {
@@ -4737,21 +5081,23 @@ const observabilityMiddleware = {
                                 return (obsSet[part] ||
                                     (obsSet[part] = new RangeSet()));
                             };
-                            const pkRangeSet = getRangeSet("");
-                            const delsRangeSet = getRangeSet(":dels");
+                            const pkRangeSet = getRangeSet('');
+                            const delsRangeSet = getRangeSet(':dels');
                             const [queriedIndex, queriedRanges] = readSubscribers[method](req);
-                            if (method === 'query' && queriedIndex.isPrimaryKey && !req.values) {
+                            if (method === 'query' &&
+                                queriedIndex.isPrimaryKey &&
+                                !req.values) {
                                 delsRangeSet.add(queriedRanges);
                             }
                             else {
-                                getRangeSet(queriedIndex.name || "").add(queriedRanges);
+                                getRangeSet(queriedIndex.name || '').add(queriedRanges);
                             }
                             if (!queriedIndex.isPrimaryKey) {
-                                if (method === "count") {
+                                if (method === 'count') {
                                     delsRangeSet.add(FULL_RANGE);
                                 }
                                 else {
-                                    const keysPromise = method === "query" &&
+                                    const keysPromise = method === 'query' &&
                                         outbound &&
                                         req.values &&
                                         table.query({
@@ -4759,9 +5105,9 @@ const observabilityMiddleware = {
                                             values: false,
                                         });
                                     return table[method].apply(this, arguments).then((res) => {
-                                        if (method === "query") {
+                                        if (method === 'query') {
                                             if (outbound && req.values) {
-                                                return keysPromise.then(({ result: resultingKeys }) => {
+                                                return keysPromise.then(({ result: resultingKeys, }) => {
                                                     pkRangeSet.addKeys(resultingKeys);
                                                     return res;
                                                 });
@@ -4776,9 +5122,10 @@ const observabilityMiddleware = {
                                                 delsRangeSet.addKeys(pKeys);
                                             }
                                         }
-                                        else if (method === "openCursor") {
+                                        else if (method === 'openCursor') {
                                             const cursor = res;
-                                            const wantValues = req.values;
+                                            const wantValues = req
+                                                .values;
                                             return (cursor &&
                                                 Object.create(cursor, {
                                                     key: {
@@ -4796,7 +5143,8 @@ const observabilityMiddleware = {
                                                     },
                                                     value: {
                                                         get() {
-                                                            wantValues && pkRangeSet.addKey(cursor.primaryKey);
+                                                            wantValues &&
+                                                                pkRangeSet.addKey(cursor.primaryKey);
                                                             return cursor.value;
                                                         },
                                                     },
@@ -4817,13 +5165,15 @@ const observabilityMiddleware = {
 };
 function trackAffectedIndexes(getRangeSet, schema, oldObjs, newObjs) {
     function addAffectedIndex(ix) {
-        const rangeSet = getRangeSet(ix.name || "");
+        const rangeSet = getRangeSet(ix.name || '');
         function extractKey(obj) {
             return obj != null ? ix.extractKey(obj) : null;
         }
         const addKeyOrKeys = (key) => ix.multiEntry && isArray(key)
-            ? key.forEach(key => rangeSet.addKey(key))
-            : rangeSet.addKey(key);
+            ?
+                key.forEach((key) => rangeSet.addKey(key))
+            :
+                rangeSet.addKey(key);
         (oldObjs || newObjs).forEach((_, i) => {
             const oldKey = oldObjs && extractKey(oldObjs[i]);
             const newKey = newObjs && extractKey(newObjs[i]);
@@ -5030,7 +5380,8 @@ function findCompatibleQuery(dbName, tableName, type, req) {
             const reqDirection = req.direction ?? 'next';
             const equalEntry = entries.find((entry) => entry.req.limit === req.limit &&
                 entry.req.values === req.values &&
-                (entry.req.direction ?? 'next') === reqDirection &&
+                (entry.req.direction ?? 'next') ===
+                    reqDirection &&
                 areRangesEqual(entry.req.query.range, req.query.range));
             if (equalEntry)
                 return [
@@ -5042,7 +5393,8 @@ function findCompatibleQuery(dbName, tableName, type, req) {
             const superEntry = entries.find((entry) => {
                 const limit = 'limit' in entry.req ? entry.req.limit : Infinity;
                 return (limit >= req.limit &&
-                    (entry.req.direction ?? 'next') === reqDirection &&
+                    (entry.req.direction ?? 'next') ===
+                        reqDirection &&
                     (req.values ? entry.req.values : true) &&
                     isSuperRange(entry.req.query.range, req.query.range));
             });
@@ -5055,7 +5407,7 @@ function findCompatibleQuery(dbName, tableName, type, req) {
 
 function subscribeToCacheEntry(cacheEntry, container, requery, signal) {
     cacheEntry.subscribers.add(requery);
-    signal.addEventListener("abort", () => {
+    signal.addEventListener('abort', () => {
         cacheEntry.subscribers.delete(requery);
         if (cacheEntry.subscribers.size === 0) {
             enqueForDeletion(cacheEntry, container);
@@ -5092,7 +5444,9 @@ const cacheMiddleware = {
                                 if (tblCache) {
                                     const table = core.table(storeName);
                                     const ops = tblCache.optimisticOps.filter((op) => op.trans === idbtrans);
-                                    if (idbtrans._explicit && wasCommitted && idbtrans.mutatedParts) {
+                                    if (idbtrans._explicit &&
+                                        wasCommitted &&
+                                        idbtrans.mutatedParts) {
                                         for (const entries of Object.values(tblCache.queries.query)) {
                                             for (const entry of entries.slice()) {
                                                 if (obsSetsOverlap(entry.obsSet, idbtrans.mutatedParts)) {
@@ -5118,7 +5472,9 @@ const cacheMiddleware = {
                                                         }
                                                         else if (modRes !== entry.res) {
                                                             entry.res = modRes;
-                                                            entry.promise = DexiePromise.resolve({ result: modRes });
+                                                            entry.promise = DexiePromise.resolve({
+                                                                result: modRes,
+                                                            });
                                                         }
                                                     }
                                                     else {
@@ -5166,7 +5522,9 @@ const cacheMiddleware = {
                         if (!tblCache)
                             return downTable.mutate(req);
                         const promise = downTable.mutate(req);
-                        if ((req.type === 'add' || req.type === 'put') && (req.values.length >= 50 || getEffectiveKeys(primKey, req).some(key => key == null))) {
+                        if ((req.type === 'add' || req.type === 'put') &&
+                            (req.values.length >= 50 ||
+                                getEffectiveKeys(primKey, req).some((key) => key == null))) {
                             promise.then((res) => {
                                 const reqWithResolvedKeys = {
                                     ...req,
@@ -5180,11 +5538,12 @@ const cacheMiddleware = {
                                             };
                                         setByKeyPath(valueWithKey, primKey.keyPath, res.results[i]);
                                         return valueWithKey;
-                                    })
+                                    }),
                                 };
                                 const adjustedReq = adjustOptimisticFromFailures(tblCache, reqWithResolvedKeys, res);
                                 tblCache.optimisticOps.push(adjustedReq);
-                                queueMicrotask(() => req.mutatedParts && signalSubscribersLazily(req.mutatedParts));
+                                queueMicrotask(() => req.mutatedParts &&
+                                    signalSubscribersLazily(req.mutatedParts));
                             });
                         }
                         else {
@@ -5208,16 +5567,20 @@ const cacheMiddleware = {
                         return promise;
                     },
                     query(req) {
-                        if (!isCachableContext(PSD, downTable) || !isCachableRequest("query", req))
+                        if (!isCachableContext(PSD, downTable) ||
+                            !isCachableRequest('query', req))
                             return downTable.query(req);
-                        const freezeResults = PSD.trans?.db._options.cache === 'immutable';
+                        const freezeResults = PSD.trans?.db._options.cache ===
+                            'immutable';
                         const { requery, signal } = PSD;
                         let [cacheEntry, exactMatch, tblCache, container] = findCompatibleQuery(dbName, tableName, 'query', req);
                         if (cacheEntry && exactMatch) {
                             cacheEntry.obsSet = req.obsSet;
                         }
                         else {
-                            const promise = downTable.query(req).then((res) => {
+                            const promise = downTable
+                                .query(req)
+                                .then((res) => {
                                 const result = res.result;
                                 if (cacheEntry)
                                     cacheEntry.res = result;
@@ -5231,7 +5594,8 @@ const cacheMiddleware = {
                                     res.result = deepClone(result);
                                 }
                                 return res;
-                            }).catch(error => {
+                            })
+                                .catch((error) => {
                                 if (container && cacheEntry)
                                     delArrayItem(container, cacheEntry);
                                 return Promise.reject(error);
@@ -5257,7 +5621,7 @@ const cacheMiddleware = {
                                         },
                                         objs: new Map(),
                                         optimisticOps: [],
-                                        unsignaledParts: {}
+                                        unsignaledParts: {},
                                     };
                                 }
                                 tblCache.queries.query[req.query.index.name || ''] = container;
@@ -5284,7 +5648,7 @@ function vipify(target, vipDb) {
             if (prop === 'db')
                 return vipDb;
             return Reflect.get(target, prop, receiver);
-        }
+        },
     });
 }
 
@@ -5300,13 +5664,13 @@ let Dexie$1 = class Dexie {
             IDBKeyRange: deps.IDBKeyRange,
             cache: 'cloned',
             maxConnections: DEFAULT_MAX_CONNECTIONS,
-            ...options
+            ...options,
         };
         this._deps = {
             indexedDB: options.indexedDB,
-            IDBKeyRange: options.IDBKeyRange
+            IDBKeyRange: options.IDBKeyRange,
         };
-        const { addons, } = options;
+        const { addons } = options;
         this._dbSchema = {};
         this._versions = [];
         this._storeNames = [];
@@ -5326,7 +5690,7 @@ let Dexie$1 = class Dexie {
             PR1398_maxLoop: 3,
             autoOpen: options.autoOpen,
         };
-        state.dbReadyPromise = new DexiePromise(resolve => {
+        state.dbReadyPromise = new DexiePromise((resolve) => {
             state.dbReadyResolve = resolve;
         });
         state.openCanceller = new DexiePromise((_, reject) => {
@@ -5334,7 +5698,9 @@ let Dexie$1 = class Dexie {
         });
         this._state = state;
         this.name = name;
-        this.on = Events(this, "populate", "blocked", "versionchange", "close", { ready: [promisableChain, nop] });
+        this.on = Events(this, 'populate', 'blocked', 'versionchange', 'close', {
+            ready: [promisableChain, nop],
+        });
         this.once = (event, callback) => {
             const fn = (...args) => {
                 this.on(event).unsubscribe(fn);
@@ -5342,7 +5708,7 @@ let Dexie$1 = class Dexie {
             };
             return this.on(event, fn);
         };
-        this.on.ready.subscribe = override(this.on.ready.subscribe, subscribe => {
+        this.on.ready.subscribe = override(this.on.ready.subscribe, (subscribe) => {
             return (subscriber, bSticky) => {
                 Dexie.vip(() => {
                     const state = this._state;
@@ -5374,14 +5740,14 @@ let Dexie$1 = class Dexie {
         this.Transaction = createTransactionConstructor(this);
         this.Version = createVersionConstructor(this);
         this.WhereClause = createWhereClauseConstructor(this);
-        this.on("versionchange", ev => {
+        this.on('versionchange', (ev) => {
             if (ev.newVersion > 0)
                 console.warn(`Another connection wants to upgrade database '${this.name}'. Closing db now to resume the upgrade.`);
             else
                 console.warn(`Another connection wants to delete database '${this.name}'. Closing db now to resume the delete request.`);
             this.close({ disableAutoOpen: false });
         });
-        this.on("blocked", ev => {
+        this.on('blocked', (ev) => {
             if (!ev.newVersion || ev.newVersion < ev.oldVersion)
                 console.warn(`Dexie.delete('${this.name}') was blocked`);
             else
@@ -5389,11 +5755,12 @@ let Dexie$1 = class Dexie {
         });
         this._maxKey = getMaxKey(options.IDBKeyRange);
         this._createTransaction = (mode, storeNames, dbschema, parentTransaction) => new this.Transaction(mode, storeNames, dbschema, this._options.chromeTransactionDurability, parentTransaction);
-        this._fireOnBlocked = ev => {
-            this.on("blocked").fire(ev);
-            connections.toArray()
-                .filter(c => c.name === this.name && c !== this && !c._state.vcFired)
-                .map(c => c.on("versionchange").fire(ev));
+        this._fireOnBlocked = (ev) => {
+            this.on('blocked').fire(ev);
+            connections
+                .toArray()
+                .filter((c) => c.name === this.name && c !== this && !c._state.vcFired)
+                .map((c) => c.on('versionchange').fire(ev));
         };
         this.use(cacheExistingValuesMiddleware);
         this.use(cacheMiddleware);
@@ -5410,27 +5777,27 @@ let Dexie$1 = class Dexie {
                 if (rv instanceof Table)
                     return vipify(rv, vipDB);
                 if (prop === 'tables')
-                    return rv.map(t => vipify(t, vipDB));
+                    return rv.map((t) => vipify(t, vipDB));
                 if (prop === '_createTransaction')
                     return function () {
                         const tx = rv.apply(this, arguments);
                         return vipify(tx, vipDB);
                     };
                 return rv;
-            }
+            },
         });
         this.vip = vipDB;
-        addons.forEach(addon => addon(this));
+        addons.forEach((addon) => addon(this));
     }
     version(versionNumber) {
         if (isNaN(versionNumber) || versionNumber < 0.1)
             throw new exceptions.Type(`Given version is not a positive number`);
         versionNumber = Math.round(versionNumber * 10) / 10;
         if (this.idbdb || this._state.isBeingOpened)
-            throw new exceptions.Schema("Cannot add version when database is open");
+            throw new exceptions.Schema('Cannot add version when database is open');
         this.verno = Math.max(this.verno, versionNumber);
         const versions = this._versions;
-        var versionInstance = versions.filter(v => v._cfg.version === versionNumber)[0];
+        var versionInstance = versions.filter((v) => v._cfg.version === versionNumber)[0];
         if (versionInstance)
             return versionInstance;
         versionInstance = new this.Version(versionNumber);
@@ -5441,33 +5808,43 @@ let Dexie$1 = class Dexie {
         return versionInstance;
     }
     _whenReady(fn) {
-        return (this.idbdb && (this._state.openComplete || PSD.letThrough || this._vip)) ? fn() : new DexiePromise((resolve, reject) => {
-            if (this._state.openComplete) {
-                return reject(new exceptions.DatabaseClosed(this._state.dbOpenError));
-            }
-            if (!this._state.isBeingOpened) {
-                if (!this._state.autoOpen) {
-                    reject(new exceptions.DatabaseClosed());
-                    return;
+        return this.idbdb &&
+            (this._state.openComplete || PSD.letThrough || this._vip)
+            ? fn()
+            : new DexiePromise((resolve, reject) => {
+                if (this._state.openComplete) {
+                    return reject(new exceptions.DatabaseClosed(this._state.dbOpenError));
                 }
-                this.open().catch(nop);
-            }
-            this._state.dbReadyPromise.then(resolve, reject);
-        }).then(fn);
+                if (!this._state.isBeingOpened) {
+                    if (!this._state.autoOpen) {
+                        reject(new exceptions.DatabaseClosed());
+                        return;
+                    }
+                    this.open().catch(nop);
+                }
+                this._state.dbReadyPromise.then(resolve, reject);
+            }).then(fn);
     }
     use({ stack, create, level, name }) {
         if (name)
             this.unuse({ stack, name });
         const middlewares = this._middlewares[stack] || (this._middlewares[stack] = []);
-        middlewares.push({ stack, create, level: level == null ? 10 : level, name });
+        middlewares.push({
+            stack,
+            create,
+            level: level == null ? 10 : level,
+            name,
+        });
         middlewares.sort((a, b) => a.level - b.level);
         return this;
     }
-    unuse({ stack, name, create }) {
+    unuse({ stack, name, create, }) {
         if (stack && this._middlewares[stack]) {
-            this._middlewares[stack] = this._middlewares[stack].filter(mw => create ? mw.create !== create :
-                name ? mw.name !== name :
-                    false);
+            this._middlewares[stack] = this._middlewares[stack].filter((mw) => create
+                ? mw.create !== create
+                : name
+                    ? mw.name !== name
+                    : false);
         }
         return this;
     }
@@ -5487,7 +5864,7 @@ let Dexie$1 = class Dexie {
             this.idbdb = null;
         }
         if (!state.isBeingOpened) {
-            state.dbReadyPromise = new DexiePromise(resolve => {
+            state.dbReadyPromise = new DexiePromise((resolve) => {
                 state.dbReadyResolve = resolve;
             });
             state.openCanceller = new DexiePromise((_, reject) => {
@@ -5507,8 +5884,7 @@ let Dexie$1 = class Dexie {
         }
         else {
             this._close();
-            state.autoOpen = this._options.autoOpen ||
-                state.isBeingOpened;
+            state.autoOpen = this._options.autoOpen || state.isBeingOpened;
             state.openComplete = false;
             state.dbOpenError = null;
         }
@@ -5528,7 +5904,7 @@ let Dexie$1 = class Dexie {
                 req.onblocked = this._fireOnBlocked;
             };
             if (hasInvalidArguments)
-                throw new exceptions.InvalidArgument("Invalid closeOptions argument to db.delete()");
+                throw new exceptions.InvalidArgument('Invalid closeOptions argument to db.delete()');
             if (state.isBeingOpened) {
                 state.dbReadyPromise.then(doDelete);
             }
@@ -5545,7 +5921,7 @@ let Dexie$1 = class Dexie {
     }
     hasBeenClosed() {
         const dbOpenError = this._state.dbOpenError;
-        return dbOpenError && (dbOpenError.name === 'DatabaseClosed');
+        return dbOpenError && dbOpenError.name === 'DatabaseClosed';
     }
     hasFailed() {
         return this._state.dbOpenError !== null;
@@ -5554,7 +5930,7 @@ let Dexie$1 = class Dexie {
         return this._state.autoSchema;
     }
     get tables() {
-        return keys(this._allTables).map(name => this._allTables[name]);
+        return keys(this._allTables).map((name) => this._allTables[name]);
     }
     transaction() {
         const args = extractTransactionArgs.apply(this, arguments);
@@ -5562,60 +5938,67 @@ let Dexie$1 = class Dexie {
     }
     _transaction(mode, tables, scopeFunc) {
         let parentTransaction = PSD.trans;
-        if (!parentTransaction || parentTransaction.db !== this || mode.indexOf('!') !== -1)
+        if (!parentTransaction ||
+            parentTransaction.db !== this ||
+            mode.indexOf('!') !== -1)
             parentTransaction = null;
         const onlyIfCompatible = mode.indexOf('?') !== -1;
         mode = mode.replace('!', '').replace('?', '');
         let idbMode, storeNames;
         try {
-            storeNames = tables.map(table => {
+            storeNames = tables.map((table) => {
                 var storeName = table instanceof this.Table ? table.name : table;
                 if (typeof storeName !== 'string')
-                    throw new TypeError("Invalid table argument to Dexie.transaction(). Only Table or String are allowed");
+                    throw new TypeError('Invalid table argument to Dexie.transaction(). Only Table or String are allowed');
                 return storeName;
             });
-            if (mode == "r" || mode === READONLY)
+            if (mode == 'r' || mode === READONLY)
                 idbMode = READONLY;
-            else if (mode == "rw" || mode == READWRITE)
+            else if (mode == 'rw' || mode == READWRITE)
                 idbMode = READWRITE;
             else
-                throw new exceptions.InvalidArgument("Invalid transaction mode: " + mode);
+                throw new exceptions.InvalidArgument('Invalid transaction mode: ' + mode);
             if (parentTransaction) {
                 if (parentTransaction.mode === READONLY && idbMode === READWRITE) {
                     if (onlyIfCompatible) {
                         parentTransaction = null;
                     }
                     else
-                        throw new exceptions.SubTransaction("Cannot enter a sub-transaction with READWRITE mode when parent transaction is READONLY");
+                        throw new exceptions.SubTransaction('Cannot enter a sub-transaction with READWRITE mode when parent transaction is READONLY');
                 }
                 if (parentTransaction) {
-                    storeNames.forEach(storeName => {
-                        if (parentTransaction && parentTransaction.storeNames.indexOf(storeName) === -1) {
+                    storeNames.forEach((storeName) => {
+                        if (parentTransaction &&
+                            parentTransaction.storeNames.indexOf(storeName) === -1) {
                             if (onlyIfCompatible) {
                                 parentTransaction = null;
                             }
                             else
-                                throw new exceptions.SubTransaction("Table " + storeName +
-                                    " not included in parent transaction.");
+                                throw new exceptions.SubTransaction('Table ' + storeName + ' not included in parent transaction.');
                         }
                     });
                 }
-                if (onlyIfCompatible && parentTransaction && !parentTransaction.active) {
+                if (onlyIfCompatible &&
+                    parentTransaction &&
+                    !parentTransaction.active) {
                     parentTransaction = null;
                 }
             }
         }
         catch (e) {
-            return parentTransaction ?
-                parentTransaction._promise(null, (_, reject) => { reject(e); }) :
-                rejection(e);
+            return parentTransaction
+                ? parentTransaction._promise(null, (_, reject) => {
+                    reject(e);
+                })
+                : rejection(e);
         }
         const enterTransaction = enterTransactionScope.bind(null, this, idbMode, storeNames, parentTransaction, scopeFunc);
-        return (parentTransaction ?
-            parentTransaction._promise(idbMode, enterTransaction, "lock") :
-            PSD.trans ?
-                usePSD(PSD.transless, () => this._whenReady(enterTransaction)) :
-                this._whenReady(enterTransaction));
+        return parentTransaction
+            ? parentTransaction._promise(idbMode, enterTransaction, 'lock')
+            : PSD.trans
+                ?
+                    usePSD(PSD.transless, () => this._whenReady(enterTransaction))
+                : this._whenReady(enterTransaction);
     }
     table(tableName) {
         if (!hasOwn(this._allTables, tableName)) {
@@ -5625,15 +6008,15 @@ let Dexie$1 = class Dexie {
     }
 };
 
-const symbolObservable = typeof Symbol !== "undefined" && "observable" in Symbol
+const symbolObservable = typeof Symbol !== 'undefined' && 'observable' in Symbol
     ? Symbol.observable
-    : "@@observable";
+    : '@@observable';
 class Observable {
     constructor(subscribe) {
         this._subscribe = subscribe;
     }
     subscribe(x, error, complete) {
-        return this._subscribe(!x || typeof x === "function" ? { next: x, error, complete } : x);
+        return this._subscribe(!x || typeof x === 'function' ? { next: x, error, complete } : x);
     }
     [symbolObservable]() {
         return this;
@@ -5643,8 +6026,11 @@ class Observable {
 let domDeps;
 try {
     domDeps = {
-        indexedDB: _global.indexedDB || _global.mozIndexedDB || _global.webkitIndexedDB || _global.msIndexedDB,
-        IDBKeyRange: _global.IDBKeyRange || _global.webkitIDBKeyRange
+        indexedDB: _global.indexedDB ||
+            _global.mozIndexedDB ||
+            _global.webkitIndexedDB ||
+            _global.msIndexedDB,
+        IDBKeyRange: _global.IDBKeyRange || _global.webkitIDBKeyRange,
     };
 }
 catch (e) {
@@ -5772,10 +6158,13 @@ props(Dexie, {
         return db.delete();
     },
     exists(name) {
-        return new Dexie(name, { addons: [] }).open().then(db => {
+        return new Dexie(name, { addons: [] })
+            .open()
+            .then((db) => {
             db.close();
             return true;
-        }).catch('NoSuchDatabaseError', () => false);
+        })
+            .catch('NoSuchDatabaseError', () => false);
     },
     getDatabaseNames(cb) {
         try {
@@ -5792,9 +6181,9 @@ props(Dexie, {
         return Class;
     },
     ignoreTransaction(scopeFunc) {
-        return PSD.trans ?
-            usePSD(PSD.transless, scopeFunc) :
-            scopeFunc();
+        return PSD.trans
+            ? usePSD(PSD.transless || globalPSD, scopeFunc)
+            : scopeFunc();
     },
     vip,
     async: function (generatorFn) {
@@ -5822,23 +6211,20 @@ props(Dexie, {
         }
     },
     currentTransaction: {
-        get: () => PSD.trans || null
+        get: () => PSD.trans || null,
     },
     waitFor: function (promiseOrFunction, optionalTimeout) {
-        const promise = DexiePromise.resolve(typeof promiseOrFunction === 'function' ?
-            Dexie.ignoreTransaction(promiseOrFunction) :
-            promiseOrFunction)
-            .timeout(optionalTimeout || 60000);
-        return PSD.trans ?
-            PSD.trans.waitFor(promise) :
-            promise;
+        const promise = DexiePromise.resolve(typeof promiseOrFunction === 'function'
+            ? Dexie.ignoreTransaction(promiseOrFunction)
+            : promiseOrFunction).timeout(optionalTimeout || 60000);
+        return PSD.trans ? PSD.trans.waitFor(promise) : promise;
     },
     Promise: DexiePromise,
     debug: {
         get: () => debug,
-        set: value => {
+        set: (value) => {
             setDebug(value);
-        }
+        },
     },
     derive: derive,
     extend: extend,
@@ -5859,24 +6245,25 @@ props(Dexie, {
     minKey: minKey,
     addons: [],
     connections: {
-        get: connections.toArray
+        get: connections.toArray,
     },
     errnames: errnames,
     dependencies: domDeps,
     cache,
     semVer: DEXIE_VERSION,
     version: DEXIE_VERSION.split('.')
-        .map(n => parseInt(n))
-        .reduce((p, c, i) => p + (c / Math.pow(10, i * 2))),
+        .map((n) => parseInt(n))
+        .reduce((p, c, i) => p + c / Math.pow(10, i * 2)),
 });
 Dexie.maxKey = getMaxKey(Dexie.dependencies.IDBKeyRange);
 
-if (typeof dispatchEvent !== 'undefined' && typeof addEventListener !== 'undefined') {
-    globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, updatedParts => {
+if (typeof dispatchEvent !== 'undefined' &&
+    typeof addEventListener !== 'undefined') {
+    globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, (updatedParts) => {
         if (!propagatingLocally) {
             let event;
             event = new CustomEvent(STORAGE_MUTATED_DOM_EVENT_NAME, {
-                detail: updatedParts
+                detail: updatedParts,
             });
             propagatingLocally = true;
             dispatchEvent(event);
@@ -5907,7 +6294,7 @@ let createBC = () => { };
 if (typeof BroadcastChannel !== 'undefined') {
     createBC = () => {
         bc = new BroadcastChannel(STORAGE_MUTATED_DOM_EVENT_NAME);
-        bc.onmessage = ev => ev.data && propagateLocally(ev.data);
+        bc.onmessage = (ev) => ev.data && propagateLocally(ev.data);
     };
     createBC();
     if (typeof bc.unref === 'function') {