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

package/dist/modern/service-worker.js

@@ -1,6 +1,23 @@
+/* ========================================================================== 
+ *                           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/
+ * 
+ */
+
 import Dexie, { cmp, liveQuery } from 'dexie';
-import { Observable, BehaviorSubject, Subject, of, fromEvent, merge, Subscription, from, throwError, combineLatest, map as map$1, share, timer } from 'rxjs';
-import { filter, take, switchMap, delay, distinctUntilChanged, map, tap, catchError, timeout, debounceTime, startWith, skip } from 'rxjs/operators';
+import { Observable as Observable$1, BehaviorSubject, Subject, firstValueFrom, from as from$1, filter as filter$1, fromEvent, of, merge, Subscription as Subscription$1, throwError, combineLatest, map as map$1, share, timer as timer$1 } from 'rxjs';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -16,6 +33,22 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 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); }); }
@@ -25,6 +58,97 @@ function __awaiter(thisArg, _arguments, P, generator) {
         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 = {
@@ -127,7 +251,7 @@ function dispatch(ev) {
         });
     }
 }
-class BroadcastedAndLocalEvent extends Observable {
+class BroadcastedAndLocalEvent extends Observable$1 {
     constructor(name) {
         const bc = typeof BroadcastChannel === "undefined"
             ? new SWBroadcastChannel(name) : new BroadcastChannel(name);
@@ -164,18 +288,1436 @@ class BroadcastedAndLocalEvent extends Observable {
                 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;
@@ -238,6 +1780,7 @@ function registerPeriodicSyncEvent(db) {
 
 function triggerSync(db, purpose) {
     if (db.cloud.usingServiceWorker) {
+        console.debug('registering sync event');
         registerSyncEvent(db, purpose);
     }
     else {
@@ -266,7 +1809,14 @@ const b64encode = typeof Buffer !== "undefined"
         }
     }
     : (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, }) {
@@ -739,14 +2289,24 @@ function getTablesToSyncify(db, syncState) {
     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.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.
@@ -765,7 +2325,9 @@ function alertUser(userInteraction, title, ...alerts) {
         type: 'message-alert',
         title,
         alerts,
-        fields: {}
+        fields: {},
+        submitLabel: 'OK',
+        cancelLabel: null,
     });
 }
 function promptForEmail(userInteraction, title, emailHint) {
@@ -824,22 +2386,48 @@ function promptForOTP(userInteraction, email, alert) {
         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`);
         }
@@ -847,8 +2435,10 @@ function loadAccessToken(db) {
         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) {
@@ -896,10 +2486,24 @@ function refreshAccessToken(url, login) {
         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;
     });
 }
@@ -931,8 +2535,15 @@ function userAuthenticate(context, fetchToken, userInteraction, hints) {
                 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;
@@ -943,6 +2554,16 @@ function userAuthenticate(context, fetchToken, userInteraction, hints) {
             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',
@@ -954,12 +2575,36 @@ function userAuthenticate(context, fetchToken, userInteraction, hints) {
             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;
         }
     });
@@ -1181,13 +2826,13 @@ var MapDef = {
     },
 };
 
-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",
@@ -1582,6 +3227,40 @@ function cloneChange(change, rewriteValues) {
             : 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* () {
@@ -1590,9 +3269,20 @@ function syncWithServer(changes, syncState, baseRevs, db, databaseUrl, schema, c
         //
         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}`;
         }
@@ -1601,27 +3291,31 @@ function syncWithServer(changes, syncState, baseRevs, db, databaseUrl, schema, c
             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);
         }
@@ -1823,12 +3517,13 @@ const CURRENT_SYNC_WORKER = 'currentSyncWorker';
 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)
@@ -2043,6 +3738,7 @@ function _sync(db, options, schema, { isInitialSync, cancelToken, justCheckIfNee
         }));
         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 });
@@ -2179,6 +3875,8 @@ function MessagesFromServerConsumer(db) {
                             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
@@ -2449,6 +4147,61 @@ class AuthPersistedContext {
     }
 }
 
