dexie 4.0.1-alpha.8 → 4.0.1-beta.2

package/dist/dexie.js

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 4.0.1-alpha.8, Fri Feb 17 2023
+ * Version 4.0.1-beta.2, Wed Nov 29 2023
  *
  * https://dexie.org
  *
@@ -149,7 +149,7 @@
         }
     }
     function getByKeyPath(obj, keyPath) {
-        if (hasOwn(obj, keyPath))
+        if (typeof keyPath === 'string' && hasOwn(obj, keyPath))
             return obj[keyPath];
         if (!keyPath)
             return obj;
@@ -232,40 +232,54 @@
     function flatten(a) {
         return concat.apply([], a);
     }
-    var intrinsicTypeNames = "Boolean,String,Date,RegExp,Blob,File,FileList,FileSystemFileHandle,FileSystemDirectoryHandle,ArrayBuffer,DataView,Uint8ClampedArray,ImageBitmap,ImageData,Map,Set,CryptoKey"
+    var intrinsicTypeNames = "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(function (num) { return ["Int", "Uint", "Float"].map(function (t) { return t + num + "Array"; }); }))).filter(function (t) { return _global[t]; });
-    var intrinsicTypes = intrinsicTypeNames.map(function (t) { return _global[t]; });
-    arrayToObject(intrinsicTypeNames, function (x) { return [x, true]; });
+    var intrinsicTypes = new Set(intrinsicTypeNames.map(function (t) { return _global[t]; }));
+    function cloneSimpleObjectTree(o) {
+        var rv = {};
+        for (var k in o)
+            if (hasOwn(o, k)) {
+                var v = o[k];
+                rv[k] = !v || typeof v !== 'object' || intrinsicTypes.has(v.constructor) ? v : cloneSimpleObjectTree(v);
+            }
+        return rv;
+    }
+    function objectIsEmpty(o) {
+        for (var k in o)
+            if (hasOwn(o, k))
+                return false;
+        return true;
+    }
     var circularRefs = null;
     function deepClone(any) {
-        circularRefs = typeof WeakMap !== 'undefined' && new WeakMap();
+        circularRefs = new WeakMap();
         var rv = innerDeepClone(any);
         circularRefs = null;
         return rv;
     }
-    function innerDeepClone(any) {
-        if (!any || typeof any !== 'object')
-            return any;
-        var rv = circularRefs && circularRefs.get(any);
+    function innerDeepClone(x) {
+        if (!x || typeof x !== 'object')
+            return x;
+        var rv = circularRefs.get(x);
         if (rv)
             return rv;
-        if (isArray(any)) {
+        if (isArray(x)) {
             rv = [];
-            circularRefs && circularRefs.set(any, rv);
-            for (var i = 0, l = any.length; i < l; ++i) {
-                rv.push(innerDeepClone(any[i]));
+            circularRefs.set(x, rv);
+            for (var i = 0, l = x.length; i < l; ++i) {
+                rv.push(innerDeepClone(x[i]));
             }
         }
-        else if (intrinsicTypes.indexOf(any.constructor) >= 0) {
-            rv = any;
+        else if (intrinsicTypes.has(x.constructor)) {
+            rv = x;
         }
         else {
-            var proto = getProto(any);
+            var proto = getProto(x);
             rv = proto === Object.prototype ? {} : Object.create(proto);
-            circularRefs && circularRefs.set(any, rv);
-            for (var prop in any) {
-                if (hasOwn(any, prop)) {
-                    rv[prop] = innerDeepClone(any[prop]);
+            circularRefs.set(x, rv);
+            for (var prop in x) {
+                if (hasOwn(x, prop)) {
+                    rv[prop] = innerDeepClone(x[prop]);
                 }
             }
         }
@@ -282,6 +296,12 @@
         var i;
         return x != null && (i = x[iteratorSymbol]) && i.apply(x);
     } : function () { return null; };
+    function delArrayItem(a, x) {
+        var i = a.indexOf(x);
+        if (i >= 0)
+            a.splice(i, 1);
+        return i >= 0;
+    }
     var NO_CHAR_ARRAY = {};
     function getArrayOf(arrayLike) {
         var i, a, x, it;
@@ -592,21 +612,9 @@
     var NativePromise = resolvedNativePromise && resolvedNativePromise.constructor;
     var patchGlobalPromise = !!resolvedGlobalPromise;
     var stack_being_generated = false;
-    var schedulePhysicalTick = resolvedGlobalPromise ?
-        function () { resolvedGlobalPromise.then(physicalTick); }
-        :
-            _global.setImmediate ?
-                setImmediate.bind(null, physicalTick) :
-                _global.MutationObserver ?
-                    function () {
-                        var hiddenDiv = document.createElement("div");
-                        (new MutationObserver(function () {
-                            physicalTick();
-                            hiddenDiv = null;
-                        })).observe(hiddenDiv, { attributes: true });
-                        hiddenDiv.setAttribute('i', '1');
-                    } :
-                    function () { setTimeout(physicalTick, 0); };
+    function schedulePhysicalTick() {
+        queueMicrotask(physicalTick);
+    }
     var asap = function (callback, args) {
         microtickQueue.push([callback, args]);
         if (needsNewPhysicalTick) {
@@ -624,17 +632,10 @@
         global: true,
         ref: 0,
         unhandleds: [],
-        onunhandled: globalError,
+        onunhandled: nop,
         pgp: false,
         env: {},
-        finalize: function () {
-            this.unhandleds.forEach(function (uh) {
-                try {
-                    globalError(uh[0], uh[1]);
-                }
-                catch (e) { }
-            });
-        }
+        finalize: nop
     };
     var PSD = globalPSD;
     var microtickQueue = [];
@@ -644,7 +645,6 @@
         if (typeof this !== 'object')
             throw new TypeError('Promises must be constructed via new');
         this._listeners = [];
-        this.onuncatched = nop;
         this._lib = false;
         var psd = (this._PSD = PSD);
         if (debug) {
@@ -711,11 +711,9 @@
         },
         finally: function (onFinally) {
             return this.then(function (value) {
-                onFinally();
-                return value;
+                return DexiePromise.resolve(onFinally()).then(function () { return value; });
             }, function (err) {
-                onFinally();
-                return PromiseReject(err);
+                return DexiePromise.resolve(onFinally()).then(function () { return PromiseReject(err); });
             });
         },
         stack: {
@@ -991,7 +989,9 @@
         }
     }
     function physicalTick() {
-        beginMicroTickScope() && endMicroTickScope();
+        usePSD(globalPSD, function () {
+            beginMicroTickScope() && endMicroTickScope();
+        });
     }
     function beginMicroTickScope() {
         var wasRootExec = isOutsideMicroTick;
@@ -1154,7 +1154,7 @@
     function switchToZone(targetZone, bEnteringZone) {
         var currentZone = PSD;
         if (bEnteringZone ? task.echoes && (!zoneEchoes++ || targetZone !== PSD) : zoneEchoes && (!--zoneEchoes || targetZone !== PSD)) {
-            enqueueNativeMicroTask(bEnteringZone ? zoneEnterEcho.bind(null, targetZone) : zoneLeaveEcho);
+            queueMicrotask(bEnteringZone ? zoneEnterEcho.bind(null, targetZone) : zoneLeaveEcho);
         }
         if (targetZone === PSD)
             return;
@@ -1204,9 +1204,6 @@
             switchToZone(outerScope, false);
         }
     }
-    function enqueueNativeMicroTask(job) {
-        nativePromiseThen.call(resolvedNativePromise, job);
-    }
     function nativeAwaitCompatibleWrap(fn, zone, possibleAwait, cleanup) {
         return typeof fn !== 'function' ? fn : function () {
             var outerZone = PSD;
@@ -1219,7 +1216,7 @@
             finally {
                 switchToZone(outerZone, false);
                 if (cleanup)
-                    enqueueNativeMicroTask(decrementExpectedAwaits);
+                    queueMicrotask(decrementExpectedAwaits);
             }
         };
     }
@@ -1228,39 +1225,6 @@
             return origThen.call(this, nativeAwaitCompatibleWrap(onResolved, zone), nativeAwaitCompatibleWrap(onRejected, zone));
         };
     }
-    var UNHANDLEDREJECTION = "unhandledrejection";
-    function globalError(err, promise) {
-        var rv;
-        try {
-            rv = promise.onuncatched(err);
-        }
-        catch (e) { }
-        if (rv !== false)
-            try {
-                var event, eventData = { promise: promise, reason: err };
-                if (_global.document && document.createEvent) {
-                    event = document.createEvent('Event');
-                    event.initEvent(UNHANDLEDREJECTION, true, true);
-                    extend(event, eventData);
-                }
-                else if (_global.CustomEvent) {
-                    event = new CustomEvent(UNHANDLEDREJECTION, { detail: eventData });
-                    extend(event, eventData);
-                }
-                if (event && _global.dispatchEvent) {
-                    dispatchEvent(event);
-                    if (!_global.PromiseRejectionEvent && _global.onunhandledrejection)
-                        try {
-                            _global.onunhandledrejection(event);
-                        }
-                        catch (_) { }
-                }
-                if (debug && event && !event.defaultPrevented) {
-                    console.warn("Unhandled rejection: ".concat(err.stack || err));
-                }
-            }
-            catch (e) { }
-    }
     var rejection = DexiePromise.reject;
 
     function tempTransaction(db, mode, storeNames, fn) {
@@ -1295,12 +1259,17 @@
                     return fn(resolve, reject, trans);
                 });
             }).then(function (result) {
-                return trans._completion.then(function () { return result; });
+                if (mode === 'readwrite')
+                    try {
+                        trans.idbtrans.commit();
+                    }
+                    catch (_a) { }
+                return mode === 'readonly' ? result : trans._completion.then(function () { return result; });
             });
         }
     }
 
-    var DEXIE_VERSION = '4.0.1-alpha.8';
+    var DEXIE_VERSION = '4.0.1-beta.2';
     var maxString = String.fromCharCode(65535);
     var minKey = -Infinity;
     var INVALID_KEY_ARGUMENT = "Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>.";
@@ -1435,7 +1404,7 @@
             }
             var wasRootExec = beginMicroTickScope();
             try {
-                return trans && trans.db === this.db ?
+                return trans && trans.db._novip === this.db._novip ?
                     trans === PSD.trans ?
                         trans._promise(mode, checkTableInTransaction, writeLocked) :
                         newScope(function () { return trans._promise(mode, checkTableInTransaction, writeLocked); }, { trans: trans, transless: PSD.transless || PSD }) :
@@ -1466,14 +1435,22 @@
                     .where(keyPaths[0])
                     .equals(indexOrCrit[keyPaths[0]]);
             var compoundIndex = this.schema.indexes.concat(this.schema.primKey).filter(function (ix) {
-                return ix.compound &&
-                    keyPaths.every(function (keyPath) { return ix.keyPath.indexOf(keyPath) >= 0; }) &&
-                    ix.keyPath.every(function (keyPath) { return keyPaths.indexOf(keyPath) >= 0; });
-            })[0];
-            if (compoundIndex && this.db._maxKey !== maxString)
+                if (ix.compound &&
+                    keyPaths.every(function (keyPath) { return ix.keyPath.indexOf(keyPath) >= 0; })) {
+                    for (var i = 0; i < keyPaths.length; ++i) {
+                        if (keyPaths.indexOf(ix.keyPath[i]) === -1)
+                            return false;
+                    }
+                    return true;
+                }
+                return false;
+            }).sort(function (a, b) { return a.keyPath.length - b.keyPath.length; })[0];
+            if (compoundIndex && this.db._maxKey !== maxString) {
+                var keyPathsInValidOrder = compoundIndex.keyPath.slice(0, keyPaths.length);
                 return this
-                    .where(compoundIndex.name)
-                    .equals(compoundIndex.keyPath.map(function (kp) { return indexOrCrit[kp]; }));
+                    .where(keyPathsInValidOrder)
+                    .equals(keyPathsInValidOrder.map(function (kp) { return indexOrCrit[kp]; }));
+            }
             if (!compoundIndex && debug)
                 console.warn("The query ".concat(JSON.stringify(indexOrCrit), " on ").concat(this.name, " would benefit of a ") +
                     "compound index [".concat(keyPaths.join('+'), "]"));
