dexie-cloud-addon 4.0.1-beta.47 → 4.0.1-beta.49

package/dist/umd/service-worker.js

@@ -1,12 +1,26 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('dexie'), require('rxjs'), require('rxjs/operators')) :
-    typeof define === 'function' && define.amd ? define(['dexie', 'rxjs', 'rxjs/operators'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Dexie, global.rxjs, global.rxjs.operators));
-})(this, (function (Dexie, rxjs, operators) { 'use strict';
-
-    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+/* ========================================================================== 
+ *                           dexie-cloud-addom.js
+ * ==========================================================================
+ *
+ * Dexie addon that syncs IndexedDB with Dexie Cloud.
+ *
+ * By David Fahlander, david@dexie.org
+ *
+ * ==========================================================================
+ *
+ * Version 4.0.1-beta.49, Sat Oct 28 2023
+ *
+ * https://dexie.org
+ *
+ * Apache License Version 2.0, January 2004, http://www.apache.org/licenses/
+ * 
+ */
 
-    var Dexie__default = /*#__PURE__*/_interopDefaultLegacy(Dexie);
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('dexie'), require('rxjs')) :
+    typeof define === 'function' && define.amd ? define(['dexie', 'rxjs'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Dexie, global.rxjs));
+})(this, (function (Dexie, rxjs) { 'use strict';
 
     /******************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -22,6 +36,22 @@
     OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
     PERFORMANCE OF THIS SOFTWARE.
     ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
 
     function __awaiter(thisArg, _arguments, P, generator) {
         function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -31,6 +61,97 @@
             function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
             step((generator = generator.apply(thisArg, _arguments || [])).next());
         });
+    }
+
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+        return to.concat(ar || Array.prototype.slice.call(from));
+    }
+
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+    }
+
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
     }
 
     const UNAUTHORIZED_USER = {
@@ -184,6 +305,1424 @@
         }
     }
 
+    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();
+                        }
+                    }
+                }));
+            });
+    }
+
+    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)));
+            };
+        }
+        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;
     let hasComplainedAboutSyncEvent = false;
     function registerSyncEvent(db, purpose) {
@@ -273,7 +1812,14 @@
             }
         }
         : (b) => {
-            return btoa(String.fromCharCode.apply(null, ArrayBuffer.isView(b) ? b : new Uint8Array(b)));
+            const u8a = ArrayBuffer.isView(b) ? b : new Uint8Array(b);
+            const CHUNK_SIZE = 0x1000;
+            const strs = [];
+            for (let i = 0, l = u8a.length; i < l; i += CHUNK_SIZE) {
+                const chunk = u8a.subarray(i, i + CHUNK_SIZE);
+                strs.push(String.fromCharCode.apply(null, chunk));
+            }
+            return btoa(strs.join(""));
         };
 
     function computeRealmSetHash({ realms, inviteRealms, }) {
@@ -763,7 +2309,7 @@
                     resolve(res);
                 }, onCancel: () => {
                     userInteraction.next(undefined);
-                    reject(new Dexie__default["default"].AbortError('User cancelled'));
+                    reject(new Dexie.AbortError('User cancelled'));
                 } });
             userInteraction.next(interactionProps);
             // Start subscribing for external updates to db.cloud.userInteraction, and if so, cancel this request.
@@ -1048,7 +2594,7 @@
                     if (isOffline) {
                         message = `You seem to be offline. Please connect to the internet and try again.`;
                     }
-                    else if (Dexie__default["default"].debug || (typeof location !== 'undefined' && (location.hostname === 'localhost' || location.hostname === '127.0.0.1'))) {
+                    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\``;
                     }
@@ -1283,13 +2829,13 @@
         },
     };
 
-    const _global = typeof globalThis !== "undefined"
+    const _global = typeof globalThis !== "undefined" // All modern environments (node, bun, deno, browser, workers, webview etc)
         ? globalThis
-        : typeof self !== "undefined"
+        : typeof self !== "undefined" // Older browsers, workers, webview, window etc
             ? self
-            : typeof global === "undefined"
+            : typeof global !== "undefined" // Older versions of node
                 ? global
-                : undefined;
+                : undefined; // Unsupported environment. No idea to return 'this' since we are in a module or a function scope anyway.
 
     var TypedArraysDefs = [
         "Int8Array",
@@ -1665,7 +3211,7 @@
                         const rewrittenKey = `${key}:${currentUser.userId}`;
                         mutClone.keys[keyIndex] = rewrittenKey;
                         if (rewriteValues) {
-                            Dexie__default["default"].setByKeyPath(mutClone.values[keyIndex], primaryKey.keyPath, rewrittenKey);
+                            Dexie.setByKeyPath(mutClone.values[keyIndex], primaryKey.keyPath, rewrittenKey);
                         }
                     }
                 });
@@ -1829,7 +3375,7 @@
 
     function throwIfCancelled(cancelToken) {
         if (cancelToken === null || cancelToken === void 0 ? void 0 : cancelToken.cancelled)
-            throw new Dexie__default["default"].AbortError(`Operation was cancelled`);
+            throw new Dexie.AbortError(`Operation was cancelled`);
     }
 
     /* Need this because navigator.onLine seems to say "false" when it is actually online.
@@ -1881,7 +3427,7 @@
                             }
                         }
                         else {
-                            Dexie__default["default"].setByKeyPath(obj, keyPath, value);
+                            Dexie.setByKeyPath(obj, keyPath, value);
                         }
                     }
                     resultKeys.push(key);
@@ -1896,7 +3442,7 @@
 
     function applyServerChanges(changes, db) {
         return __awaiter(this, void 0, void 0, function* () {
-            console.debug('Applying server changes', changes, Dexie__default["default"].currentTransaction);
+            console.debug('Applying server changes', changes, Dexie.currentTransaction);
             for (const { table: tableName, muts } of changes) {
                 const table = db.table(tableName);
                 if (!table)
@@ -1933,7 +3479,7 @@
                             else {
                                 keys.forEach((key, i) => {
                                     // Make sure inbound keys are consistent
-                                    Dexie__default["default"].setByKeyPath(mut.values[i], primaryKey.keyPath, key);
+                                    Dexie.setByKeyPath(mut.values[i], primaryKey.keyPath, key);
                                 });
                                 yield table.bulkAdd(mut.values);
                             }
@@ -1945,7 +3491,7 @@
                             else {
                                 keys.forEach((key, i) => {
                                     // Make sure inbound keys are consistent
-                                    Dexie__default["default"].setByKeyPath(mut.values[i], primaryKey.keyPath, key);
+                                    Dexie.setByKeyPath(mut.values[i], primaryKey.keyPath, key);
                                 });
                                 yield table.bulkPut(mut.values);
                             }
@@ -2315,7 +3861,7 @@
                         // It's no need to have two channels at the same time - even though it wouldnt
                         // be a problem - this is an optimization.
                         yield db.cloud.syncState
-                            .pipe(operators.filter(({ phase }) => phase === 'in-sync' || phase === 'error'), operators.take(1))
+                            .pipe(filter(({ phase }) => phase === 'in-sync' || phase === 'error'), take(1))
                             .toPromise();
                         console.debug('processing msg', msg);
                         const persistedSyncState = db.cloud.persistedSyncState.value;
@@ -2410,7 +3956,7 @@
                                         return; // Ignore message
                                     }
                                     // Verify also that the message is based on the exact same set of realms
-                                    const ourRealmSetHash = yield Dexie__default["default"].waitFor(
+                                    const ourRealmSetHash = yield Dexie.waitFor(
                                     // Keep TX in non-IDB work
                                     computeRealmSetHash(syncState));
                                     console.debug('ourRealmSetHash', ourRealmSetHash);
@@ -2896,7 +4442,7 @@
     const IS_SERVICE_WORKER = typeof self !== "undefined" && "clients" in self && !self.document;
 
     function throwVersionIncrementNeeded() {
-        throw new Dexie__default["default"].SchemaError(`Version increment needed to allow dexie-cloud change tracking`);
+        throw new Dexie.SchemaError(`Version increment needed to allow dexie-cloud change tracking`);
     }
 
     const { toString } = {};
@@ -3012,14 +4558,14 @@
                                     if (!table.schema.primaryKey.outbound) {
                                         if (!valueClones)
                                             valueClones = req.values.slice();
-                                        valueClones[idx] = Dexie__default["default"].deepClone(valueClones[idx]);
-                                        Dexie__default["default"].setByKeyPath(valueClones[idx], table.schema.primaryKey.keyPath, keys[idx]);
+                                        valueClones[idx] = Dexie.deepClone(valueClones[idx]);
+                                        Dexie.setByKeyPath(valueClones[idx], table.schema.primaryKey.keyPath, keys[idx]);
                                     }
                                 }
                                 else if (typeof key !== 'string' ||
                                     (!key.startsWith(idPrefix) && !key.startsWith('#' + idPrefix))) {
                                     // Key was specified by caller. Verify it complies with id prefix.
-                                    throw new Dexie__default["default"].ConstraintError(`The ID "${key}" is not valid for table "${tableName}". ` +
+                                    throw new Dexie.ConstraintError(`The ID "${key}" is not valid for table "${tableName}". ` +
                                         `Primary '@' keys requires the key to be prefixed with "${idPrefix}" (or "#${idPrefix}).\n` +
                                         `If you want to generate IDs programmatically, remove '@' from the schema to get rid of this constraint. Dexie Cloud supports custom IDs as long as they are random and globally unique.`);
                                 }
@@ -3044,7 +4590,7 @@
                                                     const type = Array.isArray(key)
                                                         ? key.map(toStringTag).join(',')
                                                         : toStringTag(key);
-                                                    throw new Dexie__default["default"].ConstraintError(`Invalid primary key type ${type} for table ${tableName}. Tables marked for sync has primary keys of type string or Array of string (and optional numbers)`);
+                                                    throw new Dexie.ConstraintError(`Invalid primary key type ${type} for table ${tableName}. Tables marked for sync has primary keys of type string or Array of string (and optional numbers)`);
                                                 }
                                             });
                                         }
@@ -3491,13 +5037,13 @@
     //   for just a short time.
     const userIsReallyActive = new rxjs.BehaviorSubject(true);
     userIsActive
-        .pipe(operators.switchMap((isActive) => {
+        .pipe(switchMap((isActive) => {
         //console.debug('SyncStatus: DUBB: isActive changed to', isActive);
         return isActive
             ? rxjs.of(true)
-            : rxjs.of(false).pipe(operators.delay(INACTIVE_WAIT_TIME))
+            : rxjs.of(false).pipe(delay(INACTIVE_WAIT_TIME))
                 ;
-    }), operators.distinctUntilChanged())
+    }), distinctUntilChanged())
         .subscribe(userIsReallyActive);
     //
     // First create some corner-stone observables to build the flow on
@@ -3507,9 +5053,9 @@
         ? rxjs.fromEvent(document, 'visibilitychange')
         : rxjs.of({});
     // document.onvisibilitychange makes document hidden:
-    const documentBecomesHidden = visibilityStateIsChanged.pipe(operators.filter(() => document.visibilityState === 'hidden'));
+    const documentBecomesHidden = visibilityStateIsChanged.pipe(filter(() => document.visibilityState === 'hidden'));
     // document.onvisibilitychange makes document visible
-    const documentBecomesVisible = visibilityStateIsChanged.pipe(operators.filter(() => document.visibilityState === 'visible'));
+    const documentBecomesVisible = visibilityStateIsChanged.pipe(filter(() => document.visibilityState === 'visible'));
     // Any of various user-activity-related events happen:
     const userDoesSomething = typeof window !== 'undefined'
         ? rxjs.merge(documentBecomesVisible, rxjs.fromEvent(window, 'mousedown'), rxjs.fromEvent(window, 'mousemove'), rxjs.fromEvent(window, 'keydown'), rxjs.fromEvent(window, 'wheel'), rxjs.fromEvent(window, 'touchmove'))
@@ -3527,9 +5073,9 @@
         userDoesSomething)
             .pipe(
         // No matter event source, compute whether user is visible using visibilityState:
-        operators.map(() => document.visibilityState === 'visible'), 
+        map(() => document.visibilityState === 'visible'), 
         // Make sure to emit it
-        operators.tap((isActive) => {
+        tap((isActive) => {
             if (userIsActive.value !== isActive) {
                 // Emit new value unless it already has that value
                 userIsActive.next(isActive);
@@ -3537,8 +5083,8 @@
         }), 
         // Now, if true was emitted, make sure to set a timeout to emit false
         // unless new user activity things happen (in that case, the timeout will be cancelled!)
-        operators.switchMap((isActive) => isActive
-            ? rxjs.of(0).pipe(operators.delay(USER_INACTIVITY_TIMEOUT - INACTIVE_WAIT_TIME), operators.tap(() => userIsActive.next(false)))
+        switchMap((isActive) => isActive
+            ? rxjs.of(0).pipe(delay(USER_INACTIVITY_TIMEOUT - INACTIVE_WAIT_TIME), tap(() => userIsActive.next(false)))
             : rxjs.of(0)))
             .subscribe(() => { }); // Unless we subscribe nothing will be propagated to userIsActive observable
     }
@@ -3782,7 +5328,7 @@
             yield sleep$1(3000);
             // Wait til user does something (move mouse, tap, scroll, click etc)
             console.debug('waiting for someone to do something');
-            yield userDoesSomething.pipe(operators.take(1)).toPromise();
+            yield userDoesSomething.pipe(take(1)).toPromise();
             console.debug('someone did something!');
         });
     }
@@ -3791,10 +5337,10 @@
         if (!((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.databaseUrl)) {
             throw new Error(`No database URL to connect WebSocket to`);
         }
-        const messageProducer = db.messageConsumer.readyToServe.pipe(operators.filter((isReady) => isReady), // When consumer is ready for new messages, produce such a message to inform server about it
-        operators.switchMap(() => db.getPersistedSyncState()), // We need the info on which server revision we are at:
-        operators.filter((syncState) => syncState && syncState.serverRevision), // We wont send anything to server before inital sync has taken place
-        operators.switchMap((syncState) => __awaiter(this, void 0, void 0, function* () {
+        const messageProducer = db.messageConsumer.readyToServe.pipe(filter((isReady) => isReady), // When consumer is ready for new messages, produce such a message to inform server about it
+        switchMap(() => db.getPersistedSyncState()), // We need the info on which server revision we are at:
+        filter((syncState) => syncState && syncState.serverRevision), // We wont send anything to server before inital sync has taken place
+        switchMap((syncState) => __awaiter(this, void 0, void 0, function* () {
             return ({
                 // Produce the message to trigger server to send us new messages to consume:
                 type: 'ready',
@@ -3803,22 +5349,22 @@
             });
         })));
         function createObservable() {
-            return db.cloud.persistedSyncState.pipe(operators.filter((syncState) => syncState === null || syncState === void 0 ? void 0 : syncState.serverRevision), // Don't connect before there's no initial sync performed.
-            operators.take(1), // Don't continue waking up whenever syncState change
-            operators.switchMap((syncState) => db.cloud.currentUser.pipe(operators.map((userLogin) => [userLogin, syncState]))), operators.switchMap(([userLogin, syncState]) => {
+            return db.cloud.persistedSyncState.pipe(filter((syncState) => syncState === null || syncState === void 0 ? void 0 : syncState.serverRevision), // Don't connect before there's no initial sync performed.
+            take(1), // Don't continue waking up whenever syncState change
+            switchMap((syncState) => db.cloud.currentUser.pipe(map((userLogin) => [userLogin, syncState]))), switchMap(([userLogin, syncState]) => {
                 /*if (userLogin.license?.status && userLogin.license.status !== 'ok') {
                   throw new InvalidLicenseError();
                 }*/
-                return userIsReallyActive.pipe(operators.map((isActive) => [isActive ? userLogin : null, syncState]));
-            }), operators.switchMap(([userLogin, syncState]) => {
+                return userIsReallyActive.pipe(map((isActive) => [isActive ? userLogin : null, syncState]));
+            }), switchMap(([userLogin, syncState]) => {
                 if ((userLogin === null || userLogin === void 0 ? void 0 : userLogin.isLoggedIn) && !(syncState === null || syncState === void 0 ? void 0 : syncState.realms.includes(userLogin.userId))) {
                     // We're in an in-between state when user is logged in but the user's realms are not yet synced.
                     // Don't make this change reconnect the websocket just yet. Wait till syncState is updated
                     // to iclude the user's realm.
-                    return db.cloud.persistedSyncState.pipe(operators.filter((syncState) => (syncState === null || syncState === void 0 ? void 0 : syncState.realms.includes(userLogin.userId)) || false), operators.take(1), operators.map((syncState) => [userLogin, syncState]));
+                    return db.cloud.persistedSyncState.pipe(filter((syncState) => (syncState === null || syncState === void 0 ? void 0 : syncState.realms.includes(userLogin.userId)) || false), take(1), map((syncState) => [userLogin, syncState]));
                 }
                 return new rxjs.BehaviorSubject([userLogin, syncState]);
-            }), operators.switchMap(([userLogin, syncState]) => __awaiter(this, void 0, void 0, function* () { return [userLogin, yield computeRealmSetHash(syncState)]; })), operators.distinctUntilChanged(([prevUser, prevHash], [currUser, currHash]) => prevUser === currUser && prevHash === currHash), operators.switchMap(([userLogin, realmSetHash]) => {
+            }), switchMap(([userLogin, syncState]) => __awaiter(this, void 0, void 0, function* () { return [userLogin, yield computeRealmSetHash(syncState)]; })), distinctUntilChanged(([prevUser, prevHash], [currUser, currHash]) => prevUser === currUser && prevHash === currHash), switchMap(([userLogin, realmSetHash]) => {
                 // Let server end query changes from last entry of same client-ID and forward.
                 // If no new entries, server won't bother the client. If new entries, server sends only those
                 // and the baseRev of the last from same client-ID.
@@ -3828,10 +5374,10 @@
                 else {
                     return rxjs.from([]);
                 }
-            }), operators.catchError((error) => {
+            }), catchError((error) => {
                 if ((error === null || error === void 0 ? void 0 : error.name) === 'TokenExpiredError') {
                     console.debug('WebSocket observable: Token expired. Refreshing token...');
-                    return rxjs.of(true).pipe(operators.switchMap(() => __awaiter(this, void 0, void 0, function* () {
+                    return rxjs.of(true).pipe(switchMap(() => __awaiter(this, void 0, void 0, function* () {
                         // Refresh access token
                         const user = yield db.getCurrentUser();
                         const refreshedLogin = yield refreshAccessToken(db.cloud.options.databaseUrl, user);
@@ -3842,18 +5388,18 @@
                             claims: refreshedLogin.claims,
                             license: refreshedLogin.license,
                         });
-                    })), operators.switchMap(() => createObservable()));
+                    })), switchMap(() => createObservable()));
                 }
                 else {
                     return rxjs.throwError(() => error);
                 }
-            }), operators.catchError((error) => {
+            }), catchError((error) => {
                 db.cloud.webSocketStatus.next("error");
                 if (error instanceof InvalidLicenseError) {
                     // Don't retry. Just throw and don't try connect again.
                     return rxjs.throwError(() => error);
                 }
-                return rxjs.from(waitAndReconnectWhenUserDoesSomething(error)).pipe(operators.switchMap(() => createObservable()));
+                return rxjs.from(waitAndReconnectWhenUserDoesSomething(error)).pipe(switchMap(() => createObservable()));
             }));
         }
         return createObservable().subscribe({
@@ -4058,11 +5604,11 @@
         for (const table of db.tables) {
             if ((_b = (_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[table.name]) === null || _b === void 0 ? void 0 : _b.markedForSync) {
                 if (table.schema.primKey.auto) {
-                    throw new Dexie__default["default"].SchemaError(`Table ${table.name} is both autoIncremented and synced. ` +
+                    throw new Dexie.SchemaError(`Table ${table.name} is both autoIncremented and synced. ` +
                         `Use db.cloud.configure({unsyncedTables: [${JSON.stringify(table.name)}]}) to blacklist it from sync`);
                 }
                 if (!table.schema.primKey.keyPath) {
-                    throw new Dexie__default["default"].SchemaError(`Table ${table.name} cannot be both synced and outbound. ` +
+                    throw new Dexie.SchemaError(`Table ${table.name} cannot be both synced and outbound. ` +
                         `Use db.cloud.configure({unsyncedTables: [${JSON.stringify(table.name)}]}) to blacklist it from sync`);
                 }
             }
@@ -4270,7 +5816,7 @@
 
     function computeSyncState(db) {
         let _prevStatus = db.cloud.webSocketStatus.value;
-        const lazyWebSocketStatus = db.cloud.webSocketStatus.pipe(operators.switchMap((status) => {
+        const lazyWebSocketStatus = db.cloud.webSocketStatus.pipe(switchMap((status) => {
             const prevStatus = _prevStatus;
             _prevStatus = status;
             const rv = rxjs.of(status);
@@ -4280,23 +5826,23 @@
                 // Only show disconnected if disconnected more than 500ms, or if we can
                 // see that the user is indeed not active.
                 case 'disconnected':
-                    return userIsActive.value ? rv.pipe(operators.debounceTime(500)) : rv;
+                    return userIsActive.value ? rv.pipe(debounceTime(500)) : rv;
                 // Only show connecting if previous state was 'not-started' or 'error', or if
                 // the time it takes to connect goes beyond 4 seconds.
                 case 'connecting':
                     return prevStatus === 'not-started' || prevStatus === 'error'
                         ? rv
-                        : rv.pipe(operators.debounceTime(4000));
+                        : rv.pipe(debounceTime(4000));
                 default:
                     return rv;
             }
         }));
         return rxjs.combineLatest([
             lazyWebSocketStatus,
-            db.syncStateChangedEvent.pipe(operators.startWith({ phase: 'initial' })),
+            db.syncStateChangedEvent.pipe(startWith({ phase: 'initial' })),
             getCurrentUserEmitter(db.dx._novip),
             userIsReallyActive
-        ]).pipe(operators.map(([status, syncState, user, 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 {
@@ -4385,7 +5931,7 @@
     });
 
     const getInternalAccessControlObservable = associate((db) => {
-        return createSharedValueObservable(getCurrentUserEmitter(db._novip).pipe(operators.switchMap((currentUser) => Dexie.liveQuery(() => db.transaction('r', 'realms', 'members', () => Promise.all([
+        return createSharedValueObservable(getCurrentUserEmitter(db._novip).pipe(switchMap((currentUser) => Dexie.liveQuery(() => db.transaction('r', 'realms', 'members', () => Promise.all([
             db.members.where({ userId: currentUser.userId }).toArray(),
             db.realms.toArray(),
             currentUser.userId,
@@ -4486,7 +6032,7 @@
         const o = createSharedValueObservable(rxjs.combineLatest([
             getInternalAccessControlObservable(db._novip),
             getGlobalRolesObservable(db._novip),
-        ]).pipe(operators.map(([{ selfMembers, realms, userId }, globalRoles]) => ({
+        ]).pipe(map(([{ selfMembers, realms, userId }, globalRoles]) => ({
             selfMembers,
             realms,
             userId,
@@ -4600,16 +6146,16 @@
                 return new PermissionChecker({}, tableName, !owner || owner === dexie.cloud.currentUserId);
             return new PermissionChecker(realm.permissions, tableName, realmId === dexie.cloud.currentUserId || owner === dexie.cloud.currentUserId);
         };
-        const o = source.pipe(operators.map(mapper));
+        const o = source.pipe(map(mapper));
         o.getValue = () => mapper(source.getValue());
         return o;
     }
 
     const getInvitesObservable = associate((db) => {
-        const membersByEmail = getCurrentUserEmitter(db._novip).pipe(operators.switchMap((currentUser) => Dexie.liveQuery(() => db.members.where({ email: currentUser.email || '' }).toArray())));
+        const membersByEmail = getCurrentUserEmitter(db._novip).pipe(switchMap((currentUser) => Dexie.liveQuery(() => db.members.where({ email: currentUser.email || '' }).toArray())));
         const permissions = getPermissionsLookupObservable(db._novip);
         const accessControl = getInternalAccessControlObservable(db._novip);
-        return createSharedValueObservable(rxjs.combineLatest([membersByEmail, accessControl, permissions]).pipe(operators.map(([membersByEmail, accessControl, realmLookup]) => {
+        return createSharedValueObservable(rxjs.combineLatest([membersByEmail, accessControl, permissions]).pipe(map(([membersByEmail, accessControl, realmLookup]) => {
             const reducer = (result, m) => (Object.assign(Object.assign({}, result), { [m.id]: Object.assign(Object.assign({}, m), { realm: realmLookup[m.realmId] }) }));
             const emailMembersById = membersByEmail.reduce(reducer, {});
             const membersById = accessControl.selfMembers.reduce(reducer, emailMembersById);
@@ -4655,7 +6201,7 @@
         let closed = false;
         function throwIfClosed() {
             if (closed)
-                throw new Dexie__default["default"].DatabaseClosedError();
+                throw new Dexie.DatabaseClosedError();
         }
         dbOnClosed(dexie, () => {
             subscriptions.forEach((subscription) => subscription.unsubscribe());
@@ -4666,7 +6212,7 @@
         });
         const syncComplete = new rxjs.Subject();
         dexie.cloud = {
-            version: '4.0.1-beta.47',
+            version: '{version}',
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -4725,8 +6271,8 @@
                         triggerSync(db, purpose);
                         if (wait) {
                             const newSyncState = yield db.cloud.persistedSyncState
-                                .pipe(operators.filter((newSyncState) => (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.timestamp) != null &&
-                                (!syncState || newSyncState.timestamp > syncState.timestamp)), operators.take(1))
+                                .pipe(filter((newSyncState) => (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.timestamp) != null &&
+                                (!syncState || newSyncState.timestamp > syncState.timestamp)), take(1))
                                 .toPromise();
                             if (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.error) {
                                 throw new Error(`Sync error: ` + newSyncState.error);
@@ -4746,7 +6292,7 @@
                                     throw new Error(`Sync error: ` + newSyncState.error);
                                 return syncNeeded;
                             })))
-                                .pipe(operators.filter((isNeeded) => !isNeeded), operators.take(1))
+                                .pipe(filter((isNeeded) => !isNeeded), take(1))
                                 .toPromise();
                             console.debug('Done waiting for sync completion because we have nothing to push anymore');
                         }
@@ -4757,7 +6303,7 @@
                 return permissions(dexie._novip, obj, tableName);
             },
         };
-        dexie.Version.prototype['_parseStoresSpec'] = Dexie__default["default"].override(dexie.Version.prototype['_parseStoresSpec'], (origFunc) => overrideParseStoresSpec(origFunc, dexie));
+        dexie.Version.prototype['_parseStoresSpec'] = Dexie.override(dexie.Version.prototype['_parseStoresSpec'], (origFunc) => overrideParseStoresSpec(origFunc, dexie));
         dexie.Table.prototype.newId = function ({ colocateWith } = {}) {
             const shardKey = colocateWith && colocateWith.substr(colocateWith.length - 3);
             return generateKey(dexie.cloud.schema[this.name].idPrefix || '', shardKey);
@@ -4890,8 +6436,8 @@
                     // This is so that when db.open() completes, user should be safe
                     // to subscribe to these observables and get actual data.
                     yield rxjs.combineLatest([
-                        currentUserEmitter.pipe(operators.skip(1), operators.take(1)),
-                        db.cloud.persistedSyncState.pipe(operators.skip(1), operators.take(1)),
+                        currentUserEmitter.pipe(skip(1), take(1)),
+                        db.cloud.persistedSyncState.pipe(skip(1), take(1)),
                     ]).toPromise();
                 }
                 // HERE: If requireAuth, do athentication now.
@@ -4942,8 +6488,8 @@
             });
         }
     }
-    dexieCloud.version = '4.0.1-beta.47';
-    Dexie__default["default"].Cloud = dexieCloud;
+    dexieCloud.version = '{version}';
+    Dexie.Cloud = dexieCloud;
 
     // In case the SW lives for a while, let it reuse already opened connections:
     const managedDBs = new Map();
@@ -4977,7 +6523,7 @@
                 let db = managedDBs.get(dbName);
                 if (!db) {
                     console.debug('Dexie Cloud SW: Creating new Dexie instance for', dbName);
-                    const dexie = new Dexie__default["default"](dbName, { addons: [dexieCloud] });
+                    const dexie = new Dexie(dbName, { addons: [dexieCloud] });
                     db = DexieCloudDB(dexie);
                     db.cloud.isServiceWorkerDB = true;
                     dexie.on('versionchange', stopManagingDB);
@@ -5020,7 +6566,7 @@
                     // Error occured. Stop managing this DB until we wake up again by a sync event,
                     // which will open a new Dexie and start trying to sync it.
                     stopManagingDB();
-                    if (e.name !== Dexie__default["default"].errnames.NoSuchDatabase) {
+                    if (e.name !== Dexie.errnames.NoSuchDatabase) {
                         // Unless the error was that DB doesn't exist, rethrow to trigger sync retry.
                         throw e; // Throw e to make syncEvent.waitUntil() receive a rejected promis, so it will retry.
                     }