+function waitUntil(o, // Works with Dexie's liveQuery observables if we'd need that
+predicate) {
+    return firstValueFrom(from$1(o).pipe(filter$1(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 }) {
@@ -2492,8 +4245,9 @@ function otpFetchTokenCallback(db) {
                 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') {
@@ -2525,12 +4279,6 @@ function otpFetchTokenCallback(db) {
                 }
                 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();
@@ -2543,6 +4291,18 @@ function otpFetchTokenCallback(db) {
     };
 }
 
+/** 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:
@@ -2569,85 +4329,73 @@ function setCurrentUser(db, user) {
             }));
             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;
     });
 }
 
@@ -2976,6 +4724,13 @@ function writeLock(fn, prop) {
 
 const outstandingTransactions = new 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.
@@ -2984,7 +4739,7 @@ const outstandingTransactions = new BehaviorSubject(new Set());
  * 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',
@@ -2995,7 +4750,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
             try {
                 mutTableMap = new Map(ordinaryTables.map((tbl) => [
                     tbl.name,
-                    core.table(`$${tbl.name}_mutations`)
+                    core.table(`$${tbl.name}_mutations`),
                 ]));
             }
             catch (_a) {
@@ -3029,15 +4784,9 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                             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();
                         };
@@ -3104,7 +4853,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                     .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) => {
@@ -3112,7 +4861,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                         type: 'delete',
                                         keys: res.result,
                                         trans: req.trans,
-                                        criteria: { index: null, range: req.range }
+                                        criteria: { index: null, range: req.range },
                                     });
                                 })
                                 : mutateAndLog(req);
@@ -3120,7 +4869,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                     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) => {
@@ -3141,7 +4890,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                     keys,
                                     criteria: req.criteria,
                                     txid,
-                                    userId
+                                    userId,
                                 }
                                 : req.type === 'add'
                                     ? {
@@ -3151,7 +4900,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                         keys,
                                         txid,
                                         userId,
-                                        values
+                                        values,
                                     }
                                     : req.criteria && req.changeSpec
                                         ? {
@@ -3163,7 +4912,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                             criteria: req.criteria,
                                             changeSpec: req.changeSpec,
                                             txid,
-                                            userId
+                                            userId,
                                         }
                                         : updates
                                             ? {
@@ -3174,7 +4923,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                                 keys: updates.keys,
                                                 changeSpecs: updates.changeSpecs,
                                                 txid,
-                                                userId
+                                                userId,
                                             }
                                             : {
                                                 type: 'upsert',
@@ -3183,7 +4932,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                                 keys,
                                                 values,
                                                 txid,
-                                                userId
+                                                userId,
                                             };
                             return keys.length > 0 || ('criteria' in req && req.criteria)
                                 ? mutsTable
@@ -3193,7 +4942,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                         });
                     }
                 } });
-        }
+        },
     };
 }
 
@@ -3347,13 +5096,13 @@ class TokenExpiredError extends Error {
 const SERVER_PING_TIMEOUT = 20000;
 const CLIENT_PING_INTERVAL = 30000;
 const FAIL_RETRY_WAIT_TIME = 60000;
-class WSObservable extends Observable {
+class WSObservable extends Observable$1 {
     constructor(databaseUrl, rev, realmSetHash, clientIdentity, messageProducer, webSocketStatus, token, tokenExpiration) {
         super((subscriber) => new WSConnection(databaseUrl, rev, realmSetHash, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus));
     }
 }
 let counter = 0;
-class WSConnection extends Subscription {
+class WSConnection extends Subscription$1 {
     constructor(databaseUrl, rev, realmSetHash, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus) {
         super(() => this.teardown());
         this.id = ++counter;
@@ -3552,6 +5301,20 @@ class WSConnection extends Subscription {
     }
 }
 
+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));
 }
@@ -3585,7 +5348,12 @@ function connectWebSocket(db) {
     function createObservable() {
         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]) => userIsReallyActive.pipe(map((isActive) => [isActive ? userLogin : null, syncState]))), switchMap(([userLogin, syncState]) => {
+        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
@@ -3601,7 +5369,7 @@ function connectWebSocket(db) {
                 return new WSObservable(db.cloud.options.databaseUrl, db.cloud.persistedSyncState.value.serverRevision, realmSetHash, db.cloud.persistedSyncState.value.clientIdentity, messageProducer, db.cloud.webSocketStatus, userLogin.accessToken, userLogin.accessTokenExpiration);
             }
             else {
-                return from([]);
+                return from$1([]);
             }
         }), catchError((error) => {
             if ((error === null || error === void 0 ? void 0 : error.name) === 'TokenExpiredError') {
@@ -3614,15 +5382,21 @@ function connectWebSocket(db) {
                     yield db.table('$logins').update(user.userId, {
                         accessToken: refreshedLogin.accessToken,
                         accessTokenExpiration: refreshedLogin.accessTokenExpiration,
+                        claims: refreshedLogin.claims,
+                        license: refreshedLogin.license,
                     });
                 })), switchMap(() => createObservable()));
             }
             else {
-                return throwError(error);
+                return throwError(() => error);
             }
         }), catchError((error) => {
             db.cloud.webSocketStatus.next("error");
-            return from(waitAndReconnectWhenUserDoesSomething(error)).pipe(switchMap(() => createObservable()));
+            if (error instanceof InvalidLicenseError) {
+                // Don't retry. Just throw and don't try connect again.
+                return throwError(() => error);
+            }
+            return from$1(waitAndReconnectWhenUserDoesSomething(error)).pipe(switchMap(() => createObservable()));
         }));
     }
     return createObservable().subscribe({
@@ -3650,97 +5424,12 @@ function isSyncNeeded(db) {
     });
 }
 
-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 = from(liveQuery(() => jobsTable.get(jobName))).pipe(timeout(GUARDED_JOB_TIMEOUT), 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();
@@ -3794,6 +5483,9 @@ function syncIfPossible(db, cloudOptions, cloudSchema, options) {
     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);
@@ -3801,7 +5493,7 @@ function syncIfPossible(db, cloudOptions, cloudSchema, options) {
                 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);
@@ -3823,19 +5515,29 @@ function syncIfPossible(db, cloudOptions, cloudSchema, options) {
     }
 }
 
+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) {
@@ -3845,7 +5547,13 @@ function LocalSyncWorker(db, cloudOptions, cloudSchema) {
                     // 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);
@@ -3912,10 +5620,12 @@ const Styles = {
     },
     Alert: {
         error: {
-            color: "red"
+            color: "red",
+            fontWeight: "bold"
         },
         warning: {
-            color: "yellow"
+            color: "#f80",
+            fontWeight: "bold"
         },
         info: {
             color: "black"
@@ -3956,7 +5666,8 @@ const Styles = {
         border: "3px solid #3d3d5d",
         borderRadius: "8px",
         boxShadow: "0 0 80px 10px #666",
-        width: "auto"
+        width: "auto",
+        fontFamily: "sans-serif",
     },
     Input: {
         height: "35px",
@@ -3977,11 +5688,26 @@ function Dialog({ children, className }) {
 
 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(); }, []);
@@ -3989,21 +5715,34 @@ function LoginDialog({ title, alerts, fields, onCancel, onSubmit, }) {
         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;
     }
 }
 
@@ -4014,7 +5753,7 @@ class LoginGui extends d$1 {
         this.state = { userInteraction: undefined };
     }
     componentDidMount() {
-        this.subscription = from(this.props.db.cloud.userInteraction).subscribe(this.observer);
+        this.subscription = from$1(this.props.db.cloud.userInteraction).subscribe(this.observer);
     }
     componentWillUnmount() {
         if (this.subscription) {
@@ -4057,11 +5796,20 @@ function setupDefaultGUI(db) {
         }
     };
 }
-// 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 BehaviorSubject(UNAUTHORIZED_USER));
 
 function computeSyncState(db) {
     let _prevStatus = db.cloud.webSocketStatus.value;
@@ -4089,8 +5837,17 @@ function computeSyncState(db) {
     return combineLatest([
         lazyWebSocketStatus,
         db.syncStateChangedEvent.pipe(startWith({ phase: 'initial' })),
+        getCurrentUserEmitter(db.dx._novip),
         userIsReallyActive
-    ]).pipe(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') {
@@ -4123,27 +5880,16 @@ function computeSyncState(db) {
             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 = from(o).pipe(map$1((x) => (currentValue = x)), share({ resetOnRefCountZero: () => timer(1000) }));
-    const rv = new Observable((observer) => {
+    let shared = from$1(o).pipe(map$1((x) => (currentValue = x)), share({ resetOnRefCountZero: () => timer$1(1000) }));
+    const rv = new Observable$1((observer) => {
         let didEmit = false;
         const subscription = shared.subscribe({
             next(value) {
@@ -4181,8 +5927,6 @@ const getGlobalRolesObservable = associate((db) => {
     })), {});
 });
 
-const getCurrentUserEmitter = associate((db) => new BehaviorSubject(UNAUTHORIZED_USER));
-
 const getInternalAccessControlObservable = associate((db) => {
     return createSharedValueObservable(getCurrentUserEmitter(db._novip).pipe(switchMap((currentUser) => liveQuery(() => db.transaction('r', 'realms', 'members', () => Promise.all([
         db.members.where({ userId: currentUser.userId }).toArray(),
@@ -4465,7 +6209,7 @@ function dexieCloud(dexie) {
     });
     const syncComplete = new Subject();
     dexie.cloud = {
-        version: '4.0.1-beta.46',
+        version: '{version}',
         options: Object.assign({}, DEFAULT_OPTIONS),
         schema: null,
         get currentUserId() {
@@ -4501,11 +6245,24 @@ function dexieCloud(dexie) {
             }
             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);
@@ -4524,7 +6281,7 @@ function dexieCloud(dexie) {
                     triggerSync(db, purpose);
                     if (wait) {
                         console.debug('db.cloud.login() is waiting for sync completion...');
-                        yield from(liveQuery(() => __awaiter(this, void 0, void 0, function* () {
+                        yield from$1(liveQuery(() => __awaiter(this, void 0, void 0, function* () {
                             const syncNeeded = yield isSyncNeeded(db);
                             const newSyncState = yield db.getPersistedSyncState();
                             if ((newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.timestamp) !== (syncState === null || syncState === void 0 ? void 0 : syncState.timestamp) &&
@@ -4709,7 +6466,9 @@ function dexieCloud(dexie) {
                     db.syncStateChangedEvent.next({
                         phase: 'not-in-sync',
                     });
-                    triggerSync(db, 'push');
+                    if (!isEagerSyncDisabled(db)) {
+                        triggerSync(db, 'push');
+                    }
                 }), fromEvent(self, 'offline').subscribe(() => {
                     console.debug('offline!');
                     db.syncStateChangedEvent.next({
@@ -4726,7 +6485,7 @@ function dexieCloud(dexie) {
         });
     }
 }
-dexieCloud.version = '4.0.1-beta.46';
+dexieCloud.version = '{version}';
 Dexie.Cloud = dexieCloud;
 
 // In case the SW lives for a while, let it reuse already opened connections: