dexie-cloud-addon 4.0.1-beta.46 → 4.0.1-beta.48

package/dist/umd/service-worker.js

@@ -1,12 +1,26 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('dexie'), require('rxjs'), require('rxjs/operators')) :
-    typeof define === 'function' && define.amd ? define(['dexie', 'rxjs', 'rxjs/operators'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Dexie, global.rxjs, global.rxjs.operators));
-})(this, (function (Dexie, rxjs, operators) { 'use strict';
-
-    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+/* ========================================================================== 
+ *                           dexie-cloud-addom.js
+ * ==========================================================================
+ *
+ * Dexie addon that syncs IndexedDB with Dexie Cloud.
+ *
+ * By David Fahlander, david@dexie.org
+ *
+ * ==========================================================================
+ *
+ * Version 4.0.1-beta.48, Tue Oct 17 2023
+ *
+ * https://dexie.org
+ *
+ * Apache License Version 2.0, January 2004, http://www.apache.org/licenses/
+ * 
+ */
 
-    var Dexie__default = /*#__PURE__*/_interopDefaultLegacy(Dexie);
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('dexie'), require('rxjs')) :
+    typeof define === 'function' && define.amd ? define(['dexie', 'rxjs'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Dexie, global.rxjs));
+})(this, (function (Dexie, rxjs) { 'use strict';
 
     /******************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -22,6 +36,22 @@
     OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
     PERFORMANCE OF THIS SOFTWARE.
     ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
 
     function __awaiter(thisArg, _arguments, P, generator) {
         function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -31,6 +61,97 @@
             function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
             step((generator = generator.apply(thisArg, _arguments || [])).next());
         });
+    }
+
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+        return to.concat(ar || Array.prototype.slice.call(from));
+    }
+
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+    }
+
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
     }
 
     const UNAUTHORIZED_USER = {
@@ -170,18 +291,1436 @@
                     else {
                         bc.removeEventListener("message", onMessageEvent);
                     }
-                };
+                };
+            });
+            this.name = name;
+            this.bc = bc;
+        }
+        next(message) {
+            console.debug("BroadcastedAndLocalEvent: bc.postMessage()", Object.assign({}, message), "bc is a", this.bc);
+            this.bc.postMessage(message);
+            const ev = new CustomEvent(`lbc-${this.name}`, { detail: message });
+            //self.dispatchEvent(ev);
+            dispatch(ev);
+        }
+    }
+
+    function isFunction(value) {
+        return typeof value === 'function';
+    }
+
+    function hasLift(source) {
+        return isFunction(source === null || source === void 0 ? void 0 : source.lift);
+    }
+    function operate(init) {
+        return function (source) {
+            if (hasLift(source)) {
+                return source.lift(function (liftedSource) {
+                    try {
+                        return init(liftedSource, this);
+                    }
+                    catch (err) {
+                        this.error(err);
+                    }
+                });
+            }
+            throw new TypeError('Unable to lift unknown Observable type');
+        };
+    }
+
+    var isArrayLike = (function (x) { return x && typeof x.length === 'number' && typeof x !== 'function'; });
+
+    function isPromise(value) {
+        return isFunction(value === null || value === void 0 ? void 0 : value.then);
+    }
+
+    function createErrorClass(createImpl) {
+        var _super = function (instance) {
+            Error.call(instance);
+            instance.stack = new Error().stack;
+        };
+        var ctorFunc = createImpl(_super);
+        ctorFunc.prototype = Object.create(Error.prototype);
+        ctorFunc.prototype.constructor = ctorFunc;
+        return ctorFunc;
+    }
+
+    var UnsubscriptionError = createErrorClass(function (_super) {
+        return function UnsubscriptionErrorImpl(errors) {
+            _super(this);
+            this.message = errors
+                ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) { return i + 1 + ") " + err.toString(); }).join('\n  ')
+                : '';
+            this.name = 'UnsubscriptionError';
+            this.errors = errors;
+        };
+    });
+
+    function arrRemove(arr, item) {
+        if (arr) {
+            var index = arr.indexOf(item);
+            0 <= index && arr.splice(index, 1);
+        }
+    }
+
+    var Subscription = (function () {
+        function Subscription(initialTeardown) {
+            this.initialTeardown = initialTeardown;
+            this.closed = false;
+            this._parentage = null;
+            this._finalizers = null;
+        }
+        Subscription.prototype.unsubscribe = function () {
+            var e_1, _a, e_2, _b;
+            var errors;
+            if (!this.closed) {
+                this.closed = true;
+                var _parentage = this._parentage;
+                if (_parentage) {
+                    this._parentage = null;
+                    if (Array.isArray(_parentage)) {
+                        try {
+                            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+                                var parent_1 = _parentage_1_1.value;
+                                parent_1.remove(this);
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                    }
+                    else {
+                        _parentage.remove(this);
+                    }
+                }
+                var initialFinalizer = this.initialTeardown;
+                if (isFunction(initialFinalizer)) {
+                    try {
+                        initialFinalizer();
+                    }
+                    catch (e) {
+                        errors = e instanceof UnsubscriptionError ? e.errors : [e];
+                    }
+                }
+                var _finalizers = this._finalizers;
+                if (_finalizers) {
+                    this._finalizers = null;
+                    try {
+                        for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+                            var finalizer = _finalizers_1_1.value;
+                            try {
+                                execFinalizer(finalizer);
+                            }
+                            catch (err) {
+                                errors = errors !== null && errors !== void 0 ? errors : [];
+                                if (err instanceof UnsubscriptionError) {
+                                    errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+                                }
+                                else {
+                                    errors.push(err);
+                                }
+                            }
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+                if (errors) {
+                    throw new UnsubscriptionError(errors);
+                }
+            }
+        };
+        Subscription.prototype.add = function (teardown) {
+            var _a;
+            if (teardown && teardown !== this) {
+                if (this.closed) {
+                    execFinalizer(teardown);
+                }
+                else {
+                    if (teardown instanceof Subscription) {
+                        if (teardown.closed || teardown._hasParent(this)) {
+                            return;
+                        }
+                        teardown._addParent(this);
+                    }
+                    (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+                }
+            }
+        };
+        Subscription.prototype._hasParent = function (parent) {
+            var _parentage = this._parentage;
+            return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent));
+        };
+        Subscription.prototype._addParent = function (parent) {
+            var _parentage = this._parentage;
+            this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+        };
+        Subscription.prototype._removeParent = function (parent) {
+            var _parentage = this._parentage;
+            if (_parentage === parent) {
+                this._parentage = null;
+            }
+            else if (Array.isArray(_parentage)) {
+                arrRemove(_parentage, parent);
+            }
+        };
+        Subscription.prototype.remove = function (teardown) {
+            var _finalizers = this._finalizers;
+            _finalizers && arrRemove(_finalizers, teardown);
+            if (teardown instanceof Subscription) {
+                teardown._removeParent(this);
+            }
+        };
+        Subscription.EMPTY = (function () {
+            var empty = new Subscription();
+            empty.closed = true;
+            return empty;
+        })();
+        return Subscription;
+    }());
+    Subscription.EMPTY;
+    function isSubscription(value) {
+        return (value instanceof Subscription ||
+            (value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)));
+    }
+    function execFinalizer(finalizer) {
+        if (isFunction(finalizer)) {
+            finalizer();
+        }
+        else {
+            finalizer.unsubscribe();
+        }
+    }
+
+    var config = {
+        onUnhandledError: null,
+        onStoppedNotification: null,
+        Promise: undefined,
+        useDeprecatedSynchronousErrorHandling: false,
+        useDeprecatedNextContext: false,
+    };
+
+    var timeoutProvider = {
+        setTimeout: function (handler, timeout) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            var delegate = timeoutProvider.delegate;
+            if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
+                return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout], __read(args)));
+            }
+            return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+        },
+        clearTimeout: function (handle) {
+            var delegate = timeoutProvider.delegate;
+            return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
+        },
+        delegate: undefined,
+    };
+
+    function reportUnhandledError(err) {
+        timeoutProvider.setTimeout(function () {
+            {
+                throw err;
+            }
+        });
+    }
+
+    function noop() { }
+
+    function errorContext(cb) {
+        {
+            cb();
+        }
+    }
+
+    var Subscriber = (function (_super) {
+        __extends(Subscriber, _super);
+        function Subscriber(destination) {
+            var _this = _super.call(this) || this;
+            _this.isStopped = false;
+            if (destination) {
+                _this.destination = destination;
+                if (isSubscription(destination)) {
+                    destination.add(_this);
+                }
+            }
+            else {
+                _this.destination = EMPTY_OBSERVER;
+            }
+            return _this;
+        }
+        Subscriber.create = function (next, error, complete) {
+            return new SafeSubscriber(next, error, complete);
+        };
+        Subscriber.prototype.next = function (value) {
+            if (this.isStopped) ;
+            else {
+                this._next(value);
+            }
+        };
+        Subscriber.prototype.error = function (err) {
+            if (this.isStopped) ;
+            else {
+                this.isStopped = true;
+                this._error(err);
+            }
+        };
+        Subscriber.prototype.complete = function () {
+            if (this.isStopped) ;
+            else {
+                this.isStopped = true;
+                this._complete();
+            }
+        };
+        Subscriber.prototype.unsubscribe = function () {
+            if (!this.closed) {
+                this.isStopped = true;
+                _super.prototype.unsubscribe.call(this);
+                this.destination = null;
+            }
+        };
+        Subscriber.prototype._next = function (value) {
+            this.destination.next(value);
+        };
+        Subscriber.prototype._error = function (err) {
+            try {
+                this.destination.error(err);
+            }
+            finally {
+                this.unsubscribe();
+            }
+        };
+        Subscriber.prototype._complete = function () {
+            try {
+                this.destination.complete();
+            }
+            finally {
+                this.unsubscribe();
+            }
+        };
+        return Subscriber;
+    }(Subscription));
+    var _bind = Function.prototype.bind;
+    function bind(fn, thisArg) {
+        return _bind.call(fn, thisArg);
+    }
+    var ConsumerObserver = (function () {
+        function ConsumerObserver(partialObserver) {
+            this.partialObserver = partialObserver;
+        }
+        ConsumerObserver.prototype.next = function (value) {
+            var partialObserver = this.partialObserver;
+            if (partialObserver.next) {
+                try {
+                    partialObserver.next(value);
+                }
+                catch (error) {
+                    handleUnhandledError(error);
+                }
+            }
+        };
+        ConsumerObserver.prototype.error = function (err) {
+            var partialObserver = this.partialObserver;
+            if (partialObserver.error) {
+                try {
+                    partialObserver.error(err);
+                }
+                catch (error) {
+                    handleUnhandledError(error);
+                }
+            }
+            else {
+                handleUnhandledError(err);
+            }
+        };
+        ConsumerObserver.prototype.complete = function () {
+            var partialObserver = this.partialObserver;
+            if (partialObserver.complete) {
+                try {
+                    partialObserver.complete();
+                }
+                catch (error) {
+                    handleUnhandledError(error);
+                }
+            }
+        };
+        return ConsumerObserver;
+    }());
+    var SafeSubscriber = (function (_super) {
+        __extends(SafeSubscriber, _super);
+        function SafeSubscriber(observerOrNext, error, complete) {
+            var _this = _super.call(this) || this;
+            var partialObserver;
+            if (isFunction(observerOrNext) || !observerOrNext) {
+                partialObserver = {
+                    next: (observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined),
+                    error: error !== null && error !== void 0 ? error : undefined,
+                    complete: complete !== null && complete !== void 0 ? complete : undefined,
+                };
+            }
+            else {
+                var context_1;
+                if (_this && config.useDeprecatedNextContext) {
+                    context_1 = Object.create(observerOrNext);
+                    context_1.unsubscribe = function () { return _this.unsubscribe(); };
+                    partialObserver = {
+                        next: observerOrNext.next && bind(observerOrNext.next, context_1),
+                        error: observerOrNext.error && bind(observerOrNext.error, context_1),
+                        complete: observerOrNext.complete && bind(observerOrNext.complete, context_1),
+                    };
+                }
+                else {
+                    partialObserver = observerOrNext;
+                }
+            }
+            _this.destination = new ConsumerObserver(partialObserver);
+            return _this;
+        }
+        return SafeSubscriber;
+    }(Subscriber));
+    function handleUnhandledError(error) {
+        {
+            reportUnhandledError(error);
+        }
+    }
+    function defaultErrorHandler(err) {
+        throw err;
+    }
+    var EMPTY_OBSERVER = {
+        closed: true,
+        next: noop,
+        error: defaultErrorHandler,
+        complete: noop,
+    };
+
+    var observable = (function () { return (typeof Symbol === 'function' && Symbol.observable) || '@@observable'; })();
+
+    function identity(x) {
+        return x;
+    }
+
+    function pipeFromArray(fns) {
+        if (fns.length === 0) {
+            return identity;
+        }
+        if (fns.length === 1) {
+            return fns[0];
+        }
+        return function piped(input) {
+            return fns.reduce(function (prev, fn) { return fn(prev); }, input);
+        };
+    }
+
+    var Observable = (function () {
+        function Observable(subscribe) {
+            if (subscribe) {
+                this._subscribe = subscribe;
+            }
+        }
+        Observable.prototype.lift = function (operator) {
+            var observable = new Observable();
+            observable.source = this;
+            observable.operator = operator;
+            return observable;
+        };
+        Observable.prototype.subscribe = function (observerOrNext, error, complete) {
+            var _this = this;
+            var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+            errorContext(function () {
+                var _a = _this, operator = _a.operator, source = _a.source;
+                subscriber.add(operator
+                    ?
+                        operator.call(subscriber, source)
+                    : source
+                        ?
+                            _this._subscribe(subscriber)
+                        :
+                            _this._trySubscribe(subscriber));
+            });
+            return subscriber;
+        };
+        Observable.prototype._trySubscribe = function (sink) {
+            try {
+                return this._subscribe(sink);
+            }
+            catch (err) {
+                sink.error(err);
+            }
+        };
+        Observable.prototype.forEach = function (next, promiseCtor) {
+            var _this = this;
+            promiseCtor = getPromiseCtor(promiseCtor);
+            return new promiseCtor(function (resolve, reject) {
+                var subscriber = new SafeSubscriber({
+                    next: function (value) {
+                        try {
+                            next(value);
+                        }
+                        catch (err) {
+                            reject(err);
+                            subscriber.unsubscribe();
+                        }
+                    },
+                    error: reject,
+                    complete: resolve,
+                });
+                _this.subscribe(subscriber);
+            });
+        };
+        Observable.prototype._subscribe = function (subscriber) {
+            var _a;
+            return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+        };
+        Observable.prototype[observable] = function () {
+            return this;
+        };
+        Observable.prototype.pipe = function () {
+            var operations = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                operations[_i] = arguments[_i];
+            }
+            return pipeFromArray(operations)(this);
+        };
+        Observable.prototype.toPromise = function (promiseCtor) {
+            var _this = this;
+            promiseCtor = getPromiseCtor(promiseCtor);
+            return new promiseCtor(function (resolve, reject) {
+                var value;
+                _this.subscribe(function (x) { return (value = x); }, function (err) { return reject(err); }, function () { return resolve(value); });
+            });
+        };
+        Observable.create = function (subscribe) {
+            return new Observable(subscribe);
+        };
+        return Observable;
+    }());
+    function getPromiseCtor(promiseCtor) {
+        var _a;
+        return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+    }
+    function isObserver(value) {
+        return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+    }
+    function isSubscriber(value) {
+        return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value));
+    }
+
+    function isInteropObservable(input) {
+        return isFunction(input[observable]);
+    }
+
+    function isAsyncIterable(obj) {
+        return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
+    }
+
+    function createInvalidObservableTypeError(input) {
+        return new TypeError("You provided " + (input !== null && typeof input === 'object' ? 'an invalid object' : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+    }
+
+    function getSymbolIterator() {
+        if (typeof Symbol !== 'function' || !Symbol.iterator) {
+            return '@@iterator';
+        }
+        return Symbol.iterator;
+    }
+    var iterator = getSymbolIterator();
+
+    function isIterable(input) {
+        return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
+    }
+
+    function readableStreamLikeToAsyncGenerator(readableStream) {
+        return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
+            var reader, _a, value, done;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        reader = readableStream.getReader();
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, , 9, 10]);
+                        _b.label = 2;
+                    case 2:
+                        return [4, __await(reader.read())];
+                    case 3:
+                        _a = _b.sent(), value = _a.value, done = _a.done;
+                        if (!done) return [3, 5];
+                        return [4, __await(void 0)];
+                    case 4: return [2, _b.sent()];
+                    case 5: return [4, __await(value)];
+                    case 6: return [4, _b.sent()];
+                    case 7:
+                        _b.sent();
+                        return [3, 2];
+                    case 8: return [3, 10];
+                    case 9:
+                        reader.releaseLock();
+                        return [7];
+                    case 10: return [2];
+                }
+            });
+        });
+    }
+    function isReadableStreamLike(obj) {
+        return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
+    }
+
+    function innerFrom(input) {
+        if (input instanceof Observable) {
+            return input;
+        }
+        if (input != null) {
+            if (isInteropObservable(input)) {
+                return fromInteropObservable(input);
+            }
+            if (isArrayLike(input)) {
+                return fromArrayLike(input);
+            }
+            if (isPromise(input)) {
+                return fromPromise(input);
+            }
+            if (isAsyncIterable(input)) {
+                return fromAsyncIterable(input);
+            }
+            if (isIterable(input)) {
+                return fromIterable(input);
+            }
+            if (isReadableStreamLike(input)) {
+                return fromReadableStreamLike(input);
+            }
+        }
+        throw createInvalidObservableTypeError(input);
+    }
+    function fromInteropObservable(obj) {
+        return new Observable(function (subscriber) {
+            var obs = obj[observable]();
+            if (isFunction(obs.subscribe)) {
+                return obs.subscribe(subscriber);
+            }
+            throw new TypeError('Provided object does not correctly implement Symbol.observable');
+        });
+    }
+    function fromArrayLike(array) {
+        return new Observable(function (subscriber) {
+            for (var i = 0; i < array.length && !subscriber.closed; i++) {
+                subscriber.next(array[i]);
+            }
+            subscriber.complete();
+        });
+    }
+    function fromPromise(promise) {
+        return new Observable(function (subscriber) {
+            promise
+                .then(function (value) {
+                if (!subscriber.closed) {
+                    subscriber.next(value);
+                    subscriber.complete();
+                }
+            }, function (err) { return subscriber.error(err); })
+                .then(null, reportUnhandledError);
+        });
+    }
+    function fromIterable(iterable) {
+        return new Observable(function (subscriber) {
+            var e_1, _a;
+            try {
+                for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
+                    var value = iterable_1_1.value;
+                    subscriber.next(value);
+                    if (subscriber.closed) {
+                        return;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) _a.call(iterable_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            subscriber.complete();
+        });
+    }
+    function fromAsyncIterable(asyncIterable) {
+        return new Observable(function (subscriber) {
+            process(asyncIterable, subscriber).catch(function (err) { return subscriber.error(err); });
+        });
+    }
+    function fromReadableStreamLike(readableStream) {
+        return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
+    }
+    function process(asyncIterable, subscriber) {
+        var asyncIterable_1, asyncIterable_1_1;
+        var e_2, _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var value, e_2_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 5, 6, 11]);
+                        asyncIterable_1 = __asyncValues(asyncIterable);
+                        _b.label = 1;
+                    case 1: return [4, asyncIterable_1.next()];
+                    case 2:
+                        if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4];
+                        value = asyncIterable_1_1.value;
+                        subscriber.next(value);
+                        if (subscriber.closed) {
+                            return [2];
+                        }
+                        _b.label = 3;
+                    case 3: return [3, 1];
+                    case 4: return [3, 11];
+                    case 5:
+                        e_2_1 = _b.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3, 11];
+                    case 6:
+                        _b.trys.push([6, , 9, 10]);
+                        if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))) return [3, 8];
+                        return [4, _a.call(asyncIterable_1)];
+                    case 7:
+                        _b.sent();
+                        _b.label = 8;
+                    case 8: return [3, 10];
+                    case 9:
+                        if (e_2) throw e_2.error;
+                        return [7];
+                    case 10: return [7];
+                    case 11:
+                        subscriber.complete();
+                        return [2];
+                }
+            });
+        });
+    }
+
+    function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+        return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+    }
+    var OperatorSubscriber = (function (_super) {
+        __extends(OperatorSubscriber, _super);
+        function OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+            var _this = _super.call(this, destination) || this;
+            _this.onFinalize = onFinalize;
+            _this.shouldUnsubscribe = shouldUnsubscribe;
+            _this._next = onNext
+                ? function (value) {
+                    try {
+                        onNext(value);
+                    }
+                    catch (err) {
+                        destination.error(err);
+                    }
+                }
+                : _super.prototype._next;
+            _this._error = onError
+                ? function (err) {
+                    try {
+                        onError(err);
+                    }
+                    catch (err) {
+                        destination.error(err);
+                    }
+                    finally {
+                        this.unsubscribe();
+                    }
+                }
+                : _super.prototype._error;
+            _this._complete = onComplete
+                ? function () {
+                    try {
+                        onComplete();
+                    }
+                    catch (err) {
+                        destination.error(err);
+                    }
+                    finally {
+                        this.unsubscribe();
+                    }
+                }
+                : _super.prototype._complete;
+            return _this;
+        }
+        OperatorSubscriber.prototype.unsubscribe = function () {
+            var _a;
+            if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+                var closed_1 = this.closed;
+                _super.prototype.unsubscribe.call(this);
+                !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
+            }
+        };
+        return OperatorSubscriber;
+    }(Subscriber));
+
+    var Action = (function (_super) {
+        __extends(Action, _super);
+        function Action(scheduler, work) {
+            return _super.call(this) || this;
+        }
+        Action.prototype.schedule = function (state, delay) {
+            return this;
+        };
+        return Action;
+    }(Subscription));
+
+    var intervalProvider = {
+        setInterval: function (handler, timeout) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            var delegate = intervalProvider.delegate;
+            if (delegate === null || delegate === void 0 ? void 0 : delegate.setInterval) {
+                return delegate.setInterval.apply(delegate, __spreadArray([handler, timeout], __read(args)));
+            }
+            return setInterval.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+        },
+        clearInterval: function (handle) {
+            var delegate = intervalProvider.delegate;
+            return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearInterval) || clearInterval)(handle);
+        },
+        delegate: undefined,
+    };
+
+    var AsyncAction = (function (_super) {
+        __extends(AsyncAction, _super);
+        function AsyncAction(scheduler, work) {
+            var _this = _super.call(this, scheduler, work) || this;
+            _this.scheduler = scheduler;
+            _this.work = work;
+            _this.pending = false;
+            return _this;
+        }
+        AsyncAction.prototype.schedule = function (state, delay) {
+            if (delay === void 0) { delay = 0; }
+            if (this.closed) {
+                return this;
+            }
+            this.state = state;
+            var id = this.id;
+            var scheduler = this.scheduler;
+            if (id != null) {
+                this.id = this.recycleAsyncId(scheduler, id, delay);
+            }
+            this.pending = true;
+            this.delay = delay;
+            this.id = this.id || this.requestAsyncId(scheduler, this.id, delay);
+            return this;
+        };
+        AsyncAction.prototype.requestAsyncId = function (scheduler, _id, delay) {
+            if (delay === void 0) { delay = 0; }
+            return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
+        };
+        AsyncAction.prototype.recycleAsyncId = function (_scheduler, id, delay) {
+            if (delay === void 0) { delay = 0; }
+            if (delay != null && this.delay === delay && this.pending === false) {
+                return id;
+            }
+            intervalProvider.clearInterval(id);
+            return undefined;
+        };
+        AsyncAction.prototype.execute = function (state, delay) {
+            if (this.closed) {
+                return new Error('executing a cancelled action');
+            }
+            this.pending = false;
+            var error = this._execute(state, delay);
+            if (error) {
+                return error;
+            }
+            else if (this.pending === false && this.id != null) {
+                this.id = this.recycleAsyncId(this.scheduler, this.id, null);
+            }
+        };
+        AsyncAction.prototype._execute = function (state, _delay) {
+            var errored = false;
+            var errorValue;
+            try {
+                this.work(state);
+            }
+            catch (e) {
+                errored = true;
+                errorValue = e ? e : new Error('Scheduled action threw falsy error');
+            }
+            if (errored) {
+                this.unsubscribe();
+                return errorValue;
+            }
+        };
+        AsyncAction.prototype.unsubscribe = function () {
+            if (!this.closed) {
+                var _a = this, id = _a.id, scheduler = _a.scheduler;
+                var actions = scheduler.actions;
+                this.work = this.state = this.scheduler = null;
+                this.pending = false;
+                arrRemove(actions, this);
+                if (id != null) {
+                    this.id = this.recycleAsyncId(scheduler, id, null);
+                }
+                this.delay = null;
+                _super.prototype.unsubscribe.call(this);
+            }
+        };
+        return AsyncAction;
+    }(Action));
+
+    var dateTimestampProvider = {
+        now: function () {
+            return (dateTimestampProvider.delegate || Date).now();
+        },
+        delegate: undefined,
+    };
+
+    var Scheduler = (function () {
+        function Scheduler(schedulerActionCtor, now) {
+            if (now === void 0) { now = Scheduler.now; }
+            this.schedulerActionCtor = schedulerActionCtor;
+            this.now = now;
+        }
+        Scheduler.prototype.schedule = function (work, delay, state) {
+            if (delay === void 0) { delay = 0; }
+            return new this.schedulerActionCtor(this, work).schedule(state, delay);
+        };
+        Scheduler.now = dateTimestampProvider.now;
+        return Scheduler;
+    }());
+
+    var AsyncScheduler = (function (_super) {
+        __extends(AsyncScheduler, _super);
+        function AsyncScheduler(SchedulerAction, now) {
+            if (now === void 0) { now = Scheduler.now; }
+            var _this = _super.call(this, SchedulerAction, now) || this;
+            _this.actions = [];
+            _this._active = false;
+            _this._scheduled = undefined;
+            return _this;
+        }
+        AsyncScheduler.prototype.flush = function (action) {
+            var actions = this.actions;
+            if (this._active) {
+                actions.push(action);
+                return;
+            }
+            var error;
+            this._active = true;
+            do {
+                if ((error = action.execute(action.state, action.delay))) {
+                    break;
+                }
+            } while ((action = actions.shift()));
+            this._active = false;
+            if (error) {
+                while ((action = actions.shift())) {
+                    action.unsubscribe();
+                }
+                throw error;
+            }
+        };
+        return AsyncScheduler;
+    }(Scheduler));
+
+    var asyncScheduler = new AsyncScheduler(AsyncAction);
+    var async = asyncScheduler;
+
+    function isScheduler(value) {
+        return value && isFunction(value.schedule);
+    }
+
+    function isValidDate(value) {
+        return value instanceof Date && !isNaN(value);
+    }
+
+    function timer(dueTime, intervalOrScheduler, scheduler) {
+        if (dueTime === void 0) { dueTime = 0; }
+        if (scheduler === void 0) { scheduler = async; }
+        var intervalDuration = -1;
+        if (intervalOrScheduler != null) {
+            if (isScheduler(intervalOrScheduler)) {
+                scheduler = intervalOrScheduler;
+            }
+            else {
+                intervalDuration = intervalOrScheduler;
+            }
+        }
+        return new Observable(function (subscriber) {
+            var due = isValidDate(dueTime) ? +dueTime - scheduler.now() : dueTime;
+            if (due < 0) {
+                due = 0;
+            }
+            var n = 0;
+            return scheduler.schedule(function () {
+                if (!subscriber.closed) {
+                    subscriber.next(n++);
+                    if (0 <= intervalDuration) {
+                        this.schedule(undefined, intervalDuration);
+                    }
+                    else {
+                        subscriber.complete();
+                    }
+                }
+            }, due);
+        });
+    }
+
+    function last(arr) {
+        return arr[arr.length - 1];
+    }
+    function popScheduler(args) {
+        return isScheduler(last(args)) ? args.pop() : undefined;
+    }
+
+    function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
+        if (delay === void 0) { delay = 0; }
+        if (repeat === void 0) { repeat = false; }
+        var scheduleSubscription = scheduler.schedule(function () {
+            work();
+            if (repeat) {
+                parentSubscription.add(this.schedule(null, delay));
+            }
+            else {
+                this.unsubscribe();
+            }
+        }, delay);
+        parentSubscription.add(scheduleSubscription);
+        if (!repeat) {
+            return scheduleSubscription;
+        }
+    }
+
+    function catchError(selector) {
+        return operate(function (source, subscriber) {
+            var innerSub = null;
+            var syncUnsub = false;
+            var handledResult;
+            innerSub = source.subscribe(createOperatorSubscriber(subscriber, undefined, undefined, function (err) {
+                handledResult = innerFrom(selector(err, catchError(selector)(source)));
+                if (innerSub) {
+                    innerSub.unsubscribe();
+                    innerSub = null;
+                    handledResult.subscribe(subscriber);
+                }
+                else {
+                    syncUnsub = true;
+                }
+            }));
+            if (syncUnsub) {
+                innerSub.unsubscribe();
+                innerSub = null;
+                handledResult.subscribe(subscriber);
+            }
+        });
+    }
+
+    function observeOn(scheduler, delay) {
+        if (delay === void 0) { delay = 0; }
+        return operate(function (source, subscriber) {
+            source.subscribe(createOperatorSubscriber(subscriber, function (value) { return executeSchedule(subscriber, scheduler, function () { return subscriber.next(value); }, delay); }, function () { return executeSchedule(subscriber, scheduler, function () { return subscriber.complete(); }, delay); }, function (err) { return executeSchedule(subscriber, scheduler, function () { return subscriber.error(err); }, delay); }));
+        });
+    }
+
+    function subscribeOn(scheduler, delay) {
+        if (delay === void 0) { delay = 0; }
+        return operate(function (source, subscriber) {
+            subscriber.add(scheduler.schedule(function () { return source.subscribe(subscriber); }, delay));
+        });
+    }
+
+    function scheduleObservable(input, scheduler) {
+        return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+    }
+
+    function schedulePromise(input, scheduler) {
+        return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+    }
+
+    function scheduleArray(input, scheduler) {
+        return new Observable(function (subscriber) {
+            var i = 0;
+            return scheduler.schedule(function () {
+                if (i === input.length) {
+                    subscriber.complete();
+                }
+                else {
+                    subscriber.next(input[i++]);
+                    if (!subscriber.closed) {
+                        this.schedule();
+                    }
+                }
+            });
+        });
+    }
+
+    function scheduleIterable(input, scheduler) {
+        return new Observable(function (subscriber) {
+            var iterator$1;
+            executeSchedule(subscriber, scheduler, function () {
+                iterator$1 = input[iterator]();
+                executeSchedule(subscriber, scheduler, function () {
+                    var _a;
+                    var value;
+                    var done;
+                    try {
+                        (_a = iterator$1.next(), value = _a.value, done = _a.done);
+                    }
+                    catch (err) {
+                        subscriber.error(err);
+                        return;
+                    }
+                    if (done) {
+                        subscriber.complete();
+                    }
+                    else {
+                        subscriber.next(value);
+                    }
+                }, 0, true);
+            });
+            return function () { return isFunction(iterator$1 === null || iterator$1 === void 0 ? void 0 : iterator$1.return) && iterator$1.return(); };
+        });
+    }
+
+    function scheduleAsyncIterable(input, scheduler) {
+        if (!input) {
+            throw new Error('Iterable cannot be null');
+        }
+        return new Observable(function (subscriber) {
+            executeSchedule(subscriber, scheduler, function () {
+                var iterator = input[Symbol.asyncIterator]();
+                executeSchedule(subscriber, scheduler, function () {
+                    iterator.next().then(function (result) {
+                        if (result.done) {
+                            subscriber.complete();
+                        }
+                        else {
+                            subscriber.next(result.value);
+                        }
+                    });
+                }, 0, true);
+            });
+        });
+    }
+
+    function scheduleReadableStreamLike(input, scheduler) {
+        return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
+    }
+
+    function scheduled(input, scheduler) {
+        if (input != null) {
+            if (isInteropObservable(input)) {
+                return scheduleObservable(input, scheduler);
+            }
+            if (isArrayLike(input)) {
+                return scheduleArray(input, scheduler);
+            }
+            if (isPromise(input)) {
+                return schedulePromise(input, scheduler);
+            }
+            if (isAsyncIterable(input)) {
+                return scheduleAsyncIterable(input, scheduler);
+            }
+            if (isIterable(input)) {
+                return scheduleIterable(input, scheduler);
+            }
+            if (isReadableStreamLike(input)) {
+                return scheduleReadableStreamLike(input, scheduler);
+            }
+        }
+        throw createInvalidObservableTypeError(input);
+    }
+
+    function from(input, scheduler) {
+        return scheduler ? scheduled(input, scheduler) : innerFrom(input);
+    }
+
+    function map(project, thisArg) {
+        return operate(function (source, subscriber) {
+            var index = 0;
+            source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+                subscriber.next(project.call(thisArg, value, index++));
+            }));
+        });
+    }
+
+    function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
+        var buffer = [];
+        var active = 0;
+        var index = 0;
+        var isComplete = false;
+        var checkComplete = function () {
+            if (isComplete && !buffer.length && !active) {
+                subscriber.complete();
+            }
+        };
+        var outerNext = function (value) { return (active < concurrent ? doInnerSub(value) : buffer.push(value)); };
+        var doInnerSub = function (value) {
+            expand && subscriber.next(value);
+            active++;
+            var innerComplete = false;
+            innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, function (innerValue) {
+                onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);
+                if (expand) {
+                    outerNext(innerValue);
+                }
+                else {
+                    subscriber.next(innerValue);
+                }
+            }, function () {
+                innerComplete = true;
+            }, undefined, function () {
+                if (innerComplete) {
+                    try {
+                        active--;
+                        var _loop_1 = function () {
+                            var bufferedValue = buffer.shift();
+                            if (innerSubScheduler) {
+                                executeSchedule(subscriber, innerSubScheduler, function () { return doInnerSub(bufferedValue); });
+                            }
+                            else {
+                                doInnerSub(bufferedValue);
+                            }
+                        };
+                        while (buffer.length && active < concurrent) {
+                            _loop_1();
+                        }
+                        checkComplete();
+                    }
+                    catch (err) {
+                        subscriber.error(err);
+                    }
+                }
+            }));
+        };
+        source.subscribe(createOperatorSubscriber(subscriber, outerNext, function () {
+            isComplete = true;
+            checkComplete();
+        }));
+        return function () {
+            additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer();
+        };
+    }
+
+    function mergeMap(project, resultSelector, concurrent) {
+        if (concurrent === void 0) { concurrent = Infinity; }
+        if (isFunction(resultSelector)) {
+            return mergeMap(function (a, i) { return map(function (b, ii) { return resultSelector(a, b, i, ii); })(innerFrom(project(a, i))); }, concurrent);
+        }
+        else if (typeof resultSelector === 'number') {
+            concurrent = resultSelector;
+        }
+        return operate(function (source, subscriber) { return mergeInternals(source, subscriber, project, concurrent); });
+    }
+
+    function mergeAll(concurrent) {
+        if (concurrent === void 0) { concurrent = Infinity; }
+        return mergeMap(identity, concurrent);
+    }
+
+    function concatAll() {
+        return mergeAll(1);
+    }
+
+    function debounceTime(dueTime, scheduler) {
+        if (scheduler === void 0) { scheduler = asyncScheduler; }
+        return operate(function (source, subscriber) {
+            var activeTask = null;
+            var lastValue = null;
+            var lastTime = null;
+            var emit = function () {
+                if (activeTask) {
+                    activeTask.unsubscribe();
+                    activeTask = null;
+                    var value = lastValue;
+                    lastValue = null;
+                    subscriber.next(value);
+                }
+            };
+            function emitWhenIdle() {
+                var targetTime = lastTime + dueTime;
+                var now = scheduler.now();
+                if (now < targetTime) {
+                    activeTask = this.schedule(undefined, targetTime - now);
+                    subscriber.add(activeTask);
+                    return;
+                }
+                emit();
+            }
+            source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+                lastValue = value;
+                lastTime = scheduler.now();
+                if (!activeTask) {
+                    activeTask = scheduler.schedule(emitWhenIdle, dueTime);
+                    subscriber.add(activeTask);
+                }
+            }, function () {
+                emit();
+                subscriber.complete();
+            }, undefined, function () {
+                lastValue = activeTask = null;
+            }));
+        });
+    }
+
+    function concat$1() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return concatAll()(from(args, popScheduler(args)));
+    }
+
+    var EMPTY = new Observable(function (subscriber) { return subscriber.complete(); });
+
+    function take(count) {
+        return count <= 0
+            ?
+                function () { return EMPTY; }
+            : operate(function (source, subscriber) {
+                var seen = 0;
+                source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+                    if (++seen <= count) {
+                        subscriber.next(value);
+                        if (count <= seen) {
+                            subscriber.complete();
+                        }
+                    }
+                }));
             });
-            this.name = name;
-            this.bc = bc;
+    }
+
+    function ignoreElements() {
+        return operate(function (source, subscriber) {
+            source.subscribe(createOperatorSubscriber(subscriber, noop));
+        });
+    }
+
+    function mapTo(value) {
+        return map(function () { return value; });
+    }
+
+    function delayWhen(delayDurationSelector, subscriptionDelay) {
+        if (subscriptionDelay) {
+            return function (source) {
+                return concat$1(subscriptionDelay.pipe(take(1), ignoreElements()), source.pipe(delayWhen(delayDurationSelector)));
+            };
         }
-        next(message) {
-            console.debug("BroadcastedAndLocalEvent: bc.postMessage()", Object.assign({}, message), "bc is a", this.bc);
-            this.bc.postMessage(message);
-            const ev = new CustomEvent(`lbc-${this.name}`, { detail: message });
-            //self.dispatchEvent(ev);
-            dispatch(ev);
+        return mergeMap(function (value, index) { return delayDurationSelector(value, index).pipe(take(1), mapTo(value)); });
+    }
+
+    function delay(due, scheduler) {
+        if (scheduler === void 0) { scheduler = asyncScheduler; }
+        var duration = timer(due, scheduler);
+        return delayWhen(function () { return duration; });
+    }
+
+    function distinctUntilChanged(comparator, keySelector) {
+        if (keySelector === void 0) { keySelector = identity; }
+        comparator = comparator !== null && comparator !== void 0 ? comparator : defaultCompare;
+        return operate(function (source, subscriber) {
+            var previousKey;
+            var first = true;
+            source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+                var currentKey = keySelector(value);
+                if (first || !comparator(previousKey, currentKey)) {
+                    first = false;
+                    previousKey = currentKey;
+                    subscriber.next(value);
+                }
+            }));
+        });
+    }
+    function defaultCompare(a, b) {
+        return a === b;
+    }
+
+    function filter(predicate, thisArg) {
+        return operate(function (source, subscriber) {
+            var index = 0;
+            source.subscribe(createOperatorSubscriber(subscriber, function (value) { return predicate.call(thisArg, value, index++) && subscriber.next(value); }));
+        });
+    }
+
+    function skip(count) {
+        return filter(function (_, index) { return count <= index; });
+    }
+
+    function startWith() {
+        var values = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            values[_i] = arguments[_i];
         }
+        var scheduler = popScheduler(values);
+        return operate(function (source, subscriber) {
+            (scheduler ? concat$1(values, source, scheduler) : concat$1(values, source)).subscribe(subscriber);
+        });
+    }
+
+    function switchMap(project, resultSelector) {
+        return operate(function (source, subscriber) {
+            var innerSubscriber = null;
+            var index = 0;
+            var isComplete = false;
+            var checkComplete = function () { return isComplete && !innerSubscriber && subscriber.complete(); };
+            source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+                innerSubscriber === null || innerSubscriber === void 0 ? void 0 : innerSubscriber.unsubscribe();
+                var innerIndex = 0;
+                var outerIndex = index++;
+                innerFrom(project(value, outerIndex)).subscribe((innerSubscriber = createOperatorSubscriber(subscriber, function (innerValue) { return subscriber.next(resultSelector ? resultSelector(value, innerValue, outerIndex, innerIndex++) : innerValue); }, function () {
+                    innerSubscriber = null;
+                    checkComplete();
+                })));
+            }, function () {
+                isComplete = true;
+                checkComplete();
+            }));
+        });
+    }
+
+    function tap(observerOrNext, error, complete) {
+        var tapObserver = isFunction(observerOrNext) || error || complete
+            ?
+                { next: observerOrNext, error: error, complete: complete }
+            : observerOrNext;
+        return tapObserver
+            ? operate(function (source, subscriber) {
+                var _a;
+                (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+                var isUnsub = true;
+                source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+                    var _a;
+                    (_a = tapObserver.next) === null || _a === void 0 ? void 0 : _a.call(tapObserver, value);
+                    subscriber.next(value);
+                }, function () {
+                    var _a;
+                    isUnsub = false;
+                    (_a = tapObserver.complete) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+                    subscriber.complete();
+                }, function (err) {
+                    var _a;
+                    isUnsub = false;
+                    (_a = tapObserver.error) === null || _a === void 0 ? void 0 : _a.call(tapObserver, err);
+                    subscriber.error(err);
+                }, function () {
+                    var _a, _b;
+                    if (isUnsub) {
+                        (_a = tapObserver.unsubscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+                    }
+                    (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
+                }));
+            })
+            :
+                identity;
     }
 
     //const hasSW = 'serviceWorker' in navigator;
@@ -244,6 +1783,7 @@
 
     function triggerSync(db, purpose) {
         if (db.cloud.usingServiceWorker) {
+            console.debug('registering sync event');
             registerSyncEvent(db, purpose);
         }
         else {
@@ -272,7 +1812,14 @@
             }
         }
         : (b) => {
-            return btoa(String.fromCharCode.apply(null, ArrayBuffer.isView(b) ? b : new Uint8Array(b)));
+            const u8a = ArrayBuffer.isView(b) ? b : new Uint8Array(b);
+            const CHUNK_SIZE = 0x1000;
+            const strs = [];
+            for (let i = 0, l = u8a.length; i < l; i += CHUNK_SIZE) {
+                const chunk = u8a.subarray(i, i + CHUNK_SIZE);
+                strs.push(String.fromCharCode.apply(null, chunk));
+            }
+            return btoa(strs.join(""));
         };
 
     function computeRealmSetHash({ realms, inviteRealms, }) {
@@ -745,14 +2292,24 @@
         return tablesToSyncify;
     }
 
+    class TokenErrorResponseError extends Error {
+        constructor({ title, message, messageCode, messageParams, }) {
+            super(message);
+            this.name = 'TokenErrorResponseError';
+            this.title = title;
+            this.messageCode = messageCode;
+            this.messageParams = messageParams;
+        }
+    }
+
     function interactWithUser(userInteraction, req) {
         return new Promise((resolve, reject) => {
-            const interactionProps = Object.assign(Object.assign({}, req), { onSubmit: (res) => {
+            const interactionProps = Object.assign(Object.assign({ submitLabel: 'Submit', cancelLabel: 'Cancel' }, req), { onSubmit: (res) => {
                     userInteraction.next(undefined);
                     resolve(res);
                 }, onCancel: () => {
                     userInteraction.next(undefined);
-                    reject(new Dexie__default["default"].AbortError("User cancelled"));
+                    reject(new Dexie.AbortError('User cancelled'));
                 } });
             userInteraction.next(interactionProps);
             // Start subscribing for external updates to db.cloud.userInteraction, and if so, cancel this request.
@@ -771,7 +2328,9 @@
             type: 'message-alert',
             title,
             alerts,
-            fields: {}
+            fields: {},
+            submitLabel: 'OK',
+            cancelLabel: null,
         });
     }
     function promptForEmail(userInteraction, title, emailHint) {
@@ -830,22 +2389,48 @@
             return otp;
         });
     }
+    function confirmLogout(userInteraction, currentUserId, numUnsyncedChanges) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const alerts = [
+                {
+                    type: 'warning',
+                    messageCode: 'LOGOUT_CONFIRMATION',
+                    message: `{numUnsyncedChanges} unsynced changes will get lost!
+                Logout anyway?`,
+                    messageParams: {
+                        currentUserId,
+                        numUnsyncedChanges: numUnsyncedChanges.toString(),
+                    }
+                },
+            ];
+            return yield interactWithUser(userInteraction, {
+                type: 'logout-confirmation',
+                title: 'Confirm Logout',
+                alerts,
+                fields: {},
+                submitLabel: 'Confirm logout',
+                cancelLabel: 'Cancel'
+            })
+                .then(() => true)
+                .catch(() => false);
+        });
+    }
 
     function loadAccessToken(db) {
-        var _a, _b;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const currentUser = yield db.getCurrentUser();
             const { accessToken, accessTokenExpiration, refreshToken, refreshTokenExpiration, claims, } = currentUser;
             if (!accessToken)
-                return;
+                return null;
             const expTime = (_a = accessTokenExpiration === null || accessTokenExpiration === void 0 ? void 0 : accessTokenExpiration.getTime()) !== null && _a !== void 0 ? _a : Infinity;
-            if (expTime > Date.now()) {
-                return accessToken;
+            if (expTime > Date.now() && (((_b = currentUser.license) === null || _b === void 0 ? void 0 : _b.status) || 'ok') === 'ok') {
+                return currentUser;
             }
             if (!refreshToken) {
                 throw new Error(`Refresh token missing`);
             }
-            const refreshExpTime = (_b = refreshTokenExpiration === null || refreshTokenExpiration === void 0 ? void 0 : refreshTokenExpiration.getTime()) !== null && _b !== void 0 ? _b : Infinity;
+            const refreshExpTime = (_c = refreshTokenExpiration === null || refreshTokenExpiration === void 0 ? void 0 : refreshTokenExpiration.getTime()) !== null && _c !== void 0 ? _c : Infinity;
             if (refreshExpTime <= Date.now()) {
                 throw new Error(`Refresh token has expired`);
             }
@@ -853,8 +2438,10 @@
             yield db.table('$logins').update(claims.sub, {
                 accessToken: refreshedLogin.accessToken,
                 accessTokenExpiration: refreshedLogin.accessTokenExpiration,
+                claims: refreshedLogin.claims,
+                license: refreshedLogin.license,
             });
-            return refreshedLogin.accessToken;
+            return refreshedLogin;
         });
     }
     function authenticate(url, context, fetchToken, userInteraction, hints) {
@@ -902,10 +2489,24 @@
             if (res.status !== 200)
                 throw new Error(`RefreshToken: Status ${res.status} from ${url}/token`);
             const response = yield res.json();
+            if (response.type === 'error') {
+                throw new TokenErrorResponseError(response);
+            }
             login.accessToken = response.accessToken;
             login.accessTokenExpiration = response.accessTokenExpiration
                 ? new Date(response.accessTokenExpiration)
                 : undefined;
+            login.claims = response.claims;
+            login.license = {
+                type: response.userType,
+                status: response.claims.license || 'ok',
+            };
+            if (response.evalDaysLeft != null) {
+                login.license.evalDaysLeft = response.evalDaysLeft;
+            }
+            if (response.userValidUntil != null) {
+                login.license.validUntil = new Date(response.userValidUntil);
+            }
             return login;
         });
     }
@@ -937,8 +2538,15 @@
                     public_key: publicKeyPEM,
                     hints,
                 });
+                if (response2.type === 'error') {
+                    throw new TokenErrorResponseError(response2);
+                }
                 if (response2.type !== 'tokens')
                     throw new Error(`Unexpected response type from token endpoint: ${response2.type}`);
+                /*const licenseStatus = response2.claims.license || 'ok';
+                if (licenseStatus !== 'ok') {
+                  throw new InvalidLicenseError(licenseStatus);
+                }*/
                 context.accessToken = response2.accessToken;
                 context.accessTokenExpiration = new Date(response2.accessTokenExpiration);
                 context.refreshToken = response2.refreshToken;
@@ -949,6 +2557,16 @@
                 context.email = response2.claims.email;
                 context.name = response2.claims.name;
                 context.claims = response2.claims;
+                context.license = {
+                    type: response2.userType,
+                    status: response2.claims.license || 'ok',
+                };
+                if (response2.evalDaysLeft != null) {
+                    context.license.evalDaysLeft = response2.evalDaysLeft;
+                }
+                if (response2.userValidUntil != null) {
+                    context.license.validUntil = new Date(response2.userValidUntil);
+                }
                 if (response2.alerts && response2.alerts.length > 0) {
                     yield interactWithUser(userInteraction, {
                         type: 'message-alert',
@@ -960,12 +2578,36 @@
                 return context;
             }
             catch (error) {
-                yield alertUser(userInteraction, 'Authentication Failed', {
-                    type: 'error',
-                    messageCode: 'GENERIC_ERROR',
-                    message: `We're having a problem authenticating right now.`,
-                    messageParams: {},
-                }).catch(() => { });
+                if (error instanceof TokenErrorResponseError) {
+                    yield alertUser(userInteraction, error.title, {
+                        type: 'error',
+                        messageCode: error.messageCode,
+                        message: error.message,
+                        messageParams: {},
+                    });
+                    throw error;
+                }
+                let message = `We're having a problem authenticating right now.`;
+                console.error(`Error authenticating`, error);
+                if (error instanceof TypeError) {
+                    const isOffline = typeof navigator !== undefined && !navigator.onLine;
+                    if (isOffline) {
+                        message = `You seem to be offline. Please connect to the internet and try again.`;
+                    }
+                    else if (Dexie.debug || (typeof location !== 'undefined' && (location.hostname === 'localhost' || location.hostname === '127.0.0.1'))) {
+                        // The audience is most likely the developer. Suggest to whitelist the localhost origin:
+                        message = `Could not connect to server. Please verify that your origin '${location.origin}' is whitelisted using \`npx dexie-cloud whitelist\``;
+                    }
+                    else {
+                        message = `Could not connect to server. Please verify the connection.`;
+                    }
+                    yield alertUser(userInteraction, 'Authentication Failed', {
+                        type: 'error',
+                        messageCode: 'GENERIC_ERROR',
+                        message,
+                        messageParams: {},
+                    }).catch(() => { });
+                }
                 throw error;
             }
         });
@@ -1187,13 +2829,13 @@
         },
     };
 
-    const _global = typeof globalThis !== "undefined"
+    const _global = typeof globalThis !== "undefined" // All modern environments (node, bun, deno, browser, workers, webview etc)
         ? globalThis
-        : typeof self !== "undefined"
+        : typeof self !== "undefined" // Older browsers, workers, webview, window etc
             ? self
-            : typeof global === "undefined"
+            : typeof global !== "undefined" // Older versions of node
                 ? global
-                : undefined;
+                : undefined; // Unsupported environment. No idea to return 'this' since we are in a module or a function scope anyway.
 
     var TypedArraysDefs = [
         "Int8Array",
@@ -1569,7 +3211,7 @@
                         const rewrittenKey = `${key}:${currentUser.userId}`;
                         mutClone.keys[keyIndex] = rewrittenKey;
                         if (rewriteValues) {
-                            Dexie__default["default"].setByKeyPath(mutClone.values[keyIndex], primaryKey.keyPath, rewrittenKey);
+                            Dexie.setByKeyPath(mutClone.values[keyIndex], primaryKey.keyPath, rewrittenKey);
                         }
                     }
                 });
@@ -1588,6 +3230,40 @@
                 : change.muts.map((m) => (Object.assign(Object.assign({}, m), { keys: m.keys.slice() }))) });
     }
 
+    // If we get Ratelimit-Limit and Ratelimit-Remaining where Ratelimit-Remaining is below
+    // (Ratelimit-Limit / 2), we should delay the next sync by (Ratelimit-Reset / Ratelimit-Remaining)
+    // seconds (given that there is a Ratelimit-Reset header).
+    let syncRatelimitDelays = new WeakMap();
+    function checkSyncRateLimitDelay(db) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const delatMilliseconds = ((_b = (_a = syncRatelimitDelays.get(db)) === null || _a === void 0 ? void 0 : _a.getTime()) !== null && _b !== void 0 ? _b : 0) - Date.now();
+            if (delatMilliseconds > 0) {
+                console.debug(`Stalling sync request ${delatMilliseconds} ms to spare ratelimits`);
+                yield new Promise(resolve => setTimeout(resolve, delatMilliseconds));
+            }
+        });
+    }
+    function updateSyncRateLimitDelays(db, res) {
+        const limit = res.headers.get('Ratelimit-Limit');
+        const remaining = res.headers.get('Ratelimit-Remaining');
+        const reset = res.headers.get('Ratelimit-Reset');
+        if (limit && remaining && reset) {
+            const limitNum = Number(limit);
+            const remainingNum = Math.max(0, Number(remaining));
+            const willResetInSeconds = Number(reset);
+            if (remainingNum < limitNum / 2) {
+                const delay = Math.ceil(willResetInSeconds / (remainingNum + 1));
+                syncRatelimitDelays.set(db, new Date(Date.now() + delay * 1000));
+                console.debug(`Sync ratelimit delay set to ${delay} seconds`);
+            }
+            else {
+                syncRatelimitDelays.delete(db);
+                console.debug(`Sync ratelimit delay cleared`);
+            }
+        }
+    }
+
     //import {BisonWebStreamReader} from "dreambase-library/dist/typeson-simplified/BisonWebStreamReader";
     function syncWithServer(changes, syncState, baseRevs, db, databaseUrl, schema, clientIdentity, currentUser) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1596,9 +3272,20 @@
             //
             const headers = {
                 Accept: 'application/json, application/x-bison, application/x-bison-stream',
-                'Content-Type': 'application/tson'
+                'Content-Type': 'application/tson',
             };
-            const accessToken = yield loadAccessToken(db);
+            const updatedUser = yield loadAccessToken(db);
+            /*
+            if (updatedUser?.license && changes.length > 0) {
+              if (updatedUser.license.status === 'expired') {
+                throw new Error(`License has expired`);
+              }
+              if (updatedUser.license.status === 'deactivated') {
+                throw new Error(`License deactivated`);
+              }
+            }
+            */
+            const accessToken = updatedUser === null || updatedUser === void 0 ? void 0 : updatedUser.accessToken;
             if (accessToken) {
                 headers.Authorization = `Bearer ${accessToken}`;
             }
@@ -1607,27 +3294,31 @@
                 dbID: syncState === null || syncState === void 0 ? void 0 : syncState.remoteDbId,
                 clientIdentity,
                 schema: schema || {},
-                lastPull: syncState ? {
-                    serverRevision: syncState.serverRevision,
-                    realms: syncState.realms,
-                    inviteRealms: syncState.inviteRealms
-                } : undefined,
+                lastPull: syncState
+                    ? {
+                        serverRevision: syncState.serverRevision,
+                        realms: syncState.realms,
+                        inviteRealms: syncState.inviteRealms,
+                    }
+                    : undefined,
                 baseRevs,
-                changes: encodeIdsForServer(db.dx.core.schema, currentUser, changes)
+                changes: encodeIdsForServer(db.dx.core.schema, currentUser, changes),
             };
-            console.debug("Sync request", syncRequest);
+            console.debug('Sync request', syncRequest);
             db.syncStateChangedEvent.next({
                 phase: 'pushing',
             });
             const res = yield fetch(`${databaseUrl}/sync`, {
                 method: 'post',
                 headers,
-                body: TSON.stringify(syncRequest)
+                credentials: 'include',
+                body: TSON.stringify(syncRequest),
             });
             //const contentLength = Number(res.headers.get('content-length'));
             db.syncStateChangedEvent.next({
-                phase: 'pulling'
+                phase: 'pulling',
             });
+            updateSyncRateLimitDelays(db, res);
             if (!res.ok) {
                 throw new HttpError(res);
             }
@@ -1684,7 +3375,7 @@
 
     function throwIfCancelled(cancelToken) {
         if (cancelToken === null || cancelToken === void 0 ? void 0 : cancelToken.cancelled)
-            throw new Dexie__default["default"].AbortError(`Operation was cancelled`);
+            throw new Dexie.AbortError(`Operation was cancelled`);
     }
 
     /* Need this because navigator.onLine seems to say "false" when it is actually online.
@@ -1736,7 +3427,7 @@
                             }
                         }
                         else {
-                            Dexie__default["default"].setByKeyPath(obj, keyPath, value);
+                            Dexie.setByKeyPath(obj, keyPath, value);
                         }
                     }
                     resultKeys.push(key);
@@ -1751,7 +3442,7 @@
 
     function applyServerChanges(changes, db) {
         return __awaiter(this, void 0, void 0, function* () {
-            console.debug('Applying server changes', changes, Dexie__default["default"].currentTransaction);
+            console.debug('Applying server changes', changes, Dexie.currentTransaction);
             for (const { table: tableName, muts } of changes) {
                 const table = db.table(tableName);
                 if (!table)
@@ -1788,7 +3479,7 @@
                             else {
                                 keys.forEach((key, i) => {
                                     // Make sure inbound keys are consistent
-                                    Dexie__default["default"].setByKeyPath(mut.values[i], primaryKey.keyPath, key);
+                                    Dexie.setByKeyPath(mut.values[i], primaryKey.keyPath, key);
                                 });
                                 yield table.bulkAdd(mut.values);
                             }
@@ -1800,7 +3491,7 @@
                             else {
                                 keys.forEach((key, i) => {
                                     // Make sure inbound keys are consistent
-                                    Dexie__default["default"].setByKeyPath(mut.values[i], primaryKey.keyPath, key);
+                                    Dexie.setByKeyPath(mut.values[i], primaryKey.keyPath, key);
                                 });
                                 yield table.bulkPut(mut.values);
                             }
@@ -1829,12 +3520,13 @@
     function sync(db, options, schema, syncOptions) {
         return _sync
             .apply(this, arguments)
-            .then(() => {
+            .then((result) => {
             if (!(syncOptions === null || syncOptions === void 0 ? void 0 : syncOptions.justCheckIfNeeded)) { // && syncOptions?.purpose !== 'push') {
                 db.syncStateChangedEvent.next({
                     phase: 'in-sync',
                 });
             }
+            return result;
         })
             .catch((error) => __awaiter(this, void 0, void 0, function* () {
             if (syncOptions === null || syncOptions === void 0 ? void 0 : syncOptions.justCheckIfNeeded)
@@ -2049,6 +3741,7 @@
             }));
             if (!done) {
                 console.debug('MORE SYNC NEEDED. Go for it again!');
+                yield checkSyncRateLimitDelay(db);
                 return yield _sync(db, options, schema, { isInitialSync, cancelToken });
             }
             console.debug('SYNC DONE', { isInitialSync });
@@ -2168,7 +3861,7 @@
                         // It's no need to have two channels at the same time - even though it wouldnt
                         // be a problem - this is an optimization.
                         yield db.cloud.syncState
-                            .pipe(operators.filter(({ phase }) => phase === 'in-sync' || phase === 'error'), operators.take(1))
+                            .pipe(filter(({ phase }) => phase === 'in-sync' || phase === 'error'), take(1))
                             .toPromise();
                         console.debug('processing msg', msg);
                         const persistedSyncState = db.cloud.persistedSyncState.value;
@@ -2185,6 +3878,8 @@
                                 yield db.table('$logins').update(user.userId, {
                                     accessToken: refreshedLogin.accessToken,
                                     accessTokenExpiration: refreshedLogin.accessTokenExpiration,
+                                    claims: refreshedLogin.claims,
+                                    license: refreshedLogin.license,
                                 });
                                 // Updating $logins will trigger emission of db.cloud.currentUser observable, which
                                 // in turn will lead to that connectWebSocket.ts will reconnect the socket with the
@@ -2261,7 +3956,7 @@
                                         return; // Ignore message
                                     }
                                     // Verify also that the message is based on the exact same set of realms
-                                    const ourRealmSetHash = yield Dexie__default["default"].waitFor(
+                                    const ourRealmSetHash = yield Dexie.waitFor(
                                     // Keep TX in non-IDB work
                                     computeRealmSetHash(syncState));
                                     console.debug('ourRealmSetHash', ourRealmSetHash);
@@ -2455,6 +4150,61 @@
         }
     }
 
+    function waitUntil(o, // Works with Dexie's liveQuery observables if we'd need that
+    predicate) {
+        return rxjs.firstValueFrom(rxjs.from(o).pipe(rxjs.filter(predicate)));
+    }
+
+    function logout(db) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const numUnsyncedChanges = yield _logout(db);
+            if (numUnsyncedChanges) {
+                if (yield confirmLogout(db.cloud.userInteraction, db.cloud.currentUserId, numUnsyncedChanges)) {
+                    yield _logout(db, { deleteUnsyncedData: true });
+                }
+                else {
+                    throw new Error(`User cancelled logout due to unsynced changes`);
+                }
+            }
+        });
+    }
+    function _logout(db, { deleteUnsyncedData = false } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Clear the database without emptying configuration options.
+            const [numUnsynced, loggedOut] = yield db.dx.transaction('rw', db.dx.tables, (tx) => __awaiter(this, void 0, void 0, function* () {
+                // @ts-ignore
+                const idbtrans = tx.idbtrans;
+                idbtrans.disableChangeTracking = true;
+                idbtrans.disableAccessControl = true;
+                const mutationTables = tx.storeNames.filter((tableName) => tableName.endsWith('_mutations'));
+                // Count unsynced changes
+                const unsyncCounts = yield Promise.all(mutationTables.map((mutationTable) => tx.table(mutationTable).count()));
+                const sumUnSynced = unsyncCounts.reduce((a, b) => a + b, 0);
+                if (sumUnSynced > 0 && !deleteUnsyncedData) {
+                    // Let caller ask user if they want to delete unsynced data.
+                    return [sumUnSynced, false];
+                }
+                // Either there are no unsynched changes, or caller provided flag deleteUnsynchedData = true.
+                // Clear all tables except $jobs and $syncState (except the persisted sync state which is
+                // also cleared because we're going to rebuild it using a fresh sync).
+                db.$syncState.delete('syncState');
+                for (const table of db.dx.tables) {
+                    if (table.name !== '$jobs' && table.name !== '$syncState') {
+                        table.clear();
+                    }
+                }
+                return [sumUnSynced, true];
+            }));
+            if (loggedOut) {
+                // Wait for currentUser observable to emit UNAUTHORIZED_USER
+                yield waitUntil(db.cloud.currentUser, (user) => user.userId === UNAUTHORIZED_USER.userId);
+                // Then perform an initial sync
+                yield db.cloud.sync({ purpose: 'pull', wait: true });
+            }
+            return numUnsynced;
+        });
+    }
+
     function otpFetchTokenCallback(db) {
         const { userInteraction } = db.cloud;
         return function otpAuthenticate({ public_key, hints }) {
@@ -2498,8 +4248,9 @@
                     throw new HttpError(res1, errMsg);
                 }
                 const response = yield res1.json();
-                if (response.type === 'tokens') {
+                if (response.type === 'tokens' || response.type === 'error') {
                     // Demo user request can get a "tokens" response right away
+                    // Error can also be returned right away.
                     return response;
                 }
                 else if (tokenRequest.grant_type === 'otp') {
@@ -2531,12 +4282,6 @@
                     }
                     if (res2.status !== 200) {
                         const errMsg = yield res2.text();
-                        yield alertUser(userInteraction, "OTP Authentication Failed", {
-                            type: 'error',
-                            messageCode: 'GENERIC_ERROR',
-                            message: errMsg,
-                            messageParams: {}
-                        }).catch(() => { });
                         throw new HttpError(res2, errMsg);
                     }
                     const response2 = yield res2.json();
@@ -2549,6 +4294,18 @@
         };
     }
 
+    /** A way to log to console in production without terser stripping out
+     * it from the release bundle.
+     * This should be used very rarely and only in places where it's
+     * absolutely necessary to log something in production.
+     *
+     * @param level
+     * @param args
+     */
+    function prodLog(level, ...args) {
+        globalThis["con" + "sole"][level](...args);
+    }
+
     /** This function changes or sets the current user as requested.
      *
      * Use cases:
@@ -2575,85 +4332,73 @@
                 }));
                 user.isLoggedIn = true;
                 user.lastLogin = new Date();
-                yield user.save();
-                console.debug('Saved new user', user.email);
-            }));
-            yield new Promise((resolve) => {
-                if (db.cloud.currentUserId === user.userId) {
-                    resolve(null);
+                try {
+                    yield user.save();
                 }
-                else {
-                    const subscription = db.cloud.currentUser.subscribe((currentUser) => {
-                        if (currentUser.userId === user.userId) {
-                            subscription.unsubscribe();
-                            resolve(null);
+                catch (e) {
+                    try {
+                        if (e.name === 'DataCloneError') {
+                            // We've seen this buggy behavior in some browsers and in case it happens
+                            // again we really need to collect the details to understand what's going on.
+                            prodLog('debug', `Login context property names:`, Object.keys(user));
+                            prodLog('debug', `Login context property names:`, Object.keys(user));
+                            prodLog('debug', `Login context:`, user);
+                            prodLog('debug', `Login context JSON:`, JSON.stringify(user));
                         }
-                    });
+                    }
+                    catch (_a) { }
+                    throw e;
                 }
-            });
-            // TANKAR!!!!
-            // V: Service workern kommer inte ha tillgång till currentUserObservable om den inte istället härrör från ett liveQuery.
-            // V: Samma med andra windows.
-            // V: Så kanske göra om den till att häröra från liveQuery som läser $logins.orderBy('lastLogin').last().
-            // V: Då bara vara medveten om:
-            //    V: En sån observable börjar hämta data vid första subscribe
-            //    V: Vi har inget "inital value" men kan emulera det till att vara ANONYMOUS_USER
-            //    V: Om requireAuth är true, så borde db.on(ready) hålla databasen stängd för alla utom denna observable.
-            //    V: Om inte så behöver den inte blocka.
-            // Andra tankar:
-            //    * Man kan inte byta användare när man är offline. Skulle gå att flytta realms till undanstuff-tabell vid user-change.
-            //      men troligen inte värt det.
-            //    * Istället: sälj inte inte switch-user funktionalitet utan tala enbart om inloggat vs icke inloggat läge.
-            //    * populate $logins med ANONYMOUS så att en påbörjad inloggning inte räknas, alternativt ha en boolean prop!
-            //      Kanske bäst ha en boolean prop!
-            //    * Alternativ switch-user funktionalitet:
-            //      * DBCore gömmer data från realms man inte har tillgång till.
-            //      * Cursor impl behövs också då.
-            //      * Då blir det snabba user switch.
-            //      * claims-settet som skickas till servern blir summan av alla claims. Då måste servern stödja multipla tokens eller
-            //        att ens token är ett samlad.
+                console.debug('Saved new user', user.email);
+            }));
+            yield waitUntil(db.cloud.currentUser, (currentUser) => currentUser.userId === user.userId);
         });
     }
 
     function login(db, hints) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const currentUser = yield db.getCurrentUser();
-            if (currentUser.isLoggedIn) {
-                if (hints) {
-                    if (hints.email && db.cloud.currentUser.value.email !== hints.email) {
-                        throw new Error(`Must logout before changing user`);
-                    }
-                    if (hints.userId && db.cloud.currentUserId !== hints.userId) {
-                        throw new Error(`Must logout before changing user`);
-                    }
+            const origUserId = currentUser.userId;
+            if (currentUser.isLoggedIn && (!hints || (!hints.email && !hints.userId))) {
+                const licenseStatus = ((_a = currentUser.license) === null || _a === void 0 ? void 0 : _a.status) || 'ok';
+                if (licenseStatus === 'ok' && currentUser.accessToken && (!currentUser.accessTokenExpiration || currentUser.accessTokenExpiration.getTime() > Date.now())) {
+                    // Already authenticated according to given hints. And license is valid.
+                    return false;
                 }
-                // Already authenticated according to given hints.
-                return false;
+                if (currentUser.refreshToken && (!currentUser.refreshTokenExpiration || currentUser.refreshTokenExpiration.getTime() > Date.now())) {
+                    // Refresh the token
+                    yield loadAccessToken(db);
+                    return false;
+                }
+                // No refresh token - must re-authenticate:
             }
             const context = new AuthPersistedContext(db, {
                 claims: {},
                 lastLogin: new Date(0),
             });
             yield authenticate(db.cloud.options.databaseUrl, context, db.cloud.options.fetchTokens || otpFetchTokenCallback(db), db.cloud.userInteraction, hints);
-            try {
-                yield context.save();
+            if (origUserId !== UNAUTHORIZED_USER.userId && context.userId !== origUserId) {
+                // User was logged in before, but now logged in as another user.
+                yield logout(db);
             }
-            catch (e) {
-                try {
-                    if (e.name === 'DataCloneError') {
-                        console.debug(`Login context property names:`, Object.keys(context));
-                        console.debug(`Login context:`, context);
-                        console.debug(`Login context JSON:`, JSON.stringify(context));
-                    }
+            /*try {
+              await context.save();
+            } catch (e) {
+              try {
+                if (e.name === 'DataCloneError') {
+                  console.debug(`Login context property names:`, Object.keys(context));
+                  console.debug(`Login context:`, context);
+                  console.debug(`Login context JSON:`, JSON.stringify(context));
                 }
-                catch (_a) { }
-                throw e;
-            }
+              } catch {}
+              throw e;
+            }*/
             yield setCurrentUser(db, context);
             // Make sure to resync as the new login will be authorized
             // for new realms.
             triggerSync(db, "pull");
-            return true;
+            return context.userId !== origUserId;
         });
     }
 
@@ -2697,7 +4442,7 @@
     const IS_SERVICE_WORKER = typeof self !== "undefined" && "clients" in self && !self.document;
 
     function throwVersionIncrementNeeded() {
-        throw new Dexie__default["default"].SchemaError(`Version increment needed to allow dexie-cloud change tracking`);
+        throw new Dexie.SchemaError(`Version increment needed to allow dexie-cloud change tracking`);
     }
 
     const { toString } = {};
@@ -2813,14 +4558,14 @@
                                     if (!table.schema.primaryKey.outbound) {
                                         if (!valueClones)
                                             valueClones = req.values.slice();
-                                        valueClones[idx] = Dexie__default["default"].deepClone(valueClones[idx]);
-                                        Dexie__default["default"].setByKeyPath(valueClones[idx], table.schema.primaryKey.keyPath, keys[idx]);
+                                        valueClones[idx] = Dexie.deepClone(valueClones[idx]);
+                                        Dexie.setByKeyPath(valueClones[idx], table.schema.primaryKey.keyPath, keys[idx]);
                                     }
                                 }
                                 else if (typeof key !== 'string' ||
                                     (!key.startsWith(idPrefix) && !key.startsWith('#' + idPrefix))) {
                                     // Key was specified by caller. Verify it complies with id prefix.
-                                    throw new Dexie__default["default"].ConstraintError(`The ID "${key}" is not valid for table "${tableName}". ` +
+                                    throw new Dexie.ConstraintError(`The ID "${key}" is not valid for table "${tableName}". ` +
                                         `Primary '@' keys requires the key to be prefixed with "${idPrefix}" (or "#${idPrefix}).\n` +
                                         `If you want to generate IDs programmatically, remove '@' from the schema to get rid of this constraint. Dexie Cloud supports custom IDs as long as they are random and globally unique.`);
                                 }
@@ -2845,7 +4590,7 @@
                                                     const type = Array.isArray(key)
                                                         ? key.map(toStringTag).join(',')
                                                         : toStringTag(key);
-                                                    throw new Dexie__default["default"].ConstraintError(`Invalid primary key type ${type} for table ${tableName}. Tables marked for sync has primary keys of type string or Array of string (and optional numbers)`);
+                                                    throw new Dexie.ConstraintError(`Invalid primary key type ${type} for table ${tableName}. Tables marked for sync has primary keys of type string or Array of string (and optional numbers)`);
                                                 }
                                             });
                                         }
@@ -2982,6 +4727,13 @@
 
     const outstandingTransactions = new rxjs.BehaviorSubject(new Set());
 
+    function isEagerSyncDisabled(db) {
+        var _a, _b, _c, _d;
+        return (((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.disableEagerSync) ||
+            ((_c = (_b = db.cloud.currentUser.value) === null || _b === void 0 ? void 0 : _b.license) === null || _c === void 0 ? void 0 : _c.status) !== 'ok' ||
+            !((_d = db.cloud.options) === null || _d === void 0 ? void 0 : _d.databaseUrl));
+    }
+
     /** Tracks all mutations in the same transaction as the mutations -
      * so it is guaranteed that no mutation goes untracked - and if transaction
      * aborts, the mutations won't be tracked.
@@ -2990,7 +4742,7 @@
      * changes to server and cleanup the tracked mutations once the server has
      * ackowledged that it got them.
      */
-    function createMutationTrackingMiddleware({ currentUserObservable, db }) {
+    function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
         return {
             stack: 'dbcore',
             name: 'MutationTrackingMiddleware',
@@ -3001,7 +4753,7 @@
                 try {
                     mutTableMap = new Map(ordinaryTables.map((tbl) => [
                         tbl.name,
-                        core.table(`$${tbl.name}_mutations`)
+                        core.table(`$${tbl.name}_mutations`),
                     ]));
                 }
                 catch (_a) {
@@ -3035,15 +4787,9 @@
                                 outstandingTransactions.next(outstandingTransactions.value);
                             };
                             const txComplete = () => {
-                                var _a;
-                                if (tx.mutationsAdded && ((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.databaseUrl)) {
-                                    if (db.cloud.usingServiceWorker) {
-                                        console.debug('registering sync event');
-                                        registerSyncEvent(db, "push");
-                                    }
-                                    else {
-                                        db.localSyncEvent.next({ purpose: "push" });
-                                    }
+                                if (tx.mutationsAdded &&
+                                    !isEagerSyncDisabled(db)) {
+                                    triggerSync(db, 'push');
                                 }
                                 removeTransaction();
                             };
@@ -3110,7 +4856,7 @@
                                         .query({
                                         query: { range: req.range, index: schema.primaryKey },
                                         trans: req.trans,
-                                        values: false
+                                        values: false,
                                     })
                                         // Do a delete request instead, but keep the criteria info for the server to execute
                                         .then((res) => {
@@ -3118,7 +4864,7 @@
                                             type: 'delete',
                                             keys: res.result,
                                             trans: req.trans,
-                                            criteria: { index: null, range: req.range }
+                                            criteria: { index: null, range: req.range },
                                         });
                                     })
                                     : mutateAndLog(req);
@@ -3126,7 +4872,7 @@
                         function mutateAndLog(req) {
                             const trans = req.trans;
                             trans.mutationsAdded = true;
-                            const { txid, currentUser: { userId } } = trans;
+                            const { txid, currentUser: { userId }, } = trans;
                             const { type } = req;
                             const opNo = ++trans.opCount;
                             return table.mutate(req).then((res) => {
@@ -3147,7 +4893,7 @@
                                         keys,
                                         criteria: req.criteria,
                                         txid,
-                                        userId
+                                        userId,
                                     }
                                     : req.type === 'add'
                                         ? {
@@ -3157,7 +4903,7 @@
                                             keys,
                                             txid,
                                             userId,
-                                            values
+                                            values,
                                         }
                                         : req.criteria && req.changeSpec
                                             ? {
@@ -3169,7 +4915,7 @@
                                                 criteria: req.criteria,
                                                 changeSpec: req.changeSpec,
                                                 txid,
-                                                userId
+                                                userId,
                                             }
                                             : updates
                                                 ? {
@@ -3180,7 +4926,7 @@
                                                     keys: updates.keys,
                                                     changeSpecs: updates.changeSpecs,
                                                     txid,
-                                                    userId
+                                                    userId,
                                                 }
                                                 : {
                                                     type: 'upsert',
@@ -3189,7 +4935,7 @@
                                                     keys,
                                                     values,
                                                     txid,
-                                                    userId
+                                                    userId,
                                                 };
                                 return keys.length > 0 || ('criteria' in req && req.criteria)
                                     ? mutsTable
@@ -3199,7 +4945,7 @@
                             });
                         }
                     } });
-            }
+            },
         };
     }
 
@@ -3291,13 +5037,13 @@
     //   for just a short time.
     const userIsReallyActive = new rxjs.BehaviorSubject(true);
     userIsActive
-        .pipe(operators.switchMap((isActive) => {
+        .pipe(switchMap((isActive) => {
         //console.debug('SyncStatus: DUBB: isActive changed to', isActive);
         return isActive
             ? rxjs.of(true)
-            : rxjs.of(false).pipe(operators.delay(INACTIVE_WAIT_TIME))
+            : rxjs.of(false).pipe(delay(INACTIVE_WAIT_TIME))
                 ;
-    }), operators.distinctUntilChanged())
+    }), distinctUntilChanged())
         .subscribe(userIsReallyActive);
     //
     // First create some corner-stone observables to build the flow on
@@ -3307,9 +5053,9 @@
         ? rxjs.fromEvent(document, 'visibilitychange')
         : rxjs.of({});
     // document.onvisibilitychange makes document hidden:
-    const documentBecomesHidden = visibilityStateIsChanged.pipe(operators.filter(() => document.visibilityState === 'hidden'));
+    const documentBecomesHidden = visibilityStateIsChanged.pipe(filter(() => document.visibilityState === 'hidden'));
     // document.onvisibilitychange makes document visible
-    const documentBecomesVisible = visibilityStateIsChanged.pipe(operators.filter(() => document.visibilityState === 'visible'));
+    const documentBecomesVisible = visibilityStateIsChanged.pipe(filter(() => document.visibilityState === 'visible'));
     // Any of various user-activity-related events happen:
     const userDoesSomething = typeof window !== 'undefined'
         ? rxjs.merge(documentBecomesVisible, rxjs.fromEvent(window, 'mousedown'), rxjs.fromEvent(window, 'mousemove'), rxjs.fromEvent(window, 'keydown'), rxjs.fromEvent(window, 'wheel'), rxjs.fromEvent(window, 'touchmove'))
@@ -3327,9 +5073,9 @@
         userDoesSomething)
             .pipe(
         // No matter event source, compute whether user is visible using visibilityState:
-        operators.map(() => document.visibilityState === 'visible'), 
+        map(() => document.visibilityState === 'visible'), 
         // Make sure to emit it
-        operators.tap((isActive) => {
+        tap((isActive) => {
             if (userIsActive.value !== isActive) {
                 // Emit new value unless it already has that value
                 userIsActive.next(isActive);
@@ -3337,8 +5083,8 @@
         }), 
         // Now, if true was emitted, make sure to set a timeout to emit false
         // unless new user activity things happen (in that case, the timeout will be cancelled!)
-        operators.switchMap((isActive) => isActive
-            ? rxjs.of(0).pipe(operators.delay(USER_INACTIVITY_TIMEOUT - INACTIVE_WAIT_TIME), operators.tap(() => userIsActive.next(false)))
+        switchMap((isActive) => isActive
+            ? rxjs.of(0).pipe(delay(USER_INACTIVITY_TIMEOUT - INACTIVE_WAIT_TIME), tap(() => userIsActive.next(false)))
             : rxjs.of(0)))
             .subscribe(() => { }); // Unless we subscribe nothing will be propagated to userIsActive observable
     }
@@ -3558,6 +5304,20 @@
         }
     }
 
+    class InvalidLicenseError extends Error {
+        constructor(license) {
+            super(license === 'expired'
+                ? `License expired`
+                : license === 'deactivated'
+                    ? `User deactivated`
+                    : 'Invalid license');
+            this.name = 'InvalidLicenseError';
+            if (license) {
+                this.license = license;
+            }
+        }
+    }
+
     function sleep$1(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
@@ -3568,7 +5328,7 @@
             yield sleep$1(3000);
             // Wait til user does something (move mouse, tap, scroll, click etc)
             console.debug('waiting for someone to do something');
-            yield userDoesSomething.pipe(operators.take(1)).toPromise();
+            yield userDoesSomething.pipe(take(1)).toPromise();
             console.debug('someone did something!');
         });
     }