@@ -1605,18 +1582,6 @@
                 var key = getByKeyPath(keyOrObject, this.schema.primKey.keyPath);
                 if (key === undefined)
                     return rejection(new exceptions.InvalidArgument("Given object does not contain its primary key"));
-                try {
-                    if (typeof modifications !== "function") {
-                        keys(modifications).forEach(function (keyPath) {
-                            setByKeyPath(keyOrObject, keyPath, modifications[keyPath]);
-                        });
-                    }
-                    else {
-                        modifications(keyOrObject, { value: keyOrObject, primKey: key });
-                    }
-                }
-                catch (_a) {
-                }
                 return this.where(":id").equals(key).modify(modifications);
             }
             else {
@@ -3394,8 +3359,7 @@
             dbcore: dbcore
         };
     }
-    function generateMiddlewareStacks(_a, tmpTrans) {
-        var db = _a._novip;
+    function generateMiddlewareStacks(db, tmpTrans) {
         var idbdb = tmpTrans.db;
         var stacks = createMiddlewareStacks(db._middlewares, idbdb, db._deps, tmpTrans);
         db.core = stacks.dbcore;
@@ -3410,8 +3374,7 @@
         });
     }
 
-    function setApiOnPlace(_a, objs, tableNames, dbschema) {
-        var db = _a._novip;
+    function setApiOnPlace(db, objs, tableNames, dbschema) {
         tableNames.forEach(function (tableName) {
             var schema = dbschema[tableName];
             objs.forEach(function (obj) {
@@ -3432,8 +3395,7 @@
             });
         });
     }
-    function removeTablesApi(_a, objs) {
-        var db = _a._novip;
+    function removeTablesApi(db, objs) {
         objs.forEach(function (obj) {
             for (var key in obj) {
                 if (obj[key] instanceof db.Table)
@@ -3465,8 +3427,7 @@
                 updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans).catch(rejectTransaction);
         });
     }
-    function updateTablesAndIndexes(_a, oldVersion, trans, idbUpgradeTrans) {
-        var db = _a._novip;
+    function updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans) {
         var queue = [];
         var versions = db._versions;
         var globalSchema = db._dbSchema = buildGlobalSchema(db, db.idbdb, idbUpgradeTrans);
@@ -3640,8 +3601,7 @@
         });
         return globalSchema;
     }
