dexie-cloud-addon 4.0.1-beta.38 → 4.0.1-beta.39

package/dist/umd/service-worker.js

@@ -1,8 +1,8 @@
 (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';
+    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 }; }
 
@@ -22,22 +22,6 @@
     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); }); }
@@ -47,97 +31,6 @@
             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 = {
@@ -291,1520 +184,6 @@
         }
     }
 
-    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 () {
-            var onUnhandledError = config.onUnhandledError;
-            if (onUnhandledError) {
-                onUnhandledError(err);
-            }
-            else {
-                throw err;
-            }
-        });
-    }
-
-    function noop() { }
-
-    var COMPLETE_NOTIFICATION = (function () { return createNotification('C', undefined, undefined); })();
-    function errorNotification(error) {
-        return createNotification('E', undefined, error);
-    }
-    function nextNotification(value) {
-        return createNotification('N', value, undefined);
-    }
-    function createNotification(kind, value, error) {
-        return {
-            kind: kind,
-            value: value,
-            error: error,
-        };
-    }
-
-    var context = null;
-    function errorContext(cb) {
-        if (config.useDeprecatedSynchronousErrorHandling) {
-            var isRoot = !context;
-            if (isRoot) {
-                context = { errorThrown: false, error: null };
-            }
-            cb();
-            if (isRoot) {
-                var _a = context, errorThrown = _a.errorThrown, error = _a.error;
-                context = null;
-                if (errorThrown) {
-                    throw error;
-                }
-            }
-        }
-        else {
-            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) {
-                handleStoppedNotification(nextNotification(value), this);
-            }
-            else {
-                this._next(value);
-            }
-        };
-        Subscriber.prototype.error = function (err) {
-            if (this.isStopped) {
-                handleStoppedNotification(errorNotification(err), this);
-            }
-            else {
-                this.isStopped = true;
-                this._error(err);
-            }
-        };
-        Subscriber.prototype.complete = function () {
-            if (this.isStopped) {
-                handleStoppedNotification(COMPLETE_NOTIFICATION, this);
-            }
-            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;
-    }
-    function handleStoppedNotification(notification, subscriber) {
-        var onStoppedNotification = config.onStoppedNotification;
-        onStoppedNotification && timeoutProvider.setTimeout(function () { return onStoppedNotification(notification, subscriber); });
-    }
-    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;
-    }
-
-    var TimeoutError = createErrorClass(function (_super) {
-        return function TimeoutErrorImpl(info) {
-            if (info === void 0) { info = null; }
-            _super(this);
-            this.message = 'Timeout has occurred';
-            this.name = 'TimeoutError';
-            this.info = info;
-        };
-    });
-    function timeout(config, schedulerArg) {
-        var _a = (isValidDate(config) ? { first: config } : typeof config === 'number' ? { each: config } : config), first = _a.first, each = _a.each, _b = _a.with, _with = _b === void 0 ? timeoutErrorFactory : _b, _c = _a.scheduler, scheduler = _c === void 0 ? schedulerArg !== null && schedulerArg !== void 0 ? schedulerArg : asyncScheduler : _c, _d = _a.meta, meta = _d === void 0 ? null : _d;
-        if (first == null && each == null) {
-            throw new TypeError('No timeout provided.');
-        }
-        return operate(function (source, subscriber) {
-            var originalSourceSubscription;
-            var timerSubscription;
-            var lastValue = null;
-            var seen = 0;
-            var startTimer = function (delay) {
-                timerSubscription = executeSchedule(subscriber, scheduler, function () {
-                    try {
-                        originalSourceSubscription.unsubscribe();
-                        innerFrom(_with({
-                            meta: meta,
-                            lastValue: lastValue,
-                            seen: seen,
-                        })).subscribe(subscriber);
-                    }
-                    catch (err) {
-                        subscriber.error(err);
-                    }
-                }, delay);
-            };
-            originalSourceSubscription = source.subscribe(createOperatorSubscriber(subscriber, function (value) {
-                timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.unsubscribe();
-                seen++;
-                subscriber.next((lastValue = value));
-                each > 0 && startTimer(each);
-            }, undefined, undefined, function () {
-                if (!(timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.closed)) {
-                    timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.unsubscribe();
-                }
-                lastValue = null;
-            }));
-            !seen && startTimer(first != null ? (typeof first === 'number' ? first : +first - scheduler.now()) : each);
-        });
-    }
-    function timeoutErrorFactory(info) {
-        throw new TimeoutError(info);
-    }
-
     //const hasSW = 'serviceWorker' in navigator;
     let hasComplainedAboutSyncEvent = false;
     function registerSyncEvent(db, purpose) {
@@ -3776,7 +2155,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(filter(({ phase }) => phase === 'in-sync' || phase === 'error'), take(1))
+                            .pipe(operators.filter(({ phase }) => phase === 'in-sync' || phase === 'error'), operators.take(1))
                             .toPromise();
                         console.debug('processing msg', msg);
                         const persistedSyncState = db.cloud.persistedSyncState.value;
@@ -4886,13 +3265,13 @@
     //   for just a short time.
     const userIsReallyActive = new rxjs.BehaviorSubject(true);
     userIsActive
-        .pipe(switchMap((isActive) => {
+        .pipe(operators.switchMap((isActive) => {
         //console.debug('SyncStatus: DUBB: isActive changed to', isActive);
         return isActive
             ? rxjs.of(true)
-            : rxjs.of(false).pipe(delay(INACTIVE_WAIT_TIME))
+            : rxjs.of(false).pipe(operators.delay(INACTIVE_WAIT_TIME))
                 ;
-    }), distinctUntilChanged())
+    }), operators.distinctUntilChanged())
         .subscribe(userIsReallyActive);
     //
     // First create some corner-stone observables to build the flow on
@@ -4902,9 +3281,9 @@
         ? rxjs.fromEvent(document, 'visibilitychange')
         : rxjs.of({});
     // document.onvisibilitychange makes document hidden:
-    const documentBecomesHidden = visibilityStateIsChanged.pipe(filter(() => document.visibilityState === 'hidden'));
+    const documentBecomesHidden = visibilityStateIsChanged.pipe(operators.filter(() => document.visibilityState === 'hidden'));
     // document.onvisibilitychange makes document visible
-    const documentBecomesVisible = visibilityStateIsChanged.pipe(filter(() => document.visibilityState === 'visible'));
+    const documentBecomesVisible = visibilityStateIsChanged.pipe(operators.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'))
@@ -4922,9 +3301,9 @@
         userDoesSomething)
             .pipe(
         // No matter event source, compute whether user is visible using visibilityState:
-        map(() => document.visibilityState === 'visible'), 
+        operators.map(() => document.visibilityState === 'visible'), 
         // Make sure to emit it
-        tap((isActive) => {
+        operators.tap((isActive) => {
             if (userIsActive.value !== isActive) {
                 // Emit new value unless it already has that value
                 userIsActive.next(isActive);
@@ -4932,8 +3311,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!)
-        switchMap((isActive) => isActive
-            ? rxjs.of(0).pipe(delay(USER_INACTIVITY_TIMEOUT - INACTIVE_WAIT_TIME), tap(() => userIsActive.next(false)))
+        operators.switchMap((isActive) => isActive
+            ? rxjs.of(0).pipe(operators.delay(USER_INACTIVITY_TIMEOUT - INACTIVE_WAIT_TIME), operators.tap(() => userIsActive.next(false)))
             : rxjs.of(0)))
             .subscribe(() => { }); // Unless we subscribe nothing will be propagated to userIsActive observable
     }
@@ -5163,7 +3542,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(take(1)).toPromise();
+            yield userDoesSomething.pipe(operators.take(1)).toPromise();
             console.debug('someone did something!');
         });
     }
@@ -5172,35 +3551,35 @@
         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(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
-        map((syncState) => ({
+        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.map((syncState) => ({
             // Produce the message to trigger server to send us new messages to consume:
             type: 'ready',
             rev: syncState.serverRevision,
         })));
         function createObservable() {
-            return db.cloud.persistedSyncState.pipe(filter((syncState) => syncState === null || syncState === void 0 ? void 0 : syncState.serverRevision), // Don't connect before there's no initial sync performed.
-            take(1), // Don't continue waking up whenever syncState change
-            switchMap((syncState) => db.cloud.currentUser.pipe(map((userLogin) => [userLogin, syncState]))), switchMap(([userLogin, syncState]) => userIsReallyActive.pipe(map((isActive) => [isActive ? userLogin : null, syncState]))), switchMap(([userLogin, syncState]) => {
+            return db.cloud.persistedSyncState.pipe(operators.filter((syncState) => syncState === null || syncState === void 0 ? void 0 : syncState.serverRevision), // Don't connect before there's no initial sync performed.
+            operators.take(1), // Don't continue waking up whenever syncState change
+            operators.switchMap((syncState) => db.cloud.currentUser.pipe(operators.map((userLogin) => [userLogin, syncState]))), operators.switchMap(([userLogin, syncState]) => userIsReallyActive.pipe(operators.map((isActive) => [isActive ? userLogin : null, syncState]))), operators.switchMap(([userLogin, syncState]) => {
                 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(filter((syncState) => (syncState === null || syncState === void 0 ? void 0 : syncState.realms.includes(userLogin.userId)) || false), take(1), map((syncState) => [userLogin, syncState]));
+                    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 new rxjs.BehaviorSubject([userLogin, syncState]);
-            }), switchMap(([userLogin, syncState]) => __awaiter(this, void 0, void 0, function* () { return [userLogin, yield computeRealmSetHash(syncState)]; })), switchMap(([userLogin, realmSetHash]) => 
+            }), operators.switchMap(([userLogin, syncState]) => __awaiter(this, void 0, void 0, function* () { return [userLogin, yield computeRealmSetHash(syncState)]; })), operators.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.
             userLogin
                 ? new WSObservable(db.cloud.options.databaseUrl, db.cloud.persistedSyncState.value.serverRevision, realmSetHash, db.cloud.persistedSyncState.value.clientIdentity, messageProducer, db.cloud.webSocketStatus, userLogin.accessToken, userLogin.accessTokenExpiration)
-                : rxjs.from([])), catchError((error) => {
+                : rxjs.from([])), operators.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(switchMap(() => __awaiter(this, void 0, void 0, function* () {
+                    return rxjs.of(true).pipe(operators.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);
@@ -5209,14 +3588,14 @@
                             accessToken: refreshedLogin.accessToken,
                             accessTokenExpiration: refreshedLogin.accessTokenExpiration,
                         });
-                    })), switchMap(() => createObservable()));
+                    })), operators.switchMap(() => createObservable()));
                 }
                 else {
                     return rxjs.throwError(error);
                 }
-            }), catchError((error) => {
+            }), operators.catchError((error) => {
                 db.cloud.webSocketStatus.next("error");
-                return rxjs.from(waitAndReconnectWhenUserDoesSomething(error)).pipe(switchMap(() => createObservable()));
+                return rxjs.from(waitAndReconnectWhenUserDoesSomething(error)).pipe(operators.switchMap(() => createObservable()));
             }));
         }
         return createObservable().subscribe((msg) => {
@@ -5285,7 +3664,7 @@
                     // Someone else took the job.
                     if (awaitRemoteJob) {
                         try {
-                            const jobDoneObservable = rxjs.from(Dexie.liveQuery(() => jobsTable.get(jobName))).pipe(timeout(GUARDED_JOB_TIMEOUT), filter((job) => !job)); // Wait til job is not there anymore.
+                            const jobDoneObservable = rxjs.from(Dexie.liveQuery(() => jobsTable.get(jobName))).pipe(operators.timeout(GUARDED_JOB_TIMEOUT), operators.filter((job) => !job)); // Wait til job is not there anymore.
                             yield jobDoneObservable.toPromise();
                             return false;
                         }
@@ -5655,7 +4034,7 @@
 
     function computeSyncState(db) {
         let _prevStatus = db.cloud.webSocketStatus.value;
-        const lazyWebSocketStatus = db.cloud.webSocketStatus.pipe(switchMap((status) => {
+        const lazyWebSocketStatus = db.cloud.webSocketStatus.pipe(operators.switchMap((status) => {
             const prevStatus = _prevStatus;
             _prevStatus = status;
             const rv = rxjs.of(status);
@@ -5665,22 +4044,22 @@
                 // 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(debounceTime(500)) : rv;
+                    return userIsActive.value ? rv.pipe(operators.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(debounceTime(4000));
+                        : rv.pipe(operators.debounceTime(4000));
                 default:
                     return rv;
             }
         }));
         return rxjs.combineLatest([
             lazyWebSocketStatus,
-            db.syncStateChangedEvent.pipe(startWith({ phase: 'initial' })),
+            db.syncStateChangedEvent.pipe(operators.startWith({ phase: 'initial' })),
             userIsReallyActive
-        ]).pipe(map(([status, syncState, userIsActive]) => {
+        ]).pipe(operators.map(([status, syncState, userIsActive]) => {
             let { phase, error, progress } = syncState;
             let adjustedStatus = status;
             if (phase === 'error') {
@@ -5774,7 +4153,7 @@
     const getCurrentUserEmitter = associate((db) => new rxjs.BehaviorSubject(UNAUTHORIZED_USER));
 
     const getInternalAccessControlObservable = associate((db) => {
-        return createSharedValueObservable(getCurrentUserEmitter(db._novip).pipe(switchMap((currentUser) => Dexie.liveQuery(() => db.transaction('r', 'realms', 'members', () => Promise.all([
+        return createSharedValueObservable(getCurrentUserEmitter(db._novip).pipe(operators.switchMap((currentUser) => Dexie.liveQuery(() => db.transaction('r', 'realms', 'members', () => Promise.all([
             db.members.where({ userId: currentUser.userId }).toArray(),
             db.realms.toArray(),
             currentUser.userId,
@@ -5875,7 +4254,7 @@
         const o = createSharedValueObservable(rxjs.combineLatest([
             getInternalAccessControlObservable(db._novip),
             getGlobalRolesObservable(db._novip),
-        ]).pipe(map(([{ selfMembers, realms, userId }, globalRoles]) => ({
+        ]).pipe(operators.map(([{ selfMembers, realms, userId }, globalRoles]) => ({
             selfMembers,
             realms,
             userId,
@@ -5989,16 +4368,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(map(mapper));
+        const o = source.pipe(operators.map(mapper));
         o.getValue = () => mapper(source.getValue());
         return o;
     }
 
     const getInvitesObservable = associate((db) => {
-        const membersByEmail = getCurrentUserEmitter(db._novip).pipe(switchMap((currentUser) => Dexie.liveQuery(() => db.members.where({ email: currentUser.email || '' }).toArray())));
+        const membersByEmail = getCurrentUserEmitter(db._novip).pipe(operators.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(map(([membersByEmail, accessControl, realmLookup]) => {
+        return createSharedValueObservable(rxjs.combineLatest([membersByEmail, accessControl, permissions]).pipe(operators.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);
@@ -6055,7 +4434,7 @@
         });
         const syncComplete = new rxjs.Subject();
         dexie.cloud = {
-            version: '4.0.1-beta.38',
+            version: '4.0.1-beta.39',
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -6101,8 +4480,8 @@
                         triggerSync(db, purpose);
                         if (wait) {
                             const newSyncState = yield db.cloud.persistedSyncState
-                                .pipe(filter((newSyncState) => (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.timestamp) != null &&
-                                (!syncState || newSyncState.timestamp > syncState.timestamp)), take(1))
+                                .pipe(operators.filter((newSyncState) => (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.timestamp) != null &&
+                                (!syncState || newSyncState.timestamp > syncState.timestamp)), operators.take(1))
                                 .toPromise();
                             if (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.error) {
                                 throw new Error(`Sync error: ` + newSyncState.error);
@@ -6122,7 +4501,7 @@
                                     throw new Error(`Sync error: ` + newSyncState.error);
                                 return syncNeeded;
                             })))
-                                .pipe(filter((isNeeded) => !isNeeded), take(1))
+                                .pipe(operators.filter((isNeeded) => !isNeeded), operators.take(1))
                                 .toPromise();
                             console.debug('Done waiting for sync completion because we have nothing to push anymore');
                         }
@@ -6266,8 +4645,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(skip(1), take(1)),
-                        db.cloud.persistedSyncState.pipe(skip(1), take(1)),
+                        currentUserEmitter.pipe(operators.skip(1), operators.take(1)),
+                        db.cloud.persistedSyncState.pipe(operators.skip(1), operators.take(1)),
                     ]).toPromise();
                 }
                 // HERE: If requireAuth, do athentication now.
@@ -6316,7 +4695,7 @@
             });
         }
     }
-    dexieCloud.version = '4.0.1-beta.38';
+    dexieCloud.version = '4.0.1-beta.39';
     Dexie__default["default"].Cloud = dexieCloud;
 
     // In case the SW lives for a while, let it reuse already opened connections: