dexie-cloud-addon 4.1.0-beta.49 → 4.2.0-alpha.3

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

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.1.0-beta.49, Wed Jun 11 2025
+ * Version 4.2.0-alpha.3, Fri Aug 01 2025
  *
  * https://dexie.org
  *
@@ -16,8 +16,13 @@
  * 
  */
 
-import Dexie, { PropModification, cmp, DexieYProvider, RangeSet, liveQuery } from 'dexie';
-import { firstValueFrom, from as from$1, filter as filter$1, Observable as Observable$1, BehaviorSubject, Subject, fromEvent, of, merge, switchMap as switchMap$1, tap as tap$1, mergeMap as mergeMap$1, Subscription as Subscription$1, throwError, combineLatest, map as map$1, share, timer as timer$1, startWith as startWith$1 } from 'rxjs';
+import Dexie, { PropModification, cmp, RangeSet, liveQuery } from 'dexie';
+import { Encoder, writeVarString, writeAny, writeVarUint8Array, writeBigUint64, toUint8Array } from 'lib0/encoding';
+import { Decoder, readVarString, readAny, readVarUint8Array, readBigUint64, hasContent, readUint8 } from 'lib0/decoding';
+import { firstValueFrom, from, filter, Observable, BehaviorSubject, Subject, of, fromEvent, merge, switchMap as switchMap$1, tap as tap$1, mergeMap, Subscription, throwError, combineLatest, map as map$1, share, timer, startWith as startWith$1 } from 'rxjs';
+import { filter as filter$1, switchMap, delay, distinctUntilChanged, map, tap, take, catchError, debounceTime, startWith, skip } from 'rxjs/operators';
+import * as Y from 'yjs';
+import { DexieYProvider } from 'y-dexie';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -35,20 +40,6 @@ PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
 /* global Reflect, Promise */
 
-var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-    if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
 
 function __rest(s, e) {
     var t = {};
@@ -72,34 +63,6 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-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);
@@ -112,33 +75,6 @@ function __values(o) {
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 }
 
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __spreadArray(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-}
-
 function __await(v) {
     return this instanceof __await ? (this.v = v, this) : new __await(v);
 }
@@ -467,515 +403,6 @@ function getDbNameFromDbUrl(dbUrl) {
         : url.pathname.split('/')[1];
 }
 