@@ -3577,10 +5337,10 @@
         if (!((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.databaseUrl)) {
             throw new Error(`No database URL to connect WebSocket to`);
         }
-        const messageProducer = db.messageConsumer.readyToServe.pipe(operators.filter((isReady) => isReady), // When consumer is ready for new messages, produce such a message to inform server about it
-        operators.switchMap(() => db.getPersistedSyncState()), // We need the info on which server revision we are at:
-        operators.filter((syncState) => syncState && syncState.serverRevision), // We wont send anything to server before inital sync has taken place
-        operators.switchMap((syncState) => __awaiter(this, void 0, void 0, function* () {
+        const messageProducer = db.messageConsumer.readyToServe.pipe(filter((isReady) => isReady), // When consumer is ready for new messages, produce such a message to inform server about it
+        switchMap(() => db.getPersistedSyncState()), // We need the info on which server revision we are at:
+        filter((syncState) => syncState && syncState.serverRevision), // We wont send anything to server before inital sync has taken place
+        switchMap((syncState) => __awaiter(this, void 0, void 0, function* () {
             return ({
                 // Produce the message to trigger server to send us new messages to consume:
                 type: 'ready',
@@ -3589,17 +5349,22 @@
             });
         })));
         function createObservable() {
-            return db.cloud.persistedSyncState.pipe(operators.filter((syncState) => syncState === null || syncState === void 0 ? void 0 : syncState.serverRevision), // Don't connect before there's no initial sync performed.
-            operators.take(1), // Don't continue waking up whenever syncState change
-            operators.switchMap((syncState) => db.cloud.currentUser.pipe(operators.map((userLogin) => [userLogin, syncState]))), operators.switchMap(([userLogin, syncState]) => userIsReallyActive.pipe(operators.map((isActive) => [isActive ? userLogin : null, syncState]))), operators.switchMap(([userLogin, syncState]) => {
+            return db.cloud.persistedSyncState.pipe(filter((syncState) => syncState === null || syncState === void 0 ? void 0 : syncState.serverRevision), // Don't connect before there's no initial sync performed.
+            take(1), // Don't continue waking up whenever syncState change
+            switchMap((syncState) => db.cloud.currentUser.pipe(map((userLogin) => [userLogin, syncState]))), switchMap(([userLogin, syncState]) => {
+                /*if (userLogin.license?.status && userLogin.license.status !== 'ok') {
+                  throw new InvalidLicenseError();
+                }*/
+                return userIsReallyActive.pipe(map((isActive) => [isActive ? userLogin : null, syncState]));
+            }), switchMap(([userLogin, syncState]) => {
                 if ((userLogin === null || userLogin === void 0 ? void 0 : userLogin.isLoggedIn) && !(syncState === null || syncState === void 0 ? void 0 : syncState.realms.includes(userLogin.userId))) {
                     // We're in an in-between state when user is logged in but the user's realms are not yet synced.
                     // Don't make this change reconnect the websocket just yet. Wait till syncState is updated
                     // to iclude the user's realm.
-                    return db.cloud.persistedSyncState.pipe(operators.filter((syncState) => (syncState === null || syncState === void 0 ? void 0 : syncState.realms.includes(userLogin.userId)) || false), operators.take(1), operators.map((syncState) => [userLogin, syncState]));
+                    return db.cloud.persistedSyncState.pipe(filter((syncState) => (syncState === null || syncState === void 0 ? void 0 : syncState.realms.includes(userLogin.userId)) || false), take(1), map((syncState) => [userLogin, syncState]));
                 }
                 return new rxjs.BehaviorSubject([userLogin, syncState]);
-            }), operators.switchMap(([userLogin, syncState]) => __awaiter(this, void 0, void 0, function* () { return [userLogin, yield computeRealmSetHash(syncState)]; })), operators.distinctUntilChanged(([prevUser, prevHash], [currUser, currHash]) => prevUser === currUser && prevHash === currHash), operators.switchMap(([userLogin, realmSetHash]) => {
+            }), switchMap(([userLogin, syncState]) => __awaiter(this, void 0, void 0, function* () { return [userLogin, yield computeRealmSetHash(syncState)]; })), distinctUntilChanged(([prevUser, prevHash], [currUser, currHash]) => prevUser === currUser && prevHash === currHash), switchMap(([userLogin, realmSetHash]) => {
                 // Let server end query changes from last entry of same client-ID and forward.
                 // If no new entries, server won't bother the client. If new entries, server sends only those
                 // and the baseRev of the last from same client-ID.
@@ -3609,10 +5374,10 @@
                 else {
                     return rxjs.from([]);
                 }
-            }), operators.catchError((error) => {
+            }), catchError((error) => {
                 if ((error === null || error === void 0 ? void 0 : error.name) === 'TokenExpiredError') {
                     console.debug('WebSocket observable: Token expired. Refreshing token...');
-                    return rxjs.of(true).pipe(operators.switchMap(() => __awaiter(this, void 0, void 0, function* () {
+                    return rxjs.of(true).pipe(switchMap(() => __awaiter(this, void 0, void 0, function* () {
                         // Refresh access token
                         const user = yield db.getCurrentUser();
                         const refreshedLogin = yield refreshAccessToken(db.cloud.options.databaseUrl, user);
@@ -3620,15 +5385,21 @@
                         yield db.table('$logins').update(user.userId, {
                             accessToken: refreshedLogin.accessToken,
                             accessTokenExpiration: refreshedLogin.accessTokenExpiration,
+                            claims: refreshedLogin.claims,
+                            license: refreshedLogin.license,
                         });
-                    })), operators.switchMap(() => createObservable()));
+                    })), switchMap(() => createObservable()));
                 }
                 else {
-                    return rxjs.throwError(error);
+                    return rxjs.throwError(() => error);
                 }
-            }), operators.catchError((error) => {
+            }), catchError((error) => {
                 db.cloud.webSocketStatus.next("error");
-                return rxjs.from(waitAndReconnectWhenUserDoesSomething(error)).pipe(operators.switchMap(() => createObservable()));
+                if (error instanceof InvalidLicenseError) {
+                    // Don't retry. Just throw and don't try connect again.
+                    return rxjs.throwError(() => error);
+                }
+                return rxjs.from(waitAndReconnectWhenUserDoesSomething(error)).pipe(switchMap(() => createObservable()));
             }));
         }
         return createObservable().subscribe({
@@ -3656,97 +5427,12 @@
         });
     }
 
-    const SECONDS = 1000;
-    const MINUTES = 60 * SECONDS;
-
-    const myId = randomString$1(16);
-
-    const GUARDED_JOB_HEARTBEAT = 1 * SECONDS;
-    const GUARDED_JOB_TIMEOUT = 1 * MINUTES;
-    function performGuardedJob(db, jobName, jobsTableName, job, { awaitRemoteJob } = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Start working.
-            //
-            // Check if someone else is working on this already.
-            //
-            const jobsTable = db.table(jobsTableName);
-            function aquireLock() {
-                return __awaiter(this, void 0, void 0, function* () {
-                    const gotTheLock = yield db.transaction('rw!', jobsTableName, () => __awaiter(this, void 0, void 0, function* () {
-                        const currentWork = yield jobsTable.get(jobName);
-                        if (!currentWork) {
-                            // No one else is working. Let's record that we are.
-                            yield jobsTable.add({
-                                nodeId: myId,
-                                started: new Date(),
-                                heartbeat: new Date()
-                            }, jobName);
-                            return true;
-                        }
-                        else if (currentWork.heartbeat.getTime() <
-                            Date.now() - GUARDED_JOB_TIMEOUT) {
-                            console.warn(`Latest ${jobName} worker seem to have died.\n`, `The dead job started:`, currentWork.started, `\n`, `Last heart beat was:`, currentWork.heartbeat, '\n', `We're now taking over!`);
-                            // Now, take over!
-                            yield jobsTable.put({
-                                nodeId: myId,
-                                started: new Date(),
-                                heartbeat: new Date()
-                            }, jobName);
-                            return true;
-                        }
-                        return false;
-                    }));
-                    if (gotTheLock)
-                        return true;
-                    // Someone else took the job.
-                    if (awaitRemoteJob) {
-                        try {
-                            const jobDoneObservable = rxjs.from(Dexie.liveQuery(() => jobsTable.get(jobName))).pipe(operators.timeout(GUARDED_JOB_TIMEOUT), operators.filter((job) => !job)); // Wait til job is not there anymore.
-                            yield jobDoneObservable.toPromise();
-                            return false;
-                        }
-                        catch (err) {
-                            if (err.name !== 'TimeoutError') {
-                                throw err;
-                            }
-                            // Timeout stopped us! Try aquire the lock now.
-                            // It will likely succeed this time unless
-                            // another client took it.
-                            return yield aquireLock();
-                        }
-                    }
-                    return false;
-                });
-            }
-            if (yield aquireLock()) {
-                // We own the lock entry and can do our job undisturbed.
-                // We're not within a transaction, but these type of locks
-                // spans over transactions.
-                // Start our heart beat during the job.
-                // Use setInterval to make sure we are updating heartbeat even during long-lived fetch calls.
-                const heartbeat = setInterval(() => {
-                    jobsTable.update(jobName, (job) => {
-                        if (job.nodeId === myId) {
-                            job.heartbeat = new Date();
-                        }
-                    });
-                }, GUARDED_JOB_HEARTBEAT);
-                try {
-                    return yield job();
-                }
-                finally {
-                    // Stop heartbeat
-                    clearInterval(heartbeat);
-                    // Remove the persisted job state:
-                    yield db.transaction('rw!', jobsTableName, () => __awaiter(this, void 0, void 0, function* () {
-                        const currentWork = yield jobsTable.get(jobName);
-                        if (currentWork && currentWork.nodeId === myId) {
-                            yield jobsTable.delete(jobName);
-                        }
-                    }));
-                }
-            }
-        });
+    function performGuardedJob(db, jobName, job) {
+        if (typeof navigator === 'undefined' || !navigator.locks) {
+            // No support for guarding jobs. IE11, node.js, etc.
+            return job();
+        }
+        return navigator.locks.request(db.name + '|' + jobName, () => job());
     }
 
     const ongoingSyncs = new WeakMap();
@@ -3800,6 +5486,9 @@
         function _syncIfPossible() {
             return __awaiter(this, void 0, void 0, function* () {
                 try {
+                    // Check if should delay sync due to ratelimit:
+                    yield checkSyncRateLimitDelay(db);
+                    // Check if we need to lock the sync job. Not needed if we are the service worker.
                     if (db.cloud.isServiceWorkerDB) {
                         // We are the dedicated sync SW:
                         yield sync(db, cloudOptions, cloudSchema, options);
@@ -3807,7 +5496,7 @@
                     else if (!db.cloud.usingServiceWorker) {
                         // We use a flow that is better suited for the case when multiple workers want to
                         // do the same thing.
-                        yield performGuardedJob(db, CURRENT_SYNC_WORKER, '$jobs', () => sync(db, cloudOptions, cloudSchema, options));
+                        yield performGuardedJob(db, CURRENT_SYNC_WORKER, () => sync(db, cloudOptions, cloudSchema, options));
                     }
                     else {
                         assert(false);
@@ -3829,19 +5518,29 @@
         }
     }
 
+    const SECONDS = 1000;
+    const MINUTES = 60 * SECONDS;
+
     function LocalSyncWorker(db, cloudOptions, cloudSchema) {
         let localSyncEventSubscription = null;
         //let syncHandler: ((event: Event) => void) | null = null;
         //let periodicSyncHandler: ((event: Event) => void) | null = null;
         let cancelToken = { cancelled: false };
+        let retryHandle = null;
+        let retryPurpose = null; // "pull" is superset of "push"
         function syncAndRetry(purpose, retryNum = 1) {
             // Use setTimeout() to get onto a clean stack and
             // break free from possible active transaction:
             setTimeout(() => {
+                if (retryHandle)
+                    clearTimeout(retryHandle);
+                const combPurpose = retryPurpose === 'pull' ? 'pull' : purpose;
+                retryHandle = null;
+                retryPurpose = null;
                 syncIfPossible(db, cloudOptions, cloudSchema, {
                     cancelToken,
                     retryImmediatelyOnFetchError: true,
-                    purpose,
+                    purpose: combPurpose,
                 }).catch((e) => {
                     console.error('error in syncIfPossible()', e);
                     if (cancelToken.cancelled) {
@@ -3851,7 +5550,13 @@
                         // Mimic service worker sync event: retry 3 times
                         // * first retry after 5 minutes
                         // * second retry 15 minutes later
-                        setTimeout(() => syncAndRetry(purpose, retryNum + 1), [0, 5, 15][retryNum] * MINUTES);
+                        const combinedPurpose = retryPurpose && retryPurpose === 'pull' ? 'pull' : purpose;
+                        const handle = setTimeout(() => syncAndRetry(combinedPurpose, retryNum + 1), [0, 5, 15][retryNum] * MINUTES);
+                        // Cancel the previous retryHandle if it exists to avoid scheduling loads of retries.
+                        if (retryHandle)
+                            clearTimeout(retryHandle);
+                        retryHandle = handle;
+                        retryPurpose = combinedPurpose;
                     }
                 });
             }, 0);
@@ -3899,11 +5604,11 @@
         for (const table of db.tables) {
             if ((_b = (_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[table.name]) === null || _b === void 0 ? void 0 : _b.markedForSync) {
                 if (table.schema.primKey.auto) {
-                    throw new Dexie__default["default"].SchemaError(`Table ${table.name} is both autoIncremented and synced. ` +
+                    throw new Dexie.SchemaError(`Table ${table.name} is both autoIncremented and synced. ` +
                         `Use db.cloud.configure({unsyncedTables: [${JSON.stringify(table.name)}]}) to blacklist it from sync`);
                 }
                 if (!table.schema.primKey.keyPath) {
-                    throw new Dexie__default["default"].SchemaError(`Table ${table.name} cannot be both synced and outbound. ` +
+                    throw new Dexie.SchemaError(`Table ${table.name} cannot be both synced and outbound. ` +
                         `Use db.cloud.configure({unsyncedTables: [${JSON.stringify(table.name)}]}) to blacklist it from sync`);
                 }
             }
@@ -3918,10 +5623,12 @@
         },
         Alert: {
             error: {
-                color: "red"
+                color: "red",
+                fontWeight: "bold"
             },
             warning: {
-                color: "yellow"
+                color: "#f80",
+                fontWeight: "bold"
             },
             info: {
                 color: "black"
@@ -3962,7 +5669,8 @@
             border: "3px solid #3d3d5d",
             borderRadius: "8px",
             boxShadow: "0 0 80px 10px #666",
-            width: "auto"
+            width: "auto",
+            fontFamily: "sans-serif",
         },
         Input: {
             height: "35px",
@@ -3983,11 +5691,26 @@
 
     var t,r,u,i,o=0,c=[],f=[],e=l$1.__b,a=l$1.__r,v=l$1.diffed,l=l$1.__c,m=l$1.unmount;function d(t,u){l$1.__h&&l$1.__h(r,t,o||u),o=0;var i=r.__H||(r.__H={__:[],__h:[]});return t>=i.__.length&&i.__.push({__V:f}),i.__[t]}function p(n){return o=1,y(z,n)}function y(n,u,i){var o=d(t++,2);if(o.t=n,!o.__c&&(o.__=[i?i(u):z(void 0,u),function(n){var t=o.__N?o.__N[0]:o.__[0],r=o.t(t,n);t!==r&&(o.__N=[r,o.__[1]],o.__c.setState({}));}],o.__c=r,!r.u)){r.u=!0;var c=r.shouldComponentUpdate;r.shouldComponentUpdate=function(n,t,r){if(!o.__c.__H)return !0;var u=o.__c.__H.__.filter(function(n){return n.__c});if(u.every(function(n){return !n.__N}))return !c||c.call(this,n,t,r);var i=!1;return u.forEach(function(n){if(n.__N){var t=n.__[0];n.__=n.__N,n.__N=void 0,t!==n.__[0]&&(i=!0);}}),!!i&&(!c||c.call(this,n,t,r))};}return o.__N||o.__}function s(u,i){var o=d(t++,4);!l$1.__s&&w(o.__H,i)&&(o.__=u,o.i=i,r.__h.push(o));}function _(n){return o=5,F(function(){return {current:n}},[])}function F(n,r){var u=d(t++,7);return w(u.__H,r)?(u.__V=n(),u.i=r,u.__h=n,u.__V):u.__}function b(){for(var t;t=c.shift();)if(t.__P&&t.__H)try{t.__H.__h.forEach(j),t.__H.__h.forEach(k),t.__H.__h=[];}catch(r){t.__H.__h=[],l$1.__e(r,t.__v);}}l$1.__b=function(n){r=null,e&&e(n);},l$1.__r=function(n){a&&a(n),t=0;var i=(r=n.__c).__H;i&&(u===r?(i.__h=[],r.__h=[],i.__.forEach(function(n){n.__N&&(n.__=n.__N),n.__V=f,n.__N=n.i=void 0;})):(i.__h.forEach(j),i.__h.forEach(k),i.__h=[])),u=r;},l$1.diffed=function(t){v&&v(t);var o=t.__c;o&&o.__H&&(o.__H.__h.length&&(1!==c.push(o)&&i===l$1.requestAnimationFrame||((i=l$1.requestAnimationFrame)||function(n){var t,r=function(){clearTimeout(u),g&&cancelAnimationFrame(t),setTimeout(n);},u=setTimeout(r,100);g&&(t=requestAnimationFrame(r));})(b)),o.__H.__.forEach(function(n){n.i&&(n.__H=n.i),n.__V!==f&&(n.__=n.__V),n.i=void 0,n.__V=f;})),u=r=null;},l$1.__c=function(t,r){r.some(function(t){try{t.__h.forEach(j),t.__h=t.__h.filter(function(n){return !n.__||k(n)});}catch(u){r.some(function(n){n.__h&&(n.__h=[]);}),r=[],l$1.__e(u,t.__v);}}),l&&l(t,r);},l$1.unmount=function(t){m&&m(t);var r,u=t.__c;u&&u.__H&&(u.__H.__.forEach(function(n){try{j(n);}catch(n){r=n;}}),r&&l$1.__e(r,u.__v));};var g="function"==typeof requestAnimationFrame;function j(n){var t=r,u=n.__c;"function"==typeof u&&(n.__c=void 0,u()),r=t;}function k(n){var t=r;n.__c=n.__(),r=t;}function w(n,t){return !n||n.length!==t.length||t.some(function(t,r){return t!==n[r]})}function z(n,t){return "function"==typeof t?t(n):t}
 
+    /** Resolve a message template with parameters.
+     *
+     * Example:
+     *  resolveText({
+     *    message: "Hello {name}!",
+     *    messageCode: "HELLO",
+     *    messageParams: {name: "David"}
+     *  }) => "Hello David!"
+     *
+     * @param message Template message with {vars} in it.
+     * @param messageCode Unique code for the message. Can be used for translation.
+     * @param messageParams Parameters to be used in the message.
+     * @returns A final message where parameters have been replaced with values.
+     */
     function resolveText({ message, messageCode, messageParams }) {
-        return message.replace(/\{\w+\}/ig, n => messageParams[n.substr(1, n.length - 2)]);
+        return message.replace(/\{\w+\}/ig, n => messageParams[n.substring(1, n.length - 1)]);
     }
 
-    function LoginDialog({ title, alerts, fields, onCancel, onSubmit, }) {
+    const OTP_LENGTH = 8;
+    function LoginDialog({ title, type, alerts, fields, submitLabel, cancelLabel, onCancel, onSubmit, }) {
         const [params, setParams] = p({});
         const firstFieldRef = _(null);
         s(() => { var _a; return (_a = firstFieldRef.current) === null || _a === void 0 ? void 0 : _a.focus(); }, []);
@@ -3995,21 +5718,34 @@
             h(p$1, null,
                 h("h3", { style: Styles.WindowHeader }, title),
                 alerts.map((alert) => (h("p", { style: Styles.Alert[alert.type] }, resolveText(alert)))),
-                h("form", { onSubmit: ev => {
+                h("form", { onSubmit: (ev) => {
                         ev.preventDefault();
                         onSubmit(params);
-                    } }, Object.entries(fields).map(([fieldName, { type, label, placeholder }], idx) => (h("label", { style: Styles.Label },
+                    } }, Object.entries(fields).map(([fieldName, { type, label, placeholder }], idx) => (h("label", { style: Styles.Label, key: idx },
                     label ? `${label}: ` : '',
-                    h("input", { ref: idx === 0 ? firstFieldRef : undefined, type: type, name: fieldName, autoComplete: "on", style: Styles.Input, autoFocus: true, placeholder: placeholder, value: params[fieldName] || '', onInput: (ev) => { var _a; return setParams(Object.assign(Object.assign({}, params), { [fieldName]: valueTransformer(type, (_a = ev.target) === null || _a === void 0 ? void 0 : _a['value']) })); } })))))),
+                    h("input", { ref: idx === 0 ? firstFieldRef : undefined, type: type, name: fieldName, autoComplete: "on", style: Styles.Input, autoFocus: true, placeholder: placeholder, value: params[fieldName] || '', onInput: (ev) => {
+                            var _a;
+                            const value = valueTransformer(type, (_a = ev.target) === null || _a === void 0 ? void 0 : _a['value']);
+                            let updatedParams = Object.assign(Object.assign({}, params), { [fieldName]: value });
+                            setParams(updatedParams);
+                            if (type === 'otp' && (value === null || value === void 0 ? void 0 : value.trim().length) === OTP_LENGTH) {
+                                // Auto-submit when OTP is filled in.
+                                onSubmit(updatedParams);
+                            }
+                        } })))))),
             h("div", { style: Styles.ButtonsDiv },
-                h("button", { type: "submit", style: Styles.Button, onClick: () => onSubmit(params) }, "Submit"),
-                h("button", { style: Styles.Button, onClick: onCancel }, "Cancel"))));
+                h(p$1, null,
+                    h("button", { type: "submit", style: Styles.Button, onClick: () => onSubmit(params) }, submitLabel),
+                    cancelLabel && (h("button", { style: Styles.Button, onClick: onCancel }, cancelLabel))))));
     }
     function valueTransformer(type, value) {
         switch (type) {
-            case "email": return value.toLowerCase();
-            case "otp": return value.toUpperCase();
-            default: return value;
+            case 'email':
+                return value.toLowerCase();
+            case 'otp':
+                return value.toUpperCase();
+            default:
+                return value;
         }
     }
 
@@ -4063,15 +5799,24 @@
             }
         };
     }
-    // TODO:
-    /*
-        * Gjort klart allt kring user interaction förutom att mounta default-ui på ett element.
-        * Också att kolla först om nån annan subscribar och i så fall inte göra nåt.
-    */
+
+    function associate(factory) {
+        const wm = new WeakMap();
+        return (x) => {
+            let rv = wm.get(x);
+            if (!rv) {
+                rv = factory(x);
+                wm.set(x, rv);
+            }
+            return rv;
+        };
+    }
+
+    const getCurrentUserEmitter = associate((db) => new rxjs.BehaviorSubject(UNAUTHORIZED_USER));
 
     function computeSyncState(db) {
         let _prevStatus = db.cloud.webSocketStatus.value;
-        const lazyWebSocketStatus = db.cloud.webSocketStatus.pipe(operators.switchMap((status) => {
+        const lazyWebSocketStatus = db.cloud.webSocketStatus.pipe(switchMap((status) => {
             const prevStatus = _prevStatus;
             _prevStatus = status;
             const rv = rxjs.of(status);
@@ -4081,22 +5826,31 @@
                 // Only show disconnected if disconnected more than 500ms, or if we can
                 // see that the user is indeed not active.
                 case 'disconnected':
-                    return userIsActive.value ? rv.pipe(operators.debounceTime(500)) : rv;
+                    return userIsActive.value ? rv.pipe(debounceTime(500)) : rv;
                 // Only show connecting if previous state was 'not-started' or 'error', or if
                 // the time it takes to connect goes beyond 4 seconds.
                 case 'connecting':
                     return prevStatus === 'not-started' || prevStatus === 'error'
                         ? rv
-                        : rv.pipe(operators.debounceTime(4000));
+                        : rv.pipe(debounceTime(4000));
                 default:
                     return rv;
             }
         }));
         return rxjs.combineLatest([
             lazyWebSocketStatus,
-            db.syncStateChangedEvent.pipe(operators.startWith({ phase: 'initial' })),
+            db.syncStateChangedEvent.pipe(startWith({ phase: 'initial' })),
+            getCurrentUserEmitter(db.dx._novip),
             userIsReallyActive
-        ]).pipe(operators.map(([status, syncState, userIsActive]) => {
+        ]).pipe(map(([status, syncState, user, userIsActive]) => {
+            var _a;
+            if (((_a = user.license) === null || _a === void 0 ? void 0 : _a.status) && user.license.status !== 'ok') {
+                return {
+                    phase: 'offline',
+                    status: 'offline',
+                    license: user.license.status
+                };
+            }
             let { phase, error, progress } = syncState;
             let adjustedStatus = status;
             if (phase === 'error') {
@@ -4129,23 +5883,12 @@
                 error,
                 progress,
                 status: isOnline ? adjustedStatus : 'offline',
+                license: 'ok'
             };
             return retState;
         }));
     }
 
-    function associate(factory) {
-        const wm = new WeakMap();
-        return (x) => {
-            let rv = wm.get(x);
-            if (!rv) {
-                rv = factory(x);
-                wm.set(x, rv);
-            }
-            return rv;
-        };
-    }
-
     function createSharedValueObservable(o, defaultValue) {
         let currentValue = defaultValue;
         let shared = rxjs.from(o).pipe(rxjs.map((x) => (currentValue = x)), rxjs.share({ resetOnRefCountZero: () => rxjs.timer(1000) }));
@@ -4187,10 +5930,8 @@
         })), {});
     });
 
-    const getCurrentUserEmitter = associate((db) => new rxjs.BehaviorSubject(UNAUTHORIZED_USER));
-
     const getInternalAccessControlObservable = associate((db) => {
-        return createSharedValueObservable(getCurrentUserEmitter(db._novip).pipe(operators.switchMap((currentUser) => Dexie.liveQuery(() => db.transaction('r', 'realms', 'members', () => Promise.all([
+        return createSharedValueObservable(getCurrentUserEmitter(db._novip).pipe(switchMap((currentUser) => Dexie.liveQuery(() => db.transaction('r', 'realms', 'members', () => Promise.all([
             db.members.where({ userId: currentUser.userId }).toArray(),
             db.realms.toArray(),
             currentUser.userId,
@@ -4291,7 +6032,7 @@
         const o = createSharedValueObservable(rxjs.combineLatest([
             getInternalAccessControlObservable(db._novip),
             getGlobalRolesObservable(db._novip),
-        ]).pipe(operators.map(([{ selfMembers, realms, userId }, globalRoles]) => ({
+        ]).pipe(map(([{ selfMembers, realms, userId }, globalRoles]) => ({
             selfMembers,
             realms,
             userId,
@@ -4405,16 +6146,16 @@
                 return new PermissionChecker({}, tableName, !owner || owner === dexie.cloud.currentUserId);
             return new PermissionChecker(realm.permissions, tableName, realmId === dexie.cloud.currentUserId || owner === dexie.cloud.currentUserId);
         };
-        const o = source.pipe(operators.map(mapper));
+        const o = source.pipe(map(mapper));
         o.getValue = () => mapper(source.getValue());
         return o;
     }
 
     const getInvitesObservable = associate((db) => {
-        const membersByEmail = getCurrentUserEmitter(db._novip).pipe(operators.switchMap((currentUser) => Dexie.liveQuery(() => db.members.where({ email: currentUser.email || '' }).toArray())));
+        const membersByEmail = getCurrentUserEmitter(db._novip).pipe(switchMap((currentUser) => Dexie.liveQuery(() => db.members.where({ email: currentUser.email || '' }).toArray())));
         const permissions = getPermissionsLookupObservable(db._novip);
         const accessControl = getInternalAccessControlObservable(db._novip);
-        return createSharedValueObservable(rxjs.combineLatest([membersByEmail, accessControl, permissions]).pipe(operators.map(([membersByEmail, accessControl, realmLookup]) => {
+        return createSharedValueObservable(rxjs.combineLatest([membersByEmail, accessControl, permissions]).pipe(map(([membersByEmail, accessControl, realmLookup]) => {
             const reducer = (result, m) => (Object.assign(Object.assign({}, result), { [m.id]: Object.assign(Object.assign({}, m), { realm: realmLookup[m.realmId] }) }));
             const emailMembersById = membersByEmail.reduce(reducer, {});
             const membersById = accessControl.selfMembers.reduce(reducer, emailMembersById);
@@ -4460,7 +6201,7 @@
         let closed = false;
         function throwIfClosed() {
             if (closed)
-                throw new Dexie__default["default"].DatabaseClosedError();
+                throw new Dexie.DatabaseClosedError();
         }
         dbOnClosed(dexie, () => {
             subscriptions.forEach((subscription) => subscription.unsubscribe());
@@ -4471,7 +6212,7 @@
         });
         const syncComplete = new rxjs.Subject();
         dexie.cloud = {
-            version: '4.0.1-beta.46',
+            version: '{version}',
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -4507,18 +6248,31 @@
                 }
                 updateSchemaFromOptions(dexie.cloud.schema, dexie.cloud.options);
             },
+            logout({ force } = {}) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    force
+                        ? yield _logout(DexieCloudDB(dexie), { deleteUnsyncedData: true })
+                        : yield logout(DexieCloudDB(dexie));
+                });
+            },
             sync({ wait, purpose } = { wait: true, purpose: 'push' }) {
+                var _a;
                 return __awaiter(this, void 0, void 0, function* () {
                     if (wait === undefined)
                         wait = true;
                     const db = DexieCloudDB(dexie);
+                    const licenseStatus = ((_a = db.cloud.currentUser.value.license) === null || _a === void 0 ? void 0 : _a.status) || 'ok';
+                    if (licenseStatus !== 'ok') {
+                        // Refresh access token to check for updated license
+                        yield loadAccessToken(db);
+                    }
                     if (purpose === 'pull') {
                         const syncState = db.cloud.persistedSyncState.value;
                         triggerSync(db, purpose);
                         if (wait) {
                             const newSyncState = yield db.cloud.persistedSyncState
-                                .pipe(operators.filter((newSyncState) => (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.timestamp) != null &&
-                                (!syncState || newSyncState.timestamp > syncState.timestamp)), operators.take(1))
+                                .pipe(filter((newSyncState) => (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.timestamp) != null &&
+                                (!syncState || newSyncState.timestamp > syncState.timestamp)), take(1))
                                 .toPromise();
                             if (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.error) {
                                 throw new Error(`Sync error: ` + newSyncState.error);
@@ -4538,7 +6292,7 @@
                                     throw new Error(`Sync error: ` + newSyncState.error);
                                 return syncNeeded;
                             })))
-                                .pipe(operators.filter((isNeeded) => !isNeeded), operators.take(1))
+                                .pipe(filter((isNeeded) => !isNeeded), take(1))
                                 .toPromise();
                             console.debug('Done waiting for sync completion because we have nothing to push anymore');
                         }
@@ -4549,7 +6303,7 @@
                 return permissions(dexie._novip, obj, tableName);
             },
         };
-        dexie.Version.prototype['_parseStoresSpec'] = Dexie__default["default"].override(dexie.Version.prototype['_parseStoresSpec'], (origFunc) => overrideParseStoresSpec(origFunc, dexie));
+        dexie.Version.prototype['_parseStoresSpec'] = Dexie.override(dexie.Version.prototype['_parseStoresSpec'], (origFunc) => overrideParseStoresSpec(origFunc, dexie));
         dexie.Table.prototype.newId = function ({ colocateWith } = {}) {
             const shardKey = colocateWith && colocateWith.substr(colocateWith.length - 3);
             return generateKey(dexie.cloud.schema[this.name].idPrefix || '', shardKey);
@@ -4682,8 +6436,8 @@
                     // This is so that when db.open() completes, user should be safe
                     // to subscribe to these observables and get actual data.
                     yield rxjs.combineLatest([
-                        currentUserEmitter.pipe(operators.skip(1), operators.take(1)),
-                        db.cloud.persistedSyncState.pipe(operators.skip(1), operators.take(1)),
+                        currentUserEmitter.pipe(skip(1), take(1)),
+                        db.cloud.persistedSyncState.pipe(skip(1), take(1)),
                     ]).toPromise();
                 }
                 // HERE: If requireAuth, do athentication now.
@@ -4715,7 +6469,9 @@
                         db.syncStateChangedEvent.next({
                             phase: 'not-in-sync',
                         });
-                        triggerSync(db, 'push');
+                        if (!isEagerSyncDisabled(db)) {
+                            triggerSync(db, 'push');
+                        }
                     }), rxjs.fromEvent(self, 'offline').subscribe(() => {
                         console.debug('offline!');
                         db.syncStateChangedEvent.next({
@@ -4732,8 +6488,8 @@
             });
         }
     }
-    dexieCloud.version = '4.0.1-beta.46';
-    Dexie__default["default"].Cloud = dexieCloud;
+    dexieCloud.version = '{version}';
+    Dexie.Cloud = dexieCloud;
 
     // In case the SW lives for a while, let it reuse already opened connections:
     const managedDBs = new Map();
@@ -4767,7 +6523,7 @@
                 let db = managedDBs.get(dbName);
                 if (!db) {
                     console.debug('Dexie Cloud SW: Creating new Dexie instance for', dbName);
-                    const dexie = new Dexie__default["default"](dbName, { addons: [dexieCloud] });
+                    const dexie = new Dexie(dbName, { addons: [dexieCloud] });
                     db = DexieCloudDB(dexie);
                     db.cloud.isServiceWorkerDB = true;
                     dexie.on('versionchange', stopManagingDB);
@@ -4810,7 +6566,7 @@
                     // Error occured. Stop managing this DB until we wake up again by a sync event,
                     // which will open a new Dexie and start trying to sync it.
                     stopManagingDB();
-                    if (e.name !== Dexie__default["default"].errnames.NoSuchDatabase) {
+                    if (e.name !== Dexie.errnames.NoSuchDatabase) {
                         // Unless the error was that DB doesn't exist, rethrow to trigger sync retry.
                         throw e; // Throw e to make syncEvent.waitUntil() receive a rejected promis, so it will retry.
                     }