dexie-cloud-addon 4.2.0-alpha.1 → 4.2.0-alpha.4

package/dist/umd/dexie-cloud-addon.js

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.2.0-alpha.1, Fri Aug 01 2025
+ * Version 4.2.0-alpha.4, Fri Aug 01 2025
  *
  * https://dexie.org
  *
@@ -17,10 +17,10 @@
  */
 
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('dexie'), require('rxjs')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'dexie', 'rxjs'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.DexieCloud = {}, global.Dexie, global.rxjs));
-})(this, (function (exports, Dexie, rxjs) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('dexie'), require('rxjs'), require('rxjs/operators')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'dexie', 'rxjs', 'rxjs/operators'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.DexieCloud = {}, global.Dexie, global.rxjs, global.rxjs.operators));
+})(this, (function (exports, Dexie, rxjs, operators) { 'use strict';
 
     /******************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -38,20 +38,6 @@
     ***************************************************************************** */
     /* 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 __rest(s, e) {
         var t = {};
@@ -75,34 +61,6 @@
         });
     }
 
-    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);
@@ -115,33 +73,6 @@
         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);
     }
@@ -1395,1581 +1326,163 @@
                             table,
                             prop,
                             k,
-                            u: readVarUint8Array$1(decoder),
-                            i: Number(readBigUint64(decoder)),
-                        };
-                    case 'u-s':
-                        return {
-                            type,
-                            table,
-                            prop,
-                            k,
-                            u: readVarUint8Array$1(decoder),
-                            r: (decoder.pos < decoder.arr.length && readVarString$1(decoder)) || undefined,
-                        };
-                    default:
-                        throw new TypeError(`Unknown message type: ${type}`);
-                }
-            }
-        }
-    }
-
-    async function asyncIterablePipeline(source, ...stages) {
-        var _a, e_1, _b, _c;
-        // Chain generators by sending outdata from one to another
-        let result = source(); // Start with the source generator
-        for (let i = 0; i < stages.length; i++) {
-            result = stages[i](result); // Pass on the result to next generator
-        }
-        try {
-            // Start running the machine. If the last stage is a sink, it will consume the data and never emit anything
-            // to us here...
-            for (var _d = true, result_1 = __asyncValues(result), result_1_1; result_1_1 = await result_1.next(), _a = result_1_1.done, !_a; _d = true) {
-                _c = result_1_1.value;
-                _d = false;
-                const chunk = _c;
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = result_1.return)) await _b.call(result_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    }
-
-    function consumeChunkedBinaryStream(source) {
-        return __asyncGenerator(this, arguments, function* consumeChunkedBinaryStream_1() {
-            var _a, e_1, _b, _c;
-            let state = 0;
-            let sizeBuf = new Uint8Array(4);
-            let sizeBufPos = 0;
-            let bufs = [];
-            let len = 0;
-            try {
-                for (var _d = true, source_1 = __asyncValues(source), source_1_1; source_1_1 = yield __await(source_1.next()), _a = source_1_1.done, !_a; _d = true) {
-                    _c = source_1_1.value;
-                    _d = false;
-                    const chunk = _c;
-                    const dw = new DataView(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-                    let pos = 0;
-                    while (pos < chunk.byteLength) {
-                        switch (state) {
-                            case 0:
-                                // Beginning of a size header
-                                if (pos + 4 > chunk.byteLength) {
-                                    for (const b of chunk.slice(pos)) {
-                                        if (sizeBufPos === 4)
-                                            break;
-                                        sizeBuf[sizeBufPos++] = b;
-                                        ++pos;
-                                    }
-                                    if (sizeBufPos < 4) {
-                                        // Need more bytes in order to read length.
-                                        // Will go out from while loop as well because pos is defenitely = chunk.byteLength here.
-                                        break;
-                                    }
-                                }
-                                else if (sizeBufPos > 0 && sizeBufPos < 4) {
-                                    for (const b of chunk.slice(pos, pos + 4 - sizeBufPos)) {
-                                        sizeBuf[sizeBufPos++] = b;
-                                        ++pos;
-                                    }
-                                }
-                            // Intentional fall-through...
-                            case 1:
-                                len =
-                                    sizeBufPos === 4
-                                        ? new DataView(sizeBuf.buffer, 0, 4).getUint32(0, false)
-                                        : dw.getUint32(pos, false);
-                                if (sizeBufPos)
-                                    sizeBufPos = 0; // in this case pos is already forwarded
-                                else
-                                    pos += 4; // else pos is not yet forwarded - that's why we do it now
-                            // Intentional fall-through...
-                            case 2:
-                                // Eat the chunk
-                                if (pos >= chunk.byteLength) {
-                                    state = 2;
-                                    break;
-                                }
-                                if (pos + len > chunk.byteLength) {
-                                    bufs.push(chunk.slice(pos));
-                                    len -= (chunk.byteLength - pos);
-                                    state = 2;
-                                    pos = chunk.byteLength; // will break while loop.
-                                }
-                                else {
-                                    if (bufs.length > 0) {
-                                        const concats = new Uint8Array(bufs.reduce((p, c) => p + c.byteLength, len));
-                                        let p = 0;
-                                        for (const buf of bufs) {
-                                            concats.set(buf, p);
-                                            p += buf.byteLength;
-                                        }
-                                        concats.set(chunk.slice(pos, pos + len), p);
-                                        bufs = [];
-                                        yield yield __await(concats);
-                                    }
-                                    else {
-                                        yield yield __await(chunk.slice(pos, pos + len));
-                                    }
-                                    pos += len;
-                                    state = 0;
-                                }
-                                break;
-                        }
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = source_1.return)) yield __await(_b.call(source_1));
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-        });
-    }
-
-    function getFetchResponseBodyGenerator(res) {
-        return function () {
-            return __asyncGenerator(this, arguments, function* () {
-                if (!res.body)
-                    throw new Error("Response body is not readable");
-                const reader = res.body.getReader();
-                try {
-                    while (true) {
-                        const { done, value } = yield __await(reader.read());
-                        if (done)
-                            return yield __await(void 0);
-                        yield yield __await(value);
-                    }
-                }
-                finally {
-                    reader.releaseLock();
-                }
-            });
-        };
-    }
-
-    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$1(asyncIterable, subscriber).catch(function (err) { return subscriber.error(err); });
-        });
-    }
-    function fromReadableStreamLike(readableStream) {
-        return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
-    }
-    function process$1(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$1(arr) {
-        return arr[arr.length - 1];
-    }
-    function popScheduler(args) {
-        return isScheduler(last$1(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();
-                    }
+                            u: readVarUint8Array$1(decoder),
+                            i: Number(readBigUint64(decoder)),
+                        };
+                    case 'u-s':
+                        return {
+                            type,
+                            table,
+                            prop,
+                            k,
+                            u: readVarUint8Array$1(decoder),
+                            r: (decoder.pos < decoder.arr.length && readVarString$1(decoder)) || undefined,
+                        };
+                    default:
+                        throw new TypeError(`Unknown message type: ${type}`);
                 }
-            });
-        });
-    }
-
-    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$1(input, scheduler) {
-        return scheduler ? scheduled(input, scheduler) : innerFrom(input);
-    }
-
-    function map$1(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$1(function (b, ii) { return resultSelector(a, b, i, ii); })(innerFrom(project(a, i))); }, concurrent);
+    async function asyncIterablePipeline(source, ...stages) {
+        var _a, e_1, _b, _c;
+        // Chain generators by sending outdata from one to another
+        let result = source(); // Start with the source generator
+        for (let i = 0; i < stages.length; i++) {
+            result = stages[i](result); // Pass on the result to next generator
         }
-        else if (typeof resultSelector === 'number') {
-            concurrent = resultSelector;
+        try {
+            // Start running the machine. If the last stage is a sink, it will consume the data and never emit anything
+            // to us here...
+            for (var _d = true, result_1 = __asyncValues(result), result_1_1; result_1_1 = await result_1.next(), _a = result_1_1.done, !_a; _d = true) {
+                _c = result_1_1.value;
+                _d = false;
+                const chunk = _c;
+            }
         }
-        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();
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = result_1.return)) await _b.call(result_1);
             }
-            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];
+            finally { if (e_1) throw e_1.error; }
         }
-        return concatAll()(from$1(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 consumeChunkedBinaryStream(source) {
+        return __asyncGenerator(this, arguments, function* consumeChunkedBinaryStream_1() {
+            var _a, e_1, _b, _c;
+            let state = 0;
+            let sizeBuf = new Uint8Array(4);
+            let sizeBufPos = 0;
+            let bufs = [];
+            let len = 0;
+            try {
+                for (var _d = true, source_1 = __asyncValues(source), source_1_1; source_1_1 = yield __await(source_1.next()), _a = source_1_1.done, !_a; _d = true) {
+                    _c = source_1_1.value;
+                    _d = false;
+                    const chunk = _c;
+                    const dw = new DataView(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+                    let pos = 0;
+                    while (pos < chunk.byteLength) {
+                        switch (state) {
+                            case 0:
+                                // Beginning of a size header
+                                if (pos + 4 > chunk.byteLength) {
+                                    for (const b of chunk.slice(pos)) {
+                                        if (sizeBufPos === 4)
+                                            break;
+                                        sizeBuf[sizeBufPos++] = b;
+                                        ++pos;
+                                    }
+                                    if (sizeBufPos < 4) {
+                                        // Need more bytes in order to read length.
+                                        // Will go out from while loop as well because pos is defenitely = chunk.byteLength here.
+                                        break;
+                                    }
+                                }
+                                else if (sizeBufPos > 0 && sizeBufPos < 4) {
+                                    for (const b of chunk.slice(pos, pos + 4 - sizeBufPos)) {
+                                        sizeBuf[sizeBufPos++] = b;
+                                        ++pos;
+                                    }
+                                }
+                            // Intentional fall-through...
+                            case 1:
+                                len =
+                                    sizeBufPos === 4
+                                        ? new DataView(sizeBuf.buffer, 0, 4).getUint32(0, false)
+                                        : dw.getUint32(pos, false);
+                                if (sizeBufPos)
+                                    sizeBufPos = 0; // in this case pos is already forwarded
+                                else
+                                    pos += 4; // else pos is not yet forwarded - that's why we do it now
+                            // Intentional fall-through...
+                            case 2:
+                                // Eat the chunk
+                                if (pos >= chunk.byteLength) {
+                                    state = 2;
+                                    break;
+                                }
+                                if (pos + len > chunk.byteLength) {
+                                    bufs.push(chunk.slice(pos));
+                                    len -= (chunk.byteLength - pos);
+                                    state = 2;
+                                    pos = chunk.byteLength; // will break while loop.
+                                }
+                                else {
+                                    if (bufs.length > 0) {
+                                        const concats = new Uint8Array(bufs.reduce((p, c) => p + c.byteLength, len));
+                                        let p = 0;
+                                        for (const buf of bufs) {
+                                            concats.set(buf, p);
+                                            p += buf.byteLength;
+                                        }
+                                        concats.set(chunk.slice(pos, pos + len), p);
+                                        bufs = [];
+                                        yield yield __await(concats);
+                                    }
+                                    else {
+                                        yield yield __await(chunk.slice(pos, pos + len));
+                                    }
+                                    pos += len;
+                                    state = 0;
+                                }
+                                break;
                         }
                     }
-                }));
-            });
-    }
-
-    function ignoreElements() {
-        return operate(function (source, subscriber) {
-            source.subscribe(createOperatorSubscriber(subscriber, noop));
-        });
-    }
-
-    function mapTo(value) {
-        return map$1(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();
-            }));
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = source_1.return)) yield __await(_b.call(source_1));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
         });
     }
 
-    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);
+    function getFetchResponseBodyGenerator(res) {
+        return function () {
+            return __asyncGenerator(this, arguments, function* () {
+                if (!res.body)
+                    throw new Error("Response body is not readable");
+                const reader = res.body.getReader();
+                try {
+                    while (true) {
+                        const { done, value } = yield __await(reader.read());
+                        if (done)
+                            return yield __await(void 0);
+                        yield yield __await(value);
                     }
-                    (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
-                }));
-            })
-            :
-                identity;
+                }
+                finally {
+                    reader.releaseLock();
+                }
+            });
+        };
     }
 
     //const hasSW = 'serviceWorker' in navigator;
@@ -15497,7 +14010,7 @@
      *
      * ==========================================================================
      *
-     * Version 4.2.0-alpha.2, Fri Aug 01 2025
+     * Version 4.2.0-alpha.3, Fri Aug 01 2025
      *
      * https://dexie.org
      *
@@ -15883,8 +14396,18 @@
         beforeunload: [promisableChain],
     });
     DexieYProvider.getDocCache = getDocCache;
-    // @ts-ignore
-    Dexie.Dexie.DexieYProvider = DexieYProvider;
+    //
+    // Eliminate dual package hazard 
+    //
+    // Since we're holding static state, make sure to singletonize DexieYProvider
+    //
+    if (Dexie.Dexie["DexieYProvider"]) {
+        // @ts-ignore
+        DexieYProvider = Dexie.Dexie["DexieYProvider"] || DexieYProvider;
+    }
+    else {
+        Dexie.Dexie["DexieYProvider"] = DexieYProvider;
+    }
 
     function applyYServerMessages(yMessages, db) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -16537,7 +15060,7 @@
                         // If the sync worker or service worker is syncing, wait 'til thei're done.
                         // It's no need to have two channels at the same time - even though it wouldnt
                         // be a problem - this is an optimization.
-                        yield rxjs.firstValueFrom(db.cloud.syncState.pipe(filter(({ phase }) => phase === 'in-sync' || phase === 'error')));
+                        yield rxjs.firstValueFrom(db.cloud.syncState.pipe(operators.filter(({ phase }) => phase === 'in-sync' || phase === 'error')));
                         console.debug('processing msg', msg);
                         const persistedSyncState = db.cloud.persistedSyncState.value;
                         //syncState.
@@ -17560,13 +16083,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
@@ -17576,9 +16099,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'))
@@ -17596,9 +16119,9 @@
         userDoesSomething)
             .pipe(
         // No matter event source, compute whether user is visible using visibilityState:
-        map$1(() => 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);
@@ -17606,8 +16129,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
     }
@@ -18000,10 +16523,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 readyForChangesMessage = 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* () {
+        const readyForChangesMessage = 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* () {
             return ({
                 // Produce the message to trigger server to send us new messages to consume:
                 type: 'ready',
@@ -18013,22 +16536,22 @@
         })));
         const messageProducer = rxjs.merge(readyForChangesMessage, db.messageProducer);
         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$1((userLogin) => [userLogin, 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]) => {
                 /*if (userLogin.license?.status && userLogin.license.status !== 'ok') {
                   throw new InvalidLicenseError();
                 }*/
-                return userIsReallyActive.pipe(map$1((isActive) => [isActive ? userLogin : null, syncState]));
-            }), switchMap(([userLogin, syncState]) => {
+                return 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$1((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((_a) => __awaiter(this, [_a], void 0, function* ([userLogin, syncState]) { return [userLogin, yield computeRealmSetHash(syncState)]; })), distinctUntilChanged(([prevUser, prevHash], [currUser, currHash]) => prevUser === currUser && prevHash === currHash), switchMap(([userLogin, realmSetHash]) => {
+            }), operators.switchMap((_a) => __awaiter(this, [_a], void 0, function* ([userLogin, syncState]) { return [userLogin, yield computeRealmSetHash(syncState)]; })), operators.distinctUntilChanged(([prevUser, prevHash], [currUser, currHash]) => prevUser === currUser && prevHash === currHash), operators.switchMap(([userLogin, realmSetHash]) => {
                 var _a;
                 if (!((_a = db.cloud.persistedSyncState) === null || _a === void 0 ? void 0 : _a.value)) {
                     // Restart the flow if persistedSyncState is not yet available.
@@ -18043,10 +16566,10 @@
                 else {
                     return rxjs.from([]);
                 }
-            }), catchError((error) => {
+            }), 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);
@@ -18058,18 +16581,18 @@
                             license: refreshedLogin.license,
                             data: refreshedLogin.data
                         });
-                    })), switchMap(() => createObservable()));
+                    })), operators.switchMap(() => createObservable()));
                 }
                 else {
                     return rxjs.throwError(() => error);
                 }
-            }), catchError((error) => {
+            }), operators.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(switchMap(() => createObservable()));
+                return rxjs.from(waitAndReconnectWhenUserDoesSomething(error)).pipe(operators.switchMap(() => createObservable()));
             }));
         }
         return createObservable().subscribe({
@@ -18499,7 +17022,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);
@@ -18509,23 +17032,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(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' })),
             getCurrentUserEmitter(db.dx._novip),
             userIsReallyActive
-        ]).pipe(map$1(([status, syncState, user, userIsActive]) => {
+        ]).pipe(operators.map(([status, syncState, user, userIsActive]) => {
             var _a;
             if (((_a = user.license) === null || _a === void 0 ? void 0 : _a.status) && user.license.status !== 'ok') {
                 return {
@@ -18614,7 +17137,7 @@
     });
 
     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,
@@ -18715,7 +17238,7 @@
         const o = createSharedValueObservable(rxjs.combineLatest([
             getInternalAccessControlObservable(db._novip),
             getGlobalRolesObservable(db._novip),
-        ]).pipe(map$1(([{ selfMembers, realms, userId }, globalRoles]) => ({
+        ]).pipe(operators.map(([{ selfMembers, realms, userId }, globalRoles]) => ({
             selfMembers,
             realms,
             userId,
@@ -18830,16 +17353,16 @@
                 return new PermissionChecker({}, tableName, !owner || owner === dexie.cloud.currentUserId);
             return new PermissionChecker(realm.permissions, tableName, realmId === undefined || realmId === dexie.cloud.currentUserId || owner === dexie.cloud.currentUserId);
         };
-        const o = source.pipe(map$1(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$1(([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);
@@ -19221,7 +17744,7 @@
         const syncComplete = new rxjs.Subject();
         dexie.cloud = {
             // @ts-ignore
-            version: "4.2.0-alpha.1",
+            version: "4.2.0-alpha.4",
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -19279,7 +17802,7 @@
                         const syncState = db.cloud.persistedSyncState.value;
                         triggerSync(db, purpose);
                         if (wait) {
-                            const newSyncState = yield rxjs.firstValueFrom(db.cloud.persistedSyncState.pipe(filter((newSyncState) => (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.timestamp) != null &&
+                            const newSyncState = yield rxjs.firstValueFrom(db.cloud.persistedSyncState.pipe(operators.filter((newSyncState) => (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.timestamp) != null &&
                                 (!syncState || newSyncState.timestamp > syncState.timestamp))));
                             if (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.error) {
                                 throw new Error(`Sync error: ` + newSyncState.error);
@@ -19298,7 +17821,7 @@
                                     (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.error))
                                     throw new Error(`Sync error: ` + newSyncState.error);
                                 return syncNeeded;
-                            }))).pipe(filter((isNeeded) => !isNeeded)));
+                            }))).pipe(operators.filter((isNeeded) => !isNeeded)));
                             console.debug('Done waiting for sync completion because we have nothing to push anymore');
                         }
                     }
@@ -19438,8 +17961,8 @@
                     // This is so that when db.open() completes, user should be safe
                     // to subscribe to these observables and get actual data.
                     yield rxjs.firstValueFrom(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)),
                     ]));
                     const yHandler = createYHandler(db);
                     DexieYProvider.on.new.subscribe(yHandler);
@@ -19456,7 +17979,7 @@
                         // If this is a service worker DB, we can't do authentication here,
                         // we just wait until the application has done it.
                         console.debug('Dexie Cloud Service worker. Waiting for application to authenticate.');
-                        yield rxjs.firstValueFrom(currentUserEmitter.pipe(filter((user) => !!user.isLoggedIn), take(1)));
+                        yield rxjs.firstValueFrom(currentUserEmitter.pipe(operators.filter((user) => !!user.isLoggedIn), operators.take(1)));
                         console.debug('Dexie Cloud Service worker. Application has authenticated.');
                     }
                     else {
@@ -19538,7 +18061,7 @@
         }
     }
     // @ts-ignore
-    dexieCloud.version = "4.2.0-alpha.1";
+    dexieCloud.version = "4.2.0-alpha.4";
     Dexie.Cloud = dexieCloud;
 
     exports.default = dexieCloud;