-/**
- * Common Math expressions.
- *
- * @module math
- */
-
-const floor = Math.floor;
-const abs = Math.abs;
-
-/**
- * @function
- * @param {number} a
- * @param {number} b
- * @return {number} The smaller element of a and b
- */
-const min = (a, b) => a < b ? a : b;
-
-/**
- * @function
- * @param {number} a
- * @param {number} b
- * @return {number} The bigger element of a and b
- */
-const max = (a, b) => a > b ? a : b;
-
-/**
- * @param {number} n
- * @return {boolean} Wether n is negative. This function also differentiates between -0 and +0
- */
-const isNegativeZero = n => n !== 0 ? n < 0 : 1 / n < 0;
-
-/* eslint-env browser */
-
-const BIT7 = 64;
-const BIT8 = 128;
-const BITS6 = 63;
-const BITS7 = 127;
-/**
- * @type {number}
- */
-const BITS31 = 0x7FFFFFFF;
-
-/**
- * Utility helpers for working with numbers.
- *
- * @module number
- */
-
-
-const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
-
-/* c8 ignore next */
-const isInteger = Number.isInteger || (num => typeof num === 'number' && isFinite(num) && floor(num) === num);
-
-/**
- * Utility module to work with Arrays.
- *
- * @module array
- */
-
-
-const isArray = Array.isArray;
-
-/**
- * @param {string} str
- * @return {Uint8Array}
- */
-const _encodeUtf8Polyfill = str => {
-  const encodedString = unescape(encodeURIComponent(str));
-  const len = encodedString.length;
-  const buf = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    buf[i] = /** @type {number} */ (encodedString.codePointAt(i));
-  }
-  return buf
-};
-
-/* c8 ignore next */
-const utf8TextEncoder = /** @type {TextEncoder} */ (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null);
-
-/**
- * @param {string} str
- * @return {Uint8Array}
- */
-const _encodeUtf8Native = str => utf8TextEncoder.encode(str);
-
-/**
- * @param {string} str
- * @return {Uint8Array}
- */
-/* c8 ignore next */
-const encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
-
-/* c8 ignore next */
-let utf8TextDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
-
-/* c8 ignore start */
-if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
-  // Safari doesn't handle BOM correctly.
-  // This fixes a bug in Safari 13.0.5 where it produces a BOM the first time it is called.
-  // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the first call and
-  // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the second call
-  // Another issue is that from then on no BOM chars are recognized anymore
-  /* c8 ignore next */
-  utf8TextDecoder = null;
-}
-
-/**
- * Efficient schema-less binary encoding with support for variable length encoding.
- *
- * Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.
- *
- * Encodes numbers in little-endian order (least to most significant byte order)
- * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
- * which is also used in Protocol Buffers.
- *
- * ```js
- * // encoding step
- * const encoder = encoding.createEncoder()
- * encoding.writeVarUint(encoder, 256)
- * encoding.writeVarString(encoder, 'Hello world!')
- * const buf = encoding.toUint8Array(encoder)
- * ```
- *
- * ```js
- * // decoding step
- * const decoder = decoding.createDecoder(buf)
- * decoding.readVarUint(decoder) // => 256
- * decoding.readVarString(decoder) // => 'Hello world!'
- * decoding.hasContent(decoder) // => false - all data is read
- * ```
- *
- * @module encoding
- */
-
-
-/**
- * A BinaryEncoder handles the encoding to an Uint8Array.
- */
-class Encoder {
-  constructor () {
-    this.cpos = 0;
-    this.cbuf = new Uint8Array(100);
-    /**
-     * @type {Array<Uint8Array>}
-     */
-    this.bufs = [];
-  }
-}
-
-/**
- * The current length of the encoded data.
- *
- * @function
- * @param {Encoder} encoder
- * @return {number}
- */
-const length = encoder => {
-  let len = encoder.cpos;
-  for (let i = 0; i < encoder.bufs.length; i++) {
-    len += encoder.bufs[i].length;
-  }
-  return len
-};
-
-/**
- * Transform to Uint8Array.
- *
- * @function
- * @param {Encoder} encoder
- * @return {Uint8Array} The created ArrayBuffer.
- */
-const toUint8Array = encoder => {
-  const uint8arr = new Uint8Array(length(encoder));
-  let curPos = 0;
-  for (let i = 0; i < encoder.bufs.length; i++) {
-    const d = encoder.bufs[i];
-    uint8arr.set(d, curPos);
-    curPos += d.length;
-  }
-  uint8arr.set(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos), curPos);
-  return uint8arr
-};
-
-/**
- * Verify that it is possible to write `len` bytes wtihout checking. If
- * necessary, a new Buffer with the required length is attached.
- *
- * @param {Encoder} encoder
- * @param {number} len
- */
-const verifyLen = (encoder, len) => {
-  const bufferLen = encoder.cbuf.length;
-  if (bufferLen - encoder.cpos < len) {
-    encoder.bufs.push(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos));
-    encoder.cbuf = new Uint8Array(max(bufferLen, len) * 2);
-    encoder.cpos = 0;
-  }
-};
-
-/**
- * Write one byte to the encoder.
- *
- * @function
- * @param {Encoder} encoder
- * @param {number} num The byte that is to be encoded.
- */
-const write = (encoder, num) => {
-  const bufferLen = encoder.cbuf.length;
-  if (encoder.cpos === bufferLen) {
-    encoder.bufs.push(encoder.cbuf);
-    encoder.cbuf = new Uint8Array(bufferLen * 2);
-    encoder.cpos = 0;
-  }
-  encoder.cbuf[encoder.cpos++] = num;
-};
-
-/**
- * Write a variable length unsigned integer. Max encodable integer is 2^53.
- *
- * @function
- * @param {Encoder} encoder
- * @param {number} num The number that is to be encoded.
- */
-const writeVarUint = (encoder, num) => {
-  while (num > BITS7) {
-    write(encoder, BIT8 | (BITS7 & num));
-    num = floor(num / 128); // shift >>> 7
-  }
-  write(encoder, BITS7 & num);
-};
-
-/**
- * Write a variable length integer.
- *
- * We use the 7th bit instead for signaling that this is a negative number.
- *
- * @function
- * @param {Encoder} encoder
- * @param {number} num The number that is to be encoded.
- */
-const writeVarInt = (encoder, num) => {
-  const isNegative = isNegativeZero(num);
-  if (isNegative) {
-    num = -num;
-  }
-  //             |- whether to continue reading         |- whether is negative     |- number
-  write(encoder, (num > BITS6 ? BIT8 : 0) | (isNegative ? BIT7 : 0) | (BITS6 & num));
-  num = floor(num / 64); // shift >>> 6
-  // We don't need to consider the case of num === 0 so we can use a different
-  // pattern here than above.
-  while (num > 0) {
-    write(encoder, (num > BITS7 ? BIT8 : 0) | (BITS7 & num));
-    num = floor(num / 128); // shift >>> 7
-  }
-};
-
-/**
- * A cache to store strings temporarily
- */
-const _strBuffer = new Uint8Array(30000);
-const _maxStrBSize = _strBuffer.length / 3;
-
-/**
- * Write a variable length string.
- *
- * @function
- * @param {Encoder} encoder
- * @param {String} str The string that is to be encoded.
- */
-const _writeVarStringNative = (encoder, str) => {
-  if (str.length < _maxStrBSize) {
-    // We can encode the string into the existing buffer
-    /* c8 ignore next */
-    const written = utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
-    writeVarUint(encoder, written);
-    for (let i = 0; i < written; i++) {
-      write(encoder, _strBuffer[i]);
-    }
-  } else {
-    writeVarUint8Array(encoder, encodeUtf8(str));
-  }
-};
-
-/**
- * Write a variable length string.
- *
- * @function
- * @param {Encoder} encoder
- * @param {String} str The string that is to be encoded.
- */
-const _writeVarStringPolyfill = (encoder, str) => {
-  const encodedString = unescape(encodeURIComponent(str));
-  const len = encodedString.length;
-  writeVarUint(encoder, len);
-  for (let i = 0; i < len; i++) {
-    write(encoder, /** @type {number} */ (encodedString.codePointAt(i)));
-  }
-};
-
-/**
- * Write a variable length string.
- *
- * @function
- * @param {Encoder} encoder
- * @param {String} str The string that is to be encoded.
- */
-/* c8 ignore next */
-const writeVarString = (utf8TextEncoder && /** @type {any} */ (utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill;
-
-/**
- * Append fixed-length Uint8Array to the encoder.
- *
- * @function
- * @param {Encoder} encoder
- * @param {Uint8Array} uint8Array
- */
-const writeUint8Array = (encoder, uint8Array) => {
-  const bufferLen = encoder.cbuf.length;
-  const cpos = encoder.cpos;
-  const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
-  const rightCopyLen = uint8Array.length - leftCopyLen;
-  encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
-  encoder.cpos += leftCopyLen;
-  if (rightCopyLen > 0) {
-    // Still something to write, write right half..
-    // Append new buffer
-    encoder.bufs.push(encoder.cbuf);
-    // must have at least size of remaining buffer
-    encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
-    // copy array
-    encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
-    encoder.cpos = rightCopyLen;
-  }
-};
-
-/**
- * Append an Uint8Array to Encoder.
- *
- * @function
- * @param {Encoder} encoder
- * @param {Uint8Array} uint8Array
- */
-const writeVarUint8Array = (encoder, uint8Array) => {
-  writeVarUint(encoder, uint8Array.byteLength);
-  writeUint8Array(encoder, uint8Array);
-};
-
-/**
- * Create an DataView of the next `len` bytes. Use it to write data after
- * calling this function.
- *
- * ```js
- * // write float32 using DataView
- * const dv = writeOnDataView(encoder, 4)
- * dv.setFloat32(0, 1.1)
- * // read float32 using DataView
- * const dv = readFromDataView(encoder, 4)
- * dv.getFloat32(0) // => 1.100000023841858 (leaving it to the reader to find out why this is the correct result)
- * ```
- *
- * @param {Encoder} encoder
- * @param {number} len
- * @return {DataView}
- */
-const writeOnDataView = (encoder, len) => {
-  verifyLen(encoder, len);
-  const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len);
-  encoder.cpos += len;
-  return dview
-};
-
-/**
- * @param {Encoder} encoder
- * @param {number} num
- */
-const writeFloat32 = (encoder, num) => writeOnDataView(encoder, 4).setFloat32(0, num, false);
-
-/**
- * @param {Encoder} encoder
- * @param {number} num
- */
-const writeFloat64 = (encoder, num) => writeOnDataView(encoder, 8).setFloat64(0, num, false);
-
-/**
- * @param {Encoder} encoder
- * @param {bigint} num
- */
-const writeBigInt64 = (encoder, num) => /** @type {any} */ (writeOnDataView(encoder, 8)).setBigInt64(0, num, false);
-
-/**
- * @param {Encoder} encoder
- * @param {bigint} num
- */
-const writeBigUint64 = (encoder, num) => /** @type {any} */ (writeOnDataView(encoder, 8)).setBigUint64(0, num, false);
-
-const floatTestBed = new DataView(new ArrayBuffer(4));
-/**
- * Check if a number can be encoded as a 32 bit float.
- *
- * @param {number} num
- * @return {boolean}
- */
-const isFloat32 = num => {
-  floatTestBed.setFloat32(0, num);
-  return floatTestBed.getFloat32(0) === num
-};
-
-/**
- * Encode data with efficient binary format.
- *
- * Differences to JSON:
- * • Transforms data to a binary format (not to a string)
- * • Encodes undefined, NaN, and ArrayBuffer (these can't be represented in JSON)
- * • Numbers are efficiently encoded either as a variable length integer, as a
- *   32 bit float, as a 64 bit float, or as a 64 bit bigint.
- *
- * Encoding table:
- *
- * | Data Type           | Prefix   | Encoding Method    | Comment |
- * | ------------------- | -------- | ------------------ | ------- |
- * | undefined           | 127      |                    | Functions, symbol, and everything that cannot be identified is encoded as undefined |
- * | null                | 126      |                    | |
- * | integer             | 125      | writeVarInt        | Only encodes 32 bit signed integers |
- * | float32             | 124      | writeFloat32       | |
- * | float64             | 123      | writeFloat64       | |
- * | bigint              | 122      | writeBigInt64      | |
- * | boolean (false)     | 121      |                    | True and false are different data types so we save the following byte |
- * | boolean (true)      | 120      |                    | - 0b01111000 so the last bit determines whether true or false |
- * | string              | 119      | writeVarString     | |
- * | object<string,any>  | 118      | custom             | Writes {length} then {length} key-value pairs |
- * | array<any>          | 117      | custom             | Writes {length} then {length} json values |
- * | Uint8Array          | 116      | writeVarUint8Array | We use Uint8Array for any kind of binary data |
- *
- * Reasons for the decreasing prefix:
- * We need the first bit for extendability (later we may want to encode the
- * prefix with writeVarUint). The remaining 7 bits are divided as follows:
- * [0-30]   the beginning of the data range is used for custom purposes
- *          (defined by the function that uses this library)
- * [31-127] the end of the data range is used for data encoding by
- *          lib0/encoding.js
- *
- * @param {Encoder} encoder
- * @param {undefined|null|number|bigint|boolean|string|Object<string,any>|Array<any>|Uint8Array} data
- */
-const writeAny = (encoder, data) => {
-  switch (typeof data) {
-    case 'string':
-      // TYPE 119: STRING
-      write(encoder, 119);
-      writeVarString(encoder, data);
-      break
-    case 'number':
-      if (isInteger(data) && abs(data) <= BITS31) {
-        // TYPE 125: INTEGER
-        write(encoder, 125);
-        writeVarInt(encoder, data);
-      } else if (isFloat32(data)) {
-        // TYPE 124: FLOAT32
-        write(encoder, 124);
-        writeFloat32(encoder, data);
-      } else {
-        // TYPE 123: FLOAT64
-        write(encoder, 123);
-        writeFloat64(encoder, data);
-      }
-      break
-    case 'bigint':
-      // TYPE 122: BigInt
-      write(encoder, 122);
-      writeBigInt64(encoder, data);
-      break
-    case 'object':
-      if (data === null) {
-        // TYPE 126: null
-        write(encoder, 126);
-      } else if (isArray(data)) {
-        // TYPE 117: Array
-        write(encoder, 117);
-        writeVarUint(encoder, data.length);
-        for (let i = 0; i < data.length; i++) {
-          writeAny(encoder, data[i]);
-        }
-      } else if (data instanceof Uint8Array) {
-        // TYPE 116: ArrayBuffer
-        write(encoder, 116);
-        writeVarUint8Array(encoder, data);
-      } else {
-        // TYPE 118: Object
-        write(encoder, 118);
-        const keys = Object.keys(data);
-        writeVarUint(encoder, keys.length);
-        for (let i = 0; i < keys.length; i++) {
-          const key = keys[i];
-          writeVarString(encoder, key);
-          writeAny(encoder, data[key]);
-        }
-      }
-      break
-    case 'boolean':
-      // TYPE 120/121: boolean (true/false)
-      write(encoder, data ? 120 : 121);
-      break
-    default:
-      // TYPE 127: undefined
-      write(encoder, 127);
-  }
-};
-
 function encodeYMessage(msg) {
     const encoder = new Encoder();
     writeVarString(encoder, msg.type);
@@ -1021,319 +448,6 @@ function encodeYMessage(msg) {
     return toUint8Array(encoder);
 }
 
-/**
- * Error helpers.
- *
- * @module error
- */
-
-/**
- * @param {string} s
- * @return {Error}
- */
-/* c8 ignore next */
-const create = s => new Error(s);
-
-/**
- * Efficient schema-less binary decoding with support for variable length encoding.
- *
- * Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.
- *
- * Encodes numbers in little-endian order (least to most significant byte order)
- * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
- * which is also used in Protocol Buffers.
- *
- * ```js
- * // encoding step
- * const encoder = encoding.createEncoder()
- * encoding.writeVarUint(encoder, 256)
- * encoding.writeVarString(encoder, 'Hello world!')
- * const buf = encoding.toUint8Array(encoder)
- * ```
- *
- * ```js
- * // decoding step
- * const decoder = decoding.createDecoder(buf)
- * decoding.readVarUint(decoder) // => 256
- * decoding.readVarString(decoder) // => 'Hello world!'
- * decoding.hasContent(decoder) // => false - all data is read
- * ```
- *
- * @module decoding
- */
-
-
-const errorUnexpectedEndOfArray = create('Unexpected end of array');
-const errorIntegerOutOfRange = create('Integer out of Range');
-
-/**
- * A Decoder handles the decoding of an Uint8Array.
- */
-class Decoder {
-  /**
-   * @param {Uint8Array} uint8Array Binary data to decode
-   */
-  constructor (uint8Array) {
-    /**
-     * Decoding target.
-     *
-     * @type {Uint8Array}
-     */
-    this.arr = uint8Array;
-    /**
-     * Current decoding position.
-     *
-     * @type {number}
-     */
-    this.pos = 0;
-  }
-}
-
-/**
- * @function
- * @param {Decoder} decoder
- * @return {boolean}
- */
-const hasContent = decoder => decoder.pos !== decoder.arr.length;
-
-/**
- * Create an Uint8Array view of the next `len` bytes and advance the position by `len`.
- *
- * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
- *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
- *
- * @function
- * @param {Decoder} decoder The decoder instance
- * @param {number} len The length of bytes to read
- * @return {Uint8Array}
- */
-const readUint8Array = (decoder, len) => {
-  const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
-  decoder.pos += len;
-  return view
-};
-
-/**
- * Read variable length Uint8Array.
- *
- * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
- *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
- *
- * @function
- * @param {Decoder} decoder
- * @return {Uint8Array}
- */
-const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint(decoder));
-
-/**
- * Read one byte as unsigned integer.
- * @function
- * @param {Decoder} decoder The decoder instance
- * @return {number} Unsigned 8-bit integer
- */
-const readUint8 = decoder => decoder.arr[decoder.pos++];
-
-/**
- * Read unsigned integer (32bit) with variable length.
- * 1/8th of the storage is used as encoding overhead.
- *  * numbers < 2^7 is stored in one bytlength
- *  * numbers < 2^14 is stored in two bylength
- *
- * @function
- * @param {Decoder} decoder
- * @return {number} An unsigned integer.length
- */
-const readVarUint = decoder => {
-  let num = 0;
-  let mult = 1;
-  const len = decoder.arr.length;
-  while (decoder.pos < len) {
-    const r = decoder.arr[decoder.pos++];
-    // num = num | ((r & binary.BITS7) << len)
-    num = num + (r & BITS7) * mult; // shift $r << (7*#iterations) and add it to num
-    mult *= 128; // next iteration, shift 7 "more" to the left
-    if (r < BIT8) {
-      return num
-    }
-    /* c8 ignore start */
-    if (num > MAX_SAFE_INTEGER) {
-      throw errorIntegerOutOfRange
-    }
-    /* c8 ignore stop */
-  }
-  throw errorUnexpectedEndOfArray
-};
-
-/**
- * Read signed integer (32bit) with variable length.
- * 1/8th of the storage is used as encoding overhead.
- *  * numbers < 2^7 is stored in one bytlength
- *  * numbers < 2^14 is stored in two bylength
- * @todo This should probably create the inverse ~num if number is negative - but this would be a breaking change.
- *
- * @function
- * @param {Decoder} decoder
- * @return {number} An unsigned integer.length
- */
-const readVarInt = decoder => {
-  let r = decoder.arr[decoder.pos++];
-  let num = r & BITS6;
-  let mult = 64;
-  const sign = (r & BIT7) > 0 ? -1 : 1;
-  if ((r & BIT8) === 0) {
-    // don't continue reading
-    return sign * num
-  }
-  const len = decoder.arr.length;
-  while (decoder.pos < len) {
-    r = decoder.arr[decoder.pos++];
-    // num = num | ((r & binary.BITS7) << len)
-    num = num + (r & BITS7) * mult;
-    mult *= 128;
-    if (r < BIT8) {
-      return sign * num
-    }
-    /* c8 ignore start */
-    if (num > MAX_SAFE_INTEGER) {
-      throw errorIntegerOutOfRange
-    }
-    /* c8 ignore stop */
-  }
-  throw errorUnexpectedEndOfArray
-};
-
-/**
- * We don't test this function anymore as we use native decoding/encoding by default now.
- * Better not modify this anymore..
- *
- * Transforming utf8 to a string is pretty expensive. The code performs 10x better
- * when String.fromCodePoint is fed with all characters as arguments.
- * But most environments have a maximum number of arguments per functions.
- * For effiency reasons we apply a maximum of 10000 characters at once.
- *
- * @function
- * @param {Decoder} decoder
- * @return {String} The read String.
- */
-/* c8 ignore start */
-const _readVarStringPolyfill = decoder => {
-  let remainingLen = readVarUint(decoder);
-  if (remainingLen === 0) {
-    return ''
-  } else {
-    let encodedString = String.fromCodePoint(readUint8(decoder)); // remember to decrease remainingLen
-    if (--remainingLen < 100) { // do not create a Uint8Array for small strings
-      while (remainingLen--) {
-        encodedString += String.fromCodePoint(readUint8(decoder));
-      }
-    } else {
-      while (remainingLen > 0) {
-        const nextLen = remainingLen < 10000 ? remainingLen : 10000;
-        // this is dangerous, we create a fresh array view from the existing buffer
-        const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen);
-        decoder.pos += nextLen;
-        // Starting with ES5.1 we can supply a generic array-like object as arguments
-        encodedString += String.fromCodePoint.apply(null, /** @type {any} */ (bytes));
-        remainingLen -= nextLen;
-      }
-    }
-    return decodeURIComponent(escape(encodedString))
-  }
-};
-/* c8 ignore stop */
-
-/**
- * @function
- * @param {Decoder} decoder
- * @return {String} The read String
- */
-const _readVarStringNative = decoder =>
-  /** @type any */ (utf8TextDecoder).decode(readVarUint8Array(decoder));
-
-/**
- * Read string of variable length
- * * varUint is used to store the length of the string
- *
- * @function
- * @param {Decoder} decoder
- * @return {String} The read String
- *
- */
-/* c8 ignore next */
-const readVarString = utf8TextDecoder ? _readVarStringNative : _readVarStringPolyfill;
-
-/**
- * @param {Decoder} decoder
- * @param {number} len
- * @return {DataView}
- */
-const readFromDataView = (decoder, len) => {
-  const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len);
-  decoder.pos += len;
-  return dv
-};
-
-/**
- * @param {Decoder} decoder
- */
-const readFloat32 = decoder => readFromDataView(decoder, 4).getFloat32(0, false);
-
-/**
- * @param {Decoder} decoder
- */
-const readFloat64 = decoder => readFromDataView(decoder, 8).getFloat64(0, false);
-
-/**
- * @param {Decoder} decoder
- */
-const readBigInt64 = decoder => /** @type {any} */ (readFromDataView(decoder, 8)).getBigInt64(0, false);
-
-/**
- * @param {Decoder} decoder
- */
-const readBigUint64 = decoder => /** @type {any} */ (readFromDataView(decoder, 8)).getBigUint64(0, false);
-
-/**
- * @type {Array<function(Decoder):any>}
- */
-const readAnyLookupTable = [
-  decoder => undefined, // CASE 127: undefined
-  decoder => null, // CASE 126: null
-  readVarInt, // CASE 125: integer
-  readFloat32, // CASE 124: float32
-  readFloat64, // CASE 123: float64
-  readBigInt64, // CASE 122: bigint
-  decoder => false, // CASE 121: boolean (false)
-  decoder => true, // CASE 120: boolean (true)
-  readVarString, // CASE 119: string
-  decoder => { // CASE 118: object<string,any>
-    const len = readVarUint(decoder);
-    /**
-     * @type {Object<string,any>}
-     */
-    const obj = {};
-    for (let i = 0; i < len; i++) {
-      const key = readVarString(decoder);
-      obj[key] = readAny(decoder);
-    }
-    return obj
-  },
-  decoder => { // CASE 117: array<any>
-    const len = readVarUint(decoder);
-    const arr = [];
-    for (let i = 0; i < len; i++) {
-      arr.push(readAny(decoder));
-    }
-    return arr
-  },
-  readVarUint8Array // CASE 116: Uint8Array
-];
-
-/**
- * @param {Decoder} decoder
- */
-const readAny = decoder => readAnyLookupTable[127 - readUint8(decoder)](decoder);
-
 function decodeYMessage(a) {
     const decoder = new Decoder(a);
     const type = readVarString(decoder);
@@ -1401,1572 +515,154 @@ function decodeYMessage(a) {
                         table,
                         prop,
                         k,
-                        u: readVarUint8Array(decoder),
-                        r: (decoder.pos < decoder.arr.length && readVarString(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(asyncIterable, subscriber).catch(function (err) { return subscriber.error(err); });
-    });
-}
-function fromReadableStreamLike(readableStream) {
-    return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
-}
-function process(asyncIterable, subscriber) {
-    var asyncIterable_1, asyncIterable_1_1;
-    var e_2, _a;
-    return __awaiter(this, void 0, void 0, function () {
-        var value, e_2_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 5, 6, 11]);
-                    asyncIterable_1 = __asyncValues(asyncIterable);
-                    _b.label = 1;
-                case 1: return [4, asyncIterable_1.next()];
-                case 2:
-                    if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4];
-                    value = asyncIterable_1_1.value;
-                    subscriber.next(value);
-                    if (subscriber.closed) {
-                        return [2];
-                    }
-                    _b.label = 3;
-                case 3: return [3, 1];
-                case 4: return [3, 11];
-                case 5:
-                    e_2_1 = _b.sent();
-                    e_2 = { error: e_2_1 };
-                    return [3, 11];
-                case 6:
-                    _b.trys.push([6, , 9, 10]);
-                    if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))) return [3, 8];
-                    return [4, _a.call(asyncIterable_1)];
-                case 7:
-                    _b.sent();
-                    _b.label = 8;
-                case 8: return [3, 10];
-                case 9:
-                    if (e_2) throw e_2.error;
-                    return [7];
-                case 10: return [7];
-                case 11:
-                    subscriber.complete();
-                    return [2];
-            }
-        });
-    });
-}
-
-function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
-    return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
-}
-var OperatorSubscriber = (function (_super) {
-    __extends(OperatorSubscriber, _super);
-    function OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
-        var _this = _super.call(this, destination) || this;
-        _this.onFinalize = onFinalize;
-        _this.shouldUnsubscribe = shouldUnsubscribe;
-        _this._next = onNext
-            ? function (value) {
-                try {
-                    onNext(value);
-                }
-                catch (err) {
-                    destination.error(err);
-                }
-            }
-            : _super.prototype._next;
-        _this._error = onError
-            ? function (err) {
-                try {
-                    onError(err);
-                }
-                catch (err) {
-                    destination.error(err);
-                }
-                finally {
-                    this.unsubscribe();
-                }
-            }
-            : _super.prototype._error;
-        _this._complete = onComplete
-            ? function () {
-                try {
-                    onComplete();
-                }
-                catch (err) {
-                    destination.error(err);
-                }
-                finally {
-                    this.unsubscribe();
-                }
-            }
-            : _super.prototype._complete;
-        return _this;
-    }
-    OperatorSubscriber.prototype.unsubscribe = function () {
-        var _a;
-        if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
-            var closed_1 = this.closed;
-            _super.prototype.unsubscribe.call(this);
-            !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
-        }
-    };
-    return OperatorSubscriber;
-}(Subscriber));
-
-var Action = (function (_super) {
-    __extends(Action, _super);
-    function Action(scheduler, work) {
-        return _super.call(this) || this;
-    }
-    Action.prototype.schedule = function (state, delay) {
-        return this;
-    };
-    return Action;
-}(Subscription));
-
-var intervalProvider = {
-    setInterval: function (handler, timeout) {
-        var args = [];
-        for (var _i = 2; _i < arguments.length; _i++) {
-            args[_i - 2] = arguments[_i];
-        }
-        var delegate = intervalProvider.delegate;
-        if (delegate === null || delegate === void 0 ? void 0 : delegate.setInterval) {
-            return delegate.setInterval.apply(delegate, __spreadArray([handler, timeout], __read(args)));
-        }
-        return setInterval.apply(void 0, __spreadArray([handler, timeout], __read(args)));
-    },
-    clearInterval: function (handle) {
-        var delegate = intervalProvider.delegate;
-        return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearInterval) || clearInterval)(handle);
-    },
-    delegate: undefined,
-};
-
-var AsyncAction = (function (_super) {
-    __extends(AsyncAction, _super);
-    function AsyncAction(scheduler, work) {
-        var _this = _super.call(this, scheduler, work) || this;
-        _this.scheduler = scheduler;
-        _this.work = work;
-        _this.pending = false;
-        return _this;
-    }
-    AsyncAction.prototype.schedule = function (state, delay) {
-        if (delay === void 0) { delay = 0; }
-        if (this.closed) {
-            return this;
-        }
-        this.state = state;
-        var id = this.id;
-        var scheduler = this.scheduler;
-        if (id != null) {
-            this.id = this.recycleAsyncId(scheduler, id, delay);
-        }
-        this.pending = true;
-        this.delay = delay;
-        this.id = this.id || this.requestAsyncId(scheduler, this.id, delay);
-        return this;
-    };
-    AsyncAction.prototype.requestAsyncId = function (scheduler, _id, delay) {
-        if (delay === void 0) { delay = 0; }
-        return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
-    };
-    AsyncAction.prototype.recycleAsyncId = function (_scheduler, id, delay) {
-        if (delay === void 0) { delay = 0; }
-        if (delay != null && this.delay === delay && this.pending === false) {
-            return id;
-        }
-        intervalProvider.clearInterval(id);
-        return undefined;
-    };
-    AsyncAction.prototype.execute = function (state, delay) {
-        if (this.closed) {
-            return new Error('executing a cancelled action');
-        }
-        this.pending = false;
-        var error = this._execute(state, delay);
-        if (error) {
-            return error;
-        }
-        else if (this.pending === false && this.id != null) {
-            this.id = this.recycleAsyncId(this.scheduler, this.id, null);
-        }
-    };
-    AsyncAction.prototype._execute = function (state, _delay) {
-        var errored = false;
-        var errorValue;
-        try {
-            this.work(state);
-        }
-        catch (e) {
-            errored = true;
-            errorValue = e ? e : new Error('Scheduled action threw falsy error');
-        }
-        if (errored) {
-            this.unsubscribe();
-            return errorValue;
-        }
-    };
-    AsyncAction.prototype.unsubscribe = function () {
-        if (!this.closed) {
-            var _a = this, id = _a.id, scheduler = _a.scheduler;
-            var actions = scheduler.actions;
-            this.work = this.state = this.scheduler = null;
-            this.pending = false;
-            arrRemove(actions, this);
-            if (id != null) {
-                this.id = this.recycleAsyncId(scheduler, id, null);
-            }
-            this.delay = null;
-            _super.prototype.unsubscribe.call(this);
-        }
-    };
-    return AsyncAction;
-}(Action));
-
-var dateTimestampProvider = {
-    now: function () {
-        return (dateTimestampProvider.delegate || Date).now();
-    },
-    delegate: undefined,
-};
-
-var Scheduler = (function () {
-    function Scheduler(schedulerActionCtor, now) {
-        if (now === void 0) { now = Scheduler.now; }
-        this.schedulerActionCtor = schedulerActionCtor;
-        this.now = now;
-    }
-    Scheduler.prototype.schedule = function (work, delay, state) {
-        if (delay === void 0) { delay = 0; }
-        return new this.schedulerActionCtor(this, work).schedule(state, delay);
-    };
-    Scheduler.now = dateTimestampProvider.now;
-    return Scheduler;
-}());
-
-var AsyncScheduler = (function (_super) {
-    __extends(AsyncScheduler, _super);
-    function AsyncScheduler(SchedulerAction, now) {
-        if (now === void 0) { now = Scheduler.now; }
-        var _this = _super.call(this, SchedulerAction, now) || this;
-        _this.actions = [];
-        _this._active = false;
-        _this._scheduled = undefined;
-        return _this;
-    }
-    AsyncScheduler.prototype.flush = function (action) {
-        var actions = this.actions;
-        if (this._active) {
-            actions.push(action);
-            return;
-        }
-        var error;
-        this._active = true;
-        do {
-            if ((error = action.execute(action.state, action.delay))) {
-                break;
-            }
-        } while ((action = actions.shift()));
-        this._active = false;
-        if (error) {
-            while ((action = actions.shift())) {
-                action.unsubscribe();
-            }
-            throw error;
-        }
-    };
-    return AsyncScheduler;
-}(Scheduler));
-
-var asyncScheduler = new AsyncScheduler(AsyncAction);
-var async = asyncScheduler;
-
-function isScheduler(value) {
-    return value && isFunction(value.schedule);
-}
-
-function isValidDate(value) {
-    return value instanceof Date && !isNaN(value);
-}
-
-function timer(dueTime, intervalOrScheduler, scheduler) {
-    if (dueTime === void 0) { dueTime = 0; }
-    if (scheduler === void 0) { scheduler = async; }
-    var intervalDuration = -1;
-    if (intervalOrScheduler != null) {
-        if (isScheduler(intervalOrScheduler)) {
-            scheduler = intervalOrScheduler;
-        }
-        else {
-            intervalDuration = intervalOrScheduler;
-        }
-    }
-    return new Observable(function (subscriber) {
-        var due = isValidDate(dueTime) ? +dueTime - scheduler.now() : dueTime;
-        if (due < 0) {
-            due = 0;
-        }
-        var n = 0;
-        return scheduler.schedule(function () {
-            if (!subscriber.closed) {
-                subscriber.next(n++);
-                if (0 <= intervalDuration) {
-                    this.schedule(undefined, intervalDuration);
-                }
-                else {
-                    subscriber.complete();
-                }
-            }
-        }, due);
-    });
-}
-
-function last(arr) {
-    return arr[arr.length - 1];
-}
-function popScheduler(args) {
-    return isScheduler(last(args)) ? args.pop() : undefined;
-}
-
-function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
-    if (delay === void 0) { delay = 0; }
-    if (repeat === void 0) { repeat = false; }
-    var scheduleSubscription = scheduler.schedule(function () {
-        work();
-        if (repeat) {
-            parentSubscription.add(this.schedule(null, delay));
-        }
-        else {
-            this.unsubscribe();
-        }
-    }, delay);
-    parentSubscription.add(scheduleSubscription);
-    if (!repeat) {
-        return scheduleSubscription;
-    }
-}
-
-function catchError(selector) {
-    return operate(function (source, subscriber) {
-        var innerSub = null;
-        var syncUnsub = false;
-        var handledResult;
-        innerSub = source.subscribe(createOperatorSubscriber(subscriber, undefined, undefined, function (err) {
-            handledResult = innerFrom(selector(err, catchError(selector)(source)));
-            if (innerSub) {
-                innerSub.unsubscribe();
-                innerSub = null;
-                handledResult.subscribe(subscriber);
-            }
-            else {
-                syncUnsub = true;
+                        u: readVarUint8Array(decoder),
+                        r: (decoder.pos < decoder.arr.length && readVarString(decoder)) || undefined,
+                    };
+                default:
+                    throw new TypeError(`Unknown message type: ${type}`);
             }
-        }));
-        if (syncUnsub) {
-            innerSub.unsubscribe();
-            innerSub = null;
-            handledResult.subscribe(subscriber);
         }
-    });
-}
-
-function observeOn(scheduler, delay) {
-    if (delay === void 0) { delay = 0; }
-    return operate(function (source, subscriber) {
-        source.subscribe(createOperatorSubscriber(subscriber, function (value) { return executeSchedule(subscriber, scheduler, function () { return subscriber.next(value); }, delay); }, function () { return executeSchedule(subscriber, scheduler, function () { return subscriber.complete(); }, delay); }, function (err) { return executeSchedule(subscriber, scheduler, function () { return subscriber.error(err); }, delay); }));
-    });
-}
-
-function subscribeOn(scheduler, delay) {
-    if (delay === void 0) { delay = 0; }
-    return operate(function (source, subscriber) {
-        subscriber.add(scheduler.schedule(function () { return source.subscribe(subscriber); }, delay));
-    });
-}
-
-function scheduleObservable(input, scheduler) {
-    return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
-}
-
-function schedulePromise(input, scheduler) {
-    return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
-}
-
-function scheduleArray(input, scheduler) {
-    return new Observable(function (subscriber) {
-        var i = 0;
-        return scheduler.schedule(function () {
-            if (i === input.length) {
-                subscriber.complete();
-            }
-            else {
-                subscriber.next(input[i++]);
-                if (!subscriber.closed) {
-                    this.schedule();
-                }
-            }
-        });
-    });
-}
-
-function scheduleIterable(input, scheduler) {
-    return new Observable(function (subscriber) {
-        var iterator$1;
-        executeSchedule(subscriber, scheduler, function () {
-            iterator$1 = input[iterator]();
-            executeSchedule(subscriber, scheduler, function () {
-                var _a;
-                var value;
-                var done;
-                try {
-                    (_a = iterator$1.next(), value = _a.value, done = _a.done);
-                }
-                catch (err) {
-                    subscriber.error(err);
-                    return;
-                }
-                if (done) {
-                    subscriber.complete();
-                }
-                else {
-                    subscriber.next(value);
-                }
-            }, 0, true);
-        });
-        return function () { return isFunction(iterator$1 === null || iterator$1 === void 0 ? void 0 : iterator$1.return) && iterator$1.return(); };
-    });
-}
-
-function scheduleAsyncIterable(input, scheduler) {
-    if (!input) {
-        throw new Error('Iterable cannot be null');
     }
-    return new Observable(function (subscriber) {
-        executeSchedule(subscriber, scheduler, function () {
-            var iterator = input[Symbol.asyncIterator]();
-            executeSchedule(subscriber, scheduler, function () {
-                iterator.next().then(function (result) {
-                    if (result.done) {
-                        subscriber.complete();
-                    }
-                    else {
-                        subscriber.next(result.value);
-                    }
-                });
-            }, 0, true);
-        });
-    });
-}
-
-function scheduleReadableStreamLike(input, scheduler) {
-    return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
 }
 
-function scheduled(input, scheduler) {
-    if (input != null) {
-        if (isInteropObservable(input)) {
-            return scheduleObservable(input, scheduler);
-        }
-        if (isArrayLike(input)) {
-            return scheduleArray(input, scheduler);
-        }
-        if (isPromise(input)) {
-            return schedulePromise(input, scheduler);
-        }
-        if (isAsyncIterable(input)) {
-            return scheduleAsyncIterable(input, scheduler);
-        }
-        if (isIterable(input)) {
-            return scheduleIterable(input, scheduler);
+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;
         }
-        if (isReadableStreamLike(input)) {
-            return scheduleReadableStreamLike(input, scheduler);
+    }
+    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; }
     }
-    throw createInvalidObservableTypeError(input);
-}
-
-function from(input, scheduler) {
-    return scheduler ? scheduled(input, scheduler) : innerFrom(input);
-}
-
-function map(project, thisArg) {
-    return operate(function (source, subscriber) {
-        var index = 0;
-        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
-            subscriber.next(project.call(thisArg, value, index++));
-        }));
-    });
 }
 
-function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
-    var buffer = [];
-    var active = 0;
-    var index = 0;
-    var isComplete = false;
-    var checkComplete = function () {
-        if (isComplete && !buffer.length && !active) {
-            subscriber.complete();
-        }
-    };
-    var outerNext = function (value) { return (active < concurrent ? doInnerSub(value) : buffer.push(value)); };
-    var doInnerSub = function (value) {
-        expand && subscriber.next(value);
-        active++;
-        var innerComplete = false;
-        innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, function (innerValue) {
-            onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);
-            if (expand) {
-                outerNext(innerValue);
-            }
-            else {
-                subscriber.next(innerValue);
-            }
-        }, function () {
-            innerComplete = true;
-        }, undefined, function () {
-            if (innerComplete) {
-                try {
-                    active--;
-                    var _loop_1 = function () {
-                        var bufferedValue = buffer.shift();
-                        if (innerSubScheduler) {
-                            executeSchedule(subscriber, innerSubScheduler, function () { return doInnerSub(bufferedValue); });
-                        }
-                        else {
-                            doInnerSub(bufferedValue);
-                        }
-                    };
-                    while (buffer.length && active < concurrent) {
-                        _loop_1();
+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;
                     }
-                    checkComplete();
-                }
-                catch (err) {
-                    subscriber.error(err);
                 }
             }
-        }));
-    };
-    source.subscribe(createOperatorSubscriber(subscriber, outerNext, function () {
-        isComplete = true;
-        checkComplete();
-    }));
-    return function () {
-        additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer();
-    };
-}
-
-function mergeMap(project, resultSelector, concurrent) {
-    if (concurrent === void 0) { concurrent = Infinity; }
-    if (isFunction(resultSelector)) {
-        return mergeMap(function (a, i) { return map(function (b, ii) { return resultSelector(a, b, i, ii); })(innerFrom(project(a, i))); }, concurrent);
-    }
-    else if (typeof resultSelector === 'number') {
-        concurrent = resultSelector;
-    }
-    return operate(function (source, subscriber) { return mergeInternals(source, subscriber, project, concurrent); });
-}
-
-function mergeAll(concurrent) {
-    if (concurrent === void 0) { concurrent = Infinity; }
-    return mergeMap(identity, concurrent);
-}
-
-function concatAll() {
-    return mergeAll(1);
-}
-
-function debounceTime(dueTime, scheduler) {
-    if (scheduler === void 0) { scheduler = asyncScheduler; }
-    return operate(function (source, subscriber) {
-        var activeTask = null;
-        var lastValue = null;
-        var lastTime = null;
-        var emit = function () {
-            if (activeTask) {
-                activeTask.unsubscribe();
-                activeTask = null;
-                var value = lastValue;
-                lastValue = null;
-                subscriber.next(value);
-            }
-        };
-        function emitWhenIdle() {
-            var targetTime = lastTime + dueTime;
-            var now = scheduler.now();
-            if (now < targetTime) {
-                activeTask = this.schedule(undefined, targetTime - now);
-                subscriber.add(activeTask);
-                return;
+        }
+        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));
             }
-            emit();
+            finally { if (e_1) throw e_1.error; }
         }
-        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
-            lastValue = value;
-            lastTime = scheduler.now();
-            if (!activeTask) {
-                activeTask = scheduler.schedule(emitWhenIdle, dueTime);
-                subscriber.add(activeTask);
-            }
-        }, function () {
-            emit();
-            subscriber.complete();
-        }, undefined, function () {
-            lastValue = activeTask = null;
-        }));
     });
 }
 
-function concat$1() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    return concatAll()(from(args, popScheduler(args)));
-}
-
-var EMPTY = new Observable(function (subscriber) { return subscriber.complete(); });
-
-function take(count) {
-    return count <= 0
-        ?
-            function () { return EMPTY; }
-        : operate(function (source, subscriber) {
-            var seen = 0;
-            source.subscribe(createOperatorSubscriber(subscriber, function (value) {
-                if (++seen <= count) {
-                    subscriber.next(value);
-                    if (count <= seen) {
-                        subscriber.complete();
-                    }
+function 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);
                 }
-            }));
-        });
-}
-
-function ignoreElements() {
-    return operate(function (source, subscriber) {
-        source.subscribe(createOperatorSubscriber(subscriber, noop));
-    });
-}
-
-function mapTo(value) {
-    return map(function () { return value; });
-}
-
-function delayWhen(delayDurationSelector, subscriptionDelay) {
-    if (subscriptionDelay) {
-        return function (source) {
-            return concat$1(subscriptionDelay.pipe(take(1), ignoreElements()), source.pipe(delayWhen(delayDurationSelector)));
-        };
-    }
-    return mergeMap(function (value, index) { return delayDurationSelector(value, index).pipe(take(1), mapTo(value)); });
-}
-
-function delay(due, scheduler) {
-    if (scheduler === void 0) { scheduler = asyncScheduler; }
-    var duration = timer(due, scheduler);
-    return delayWhen(function () { return duration; });
-}
-
-function distinctUntilChanged(comparator, keySelector) {
-    if (keySelector === void 0) { keySelector = identity; }
-    comparator = comparator !== null && comparator !== void 0 ? comparator : defaultCompare;
-    return operate(function (source, subscriber) {
-        var previousKey;
-        var first = true;
-        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
-            var currentKey = keySelector(value);
-            if (first || !comparator(previousKey, currentKey)) {
-                first = false;
-                previousKey = currentKey;
-                subscriber.next(value);
             }
-        }));
-    });
-}
-function defaultCompare(a, b) {
-    return a === b;
-}
-
-function filter(predicate, thisArg) {
-    return operate(function (source, subscriber) {
-        var index = 0;
-        source.subscribe(createOperatorSubscriber(subscriber, function (value) { return predicate.call(thisArg, value, index++) && subscriber.next(value); }));
-    });
-}
-
-function skip(count) {
-    return filter(function (_, index) { return count <= index; });
-}
-
-function startWith() {
-    var values = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        values[_i] = arguments[_i];
-    }
-    var scheduler = popScheduler(values);
-    return operate(function (source, subscriber) {
-        (scheduler ? concat$1(values, source, scheduler) : concat$1(values, source)).subscribe(subscriber);
-    });
-}
-
-function switchMap(project, resultSelector) {
-    return operate(function (source, subscriber) {
-        var innerSubscriber = null;
-        var index = 0;
-        var isComplete = false;
-        var checkComplete = function () { return isComplete && !innerSubscriber && subscriber.complete(); };
-        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
-            innerSubscriber === null || innerSubscriber === void 0 ? void 0 : innerSubscriber.unsubscribe();
-            var innerIndex = 0;
-            var outerIndex = index++;
-            innerFrom(project(value, outerIndex)).subscribe((innerSubscriber = createOperatorSubscriber(subscriber, function (innerValue) { return subscriber.next(resultSelector ? resultSelector(value, innerValue, outerIndex, innerIndex++) : innerValue); }, function () {
-                innerSubscriber = null;
-                checkComplete();
-            })));
-        }, function () {
-            isComplete = true;
-            checkComplete();
-        }));
-    });
-}
-
-function tap(observerOrNext, error, complete) {
-    var tapObserver = isFunction(observerOrNext) || error || complete
-        ?
-            { next: observerOrNext, error: error, complete: complete }
-        : observerOrNext;
-    return tapObserver
-        ? operate(function (source, subscriber) {
-            var _a;
-            (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
-            var isUnsub = true;
-            source.subscribe(createOperatorSubscriber(subscriber, function (value) {
-                var _a;
-                (_a = tapObserver.next) === null || _a === void 0 ? void 0 : _a.call(tapObserver, value);
-                subscriber.next(value);
-            }, function () {
-                var _a;
-                isUnsub = false;
-                (_a = tapObserver.complete) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
-                subscriber.complete();
-            }, function (err) {
-                var _a;
-                isUnsub = false;
-                (_a = tapObserver.error) === null || _a === void 0 ? void 0 : _a.call(tapObserver, err);
-                subscriber.error(err);
-            }, function () {
-                var _a, _b;
-                if (isUnsub) {
-                    (_a = tapObserver.unsubscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
-                }
-                (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
-            }));
-        })
-        :
-            identity;
+            finally {
+                reader.releaseLock();
+            }
+        });
+    };
 }
 
 //const hasSW = 'serviceWorker' in navigator;
@@ -3487,7 +1183,7 @@ catch (_a) { }
 
 function waitUntil(o, // Works with Dexie's liveQuery observables if we'd need that
 predicate) {
-    return firstValueFrom(from$1(o).pipe(filter$1(predicate)));
+    return firstValueFrom(from(o).pipe(filter(predicate)));
 }
 
 function logout(db) {
@@ -3858,7 +1554,7 @@ function dispatch(ev) {
         });
     }
 }
-class BroadcastedAndLocalEvent extends Observable$1 {
+class BroadcastedAndLocalEvent extends Observable {
     constructor(name) {
         const bc = typeof BroadcastChannel === "undefined"
             ? new SWBroadcastChannel(name) : new BroadcastChannel(name);
@@ -5003,13 +2699,6 @@ function listUpdatesSince(yTable, sinceIncluding) {
         .toArray();
 }
 
-function $Y(db) {
-    const $Y = db.dx._options.Y;
-    if (!$Y)
-        throw new Error('Y library not supplied to Dexie constructor');
-    return $Y;
-}
-
 /** Queries the local database for YMessages to send to server.
  *
  * There are 2 messages that this function can provide:
@@ -5033,7 +2722,6 @@ function listYClientMessagesAndStateVector(db, tablesToSync) {
         for (const table of tablesToSync) {
             if (table.schema.yProps) {
                 for (const yProp of table.schema.yProps) {
-                    const Y = $Y(db); // This is how we retrieve the user-provided Y library
                     const yTable = db.table(yProp.updatesTable); // the updates-table for this combo of table+propName
                     const syncState = (yield yTable.get(DEXIE_CLOUD_SYNCER_ID));
                     // unsentFrom = the `i` value of updates that aren't yet sent to server (or at least not acked by the server yet)
@@ -5193,7 +2881,7 @@ function applyYServerMessages(yMessages, db) {
                     case 'in-sync': {
                         const doc = DexieYProvider.getDocCache(db.dx).find(m.table, m.k, m.prop);
                         if (doc && !doc.isSynced) {
-                            doc.emit('sync', [true]);
+                            doc.emit('sync', [true, doc]);
                         }
                         break;
                     }
@@ -5773,7 +3461,7 @@ function MessagesFromServerConsumer(db) {
                     // 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 firstValueFrom(db.cloud.syncState.pipe(filter(({ phase }) => phase === 'in-sync' || phase === 'error')));
+                    yield firstValueFrom(db.cloud.syncState.pipe(filter$1(({ phase }) => phase === 'in-sync' || phase === 'error')));
                     console.debug('processing msg', msg);
                     const persistedSyncState = db.cloud.persistedSyncState.value;
                     //syncState.
@@ -6812,9 +4500,9 @@ const visibilityStateIsChanged = typeof document !== 'undefined'
     ? fromEvent(document, 'visibilitychange')
     : of({});
 // document.onvisibilitychange makes document hidden:
-const documentBecomesHidden = visibilityStateIsChanged.pipe(filter(() => document.visibilityState === 'hidden'));
+const documentBecomesHidden = visibilityStateIsChanged.pipe(filter$1(() => document.visibilityState === 'hidden'));
 // document.onvisibilitychange makes document visible
-const documentBecomesVisible = visibilityStateIsChanged.pipe(filter(() => document.visibilityState === 'visible'));
+const documentBecomesVisible = visibilityStateIsChanged.pipe(filter$1(() => document.visibilityState === 'visible'));
 // Any of various user-activity-related events happen:
 const userDoesSomething = typeof window !== 'undefined'
     ? merge(documentBecomesVisible, fromEvent(window, 'mousedown'), fromEvent(window, 'mousemove'), fromEvent(window, 'keydown'), fromEvent(window, 'wheel'), fromEvent(window, 'touchmove'))
@@ -6867,9 +4555,9 @@ function createYClientUpdateObservable(db) {
         // Per updates table (table+prop combo), we first read syncer.unsentFrom,
         // and then start listening for updates since that number.
         const yTbl = db.table(updatesTable);
-        return from$1(yTbl.get(DEXIE_CLOUD_SYNCER_ID)).pipe(switchMap$1((syncer) => {
+        return from(yTbl.get(DEXIE_CLOUD_SYNCER_ID)).pipe(switchMap$1((syncer) => {
             let currentUnsentFrom = (syncer === null || syncer === void 0 ? void 0 : syncer.unsentFrom) || 1;
-            return from$1(liveQuery(() => __awaiter(this, void 0, void 0, function* () {
+            return from(liveQuery(() => __awaiter(this, void 0, void 0, function* () {
                 const addedUpdates = yield listUpdatesSince(yTbl, currentUnsentFrom);
                 return addedUpdates
                     .filter((update) => update.f && update.f & 1) // Only include local updates
@@ -6899,7 +4587,7 @@ function createYClientUpdateObservable(db) {
     // If messageProducer emits empty array, nothing is emitted
     // but if messageProducer emits array of messages, they are
     // emitted one by one.
-    mergeMap$1((messages) => messages));
+    mergeMap((messages) => messages));
 }
 
 function getAwarenessLibrary(db) {
@@ -6932,13 +4620,13 @@ function getOpenDocSignal(doc) {
 const SERVER_PING_TIMEOUT = 20000;
 const CLIENT_PING_INTERVAL = 30000;
 const FAIL_RETRY_WAIT_TIME = 60000;
-class WSObservable extends Observable$1 {
+class WSObservable extends Observable {
     constructor(db, rev, yrev, realmSetHash, clientIdentity, messageProducer, webSocketStatus, user) {
         super((subscriber) => new WSConnection(db, rev, yrev, realmSetHash, clientIdentity, user, subscriber, messageProducer, webSocketStatus));
     }
 }
 let counter = 0;
-class WSConnection extends Subscription$1 {
+class WSConnection extends Subscription {
     constructor(db, rev, yrev, realmSetHash, clientIdentity, user, subscriber, messageProducer, webSocketStatus) {
         super(() => this.teardown());
         this.id = ++counter;
@@ -7236,9 +4924,9 @@ function connectWebSocket(db) {
     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
+    const readyForChangesMessage = db.messageConsumer.readyToServe.pipe(filter$1((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
+    filter$1((syncState) => syncState && syncState.serverRevision), // We wont send anything to server before inital sync has taken place
     switchMap((syncState) => __awaiter(this, void 0, void 0, function* () {
         return ({
             // Produce the message to trigger server to send us new messages to consume:
@@ -7249,7 +4937,7 @@ function connectWebSocket(db) {
     })));
     const messageProducer = 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.
+        return db.cloud.persistedSyncState.pipe(filter$1((syncState) => syncState === null || syncState === void 0 ? void 0 : syncState.serverRevision), // Don't connect before there's no initial sync performed.
         take(1), // Don't continue waking up whenever syncState change
         switchMap((syncState) => db.cloud.currentUser.pipe(map((userLogin) => [userLogin, syncState]))), switchMap(([userLogin, syncState]) => {
             /*if (userLogin.license?.status && userLogin.license.status !== 'ok') {
@@ -7261,7 +4949,7 @@ function connectWebSocket(db) {
                 // We're in an in-between state when user is logged in but the user's realms are not yet synced.
                 // Don't make this change reconnect the websocket just yet. Wait till syncState is updated
                 // to iclude the user's realm.
-                return db.cloud.persistedSyncState.pipe(filter((syncState) => (syncState === null || syncState === void 0 ? void 0 : syncState.realms.includes(userLogin.userId)) || false), take(1), map((syncState) => [userLogin, syncState]));
+                return db.cloud.persistedSyncState.pipe(filter$1((syncState) => (syncState === null || syncState === void 0 ? void 0 : syncState.realms.includes(userLogin.userId)) || false), take(1), map((syncState) => [userLogin, syncState]));
             }
             return new 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]) => {
@@ -7277,7 +4965,7 @@ function connectWebSocket(db) {
                 return new WSObservable(db, db.cloud.persistedSyncState.value.serverRevision, db.cloud.persistedSyncState.value.yServerRevision, realmSetHash, db.cloud.persistedSyncState.value.clientIdentity, messageProducer, db.cloud.webSocketStatus, userLogin);
             }
             else {
-                return from$1([]);
+                return from([]);
             }
         }), catchError((error) => {
             if ((error === null || error === void 0 ? void 0 : error.name) === 'TokenExpiredError') {
@@ -7305,7 +4993,7 @@ function connectWebSocket(db) {
                 // Don't retry. Just throw and don't try connect again.
                 return throwError(() => error);
             }
-            return from$1(waitAndReconnectWhenUserDoesSomething(error)).pipe(switchMap(() => createObservable()));
+            return from(waitAndReconnectWhenUserDoesSomething(error)).pipe(switchMap(() => createObservable()));
         }));
     }
     return createObservable().subscribe({
@@ -7675,7 +5363,7 @@ class LoginGui extends d$1 {
         this.state = { userInteraction: undefined };
     }
     componentDidMount() {
-        this.subscription = from$1(this.props.db.cloud.userInteraction).subscribe(this.observer);
+        this.subscription = from(this.props.db.cloud.userInteraction).subscribe(this.observer);
     }
     componentWillUnmount() {
         if (this.subscription) {
@@ -7810,8 +5498,8 @@ function computeSyncState(db) {
 
 function createSharedValueObservable(o, defaultValue) {
     let currentValue = defaultValue;
-    let shared = from$1(o).pipe(map$1((x) => (currentValue = x)), share({ resetOnRefCountZero: () => timer$1(1000) }));
-    const rv = new Observable$1((observer) => {
+    let shared = from(o).pipe(map$1((x) => (currentValue = x)), share({ resetOnRefCountZero: () => timer(1000) }));
+    const rv = new Observable((observer) => {
         let didEmit = false;
         const subscription = shared.subscribe({
             next(value) {
@@ -8098,6 +5786,9 @@ function createYHandler(db) {
     return (provider) => {
         var _a;
         const doc = provider.doc;
+        if (!doc) {
+            throw new Error('Internal error: DexieYProvider.createYHandler called without a doc. This is unexpected.');
+        }
         const { parentTable } = doc.meta || {};
         if (!((_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[parentTable].markedForSync)) {
             return; // The table that holds the doc is not marked for sync - leave it to dexie. No syncing, no awareness.
@@ -8232,7 +5923,6 @@ function createAwareness(db, doc, provider) {
                 if (provider.destroyed || currentFlowId !== myFlow || !connected)
                     return;
                 if (serverUpdatesSinceLastSync.length > 0) {
-                    const Y = $Y(db); // Get the Yjs library from Dexie constructor options
                     const mergedUpdate = Y.mergeUpdatesV2(serverUpdatesSinceLastSync.map((update) => update.u));
                     const stateVector = Y.encodeStateVectorFromUpdateV2(mergedUpdate);
                     docOpenMsg.sv = stateVector;
@@ -8455,7 +6145,7 @@ function dexieCloud(dexie) {
     const syncComplete = new Subject();
     dexie.cloud = {
         // @ts-ignore
-        version: "4.1.0-beta.49",
+        version: "4.2.0-alpha.3",
         options: Object.assign({}, DEFAULT_OPTIONS),
         schema: null,
         get currentUserId() {
@@ -8513,7 +6203,7 @@ function dexieCloud(dexie) {
                     const syncState = db.cloud.persistedSyncState.value;
                     triggerSync(db, purpose);
                     if (wait) {
-                        const newSyncState = yield firstValueFrom(db.cloud.persistedSyncState.pipe(filter((newSyncState) => (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.timestamp) != null &&
+                        const newSyncState = yield firstValueFrom(db.cloud.persistedSyncState.pipe(filter$1((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);
@@ -8525,14 +6215,14 @@ function dexieCloud(dexie) {
                     triggerSync(db, purpose);
                     if (wait) {
                         console.debug('db.cloud.login() is waiting for sync completion...');
-                        yield firstValueFrom(from$1(liveQuery(() => __awaiter(this, void 0, void 0, function* () {
+                        yield firstValueFrom(from(liveQuery(() => __awaiter(this, void 0, void 0, function* () {
                             const syncNeeded = yield isSyncNeeded(db);
                             const newSyncState = yield db.getPersistedSyncState();
                             if ((newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.timestamp) !== (syncState === null || syncState === void 0 ? void 0 : syncState.timestamp) &&
                                 (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.error))
                                 throw new Error(`Sync error: ` + newSyncState.error);
                             return syncNeeded;
-                        }))).pipe(filter((isNeeded) => !isNeeded)));
+                        }))).pipe(filter$1((isNeeded) => !isNeeded)));
                         console.debug('Done waiting for sync completion because we have nothing to push anymore');
                     }
                 }
@@ -8676,10 +6366,9 @@ function dexieCloud(dexie) {
                     db.cloud.persistedSyncState.pipe(skip(1), take(1)),
                 ]));
                 const yHandler = createYHandler(db);
-                db.dx.on('y', yHandler);
+                DexieYProvider.on.new.subscribe(yHandler);
                 db.dx.once('close', () => {
-                    var _a;
-                    (_a = db.dx.on.y) === null || _a === void 0 ? void 0 : _a.unsubscribe(yHandler);
+                    DexieYProvider.on.new.unsubscribe(yHandler);
                 });
             }
             // HERE: If requireAuth, do athentication now.
@@ -8691,7 +6380,7 @@ function dexieCloud(dexie) {
                     // 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 firstValueFrom(currentUserEmitter.pipe(filter((user) => !!user.isLoggedIn), take(1)));
+                    yield firstValueFrom(currentUserEmitter.pipe(filter$1((user) => !!user.isLoggedIn), take(1)));
                     console.debug('Dexie Cloud Service worker. Application has authenticated.');
                 }
                 else {
@@ -8773,7 +6462,7 @@ function dexieCloud(dexie) {
     }
 }
 // @ts-ignore
-dexieCloud.version = "4.1.0-beta.49";
+dexieCloud.version = "4.2.0-alpha.3";
 Dexie.Cloud = dexieCloud;
 
 export { dexieCloud as default, defineYDocTrigger, dexieCloud, getTiedObjectId, getTiedRealmId, resolveText };