-    function readGlobalSchema(_a, idbdb, tmpTrans) {
-        var db = _a._novip;
+    function readGlobalSchema(db, idbdb, tmpTrans) {
         db.verno = idbdb.version / 10;
         var globalSchema = db._dbSchema = buildGlobalSchema(db, idbdb, tmpTrans);
         db._storeNames = slice(idbdb.objectStoreNames, 0);
@@ -3652,8 +3612,7 @@
         var diff = getSchemaDiff(installedSchema, db._dbSchema);
         return !(diff.add.length || diff.change.some(function (ch) { return ch.add.length || ch.change.length; }));
     }
-    function adjustToExistingIndexNames(_a, schema, idbtrans) {
-        var db = _a._novip;
+    function adjustToExistingIndexNames(db, schema, idbtrans) {
         var storeNames = idbtrans.db.objectStoreNames;
         for (var i = 0; i < storeNames.length; ++i) {
             var storeName = storeNames[i];
@@ -3807,6 +3766,237 @@
         }).finally(function () { return clearInterval(intervalId); });
     }
 
+    var _a;
+    function isEmptyRange(node) {
+        return !("from" in node);
+    }
+    var RangeSet = function (fromOrTree, to) {
+        if (this) {
+            extend(this, arguments.length ? { d: 1, from: fromOrTree, to: arguments.length > 1 ? to : fromOrTree } : { d: 0 });
+        }
+        else {
+            var rv = new RangeSet();
+            if (fromOrTree && ("d" in fromOrTree)) {
+                extend(rv, fromOrTree);
+            }
+            return rv;
+        }
+    };
+    props(RangeSet.prototype, (_a = {
+            add: function (rangeSet) {
+                mergeRanges(this, rangeSet);
+                return this;
+            },
+            addKey: function (key) {
+                addRange(this, key, key);
+                return this;
+            },
+            addKeys: function (keys) {
+                var _this = this;
+                keys.forEach(function (key) { return addRange(_this, key, key); });
+                return this;
+            }
+        },
+        _a[iteratorSymbol] = function () {
+            return getRangeSetIterator(this);
+        },
+        _a));
+    function addRange(target, from, to) {
+        var diff = cmp(from, to);
+        if (isNaN(diff))
+            return;
+        if (diff > 0)
+            throw RangeError();
+        if (isEmptyRange(target))
+            return extend(target, { from: from, to: to, d: 1 });
+        var left = target.l;
+        var right = target.r;
+        if (cmp(to, target.from) < 0) {
+            left
+                ? addRange(left, from, to)
+                : (target.l = { from: from, to: to, d: 1, l: null, r: null });
+            return rebalance(target);
+        }
+        if (cmp(from, target.to) > 0) {
+            right
+                ? addRange(right, from, to)
+                : (target.r = { from: from, to: to, d: 1, l: null, r: null });
+            return rebalance(target);
+        }
+        if (cmp(from, target.from) < 0) {
+            target.from = from;
+            target.l = null;
+            target.d = right ? right.d + 1 : 1;
+        }
+        if (cmp(to, target.to) > 0) {
+            target.to = to;
+            target.r = null;
+            target.d = target.l ? target.l.d + 1 : 1;
+        }
+        var rightWasCutOff = !target.r;
+        if (left && !target.l) {
+            mergeRanges(target, left);
+        }
+        if (right && rightWasCutOff) {
+            mergeRanges(target, right);
+        }
+    }
+    function mergeRanges(target, newSet) {
+        function _addRangeSet(target, _a) {
+            var from = _a.from, to = _a.to, l = _a.l, r = _a.r;
+            addRange(target, from, to);
+            if (l)
+                _addRangeSet(target, l);
+            if (r)
+                _addRangeSet(target, r);
+        }
+        if (!isEmptyRange(newSet))
+            _addRangeSet(target, newSet);
+    }
+    function rangesOverlap(rangeSet1, rangeSet2) {
+        var i1 = getRangeSetIterator(rangeSet2);
+        var nextResult1 = i1.next();
+        if (nextResult1.done)
+            return false;
+        var a = nextResult1.value;
+        var i2 = getRangeSetIterator(rangeSet1);
+        var nextResult2 = i2.next(a.from);
+        var b = nextResult2.value;
+        while (!nextResult1.done && !nextResult2.done) {
+            if (cmp(b.from, a.to) <= 0 && cmp(b.to, a.from) >= 0)
+                return true;
+            cmp(a.from, b.from) < 0
+                ? (a = (nextResult1 = i1.next(b.from)).value)
+                : (b = (nextResult2 = i2.next(a.from)).value);
+        }
+        return false;
+    }
+    function getRangeSetIterator(node) {
+        var state = isEmptyRange(node) ? null : { s: 0, n: node };
+        return {
+            next: function (key) {
+                var keyProvided = arguments.length > 0;
+                while (state) {
+                    switch (state.s) {
+                        case 0:
+                            state.s = 1;
+                            if (keyProvided) {
+                                while (state.n.l && cmp(key, state.n.from) < 0)
+                                    state = { up: state, n: state.n.l, s: 1 };
+                            }
+                            else {
+                                while (state.n.l)
+                                    state = { up: state, n: state.n.l, s: 1 };
+                            }
+                        case 1:
+                            state.s = 2;
+                            if (!keyProvided || cmp(key, state.n.to) <= 0)
+                                return { value: state.n, done: false };
+                        case 2:
+                            if (state.n.r) {
+                                state.s = 3;
+                                state = { up: state, n: state.n.r, s: 0 };
+                                continue;
+                            }
+                        case 3:
+                            state = state.up;
+                    }
+                }
+                return { done: true };
+            },
+        };
+    }
+    function rebalance(target) {
+        var _a, _b;
+        var diff = (((_a = target.r) === null || _a === void 0 ? void 0 : _a.d) || 0) - (((_b = target.l) === null || _b === void 0 ? void 0 : _b.d) || 0);
+        var r = diff > 1 ? "r" : diff < -1 ? "l" : "";
+        if (r) {
+            var l = r === "r" ? "l" : "r";
+            var rootClone = __assign({}, target);
+            var oldRootRight = target[r];
+            target.from = oldRootRight.from;
+            target.to = oldRootRight.to;
+            target[r] = oldRootRight[r];
+            rootClone[r] = oldRootRight[l];
+            target[l] = rootClone;
+            rootClone.d = computeDepth(rootClone);
+        }
+        target.d = computeDepth(target);
+    }
+    function computeDepth(_a) {
+        var r = _a.r, l = _a.l;
+        return (r ? (l ? Math.max(r.d, l.d) : r.d) : l ? l.d : 0) + 1;
+    }
+
+    function extendObservabilitySet(target, newSet) {
+        keys(newSet).forEach(function (part) {
+            if (target[part])
+                mergeRanges(target[part], newSet[part]);
+            else
+                target[part] = cloneSimpleObjectTree(newSet[part]);
+        });
+        return target;
+    }
+
+    function obsSetsOverlap(os1, os2) {
+        return Object.keys(os1).some(function (key) { return os2[key] && rangesOverlap(os2[key], os1[key]); });
+    }
+
+    var cache = {};
+
+    var unsignaledParts = {};
+    var isTaskEnqueued = false;
+    function signalSubscribersLazily(part) {
+        extendObservabilitySet(unsignaledParts, part);
+        if (!isTaskEnqueued) {
+            isTaskEnqueued = true;
+            setTimeout(function () {
+                isTaskEnqueued = false;
+                var parts = unsignaledParts;
+                unsignaledParts = {};
+                signalSubscribersNow(parts);
+            }, 0);
+        }
+    }
+    function signalSubscribersNow(updatedParts, deleteAffectedCacheEntries) {
+        if (deleteAffectedCacheEntries === void 0) { deleteAffectedCacheEntries = false; }
+        var queriesToSignal = new Set();
+        for (var key in updatedParts) {
+            var parts = /^idb\:\/\/(.*)\/(.*)\//.exec(key);
+            if (parts) {
+                var dbName = parts[1], tableName = parts[2];
+                var tblCache = cache["idb://".concat(dbName, "/").concat(tableName)];
+                if (tblCache)
+                    signalTableSubscribersNow(tblCache, updatedParts, queriesToSignal, deleteAffectedCacheEntries);
+            }
+        }
+        queriesToSignal.forEach(function (requery) { return requery(); });
+    }
+    function signalTableSubscribersNow(tblCache, updatedParts, outQueriesToSignal, deleteAffectedCacheEntries) {
+        var updatedEntryLists = deleteAffectedCacheEntries && [];
+        for (var _i = 0, _a = Object.entries(tblCache.queries.query); _i < _a.length; _i++) {
+            var _b = _a[_i], indexName = _b[0], entries = _b[1];
+            var filteredEntries = deleteAffectedCacheEntries && [];
+            for (var _c = 0, entries_1 = entries; _c < entries_1.length; _c++) {
+                var entry = entries_1[_c];
+                if (entry.obsSet && obsSetsOverlap(updatedParts, entry.obsSet)) {
+                    entry.subscribers.forEach(function (requery) { return outQueriesToSignal.add(requery); });
+                }
+                else if (deleteAffectedCacheEntries) {
+                    filteredEntries.push(entry);
+                }
+            }
+            if (deleteAffectedCacheEntries)
+                updatedEntryLists.push([indexName, filteredEntries]);
+        }
+        if (deleteAffectedCacheEntries) {
+            for (var _d = 0, updatedEntryLists_1 = updatedEntryLists; _d < updatedEntryLists_1.length; _d++) {
+                var _e = updatedEntryLists_1[_d], indexName = _e[0], filteredEntries = _e[1];
+                tblCache.queries.query[indexName] = filteredEntries;
+            }
+        }
+    }
+
     function dexieOpen(db) {
         var state = db._state;
         var indexedDB = db._deps.indexedDB;
@@ -3825,69 +4015,82 @@
         }
         var resolveDbReady = state.dbReadyResolve,
         upgradeTransaction = null, wasCreated = false;
-        return DexiePromise.race([openCanceller, (typeof navigator === 'undefined' ? DexiePromise.resolve() : idbReady()).then(function () { return new DexiePromise(function (resolve, reject) {
-                throwIfCancelled();
-                if (!indexedDB)
-                    throw new exceptions.MissingAPI();
-                var dbName = db.name;
-                var req = state.autoSchema ?
-                    indexedDB.open(dbName) :
-                    indexedDB.open(dbName, Math.round(db.verno * 10));
-                if (!req)
-                    throw new exceptions.MissingAPI();
-                req.onerror = eventRejectHandler(reject);
-                req.onblocked = wrap(db._fireOnBlocked);
-                req.onupgradeneeded = wrap(function (e) {
-                    upgradeTransaction = req.transaction;
-                    if (state.autoSchema && !db._options.allowEmptyDB) {
-                        req.onerror = preventDefault;
-                        upgradeTransaction.abort();
-                        req.result.close();
-                        var delreq = indexedDB.deleteDatabase(dbName);
-                        delreq.onsuccess = delreq.onerror = wrap(function () {
-                            reject(new exceptions.NoSuchDatabase("Database ".concat(dbName, " doesnt exist")));
-                        });
-                    }
-                    else {
-                        upgradeTransaction.onerror = eventRejectHandler(reject);
-                        var oldVer = e.oldVersion > Math.pow(2, 62) ? 0 : e.oldVersion;
-                        wasCreated = oldVer < 1;
-                        db._novip.idbdb = req.result;
-                        runUpgraders(db, oldVer / 10, upgradeTransaction, reject);
-                    }
-                }, reject);
-                req.onsuccess = wrap(function () {
-                    upgradeTransaction = null;
-                    var idbdb = db._novip.idbdb = req.result;
-                    var objectStoreNames = slice(idbdb.objectStoreNames);
-                    if (objectStoreNames.length > 0)
-                        try {
-                            var tmpTrans = idbdb.transaction(safariMultiStoreFix(objectStoreNames), 'readonly');
-                            if (state.autoSchema)
-                                readGlobalSchema(db, idbdb, tmpTrans);
-                            else {
-                                adjustToExistingIndexNames(db, db._dbSchema, tmpTrans);
-                                if (!verifyInstalledSchema(db, tmpTrans)) {
-                                    console.warn("Dexie SchemaDiff: Schema was extended without increasing the number passed to db.version(). Some queries may fail.");
-                                }
+        var tryOpenDB = function () { return new DexiePromise(function (resolve, reject) {
+            throwIfCancelled();
+            if (!indexedDB)
+                throw new exceptions.MissingAPI();
+            var dbName = db.name;
+            var req = state.autoSchema ?
+                indexedDB.open(dbName) :
+                indexedDB.open(dbName, Math.round(db.verno * 10));
+            if (!req)
+                throw new exceptions.MissingAPI();
+            req.onerror = eventRejectHandler(reject);
+            req.onblocked = wrap(db._fireOnBlocked);
+            req.onupgradeneeded = wrap(function (e) {
+                upgradeTransaction = req.transaction;
+                if (state.autoSchema && !db._options.allowEmptyDB) {
+                    req.onerror = preventDefault;
+                    upgradeTransaction.abort();
+                    req.result.close();
+                    var delreq = indexedDB.deleteDatabase(dbName);
+                    delreq.onsuccess = delreq.onerror = wrap(function () {
+                        reject(new exceptions.NoSuchDatabase("Database ".concat(dbName, " doesnt exist")));
+                    });
+                }
+                else {
+                    upgradeTransaction.onerror = eventRejectHandler(reject);
+                    var oldVer = e.oldVersion > Math.pow(2, 62) ? 0 : e.oldVersion;
+                    wasCreated = oldVer < 1;
+                    db.idbdb = req.result;
+                    runUpgraders(db, oldVer / 10, upgradeTransaction, reject);
+                }
+            }, reject);
+            req.onsuccess = wrap(function () {
+                upgradeTransaction = null;
+                var idbdb = db.idbdb = req.result;
+                var objectStoreNames = slice(idbdb.objectStoreNames);
+                if (objectStoreNames.length > 0)
+                    try {
+                        var tmpTrans = idbdb.transaction(safariMultiStoreFix(objectStoreNames), 'readonly');
+                        if (state.autoSchema)
+                            readGlobalSchema(db, idbdb, tmpTrans);
+                        else {
+                            adjustToExistingIndexNames(db, db._dbSchema, tmpTrans);
+                            if (!verifyInstalledSchema(db, tmpTrans)) {
+                                console.warn("Dexie SchemaDiff: Schema was extended without increasing the number passed to db.version(). Some queries may fail.");
                             }
-                            generateMiddlewareStacks(db, tmpTrans);
                         }
-                        catch (e) {
-                        }
-                    connections.push(db);
-                    idbdb.onversionchange = wrap(function (ev) {
-                        state.vcFired = true;
-                        db.on("versionchange").fire(ev);
-                    });
-                    idbdb.onclose = wrap(function (ev) {
-                        db.on("close").fire(ev);
-                    });
-                    if (wasCreated)
-                        _onDatabaseCreated(db._deps, dbName);
-                    resolve();
-                }, reject);
-            }); })]).then(function () {
+                        generateMiddlewareStacks(db, tmpTrans);
+                    }
+                    catch (e) {
+                    }
+                connections.push(db);
+                idbdb.onversionchange = wrap(function (ev) {
+                    state.vcFired = true;
+                    db.on("versionchange").fire(ev);
+                });
+                idbdb.onclose = wrap(function (ev) {
+                    db.on("close").fire(ev);
+                });
+                if (wasCreated)
+                    _onDatabaseCreated(db._deps, dbName);
+                resolve();
+            }, reject);
+        }).catch(function (err) {
+            if (err && err.name === 'UnknownError' && state.PR1398_maxLoop > 0) {
+                state.PR1398_maxLoop--;
+                console.warn('Dexie: Workaround for Chrome UnknownError on open()');
+                return tryOpenDB();
+            }
+            else {
+                return DexiePromise.reject(err);
+            }
+        }); };
+        return DexiePromise.race([
+            openCanceller,
+            (typeof navigator === 'undefined' ? DexiePromise.resolve() : idbReady()).then(tryOpenDB)
+        ]).then(function () {
             throwIfCancelled();
             state.onReadyBeingFired = [];
             return DexiePromise.resolve(vip(function () { return db.on.ready.fire(db.vip); })).then(function fireRemainders() {
@@ -3898,10 +4101,10 @@
                 }
             });
         }).finally(function () {
-            state.onReadyBeingFired = null;
-            state.isBeingOpened = false;
-        }).then(function () {
-            return db;
+            if (state.openCanceller === openCanceller) {
+                state.onReadyBeingFired = null;
+                state.isBeingOpened = false;
+            }
         }).catch(function (err) {
             state.dbOpenError = err;
             try {
@@ -3915,6 +4118,20 @@
         }).finally(function () {
             state.openComplete = true;
             resolveDbReady();
+        }).then(function () {
+            if (wasCreated) {
+                var everything_1 = {};
+                db.tables.forEach(function (table) {
+                    table.schema.indexes.forEach(function (idx) {
+                        if (idx.name)
+                            everything_1["idb://".concat(db.name, "/").concat(table.name, "/").concat(idx.name)] = new RangeSet(-Infinity, [[[]]]);
+                    });
+                    everything_1["idb://".concat(db.name, "/").concat(table.name, "/")] = everything_1["idb://".concat(db.name, "/").concat(table.name, "/:dels")] = new RangeSet(-Infinity, [[[]]]);
+                });
+                globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME).fire(everything_1);
+                signalSubscribersNow(everything_1, true);
+            }
+            return db;
         });
     }
 
@@ -3947,6 +4164,7 @@
         return DexiePromise.resolve().then(function () {
             var transless = PSD.transless || PSD;
             var trans = db._createTransaction(mode, storeNames, db._dbSchema, parentTransaction);
+            trans.explicit = true;
             var zoneProps = {
                 trans: trans,
                 transless: transless
@@ -4017,7 +4235,9 @@
                     var indexList = (indexLookup[keyPathAlias] = indexLookup[keyPathAlias] || []);
                     var keyLength = keyPath == null ? 0 : typeof keyPath === 'string' ? 1 : keyPath.length;
                     var isVirtual = keyTail > 0;
-                    var virtualIndex = __assign(__assign({}, lowLevelIndex), { isVirtual: isVirtual, keyTail: keyTail, keyLength: keyLength, extractKey: getKeyExtractor(keyPath), unique: !isVirtual && lowLevelIndex.unique });
+                    var virtualIndex = __assign(__assign({}, lowLevelIndex), { name: isVirtual
+                            ? "".concat(keyPathAlias, "(virtual-from:").concat(lowLevelIndex.name, ")")
+                            : lowLevelIndex.name, lowLevelIndex: lowLevelIndex, isVirtual: isVirtual, keyTail: keyTail, keyLength: keyLength, extractKey: getKeyExtractor(keyPath), unique: !isVirtual && lowLevelIndex.unique });
                     indexList.push(virtualIndex);
                     if (!virtualIndex.isPrimaryKey) {
                         allVirtualIndexes.push(virtualIndex);
@@ -4055,7 +4275,7 @@
                 function translateRequest(req) {
                     var index = req.query.index;
                     return index.isVirtual ? __assign(__assign({}, req), { query: {
-                            index: index,
+                            index: index.lowLevelIndex,
                             range: translateRange(req.query.range, index.keyTail)
                         } }) : req;
                 }
@@ -4334,182 +4554,49 @@
         },
     };
 
-    var _a;
-    function isEmptyRange(node) {
-        return !("from" in node);
-    }
-    var RangeSet = function (fromOrTree, to) {
-        if (this) {
-            extend(this, arguments.length ? { d: 1, from: fromOrTree, to: arguments.length > 1 ? to : fromOrTree } : { d: 0 });
-        }
-        else {
-            var rv = new RangeSet();
-            if (fromOrTree && ("d" in fromOrTree)) {
-                extend(rv, fromOrTree);
-            }
-            return rv;
-        }
-    };
-    props(RangeSet.prototype, (_a = {
-            add: function (rangeSet) {
-                mergeRanges(this, rangeSet);
-                return this;
-            },
-            addKey: function (key) {
-                addRange(this, key, key);
-                return this;
-            },
-            addKeys: function (keys) {
-                var _this = this;
-                keys.forEach(function (key) { return addRange(_this, key, key); });
-                return this;
-            }
-        },
-        _a[iteratorSymbol] = function () {
-            return getRangeSetIterator(this);
-        },
-        _a));
-    function addRange(target, from, to) {
-        var diff = cmp(from, to);
-        if (isNaN(diff))
-            return;
-        if (diff > 0)
-            throw RangeError();
-        if (isEmptyRange(target))
-            return extend(target, { from: from, to: to, d: 1 });
-        var left = target.l;
-        var right = target.r;
-        if (cmp(to, target.from) < 0) {
-            left
-                ? addRange(left, from, to)
-                : (target.l = { from: from, to: to, d: 1, l: null, r: null });
-            return rebalance(target);
-        }
-        if (cmp(from, target.to) > 0) {
-            right
-                ? addRange(right, from, to)
-                : (target.r = { from: from, to: to, d: 1, l: null, r: null });
-            return rebalance(target);
-        }
-        if (cmp(from, target.from) < 0) {
-            target.from = from;
-            target.l = null;
-            target.d = right ? right.d + 1 : 1;
-        }
-        if (cmp(to, target.to) > 0) {
-            target.to = to;
-            target.r = null;
-            target.d = target.l ? target.l.d + 1 : 1;
-        }
-        var rightWasCutOff = !target.r;
-        if (left && !target.l) {
-            mergeRanges(target, left);
-        }
-        if (right && rightWasCutOff) {
-            mergeRanges(target, right);
-        }
+    function isCachableContext(ctx, table) {
+        return (ctx.trans.mode === 'readonly' &&
+            !!ctx.subscr &&
+            !ctx.trans.explicit &&
+            ctx.trans.db._options.cache !== 'disabled' &&
+            !table.schema.primaryKey.outbound);
     }
-    function mergeRanges(target, newSet) {
-        function _addRangeSet(target, _a) {
-            var from = _a.from, to = _a.to, l = _a.l, r = _a.r;
-            addRange(target, from, to);
-            if (l)
-                _addRangeSet(target, l);
-            if (r)
-                _addRangeSet(target, r);
-        }
-        if (!isEmptyRange(newSet))
-            _addRangeSet(target, newSet);
-    }
-    function rangesOverlap(rangeSet1, rangeSet2) {
-        var i1 = getRangeSetIterator(rangeSet2);
-        var nextResult1 = i1.next();
-        if (nextResult1.done)
-            return false;
-        var a = nextResult1.value;
-        var i2 = getRangeSetIterator(rangeSet1);
-        var nextResult2 = i2.next(a.from);
-        var b = nextResult2.value;
-        while (!nextResult1.done && !nextResult2.done) {
-            if (cmp(b.from, a.to) <= 0 && cmp(b.to, a.from) >= 0)
-                return true;
-            cmp(a.from, b.from) < 0
-                ? (a = (nextResult1 = i1.next(b.from)).value)
-                : (b = (nextResult2 = i2.next(a.from)).value);
-        }
-        return false;
-    }
-    function getRangeSetIterator(node) {
-        var state = isEmptyRange(node) ? null : { s: 0, n: node };
-        return {
-            next: function (key) {
-                var keyProvided = arguments.length > 0;
-                while (state) {
-                    switch (state.s) {
-                        case 0:
-                            state.s = 1;
-                            if (keyProvided) {
-                                while (state.n.l && cmp(key, state.n.from) < 0)
-                                    state = { up: state, n: state.n.l, s: 1 };
-                            }
-                            else {
-                                while (state.n.l)
-                                    state = { up: state, n: state.n.l, s: 1 };
-                            }
-                        case 1:
-                            state.s = 2;
-                            if (!keyProvided || cmp(key, state.n.to) <= 0)
-                                return { value: state.n, done: false };
-                        case 2:
-                            if (state.n.r) {
-                                state.s = 3;
-                                state = { up: state, n: state.n.r, s: 0 };
-                                continue;
-                            }
-                        case 3:
-                            state = state.up;
-                    }
-                }
-                return { done: true };
-            },
-        };
-    }
-    function rebalance(target) {
-        var _a, _b;
-        var diff = (((_a = target.r) === null || _a === void 0 ? void 0 : _a.d) || 0) - (((_b = target.l) === null || _b === void 0 ? void 0 : _b.d) || 0);
-        var r = diff > 1 ? "r" : diff < -1 ? "l" : "";
-        if (r) {
-            var l = r === "r" ? "l" : "r";
-            var rootClone = __assign({}, target);
-            var oldRootRight = target[r];
-            target.from = oldRootRight.from;
-            target.to = oldRootRight.to;
-            target[r] = oldRootRight[r];
-            rootClone[r] = oldRootRight[l];
-            target[l] = rootClone;
-            rootClone.d = computeDepth(rootClone);
+
+    function isCachableRequest(type, req) {
+        switch (type) {
+            case 'query':
+                return req.values && !req.unique;
+            case 'get':
+                return false;
+            case 'getMany':
+                return false;
+            case 'count':
+                return false;
+            case 'openCursor':
+                return false;
         }
-        target.d = computeDepth(target);
-    }
-    function computeDepth(_a) {
-        var r = _a.r, l = _a.l;
-        return (r ? (l ? Math.max(r.d, l.d) : r.d) : l ? l.d : 0) + 1;
     }
 
     var observabilityMiddleware = {
         stack: "dbcore",
         level: 0,
+        name: "Observability",
         create: function (core) {
             var dbName = core.schema.name;
             var FULL_RANGE = new RangeSet(core.MIN_KEY, core.MAX_KEY);
-            return __assign(__assign({}, core), { table: function (tableName) {
+            return __assign(__assign({}, core), { transaction: function (stores, mode, options) {
+                    if (PSD.subscr && mode !== 'readonly') {
+                        throw new exceptions.ReadOnly("Readwrite transaction in liveQuery context. Querier source: ".concat(PSD.querier));
+                    }
+                    return core.transaction(stores, mode, options);
+                }, table: function (tableName) {
                     var table = core.table(tableName);
                     var schema = table.schema;
                     var primaryKey = schema.primaryKey;
                     var extractKey = primaryKey.extractKey, outbound = primaryKey.outbound;
                     var tableClone = __assign(__assign({}, table), { mutate: function (req) {
                             var trans = req.trans;
-                            var mutatedParts = trans.mutatedParts || (trans.mutatedParts = {});
+                            var mutatedParts = req.mutatedParts || (req.mutatedParts = {});
                             var getRangeSet = function (indexName) {
                                 var part = "idb://".concat(dbName, "/").concat(tableName, "/").concat(indexName);
                                 return (mutatedParts[part] ||
@@ -4523,32 +4610,34 @@
                                 : req.type === "delete"
                                     ? [req.keys]
                                     : req.values.length < 50
-                                        ? [[], req.values]
+                                        ? [getEffectiveKeys(primaryKey, req).filter(function (id) { return id; }), req.values]
                                         : [], keys = _a[0], newObjs = _a[1];
                             var oldCache = req.trans["_cache"];
-                            return table.mutate(req).then(function (res) {
-                                if (isArray(keys)) {
-                                    if (type !== "delete")
-                                        keys = res.results;
-                                    pkRangeSet.addKeys(keys);
-                                    var oldObjs = getFromTransactionCache(keys, oldCache);
-                                    if (!oldObjs && type !== "add") {
-                                        delsRangeSet.addKeys(keys);
-                                    }
-                                    if (oldObjs || newObjs) {
-                                        trackAffectedIndexes(getRangeSet, schema, oldObjs, newObjs);
-                                    }
+                            if (isArray(keys)) {
+                                pkRangeSet.addKeys(keys);
+                                var oldObjs = type === 'delete' || keys.length === newObjs.length ? getFromTransactionCache(keys, oldCache) : null;
+                                if (!oldObjs && type !== "add") {
+                                    delsRangeSet.addKeys(keys);
                                 }
-                                else if (keys) {
-                                    var range = { from: keys.lower, to: keys.upper };
-                                    delsRangeSet.add(range);
-                                    pkRangeSet.add(range);
+                                if (oldObjs || newObjs) {
+                                    trackAffectedIndexes(getRangeSet, schema, oldObjs, newObjs);
                                 }
-                                else {
-                                    pkRangeSet.add(FULL_RANGE);
-                                    delsRangeSet.add(FULL_RANGE);
-                                    schema.indexes.forEach(function (idx) { return getRangeSet(idx.name).add(FULL_RANGE); });
+                            }
+                            else if (keys) {
+                                var range = { from: keys.lower, to: keys.upper };
+                                delsRangeSet.add(range);
+                                pkRangeSet.add(range);
+                            }
+                            else {
+                                pkRangeSet.add(FULL_RANGE);
+                                delsRangeSet.add(FULL_RANGE);
+                                schema.indexes.forEach(function (idx) { return getRangeSet(idx.name).add(FULL_RANGE); });
+                            }
+                            return table.mutate(req).then(function (res) {
+                                if (keys && (req.type === 'add' || req.type === 'put')) {
+                                    pkRangeSet.addKeys(res.results);
                                 }
+                                trans.mutatedParts = extendObservabilitySet(trans.mutatedParts || {}, mutatedParts);
                                 return res;
                             });
                         } });
@@ -4570,11 +4659,16 @@
                     keys(readSubscribers).forEach(function (method) {
                         tableClone[method] = function (req) {
                             var subscr = PSD.subscr;
-                            if (subscr) {
+                            var isLiveQuery = !!subscr;
+                            var cachable = isCachableContext(PSD, table) && isCachableRequest(method, req);
+                            var obsSet = cachable
+                                ? req.obsSet = {}
+                                : subscr;
+                            if (isLiveQuery) {
                                 var getRangeSet = function (indexName) {
                                     var part = "idb://".concat(dbName, "/").concat(tableName, "/").concat(indexName);
-                                    return (subscr[part] ||
-                                        (subscr[part] = new RangeSet()));
+                                    return (obsSet[part] ||
+                                        (obsSet[part] = new RangeSet()));
                                 };
                                 var pkRangeSet_1 = getRangeSet("");
                                 var delsRangeSet_1 = getRangeSet(":dels");
@@ -4669,6 +4763,409 @@
         schema.indexes.forEach(addAffectedIndex);
     }
 
+    function adjustOptimisticFromFailures(tblCache, req, res) {
+        if (res.numFailures === 0)
+            return req;
+        if (req.type === 'deleteRange') {
+            return null;
+        }
+        var numBulkOps = req.keys
+            ? req.keys.length
+            : 'values' in req && req.values
+                ? req.values.length
+                : 1;
+        if (res.numFailures === numBulkOps) {
+            return null;
+        }
+        var clone = __assign({}, req);
+        if (isArray(clone.keys)) {
+            clone.keys = clone.keys.filter(function (_, i) { return !(i in res.failures); });
+        }
+        if ('values' in clone && isArray(clone.values)) {
+            clone.values = clone.values.filter(function (_, i) { return !(i in res.failures); });
+        }
+        return clone;
+    }
+
+    function isAboveLower(key, range) {
+        return range.lower === undefined
+            ? true
+            : range.lowerOpen
+                ? cmp(key, range.lower) > 0
+                : cmp(key, range.lower) >= 0;
+    }
+    function isBelowUpper(key, range) {
+        return range.upper === undefined
+            ? true
+            : range.upperOpen
+                ? cmp(key, range.upper) < 0
+                : cmp(key, range.upper) <= 0;
+    }
+    function isWithinRange(key, range) {
+        return isAboveLower(key, range) && isBelowUpper(key, range);
+    }
+
+    function applyOptimisticOps(result, req, ops, table, cacheEntry, immutable) {
+        if (!ops || ops.length === 0)
+            return result;
+        var index = req.query.index;
+        var primaryKey = table.schema.primaryKey;
+        var extractPrimKey = primaryKey.extractKey;
+        var extractIndex = index.extractKey;
+        var extractLowLevelIndex = (index.lowLevelIndex || index).extractKey;
+        var finalResult = ops.reduce(function (result, op) {
+            var modifedResult = result;
+            var includedValues = op.type === 'add' || op.type === 'put'
+                ? op.values.filter(function (v) {
+                    return isWithinRange(extractIndex(v), req.query.range);
+                }).map(function (v) {
+                    v = deepClone(v);
+                    if (immutable)
+                        Object.freeze(v);
+                    return v;
+                })
+                : [];
+            switch (op.type) {
+                case 'add':
+                    modifedResult = result.concat(req.values
+                        ? includedValues
+                        : includedValues.map(function (v) { return extractPrimKey(v); }));
+                    break;
+                case 'put':
+                    var keySet_1 = new RangeSet().addKeys(op.values.map(function (v) { return extractPrimKey(v); }));
+                    modifedResult = result
+                        .filter(function (item) {
+                        var key = req.values ? extractPrimKey(item) : item;
+                        return !rangesOverlap(new RangeSet(key), keySet_1);
+                    })
+                        .concat(req.values
+                        ? includedValues
+                        : includedValues.map(function (v) { return extractPrimKey(v); }));
+                    break;
+                case 'delete':
+                    var keysToDelete_1 = new RangeSet().addKeys(op.keys);
+                    modifedResult = result.filter(function (item) {
+                        var key = req.values ? extractPrimKey(item) : item;
+                        return !rangesOverlap(new RangeSet(key), keysToDelete_1);
+                    });
+                    break;
+                case 'deleteRange':
+                    var range_1 = op.range;
+                    modifedResult = result.filter(function (item) { return !isWithinRange(extractPrimKey(item), range_1); });
+                    break;
+            }
+            return modifedResult;
+        }, result);
+        if (finalResult === result)
+            return result;
+        finalResult.sort(function (a, b) {
+            return cmp(extractLowLevelIndex(a), extractLowLevelIndex(b)) ||
+                cmp(extractPrimKey(a), extractPrimKey(b));
+        });
+        if (req.limit && req.limit < Infinity) {
+            if (finalResult.length > req.limit) {
+                finalResult.length = req.limit;
+            }
+            else if (result.length === req.limit && finalResult.length < req.limit) {
+                cacheEntry.dirty = true;
+            }
+        }
+        return immutable ? Object.freeze(finalResult) : finalResult;
+    }
+
+    function areRangesEqual(r1, r2) {
+        return (cmp(r1.lower, r2.lower) === 0 &&
+            cmp(r1.upper, r2.upper) === 0 &&
+            !!r1.lowerOpen === !!r2.lowerOpen &&
+            !!r1.upperOpen === !!r2.upperOpen);
+    }
+
+    function compareLowers(lower1, lower2, lowerOpen1, lowerOpen2) {
+        if (lower1 === undefined)
+            return lower2 !== undefined ? -1 : 0;
+        if (lower2 === undefined)
+            return 1;
+        var c = cmp(lower1, lower2);
+        if (c === 0) {
+            if (lowerOpen1 && lowerOpen2)
+                return 0;
+            if (lowerOpen1)
+                return 1;
+            if (lowerOpen2)
+                return -1;
+        }
+        return c;
+    }
+    function compareUppers(upper1, upper2, upperOpen1, upperOpen2) {
+        if (upper1 === undefined)
+            return upper2 !== undefined ? 1 : 0;
+        if (upper2 === undefined)
+            return -1;
+        var c = cmp(upper1, upper2);
+        if (c === 0) {
+            if (upperOpen1 && upperOpen2)
+                return 0;
+            if (upperOpen1)
+                return -1;
+            if (upperOpen2)
+                return 1;
+        }
+        return c;
+    }
+    function isSuperRange(r1, r2) {
+        return (compareLowers(r1.lower, r2.lower, r1.lowerOpen, r2.lowerOpen) <= 0 &&
+            compareUppers(r1.upper, r2.upper, r1.upperOpen, r2.upperOpen) >= 0);
+    }
+
+    function findCompatibleQuery(dbName, tableName, type, req) {
+        var tblCache = cache["idb://".concat(dbName, "/").concat(tableName)];
+        if (!tblCache)
+            return [];
+        var queries = tblCache.queries[type];
+        if (!queries)
+            return [null, false, tblCache, null];
+        var indexName = req.query ? req.query.index.name : null;
+        var entries = queries[indexName || ''];
+        if (!entries)
+            return [null, false, tblCache, null];
+        switch (type) {
+            case 'query':
+                var equalEntry = entries.find(function (entry) {
+                    return entry.req.limit === req.limit &&
+                        entry.req.values === req.values &&
+                        areRangesEqual(entry.req.query.range, req.query.range);
+                });
+                if (equalEntry)
+                    return [
+                        equalEntry,
+                        true,
+                        tblCache,
+                        entries,
+                    ];
+                var superEntry = entries.find(function (entry) {
+                    var limit = 'limit' in entry.req ? entry.req.limit : Infinity;
+                    return (limit >= req.limit &&
+                        (req.values ? entry.req.values : true) &&
+                        isSuperRange(entry.req.query.range, req.query.range));
+                });
+                return [superEntry, false, tblCache, entries];
+            case 'count':
+                var countQuery = entries.find(function (entry) {
+                    return areRangesEqual(entry.req.query.range, req.query.range);
+                });
+                return [countQuery, !!countQuery, tblCache, entries];
+        }
+    }
+
+    function subscribeToCacheEntry(cacheEntry, container, requery, signal) {
+        cacheEntry.subscribers.add(requery);
+        signal.addEventListener("abort", function () {
+            cacheEntry.subscribers.delete(requery);
+            if (cacheEntry.subscribers.size === 0) {
+                enqueForDeletion(cacheEntry, container);
+            }
+        });
+    }
+    function enqueForDeletion(cacheEntry, container) {
+        setTimeout(function () {
+            if (cacheEntry.subscribers.size === 0) {
+                delArrayItem(container, cacheEntry);
+            }
+        }, 3000);
+    }
+
+    var cacheMiddleware = {
+        stack: 'dbcore',
+        level: 0,
+        name: 'Cache',
+        create: function (core) {
+            var dbName = core.schema.name;
+            var coreMW = __assign(__assign({}, core), { transaction: function (stores, mode, options) {
+                    var idbtrans = core.transaction(stores, mode, options);
+                    if (mode === 'readwrite') {
+                        var ac_1 = new AbortController();
+                        var signal = ac_1.signal;
+                        var endTransaction = function (wasCommitted) { return function () {
+                            ac_1.abort();
+                            if (mode === 'readwrite') {
+                                var affectedSubscribers_1 = new Set();
+                                for (var _i = 0, stores_1 = stores; _i < stores_1.length; _i++) {
+                                    var storeName = stores_1[_i];
+                                    var tblCache = cache["idb://".concat(dbName, "/").concat(storeName)];
+                                    var table = core.table(storeName);
+                                    if (tblCache) {
+                                        var ops = tblCache.optimisticOps.filter(function (op) { return op.trans === idbtrans; });
+                                        if (ops.length > 0) {
+                                            tblCache.optimisticOps = tblCache.optimisticOps.filter(function (op) { return op.trans !== idbtrans; });
+                                            for (var _a = 0, _b = Object.values(tblCache.queries.query); _a < _b.length; _a++) {
+                                                var entries = _b[_a];
+                                                for (var _c = 0, _d = entries.slice(); _c < _d.length; _c++) {
+                                                    var entry = _d[_c];
+                                                    if (entry.res != null &&
+                                                        idbtrans.mutatedParts
+    ) {
+                                                        if (wasCommitted && !entry.dirty) {
+                                                            var freezeResults = Object.isFrozen(entry.res);
+                                                            var modRes = applyOptimisticOps(entry.res, entry.req, ops, table, entry, freezeResults);
+                                                            if (entry.dirty) {
+                                                                delArrayItem(entries, entry);
+                                                                entry.subscribers.forEach(function (requery) { return affectedSubscribers_1.add(requery); });
+                                                            }
+                                                            else if (modRes !== entry.res) {
+                                                                entry.res = modRes;
+                                                                entry.promise = DexiePromise.resolve({ result: modRes });
+                                                            }
+                                                        }
+                                                        else {
+                                                            if (entry.dirty) {
+                                                                delArrayItem(entries, entry);
+                                                            }
+                                                            entry.subscribers.forEach(function (requery) { return affectedSubscribers_1.add(requery); });
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                affectedSubscribers_1.forEach(function (requery) { return requery(); });
+                            }
+                        }; };
+                        idbtrans.addEventListener('abort', endTransaction(false), {
+                            signal: signal,
+                        });
+                        idbtrans.addEventListener('error', endTransaction(false), {
+                            signal: signal,
+                        });
+                        idbtrans.addEventListener('complete', endTransaction(true), {
+                            signal: signal,
+                        });
+                    }
+                    return idbtrans;
+                }, table: function (tableName) {
+                    var downTable = core.table(tableName);
+                    var primKey = downTable.schema.primaryKey;
+                    var tableMW = __assign(__assign({}, downTable), { mutate: function (req) {
+                            if (primKey.outbound ||
+                                PSD.trans.db._options.cache === 'disabled'
+                            ) {
+                                return downTable.mutate(req);
+                            }
+                            var tblCache = cache["idb://".concat(dbName, "/").concat(tableName)];
+                            if (!tblCache)
+                                return downTable.mutate(req);
+                            var promise = downTable.mutate(req);
+                            if ((req.type === 'add' || req.type === 'put') && (req.values.length >= 50 || getEffectiveKeys(primKey, req).some(function (key) { return key == null; }))) {
+                                promise.then(function (res) {
+                                    var reqWithResolvedKeys = __assign(__assign({}, req), { values: req.values.map(function (value, i) {
+                                            var valueWithKey = primKey.keyPath.includes('.')
+                                                ? deepClone(value)
+                                                : __assign({}, value);
+                                            setByKeyPath(valueWithKey, primKey.keyPath, res.results[i]);
+                                            return valueWithKey;
+                                        }) });
+                                    var adjustedReq = adjustOptimisticFromFailures(tblCache, reqWithResolvedKeys, res);
+                                    tblCache.optimisticOps.push(adjustedReq);
+                                    queueMicrotask(function () { return signalSubscribersLazily(req.mutatedParts); });
+                                });
+                            }
+                            else {
+                                tblCache.optimisticOps.push(req);
+                                signalSubscribersLazily(req.mutatedParts);
+                                promise.then(function (res) {
+                                    if (res.numFailures > 0) {
+                                        delArrayItem(tblCache.optimisticOps, req);
+                                        var adjustedReq = adjustOptimisticFromFailures(tblCache, req, res);
+                                        if (adjustedReq) {
+                                            tblCache.optimisticOps.push(adjustedReq);
+                                        }
+                                        signalSubscribersLazily(req.mutatedParts);
+                                    }
+                                });
+                                promise.catch(function () {
+                                    delArrayItem(tblCache.optimisticOps, req);
+                                    signalSubscribersLazily(req.mutatedParts);
+                                });
+                            }
+                            return promise;
+                        }, query: function (req) {
+                            if (!isCachableContext(PSD, downTable) || !isCachableRequest("query", req))
+                                return downTable.query(req);
+                            var freezeResults = PSD.trans.db._options.cache === 'immutable';
+                            var _a = PSD, requery = _a.requery, signal = _a.signal;
+                            var _b = findCompatibleQuery(dbName, tableName, 'query', req), cacheEntry = _b[0], exactMatch = _b[1], tblCache = _b[2], container = _b[3];
+                            if (cacheEntry && exactMatch) {
+                                cacheEntry.obsSet = req.obsSet;
+                            }
+                            else {
+                                var promise = downTable.query(req).then(function (res) {
+                                    var result = res.result;
+                                    cacheEntry.res = result;
+                                    if (freezeResults) {
+                                        for (var i = 0, l = result.length; i < l; ++i) {
+                                            Object.freeze(result[i]);
+                                        }
+                                        Object.freeze(result);
+                                    }
+                                    else {
+                                        res.result = deepClone(result);
+                                    }
+                                    return res;
+                                }).catch(function (error) {
+                                    if (container && cacheEntry)
+                                        delArrayItem(container, cacheEntry);
+                                    return Promise.reject(error);
+                                });
+                                cacheEntry = {
+                                    obsSet: req.obsSet,
+                                    promise: promise,
+                                    subscribers: new Set(),
+                                    type: 'query',
+                                    req: req,
+                                    dirty: false,
+                                };
+                                if (container) {
+                                    container.push(cacheEntry);
+                                }
+                                else {
+                                    container = [cacheEntry];
+                                    if (!tblCache) {
+                                        tblCache = cache["idb://".concat(dbName, "/").concat(tableName)] = {
+                                            queries: {
+                                                query: {},
+                                                count: {},
+                                            },
+                                            objs: new Map(),
+                                            optimisticOps: [],
+                                            unsignaledParts: {}
+                                        };
+                                    }
+                                    tblCache.queries.query[req.query.index.name || ''] = container;
+                                }
+                            }
+                            subscribeToCacheEntry(cacheEntry, container, requery, signal);
+                            return cacheEntry.promise.then(function (res) {
+                                return {
+                                    result: applyOptimisticOps(res.result, req, tblCache === null || tblCache === void 0 ? void 0 : tblCache.optimisticOps, downTable, cacheEntry, freezeResults),
+                                };
+                            });
+                        } });
+                    return tableMW;
+                } });
+            return coreMW;
+        },
+    };
+
+    function vipify(target, vipDb) {
+        return new Proxy(target, {
+            get: function (target, prop, receiver) {
+                if (prop === 'db')
+                    return vipDb;
+                return Reflect.get(target, prop, receiver);
+            }
+        });
+    }
+
     var Dexie$1 =  (function () {
         function Dexie(name, options) {
             var _this = this;
@@ -4677,7 +5174,7 @@
             var deps = Dexie.dependencies;
             this._options = options = __assign({
                 addons: Dexie.addons, autoOpen: true,
-                indexedDB: deps.indexedDB, IDBKeyRange: deps.IDBKeyRange }, options);
+                indexedDB: deps.indexedDB, IDBKeyRange: deps.IDBKeyRange, cache: 'cloned' }, options);
             this._deps = {
                 indexedDB: options.indexedDB,
                 IDBKeyRange: options.IDBKeyRange
@@ -4747,7 +5244,8 @@
                     console.warn("Another connection wants to upgrade database '".concat(_this.name, "'. Closing db now to resume the upgrade."));
                 else
                     console.warn("Another connection wants to delete database '".concat(_this.name, "'. Closing db now to resume the delete request."));
-                _this.close();
+                _this.close({ disableAutoOpen: false });
+                _this._state.openComplete = false;
             });
             this.on("blocked", function (ev) {
                 if (!ev.newVersion || ev.newVersion < ev.oldVersion)
@@ -4763,11 +5261,31 @@
                     .filter(function (c) { return c.name === _this.name && c !== _this && !c._state.vcFired; })
                     .map(function (c) { return c.on("versionchange").fire(ev); });
             };
+            this.use(cacheExistingValuesMiddleware);
+            this.use(cacheMiddleware);
+            this.use(observabilityMiddleware);
             this.use(virtualIndexMiddleware);
             this.use(hooksMiddleware);
-            this.use(observabilityMiddleware);
-            this.use(cacheExistingValuesMiddleware);
-            this.vip = Object.create(this, { _vip: { value: true } });
+            var vipDB = new Proxy(this, {
+                get: function (_, prop, receiver) {
+                    if (prop === '_vip')
+                        return true;
+                    if (prop === 'table')
+                        return function (tableName) { return vipify(_this.table(tableName), vipDB); };
+                    var rv = Reflect.get(_, prop, receiver);
+                    if (rv instanceof Table)
+                        return vipify(rv, vipDB);
+                    if (prop === 'tables')
+                        return rv.map(function (t) { return vipify(t, vipDB); });
+                    if (prop === '_createTransaction')
+                        return function () {
+                            var tx = rv.apply(this, arguments);
+                            return vipify(tx, vipDB);
+                        };
+                    return rv;
+                }
+            });
+            this.vip = vipDB;
             addons.forEach(function (addon) { return addon(_this); });
         }
         Dexie.prototype.version = function (versionNumber) {
@@ -4825,7 +5343,9 @@
             return this;
         };
         Dexie.prototype.open = function () {
-            return dexieOpen(this);
+            var _this = this;
+            return usePSD(globalPSD,
+            function () { return dexieOpen(_this); });
         };
         Dexie.prototype._close = function () {
             var state = this._state;
@@ -4837,7 +5357,7 @@
                     this.idbdb.close();
                 }
                 catch (e) { }
-                this._novip.idbdb = null;
+                this.idbdb = null;
             }
             state.dbReadyPromise = new DexiePromise(function (resolve) {
                 state.dbReadyResolve = resolve;
@@ -4846,10 +5366,12 @@
                 state.cancelOpen = reject;
             });
         };
-        Dexie.prototype.close = function () {
+        Dexie.prototype.close = function (_a) {
+            var _b = _a === void 0 ? { disableAutoOpen: true } : _a, disableAutoOpen = _b.disableAutoOpen;
             this._close();
             var state = this._state;
-            this._options.autoOpen = false;
+            if (disableAutoOpen)
+                this._options.autoOpen = false;
             state.dbOpenError = new exceptions.DatabaseClosed();
             if (state.isBeingOpened)
                 state.cancelOpen(state.dbOpenError);
@@ -4860,7 +5382,7 @@
             var state = this._state;
             return new DexiePromise(function (resolve, reject) {
                 var doDelete = function () {
-                    _this.close();
+                    _this.close({ disableAutoOpen: false });
                     var req = _this._deps.indexedDB.deleteDatabase(_this.name);
                     req.onsuccess = wrap(function () {
                         _onDatabaseDeleted(_this._deps, _this.name);
@@ -4990,32 +5512,45 @@
         return Observable;
     }());
 
-    function extendObservabilitySet(target, newSet) {
-        keys(newSet).forEach(function (part) {
-            var rangeSet = target[part] || (target[part] = new RangeSet());
-            mergeRanges(rangeSet, newSet[part]);
-        });
-        return target;
+    var domDeps;
+    try {
+        domDeps = {
+            indexedDB: _global.indexedDB || _global.mozIndexedDB || _global.webkitIndexedDB || _global.msIndexedDB,
+            IDBKeyRange: _global.IDBKeyRange || _global.webkitIDBKeyRange
+        };
+    }
+    catch (e) {
+        domDeps = { indexedDB: null, IDBKeyRange: null };
     }
 
     function liveQuery(querier) {
-        return new Observable(function (observer) {
+        var hasValue = false;
+        var currentValue;
+        var observable = new Observable(function (observer) {
             var scopeFuncIsAsync = isAsyncFunction(querier);
-            function execute(subscr) {
-                if (scopeFuncIsAsync) {
-                    incrementExpectedAwaits();
+            function execute(ctx) {
+                var wasRootExec = beginMicroTickScope();
+                try {
+                    if (scopeFuncIsAsync) {
+                        incrementExpectedAwaits();
+                    }
+                    var rv = newScope(querier, ctx);
+                    if (scopeFuncIsAsync) {
+                        rv = rv.finally(decrementExpectedAwaits);
+                    }
+                    return Promise.resolve(rv).finally(function () {
+                        if (PSD.subscr === ctx.subscr) {
+                            console.warn("Dexie liveQuery()'s querier callback did'nt await all of its spawned promises. Querier source: ".concat(querier));
+                            return new NativePromise(function (resolve) { return setTimeout(resolve, 0); });
+                        }
+                    });
                 }
-                var exec = function () { return newScope(querier, { subscr: subscr, trans: null }); };
-                var rv = PSD.trans
-                    ?
-                        usePSD(PSD.transless, exec)
-                    : exec();
-                if (scopeFuncIsAsync) {
-                    rv.then(decrementExpectedAwaits, decrementExpectedAwaits);
+                finally {
+                    wasRootExec && endMicroTickScope();
                 }
-                return rv;
             }
             var closed = false;
+            var abortController;
             var accumMuts = {};
             var currentObs = {};
             var subscription = {
@@ -5023,16 +5558,19 @@
                     return closed;
                 },
                 unsubscribe: function () {
+                    if (closed)
+                        return;
                     closed = true;
-                    globalEvents.storagemutated.unsubscribe(mutationListener);
+                    if (abortController)
+                        abortController.abort();
+                    if (startedListening)
+                        globalEvents.storagemutated.unsubscribe(mutationListener);
                 },
             };
             observer.start && observer.start(subscription);
-            var querying = false, startedListening = false;
+            var startedListening = false;
             function shouldNotify() {
-                return keys(currentObs).some(function (key) {
-                    return accumMuts[key] && rangesOverlap(accumMuts[key], currentObs[key]);
-                });
+                return obsSetsOverlap(currentObs, accumMuts);
             }
             var mutationListener = function (parts) {
                 extendObservabilitySet(accumMuts, parts);
@@ -5041,52 +5579,52 @@
                 }
             };
             var doQuery = function () {
-                if (querying || closed) {
+                if (closed ||
+                    !domDeps.indexedDB)
+                 {
                     return;
                 }
                 accumMuts = {};
                 var subscr = {};
-                var ret = execute(subscr);
-                if (!startedListening) {
-                    globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, mutationListener);
-                    startedListening = true;
-                }
-                querying = true;
+                if (abortController)
+                    abortController.abort();
+                abortController = new AbortController();
+                var ctx = {
+                    subscr: subscr,
+                    signal: abortController.signal,
+                    requery: doQuery,
+                    querier: querier,
+                    trans: null
+                };
+                var ret = execute(ctx);
                 Promise.resolve(ret).then(function (result) {
-                    querying = false;
-                    if (closed) {
+                    hasValue = true;
+                    currentValue = result;
+                    if (closed || ctx.signal.aborted) {
                         return;
                     }
-                    if (shouldNotify()) {
-                        doQuery();
-                    }
-                    else {
-                        accumMuts = {};
-                        currentObs = subscr;
-                        observer.next && observer.next(result);
+                    accumMuts = {};
+                    currentObs = subscr;
+                    if (!objectIsEmpty(currentObs) && !startedListening) {
+                        globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, mutationListener);
+                        startedListening = true;
                     }
+                    observer.next && observer.next(result);
                 }, function (err) {
+                    hasValue = false;
                     if (!['DatabaseClosedError', 'AbortError'].includes(err === null || err === void 0 ? void 0 : err.name)) {
-                        querying = false;
+                        if (closed)
+                            return;
                         observer.error && observer.error(err);
-                        subscription.unsubscribe();
                     }
                 });
             };
             doQuery();
             return subscription;
         });
-    }
-
-    var domDeps;
-    try {
-        domDeps = {
-            indexedDB: _global.indexedDB || _global.mozIndexedDB || _global.webkitIndexedDB || _global.msIndexedDB,
-            IDBKeyRange: _global.IDBKeyRange || _global.webkitIDBKeyRange
-        };
-    }
-    catch (e) {
-        domDeps = { indexedDB: null, IDBKeyRange: null };
+        observable.hasValue = function () { return hasValue; };
+        observable.getValue = function () { return currentValue; };
+        return observable;
     }
 
     var Dexie = Dexie$1;
@@ -5166,7 +5704,7 @@
         addons: [],
         connections: connections,
         errnames: errnames,
-        dependencies: domDeps,
+        dependencies: domDeps, cache: cache,
         semVer: DEXIE_VERSION, version: DEXIE_VERSION.split('.')
             .map(function (n) { return parseInt(n); })
             .reduce(function (p, c, i) { return p + (c / Math.pow(10, i * 2)); }) }));
@@ -5202,6 +5740,7 @@
         try {
             propagatingLocally = true;
             globalEvents.storagemutated.fire(updateParts);
+            signalSubscribersNow(updateParts, true);
         }
         finally {
             propagatingLocally = wasMe;