dexie-cloud-addon 4.2.3 → 4.2.5

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

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.2.3, Fri Nov 28 2025
+ * Version 4.2.5, Sat Dec 20 2025
  *
  * https://dexie.org
  *
@@ -36,7 +36,7 @@
     OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
     PERFORMANCE OF THIS SOFTWARE.
     ***************************************************************************** */
-    /* global Reflect, Promise */
+    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
     function __rest(s, e) {
@@ -80,8 +80,9 @@
     function __asyncGenerator(thisArg, _arguments, generator) {
         if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
         var g = generator.apply(thisArg, _arguments || []), i, q = [];
-        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+        function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
         function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
         function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
         function fulfill(value) { resume("next", value); }
@@ -95,7 +96,12 @@
         return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
         function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
         function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-    }
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
 
     function assert(b) {
         if (!b)
@@ -276,13 +282,12 @@
     function subtractChanges(target, // Server change set
     changesToSubtract // additional mutations on client during syncWithServer()
     ) {
-        var _a, _b, _c;
         for (const [table, mutationSet] of Object.entries(changesToSubtract)) {
             for (const [key, mut] of Object.entries(mutationSet)) {
                 switch (mut.type) {
                     case 'ups':
                         {
-                            const targetMut = (_a = target[table]) === null || _a === void 0 ? void 0 : _a[key];
+                            const targetMut = target[table]?.[key];
                             if (targetMut) {
                                 switch (targetMut.type) {
                                     case 'ups':
@@ -300,10 +305,10 @@
                         }
                         break;
                     case 'del':
-                        (_b = target[table]) === null || _b === void 0 ? true : delete _b[key];
+                        delete target[table]?.[key];
                         break;
                     case 'upd': {
-                        const targetMut = (_c = target[table]) === null || _c === void 0 ? void 0 : _c[key];
+                        const targetMut = target[table]?.[key];
                         if (targetMut) {
                             switch (targetMut.type) {
                                 case 'ups':
@@ -336,17 +341,14 @@
      * @param inSet
      * @returns DBOperationsSet representing inSet
      */
-    function toDBOperationSet(inSet, txid = "") {
-        // Fictive transaction:
-        if (!txid)
-            txid = randomString$1(16);
+    function toDBOperationSet(inSet, txid) {
         // Convert data into a temporary map to collect mutations of same table and type
         const map = {};
         for (const [table, ops] of Object.entries(inSet)) {
             for (const [key, op] of Object.entries(ops)) {
                 const mapEntry = map[table] || (map[table] = {});
                 const ops = mapEntry[op.type] || (mapEntry[op.type] = []);
-                ops.push(Object.assign({ key }, op)); // DBKeyMutation doesn't contain key, so we need to bring it in.
+                ops.push({ key, ...op }); // DBKeyMutation doesn't contain key, so we need to bring it in.
             }
         }
         // Start computing the resulting format:
@@ -407,8 +409,8 @@
      * @module math
      */
 
-    const floor$1 = Math.floor;
-    const abs$1 = Math.abs;
+    const floor = Math.floor;
+    const abs = Math.abs;
 
     /**
      * @function
@@ -416,7 +418,7 @@
      * @param {number} b
      * @return {number} The smaller element of a and b
      */
-    const min$1 = (a, b) => a < b ? a : b;
+    const min = (a, b) => a < b ? a : b;
 
     /**
      * @function
@@ -424,24 +426,41 @@
      * @param {number} b
      * @return {number} The bigger element of a and b
      */
-    const max$1 = (a, b) => a > b ? a : 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$1 = n => n !== 0 ? n < 0 : 1 / n < 0;
+    const isNegativeZero = n => n !== 0 ? n < 0 : 1 / n < 0;
 
     /* eslint-env browser */
 
-    const BIT7$1 = 64;
-    const BIT8$1 = 128;
-    const BITS6$1 = 63;
-    const BITS7$1 = 127;
+    /**
+     * Binary data constants.
+     *
+     * @module binary
+     */
+
+    /**
+     * n-th bit activated.
+     *
+     * @type {number}
+     */
+    const BIT1 = 1;
+    const BIT2 = 2;
+    const BIT3 = 4;
+    const BIT4 = 8;
+    const BIT6 = 32;
+    const BIT7 = 64;
+    const BIT8 = 128;
+    const BITS5 = 31;
+    const BITS6 = 63;
+    const BITS7 = 127;
     /**
      * @type {number}
      */
-    const BITS31$1 = 0x7FFFFFFF;
+    const BITS31 = 0x7FFFFFFF;
 
     /**
      * Utility helpers for working with numbers.
@@ -450,10 +469,18 @@
      */
 
 
-    const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER;
+    const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
 
     /* c8 ignore next */
-    const isInteger$1 = Number.isInteger || (num => typeof num === 'number' && isFinite(num) && floor$1(num) === num);
+    const isInteger = Number.isInteger || (num => typeof num === 'number' && isFinite(num) && floor(num) === num);
+
+    /**
+     * Utility module to work with sets.
+     *
+     * @module set
+     */
+
+    const create$5 = () => new Set();
 
     /**
      * Utility module to work with Arrays.
@@ -462,13 +489,68 @@
      */
 
 
-    const isArray$1 = Array.isArray;
+    /**
+     * Return the last element of an array. The element must exist
+     *
+     * @template L
+     * @param {ArrayLike<L>} arr
+     * @return {L}
+     */
+    const last = arr => arr[arr.length - 1];
+
+    /**
+     * Append elements from src to dest
+     *
+     * @template M
+     * @param {Array<M>} dest
+     * @param {Array<M>} src
+     */
+    const appendTo = (dest, src) => {
+      for (let i = 0; i < src.length; i++) {
+        dest.push(src[i]);
+      }
+    };
+
+    /**
+     * Transforms something array-like to an actual Array.
+     *
+     * @function
+     * @template T
+     * @param {ArrayLike<T>|Iterable<T>} arraylike
+     * @return {T}
+     */
+    const from = Array.from;
+
+    const isArray = Array.isArray;
+
+    /**
+     * @param {string} s
+     * @return {string}
+     */
+    const toLowerCase = s => s.toLowerCase();
+
+    const trimLeftRegex = /^\s*/g;
+
+    /**
+     * @param {string} s
+     * @return {string}
+     */
+    const trimLeft = s => s.replace(trimLeftRegex, '');
+
+    const fromCamelCaseRegex = /([A-Z])/g;
+
+    /**
+     * @param {string} s
+     * @param {string} separator
+     * @return {string}
+     */
+    const fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, match => `${separator}${toLowerCase(match)}`));
 
     /**
      * @param {string} str
      * @return {Uint8Array}
      */
-    const _encodeUtf8Polyfill$1 = str => {
+    const _encodeUtf8Polyfill = str => {
       const encodedString = unescape(encodeURIComponent(str));
       const len = encodedString.length;
       const buf = new Uint8Array(len);
@@ -479,33 +561,33 @@
     };
 
     /* c8 ignore next */
-    const utf8TextEncoder$1 = /** @type {TextEncoder} */ (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null);
+    const utf8TextEncoder = /** @type {TextEncoder} */ (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null);
 
     /**
      * @param {string} str
      * @return {Uint8Array}
      */
-    const _encodeUtf8Native$1 = str => utf8TextEncoder$1.encode(str);
+    const _encodeUtf8Native = str => utf8TextEncoder.encode(str);
 
     /**
      * @param {string} str
      * @return {Uint8Array}
      */
     /* c8 ignore next */
-    const encodeUtf8$1 = utf8TextEncoder$1 ? _encodeUtf8Native$1 : _encodeUtf8Polyfill$1;
+    const encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
 
     /* c8 ignore next */
-    let utf8TextDecoder$1 = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+    let utf8TextDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
 
     /* c8 ignore start */
-    if (utf8TextDecoder$1 && utf8TextDecoder$1.decode(new Uint8Array()).length === 1) {
+    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$1 = null;
+      utf8TextDecoder = null;
     }
 
     /**
@@ -540,7 +622,7 @@
     /**
      * A BinaryEncoder handles the encoding to an Uint8Array.
      */
-    let Encoder$1 = class Encoder {
+    class Encoder {
       constructor () {
         this.cpos = 0;
         this.cbuf = new Uint8Array(100);
@@ -549,7 +631,13 @@
          */
         this.bufs = [];
       }
-    };
+    }
+
+    /**
+     * @function
+     * @return {Encoder}
+     */
+    const createEncoder = () => new Encoder();
 
     /**
      * The current length of the encoded data.
@@ -558,7 +646,7 @@
      * @param {Encoder} encoder
      * @return {number}
      */
-    const length$2 = encoder => {
+    const length$1 = encoder => {
       let len = encoder.cpos;
       for (let i = 0; i < encoder.bufs.length; i++) {
         len += encoder.bufs[i].length;
@@ -573,8 +661,8 @@
      * @param {Encoder} encoder
      * @return {Uint8Array} The created ArrayBuffer.
      */
-    const toUint8Array$1 = encoder => {
-      const uint8arr = new Uint8Array(length$2(encoder));
+    const toUint8Array = encoder => {
+      const uint8arr = new Uint8Array(length$1(encoder));
       let curPos = 0;
       for (let i = 0; i < encoder.bufs.length; i++) {
         const d = encoder.bufs[i];
@@ -592,11 +680,11 @@
      * @param {Encoder} encoder
      * @param {number} len
      */
-    const verifyLen$1 = (encoder, 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$1(bufferLen, len) * 2);
+        encoder.cbuf = new Uint8Array(max(bufferLen, len) * 2);
         encoder.cpos = 0;
       }
     };
@@ -608,7 +696,7 @@
      * @param {Encoder} encoder
      * @param {number} num The byte that is to be encoded.
      */
-    const write$1 = (encoder, num) => {
+    const write = (encoder, num) => {
       const bufferLen = encoder.cbuf.length;
       if (encoder.cpos === bufferLen) {
         encoder.bufs.push(encoder.cbuf);
@@ -618,6 +706,15 @@
       encoder.cbuf[encoder.cpos++] = num;
     };
 
+    /**
+     * Write one byte as an unsigned integer.
+     *
+     * @function
+     * @param {Encoder} encoder
+     * @param {number} num The number that is to be encoded.
+     */
+    const writeUint8 = write;
+
     /**
      * Write a variable length unsigned integer. Max encodable integer is 2^53.
      *
@@ -625,12 +722,12 @@
      * @param {Encoder} encoder
      * @param {number} num The number that is to be encoded.
      */
-    const writeVarUint$1 = (encoder, num) => {
-      while (num > BITS7$1) {
-        write$1(encoder, BIT8$1 | (BITS7$1 & num));
-        num = floor$1(num / 128); // shift >>> 7
+    const writeVarUint = (encoder, num) => {
+      while (num > BITS7) {
+        write(encoder, BIT8 | (BITS7 & num));
+        num = floor(num / 128); // shift >>> 7
       }
-      write$1(encoder, BITS7$1 & num);
+      write(encoder, BITS7 & num);
     };
 
     /**
@@ -642,27 +739,27 @@
      * @param {Encoder} encoder
      * @param {number} num The number that is to be encoded.
      */
-    const writeVarInt$1 = (encoder, num) => {
-      const isNegative = isNegativeZero$1(num);
+    const writeVarInt = (encoder, num) => {
+      const isNegative = isNegativeZero(num);
       if (isNegative) {
         num = -num;
       }
       //             |- whether to continue reading         |- whether is negative     |- number
-      write$1(encoder, (num > BITS6$1 ? BIT8$1 : 0) | (isNegative ? BIT7$1 : 0) | (BITS6$1 & num));
-      num = floor$1(num / 64); // shift >>> 6
+      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$1(encoder, (num > BITS7$1 ? BIT8$1 : 0) | (BITS7$1 & num));
-        num = floor$1(num / 128); // shift >>> 7
+        write(encoder, (num > BITS7 ? BIT8 : 0) | (BITS7 & num));
+        num = floor(num / 128); // shift >>> 7
       }
     };
 
     /**
      * A cache to store strings temporarily
      */
-    const _strBuffer$1 = new Uint8Array(30000);
-    const _maxStrBSize$1 = _strBuffer$1.length / 3;
+    const _strBuffer = new Uint8Array(30000);
+    const _maxStrBSize = _strBuffer.length / 3;
 
     /**
      * Write a variable length string.
@@ -671,17 +768,17 @@
      * @param {Encoder} encoder
      * @param {String} str The string that is to be encoded.
      */
-    const _writeVarStringNative$1 = (encoder, str) => {
-      if (str.length < _maxStrBSize$1) {
+    const _writeVarStringNative = (encoder, str) => {
+      if (str.length < _maxStrBSize) {
         // We can encode the string into the existing buffer
         /* c8 ignore next */
-        const written = utf8TextEncoder$1.encodeInto(str, _strBuffer$1).written || 0;
-        writeVarUint$1(encoder, written);
+        const written = utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
+        writeVarUint(encoder, written);
         for (let i = 0; i < written; i++) {
-          write$1(encoder, _strBuffer$1[i]);
+          write(encoder, _strBuffer[i]);
         }
       } else {
-        writeVarUint8Array$1(encoder, encodeUtf8$1(str));
+        writeVarUint8Array(encoder, encodeUtf8(str));
       }
     };
 
@@ -692,12 +789,12 @@
      * @param {Encoder} encoder
      * @param {String} str The string that is to be encoded.
      */
-    const _writeVarStringPolyfill$1 = (encoder, str) => {
+    const _writeVarStringPolyfill = (encoder, str) => {
       const encodedString = unescape(encodeURIComponent(str));
       const len = encodedString.length;
-      writeVarUint$1(encoder, len);
+      writeVarUint(encoder, len);
       for (let i = 0; i < len; i++) {
-        write$1(encoder, /** @type {number} */ (encodedString.codePointAt(i)));
+        write(encoder, /** @type {number} */ (encodedString.codePointAt(i)));
       }
     };
 
@@ -709,7 +806,20 @@
      * @param {String} str The string that is to be encoded.
      */
     /* c8 ignore next */
-    const writeVarString$1 = (utf8TextEncoder$1 && /** @type {any} */ (utf8TextEncoder$1).encodeInto) ? _writeVarStringNative$1 : _writeVarStringPolyfill$1;
+    const writeVarString = (utf8TextEncoder && /** @type {any} */ (utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill;
+
+    /**
+     * Write the content of another Encoder.
+     *
+     * @TODO: can be improved!
+     *        - Note: Should consider that when appending a lot of small Encoders, we should rather clone than referencing the old structure.
+     *                Encoders start with a rather big initial buffer.
+     *
+     * @function
+     * @param {Encoder} encoder The enUint8Arr
+     * @param {Encoder} append The BinaryEncoder to be written.
+     */
+    const writeBinaryEncoder = (encoder, append) => writeUint8Array(encoder, toUint8Array(append));
 
     /**
      * Append fixed-length Uint8Array to the encoder.
@@ -718,10 +828,10 @@
      * @param {Encoder} encoder
      * @param {Uint8Array} uint8Array
      */
-    const writeUint8Array$1 = (encoder, uint8Array) => {
+    const writeUint8Array = (encoder, uint8Array) => {
       const bufferLen = encoder.cbuf.length;
       const cpos = encoder.cpos;
-      const leftCopyLen = min$1(bufferLen - cpos, uint8Array.length);
+      const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
       const rightCopyLen = uint8Array.length - leftCopyLen;
       encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
       encoder.cpos += leftCopyLen;
@@ -730,7 +840,7 @@
         // Append new buffer
         encoder.bufs.push(encoder.cbuf);
         // must have at least size of remaining buffer
-        encoder.cbuf = new Uint8Array(max$1(bufferLen * 2, rightCopyLen));
+        encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
         // copy array
         encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
         encoder.cpos = rightCopyLen;
@@ -744,9 +854,9 @@
      * @param {Encoder} encoder
      * @param {Uint8Array} uint8Array
      */
-    const writeVarUint8Array$1 = (encoder, uint8Array) => {
-      writeVarUint$1(encoder, uint8Array.byteLength);
-      writeUint8Array$1(encoder, uint8Array);
+    const writeVarUint8Array = (encoder, uint8Array) => {
+      writeVarUint(encoder, uint8Array.byteLength);
+      writeUint8Array(encoder, uint8Array);
     };
 
     /**
@@ -766,8 +876,8 @@
      * @param {number} len
      * @return {DataView}
      */
-    const writeOnDataView$1 = (encoder, len) => {
-      verifyLen$1(encoder, len);
+    const writeOnDataView = (encoder, len) => {
+      verifyLen(encoder, len);
       const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len);
       encoder.cpos += len;
       return dview
@@ -777,36 +887,36 @@
      * @param {Encoder} encoder
      * @param {number} num
      */
-    const writeFloat32$1 = (encoder, num) => writeOnDataView$1(encoder, 4).setFloat32(0, num, false);
+    const writeFloat32 = (encoder, num) => writeOnDataView(encoder, 4).setFloat32(0, num, false);
 
     /**
      * @param {Encoder} encoder
      * @param {number} num
      */
-    const writeFloat64$1 = (encoder, num) => writeOnDataView$1(encoder, 8).setFloat64(0, num, false);
+    const writeFloat64 = (encoder, num) => writeOnDataView(encoder, 8).setFloat64(0, num, false);
 
     /**
      * @param {Encoder} encoder
      * @param {bigint} num
      */
-    const writeBigInt64$1 = (encoder, num) => /** @type {any} */ (writeOnDataView$1(encoder, 8)).setBigInt64(0, num, false);
+    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$1(encoder, 8)).setBigUint64(0, num, false);
+    const writeBigUint64 = (encoder, num) => /** @type {any} */ (writeOnDataView(encoder, 8)).setBigUint64(0, num, false);
 
-    const floatTestBed$1 = new DataView(new ArrayBuffer(4));
+    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$1 = num => {
-      floatTestBed$1.setFloat32(0, num);
-      return floatTestBed$1.getFloat32(0) === num
+    const isFloat32 = num => {
+      floatTestBed.setFloat32(0, num);
+      return floatTestBed.getFloat32(0) === num
     };
 
     /**
@@ -846,795 +956,1137 @@
      * @param {Encoder} encoder
      * @param {undefined|null|number|bigint|boolean|string|Object<string,any>|Array<any>|Uint8Array} data
      */
-    const writeAny$1 = (encoder, data) => {
+    const writeAny = (encoder, data) => {
       switch (typeof data) {
         case 'string':
           // TYPE 119: STRING
-          write$1(encoder, 119);
-          writeVarString$1(encoder, data);
+          write(encoder, 119);
+          writeVarString(encoder, data);
           break
         case 'number':
-          if (isInteger$1(data) && abs$1(data) <= BITS31$1) {
+          if (isInteger(data) && abs(data) <= BITS31) {
             // TYPE 125: INTEGER
-            write$1(encoder, 125);
-            writeVarInt$1(encoder, data);
-          } else if (isFloat32$1(data)) {
+            write(encoder, 125);
+            writeVarInt(encoder, data);
+          } else if (isFloat32(data)) {
             // TYPE 124: FLOAT32
-            write$1(encoder, 124);
-            writeFloat32$1(encoder, data);
+            write(encoder, 124);
+            writeFloat32(encoder, data);
           } else {
             // TYPE 123: FLOAT64
-            write$1(encoder, 123);
-            writeFloat64$1(encoder, data);
+            write(encoder, 123);
+            writeFloat64(encoder, data);
           }
           break
         case 'bigint':
           // TYPE 122: BigInt
-          write$1(encoder, 122);
-          writeBigInt64$1(encoder, data);
+          write(encoder, 122);
+          writeBigInt64(encoder, data);
           break
         case 'object':
           if (data === null) {
             // TYPE 126: null
-            write$1(encoder, 126);
-          } else if (isArray$1(data)) {
+            write(encoder, 126);
+          } else if (isArray(data)) {
             // TYPE 117: Array
-            write$1(encoder, 117);
-            writeVarUint$1(encoder, data.length);
+            write(encoder, 117);
+            writeVarUint(encoder, data.length);
             for (let i = 0; i < data.length; i++) {
-              writeAny$1(encoder, data[i]);
+              writeAny(encoder, data[i]);
             }
           } else if (data instanceof Uint8Array) {
             // TYPE 116: ArrayBuffer
-            write$1(encoder, 116);
-            writeVarUint8Array$1(encoder, data);
+            write(encoder, 116);
+            writeVarUint8Array(encoder, data);
           } else {
             // TYPE 118: Object
-            write$1(encoder, 118);
+            write(encoder, 118);
             const keys = Object.keys(data);
-            writeVarUint$1(encoder, keys.length);
+            writeVarUint(encoder, keys.length);
             for (let i = 0; i < keys.length; i++) {
               const key = keys[i];
-              writeVarString$1(encoder, key);
-              writeAny$1(encoder, data[key]);
+              writeVarString(encoder, key);
+              writeAny(encoder, data[key]);
             }
           }
           break
         case 'boolean':
           // TYPE 120/121: boolean (true/false)
-          write$1(encoder, data ? 120 : 121);
+          write(encoder, data ? 120 : 121);
           break
         default:
           // TYPE 127: undefined
-          write$1(encoder, 127);
+          write(encoder, 127);
       }
     };
 
-    function encodeYMessage(msg) {
-        const encoder = new Encoder$1();
-        writeVarString$1(encoder, msg.type);
-        if ('table' in msg)
-            writeVarString$1(encoder, msg.table);
-        if ('prop' in msg)
-            writeVarString$1(encoder, msg.prop);
-        switch (msg.type) {
-            case 'u-ack':
-            case 'u-reject':
-                writeBigUint64(encoder, BigInt(msg.i));
-                break;
-            case 'outdated-server-rev':
-                break;
-            case 'y-complete-sync-done':
-                writeVarString$1(encoder, msg.yServerRev);
-                break;
-            default:
-                writeAny$1(encoder, msg.k);
-                switch (msg.type) {
-                    case 'aware':
-                        writeVarUint8Array$1(encoder, msg.u);
-                        break;
-                    case 'doc-open':
-                        writeAny$1(encoder, msg.serverRev);
-                        writeAny$1(encoder, msg.sv);
-                        break;
-                    case 'doc-close':
-                        break;
-                    case 'sv':
-                        writeVarUint8Array$1(encoder, msg.sv);
-                        break;
-                    case 'u-c':
-                        writeVarUint8Array$1(encoder, msg.u);
-                        writeBigUint64(encoder, BigInt(msg.i));
-                        break;
-                    case 'u-s':
-                        writeVarUint8Array$1(encoder, msg.u);
-                        writeVarString$1(encoder, msg.r || '');
-                        break;
-                }
-        }
-        return toUint8Array$1(encoder);
-    }
-
-    /**
-     * Error helpers.
-     *
-     * @module error
-     */
-
     /**
-     * @param {string} s
-     * @return {Error}
+     * Now come a few stateful encoder that have their own classes.
      */
-    /* c8 ignore next */
-    const create$6 = s => new Error(s);
 
     /**
-     * Efficient schema-less binary decoding with support for variable length encoding.
+     * Basic Run Length Encoder - a basic compression implementation.
      *
-     * Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.
+     * Encodes [1,1,1,7] to [1,3,7,1] (3 times 1, 1 time 7). This encoder might do more harm than good if there are a lot of values that are not repeated.
      *
-     * 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.
+     * It was originally used for image compression. Cool .. article http://csbruce.com/cbm/transactor/pdfs/trans_v7_i06.pdf
      *
-     * ```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
-     * ```
+     * @note T must not be null!
      *
-     * @module decoding
-     */
-
-
-    const errorUnexpectedEndOfArray$1 = create$6('Unexpected end of array');
-    const errorIntegerOutOfRange$1 = create$6('Integer out of Range');
-
-    /**
-     * A Decoder handles the decoding of an Uint8Array.
+     * @template T
      */
-    let Decoder$1 = class Decoder {
+    class RleEncoder extends Encoder {
       /**
-       * @param {Uint8Array} uint8Array Binary data to decode
+       * @param {function(Encoder, T):void} writer
        */
-      constructor (uint8Array) {
+      constructor (writer) {
+        super();
         /**
-         * Decoding target.
-         *
-         * @type {Uint8Array}
+         * The writer
          */
-        this.arr = uint8Array;
+        this.w = writer;
         /**
-         * Current decoding position.
-         *
-         * @type {number}
+         * Current state
+         * @type {T|null}
          */
-        this.pos = 0;
+        this.s = null;
+        this.count = 0;
       }
-    };
 
-    /**
-     * @function
-     * @param {Decoder} decoder
-     * @return {boolean}
-     */
-    const hasContent$1 = decoder => decoder.pos !== decoder.arr.length;
+      /**
+       * @param {T} v
+       */
+      write (v) {
+        if (this.s === v) {
+          this.count++;
+        } else {
+          if (this.count > 0) {
+            // flush counter, unless this is the first value (count = 0)
+            writeVarUint(this, this.count - 1); // since count is always > 0, we can decrement by one. non-standard encoding ftw
+          }
+          this.count = 1;
+          // write first value
+          this.w(this, v);
+          this.s = v;
+        }
+      }
+    }
 
     /**
-     * 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}
+     * @param {UintOptRleEncoder} encoder
      */
-    const readUint8Array$1 = (decoder, len) => {
-      const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
-      decoder.pos += len;
-      return view
+    const flushUintOptRleEncoder = encoder => {
+      if (encoder.count > 0) {
+        // flush counter, unless this is the first value (count = 0)
+        // case 1: just a single value. set sign to positive
+        // case 2: write several values. set sign to negative to indicate that there is a length coming
+        writeVarInt(encoder.encoder, encoder.count === 1 ? encoder.s : -encoder.s);
+        if (encoder.count > 1) {
+          writeVarUint(encoder.encoder, encoder.count - 2); // since count is always > 1, we can decrement by one. non-standard encoding ftw
+        }
+      }
     };
 
     /**
-     * Read variable length Uint8Array.
+     * Optimized Rle encoder that does not suffer from the mentioned problem of the basic Rle encoder.
      *
-     * 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.
+     * Internally uses VarInt encoder to write unsigned integers. If the input occurs multiple times, we write
+     * write it as a negative number. The UintOptRleDecoder then understands that it needs to read a count.
      *
-     * @function
-     * @param {Decoder} decoder
-     * @return {Uint8Array}
+     * Encodes [1,2,3,3,3] as [1,2,-3,3] (once 1, once 2, three times 3)
      */
-    const readVarUint8Array$1 = decoder => readUint8Array$1(decoder, readVarUint$1(decoder));
+    class UintOptRleEncoder {
+      constructor () {
+        this.encoder = new Encoder();
+        /**
+         * @type {number}
+         */
+        this.s = 0;
+        this.count = 0;
+      }
 
-    /**
-     * Read one byte as unsigned integer.
-     * @function
-     * @param {Decoder} decoder The decoder instance
-     * @return {number} Unsigned 8-bit integer
-     */
-    const readUint8$1 = decoder => decoder.arr[decoder.pos++];
+      /**
+       * @param {number} v
+       */
+      write (v) {
+        if (this.s === v) {
+          this.count++;
+        } else {
+          flushUintOptRleEncoder(this);
+          this.count = 1;
+          this.s = v;
+        }
+      }
+
+      /**
+       * Flush the encoded state and transform this to a Uint8Array.
+       *
+       * Note that this should only be called once.
+       */
+      toUint8Array () {
+        flushUintOptRleEncoder(this);
+        return toUint8Array(this.encoder)
+      }
+    }
 
     /**
-     * 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
+     * @param {IntDiffOptRleEncoder} encoder
      */
-    const readVarUint$1 = 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$1) * mult; // shift $r << (7*#iterations) and add it to num
-        mult *= 128; // next iteration, shift 7 "more" to the left
-        if (r < BIT8$1) {
-          return num
-        }
-        /* c8 ignore start */
-        if (num > MAX_SAFE_INTEGER$1) {
-          throw errorIntegerOutOfRange$1
+    const flushIntDiffOptRleEncoder = encoder => {
+      if (encoder.count > 0) {
+        //          31 bit making up the diff | wether to write the counter
+        // const encodedDiff = encoder.diff << 1 | (encoder.count === 1 ? 0 : 1)
+        const encodedDiff = encoder.diff * 2 + (encoder.count === 1 ? 0 : 1);
+        // flush counter, unless this is the first value (count = 0)
+        // case 1: just a single value. set first bit to positive
+        // case 2: write several values. set first bit to negative to indicate that there is a length coming
+        writeVarInt(encoder.encoder, encodedDiff);
+        if (encoder.count > 1) {
+          writeVarUint(encoder.encoder, encoder.count - 2); // since count is always > 1, we can decrement by one. non-standard encoding ftw
         }
-        /* c8 ignore stop */
       }
-      throw errorUnexpectedEndOfArray$1
     };
 
     /**
-     * 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.
+     * A combination of the IntDiffEncoder and the UintOptRleEncoder.
      *
-     * @function
-     * @param {Decoder} decoder
-     * @return {number} An unsigned integer.length
+     * The count approach is similar to the UintDiffOptRleEncoder, but instead of using the negative bitflag, it encodes
+     * in the LSB whether a count is to be read. Therefore this Encoder only supports 31 bit integers!
+     *
+     * Encodes [1, 2, 3, 2] as [3, 1, 6, -1] (more specifically [(1 << 1) | 1, (3 << 0) | 0, -1])
+     *
+     * Internally uses variable length encoding. Contrary to normal UintVar encoding, the first byte contains:
+     * * 1 bit that denotes whether the next value is a count (LSB)
+     * * 1 bit that denotes whether this value is negative (MSB - 1)
+     * * 1 bit that denotes whether to continue reading the variable length integer (MSB)
+     *
+     * Therefore, only five bits remain to encode diff ranges.
+     *
+     * Use this Encoder only when appropriate. In most cases, this is probably a bad idea.
      */
-    const readVarInt$1 = decoder => {
-      let r = decoder.arr[decoder.pos++];
-      let num = r & BITS6$1;
-      let mult = 64;
-      const sign = (r & BIT7$1) > 0 ? -1 : 1;
-      if ((r & BIT8$1) === 0) {
-        // don't continue reading
-        return sign * num
+    class IntDiffOptRleEncoder {
+      constructor () {
+        this.encoder = new Encoder();
+        /**
+         * @type {number}
+         */
+        this.s = 0;
+        this.count = 0;
+        this.diff = 0;
       }
-      const len = decoder.arr.length;
-      while (decoder.pos < len) {
-        r = decoder.arr[decoder.pos++];
-        // num = num | ((r & binary.BITS7) << len)
-        num = num + (r & BITS7$1) * mult;
-        mult *= 128;
-        if (r < BIT8$1) {
-          return sign * num
-        }
-        /* c8 ignore start */
-        if (num > MAX_SAFE_INTEGER$1) {
-          throw errorIntegerOutOfRange$1
+
+      /**
+       * @param {number} v
+       */
+      write (v) {
+        if (this.diff === v - this.s) {
+          this.s = v;
+          this.count++;
+        } else {
+          flushIntDiffOptRleEncoder(this);
+          this.count = 1;
+          this.diff = v - this.s;
+          this.s = v;
         }
-        /* c8 ignore stop */
       }
-      throw errorUnexpectedEndOfArray$1
-    };
+
+      /**
+       * Flush the encoded state and transform this to a Uint8Array.
+       *
+       * Note that this should only be called once.
+       */
+      toUint8Array () {
+        flushIntDiffOptRleEncoder(this);
+        return toUint8Array(this.encoder)
+      }
+    }
 
     /**
-     * We don't test this function anymore as we use native decoding/encoding by default now.
-     * Better not modify this anymore..
+     * Optimized String Encoder.
      *
-     * 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.
+     * Encoding many small strings in a simple Encoder is not very efficient. The function call to decode a string takes some time and creates references that must be eventually deleted.
+     * In practice, when decoding several million small strings, the GC will kick in more and more often to collect orphaned string objects (or maybe there is another reason?).
      *
-     * @function
-     * @param {Decoder} decoder
-     * @return {String} The read String.
+     * This string encoder solves the above problem. All strings are concatenated and written as a single string using a single encoding call.
+     *
+     * The lengths are encoded using a UintOptRleEncoder.
      */
-    /* c8 ignore start */
-    const _readVarStringPolyfill$1 = decoder => {
-      let remainingLen = readVarUint$1(decoder);
-      if (remainingLen === 0) {
-        return ''
-      } else {
-        let encodedString = String.fromCodePoint(readUint8$1(decoder)); // remember to decrease remainingLen
-        if (--remainingLen < 100) { // do not create a Uint8Array for small strings
-          while (remainingLen--) {
-            encodedString += String.fromCodePoint(readUint8$1(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;
-          }
+    class StringEncoder {
+      constructor () {
+        /**
+         * @type {Array<string>}
+         */
+        this.sarr = [];
+        this.s = '';
+        this.lensE = new UintOptRleEncoder();
+      }
+
+      /**
+       * @param {string} string
+       */
+      write (string) {
+        this.s += string;
+        if (this.s.length > 19) {
+          this.sarr.push(this.s);
+          this.s = '';
         }
-        return decodeURIComponent(escape(encodedString))
+        this.lensE.write(string.length);
+      }
+
+      toUint8Array () {
+        const encoder = new Encoder();
+        this.sarr.push(this.s);
+        this.s = '';
+        writeVarString(encoder, this.sarr.join(''));
+        writeUint8Array(encoder, this.lensE.toUint8Array());
+        return toUint8Array(encoder)
       }
+    }
+
+    function encodeYMessage(msg) {
+        const encoder = new Encoder();
+        writeVarString(encoder, msg.type);
+        if ('table' in msg)
+            writeVarString(encoder, msg.table);
+        if ('prop' in msg)
+            writeVarString(encoder, msg.prop);
+        switch (msg.type) {
+            case 'u-ack':
+            case 'u-reject':
+                writeBigUint64(encoder, BigInt(msg.i));
+                break;
+            case 'outdated-server-rev':
+                break;
+            case 'y-complete-sync-done':
+                writeVarString(encoder, msg.yServerRev);
+                break;
+            default:
+                writeAny(encoder, msg.k);
+                switch (msg.type) {
+                    case 'aware':
+                        writeVarUint8Array(encoder, msg.u);
+                        break;
+                    case 'doc-open':
+                        writeAny(encoder, msg.serverRev);
+                        writeAny(encoder, msg.sv);
+                        break;
+                    case 'doc-close':
+                        break;
+                    case 'sv':
+                        writeVarUint8Array(encoder, msg.sv);
+                        break;
+                    case 'u-c':
+                        writeVarUint8Array(encoder, msg.u);
+                        writeBigUint64(encoder, BigInt(msg.i));
+                        break;
+                    case 'u-s':
+                        writeVarUint8Array(encoder, msg.u);
+                        writeVarString(encoder, msg.r || '');
+                        break;
+                }
+        }
+        return toUint8Array(encoder);
+    }
+
+    /**
+     * Error helpers.
+     *
+     * @module error
+     */
+
+    /**
+     * @param {string} s
+     * @return {Error}
+     */
+    /* c8 ignore next */
+    const create$4 = s => new Error(s);
+
+    /**
+     * @throws {Error}
+     * @return {never}
+     */
+    /* c8 ignore next 3 */
+    const methodUnimplemented = () => {
+      throw create$4('Method unimplemented')
     };
-    /* c8 ignore stop */
 
     /**
-     * @function
-     * @param {Decoder} decoder
-     * @return {String} The read String
+     * @throws {Error}
+     * @return {never}
      */
-    const _readVarStringNative$1 = decoder =>
-      /** @type any */ (utf8TextDecoder$1).decode(readVarUint8Array$1(decoder));
+    /* c8 ignore next 3 */
+    const unexpectedCase = () => {
+      throw create$4('Unexpected case')
+    };
 
     /**
-     * Read string of variable length
-     * * varUint is used to store the length of the string
+     * Efficient schema-less binary decoding with support for variable length encoding.
      *
-     * @function
-     * @param {Decoder} decoder
-     * @return {String} The read String
+     * 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
      */
-    /* c8 ignore next */
-    const readVarString$1 = utf8TextDecoder$1 ? _readVarStringNative$1 : _readVarStringPolyfill$1;
+
+
+    const errorUnexpectedEndOfArray = create$4('Unexpected end of array');
+    const errorIntegerOutOfRange = create$4('Integer out of Range');
 
     /**
-     * @param {Decoder} decoder
-     * @param {number} len
-     * @return {DataView}
+     * A Decoder handles the decoding of an Uint8Array.
      */
-    const readFromDataView$1 = (decoder, len) => {
-      const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len);
-      decoder.pos += len;
-      return dv
-    };
+    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;
+      }
+    }
 
     /**
-     * @param {Decoder} decoder
+     * @function
+     * @param {Uint8Array} uint8Array
+     * @return {Decoder}
      */
-    const readFloat32$1 = decoder => readFromDataView$1(decoder, 4).getFloat32(0, false);
+    const createDecoder = uint8Array => new Decoder(uint8Array);
 
     /**
+     * @function
      * @param {Decoder} decoder
+     * @return {boolean}
      */
-    const readFloat64$1 = decoder => readFromDataView$1(decoder, 8).getFloat64(0, false);
+    const hasContent = decoder => decoder.pos !== decoder.arr.length;
 
     /**
-     * @param {Decoder} decoder
+     * 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 readBigInt64$1 = decoder => /** @type {any} */ (readFromDataView$1(decoder, 8)).getBigInt64(0, false);
+    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 readBigUint64 = decoder => /** @type {any} */ (readFromDataView$1(decoder, 8)).getBigUint64(0, false);
+    const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint(decoder));
 
     /**
-     * @type {Array<function(Decoder):any>}
+     * Read one byte as unsigned integer.
+     * @function
+     * @param {Decoder} decoder The decoder instance
+     * @return {number} Unsigned 8-bit integer
      */
-    const readAnyLookupTable$1 = [
-      decoder => undefined, // CASE 127: undefined
-      decoder => null, // CASE 126: null
-      readVarInt$1, // CASE 125: integer
-      readFloat32$1, // CASE 124: float32
-      readFloat64$1, // CASE 123: float64
-      readBigInt64$1, // CASE 122: bigint
-      decoder => false, // CASE 121: boolean (false)
-      decoder => true, // CASE 120: boolean (true)
-      readVarString$1, // CASE 119: string
-      decoder => { // CASE 118: object<string,any>
-        const len = readVarUint$1(decoder);
-        /**
-         * @type {Object<string,any>}
-         */
-        const obj = {};
-        for (let i = 0; i < len; i++) {
-          const key = readVarString$1(decoder);
-          obj[key] = readAny$1(decoder);
-        }
-        return obj
-      },
-      decoder => { // CASE 117: array<any>
-        const len = readVarUint$1(decoder);
-        const arr = [];
-        for (let i = 0; i < len; i++) {
-          arr.push(readAny$1(decoder));
-        }
-        return arr
-      },
-      readVarUint8Array$1 // CASE 116: Uint8Array
-    ];
+    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 readAny$1 = decoder => readAnyLookupTable$1[127 - readUint8$1(decoder)](decoder);
-
-    function decodeYMessage(a) {
-        const decoder = new Decoder$1(a);
-        const type = readVarString$1(decoder);
-        if (type === 'outdated-server-rev') {
-            return { type };
+    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
         }
-        if (type === 'y-complete-sync-done') {
-            return { type, yServerRev: readVarString$1(decoder) };
+        /* c8 ignore start */
+        if (num > MAX_SAFE_INTEGER) {
+          throw errorIntegerOutOfRange
         }
-        const table = readVarString$1(decoder);
-        const prop = readVarString$1(decoder);
-        switch (type) {
-            case 'u-ack':
-            case 'u-reject':
-                return {
-                    type,
-                    table,
-                    prop,
-                    i: Number(readBigUint64(decoder)),
-                };
-            default: {
-                const k = readAny$1(decoder);
-                switch (type) {
-                    case 'in-sync':
-                        return { type, table, prop, k };
-                    case 'aware':
-                        return {
-                            type,
-                            table,
-                            prop,
-                            k,
-                            u: readVarUint8Array$1(decoder),
-                        };
-                    case 'doc-open':
-                        return {
-                            type,
-                            table,
-                            prop,
-                            k,
-                            serverRev: readAny$1(decoder),
-                            sv: readAny$1(decoder),
-                        };
-                    case 'doc-close':
-                        return { type, table, prop, k };
-                    case 'sv':
-                        return {
-                            type,
-                            table,
-                            prop,
-                            k,
-                            sv: readVarUint8Array$1(decoder),
-                        };
-                    case 'u-c':
-                        return {
-                            type,
-                            table,
-                            prop,
-                            k,
-                            u: readVarUint8Array$1(decoder),
-                            i: Number(readBigUint64(decoder)),
-                        };
-                    case 'u-s':
-                        return {
-                            type,
-                            table,
-                            prop,
-                            k,
-                            u: readVarUint8Array$1(decoder),
-                            r: (decoder.pos < decoder.arr.length && readVarString$1(decoder)) || undefined,
-                        };
-                    default:
-                        throw new TypeError(`Unknown message type: ${type}`);
-                }
-            }
-        }
-    }
+        /* c8 ignore stop */
+      }
+      throw errorUnexpectedEndOfArray
+    };
 
-    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
+    /**
+     * 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
         }
-        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;
-            }
+        /* c8 ignore start */
+        if (num > MAX_SAFE_INTEGER) {
+          throw errorIntegerOutOfRange
         }
-        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; }
+        /* 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 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
+     * @param {Decoder} decoder
+     * @return {String} The read String
+     */
+    const _readVarStringNative = decoder =>
+      /** @type any */ (utf8TextDecoder).decode(readVarUint8Array(decoder));
 
-    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();
-                }
-            });
-        };
-    }
+    /**
+     * 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;
 
-    //const hasSW = 'serviceWorker' in navigator;
-    let hasComplainedAboutSyncEvent = false;
-    function registerSyncEvent(db, purpose) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // Send sync event to SW:
-                const sw = yield navigator.serviceWorker.ready;
-                if (purpose === "push" && sw.sync) {
-                    yield sw.sync.register(`dexie-cloud:${db.name}`);
-                }
-                if (sw.active) {
-                    // Use postMessage for pull syncs and for browsers not supporting sync event (Firefox, Safari).
-                    // Also chromium based browsers with sw.sync as a fallback for sleepy sync events not taking action for a while.
-                    sw.active.postMessage({
-                        type: 'dexie-cloud-sync',
-                        dbName: db.name,
-                        purpose
-                    });
-                }
-                else {
-                    throw new Error(`Failed to trigger sync - there's no active service worker`);
-                }
-                return;
-            }
-            catch (e) {
-                if (!hasComplainedAboutSyncEvent) {
-                    console.debug(`Dexie Cloud: Could not register sync event`, e);
-                    hasComplainedAboutSyncEvent = true;
-                }
-            }
-        });
-    }
-    function registerPeriodicSyncEvent(db) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            try {
-                // Register periodicSync event to SW:
-                // @ts-ignore
-                const { periodicSync } = yield navigator.serviceWorker.ready;
-                if (periodicSync) {
-                    try {
-                        yield periodicSync.register(`dexie-cloud:${db.name}`, (_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.periodicSync);
-                        console.debug(`Dexie Cloud: Successfully registered periodicsync event for ${db.name}`);
-                    }
-                    catch (e) {
-                        console.debug(`Dexie Cloud: Failed to register periodic sync. Your PWA must be installed to allow background sync.`, e);
-                    }
-                }
-                else {
-                    console.debug(`Dexie Cloud: periodicSync not supported.`);
-                }
-            }
-            catch (e) {
-                console.debug(`Dexie Cloud: Could not register periodicSync for ${db.name}`, e);
-            }
-        });
-    }
+    /**
+     * @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
+    };
 
-    function triggerSync(db, purpose) {
-        if (db.cloud.usingServiceWorker) {
-            console.debug('registering sync event');
-            registerSyncEvent(db, purpose);
+    /**
+     * @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);
         }
-        else {
-            db.localSyncEvent.next({ purpose });
+        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);
+
+    /**
+     * T must not be null.
+     *
+     * @template T
+     */
+    class RleDecoder extends Decoder {
+      /**
+       * @param {Uint8Array} uint8Array
+       * @param {function(Decoder):T} reader
+       */
+      constructor (uint8Array, reader) {
+        super(uint8Array);
+        /**
+         * The reader
+         */
+        this.reader = reader;
+        /**
+         * Current state
+         * @type {T|null}
+         */
+        this.s = null;
+        this.count = 0;
+      }
+
+      read () {
+        if (this.count === 0) {
+          this.s = this.reader(this);
+          if (hasContent(this)) {
+            this.count = readVarUint(this) + 1; // see encoder implementation for the reason why this is incremented
+          } else {
+            this.count = -1; // read the current value forever
+          }
         }
+        this.count--;
+        return /** @type {T} */ (this.s)
+      }
     }
 
-    const hasArrayBufferFromBase64 = "fromBase64" in Uint8Array; // https://github.com/tc39/proposal-arraybuffer-base64;
-    const hasArrayBufferToBase64 = "toBase64" in Uint8Array.prototype; // https://github.com/tc39/proposal-arraybuffer-base64;
-    const b64decode = typeof Buffer !== "undefined"
-        ? (base64) => Buffer.from(base64, "base64") // Node
-        : hasArrayBufferFromBase64
-            ? // @ts-ignore: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/fromBase64
-                (base64) => Uint8Array.fromBase64(base64) // Modern javascript standard
-            : (base64) => {
-                // Legacy DOM workaround
-                const binary_string = atob(base64);
-                const len = binary_string.length;
-                const bytes = new Uint8Array(len);
-                for (var i = 0; i < len; i++) {
-                    bytes[i] = binary_string.charCodeAt(i);
-                }
-                return bytes;
-            };
-    const b64encode = typeof Buffer !== "undefined"
-        ? (b) => {
-            // Node
-            if (ArrayBuffer.isView(b)) {
-                return Buffer.from(b.buffer, b.byteOffset, b.byteLength).toString("base64");
-            }
-            else {
-                return Buffer.from(b).toString("base64");
-            }
+    class UintOptRleDecoder extends Decoder {
+      /**
+       * @param {Uint8Array} uint8Array
+       */
+      constructor (uint8Array) {
+        super(uint8Array);
+        /**
+         * @type {number}
+         */
+        this.s = 0;
+        this.count = 0;
+      }
+
+      read () {
+        if (this.count === 0) {
+          this.s = readVarInt(this);
+          // if the sign is negative, we read the count too, otherwise count is 1
+          const isNegative = isNegativeZero(this.s);
+          this.count = 1;
+          if (isNegative) {
+            this.s = -this.s;
+            this.count = readVarUint(this) + 2;
+          }
         }
-        : hasArrayBufferToBase64
-            ? (b) => {
-                // Uint8Array.prototype.toBase64 is available in modern browsers
-                const u8a = ArrayBuffer.isView(b) ? b : new Uint8Array(b);
-                // @ts-ignore: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toBase64
-                return u8a.toBase64();
-            }
-            : (b) => {
-                // Legacy DOM workaround
-                const u8a = ArrayBuffer.isView(b) ? b : new Uint8Array(b);
-                const CHUNK_SIZE = 0x1000;
-                const strs = [];
-                for (let i = 0, l = u8a.length; i < l; i += CHUNK_SIZE) {
-                    const chunk = u8a.subarray(i, i + CHUNK_SIZE);
-                    strs.push(String.fromCharCode.apply(null, chunk));
-                }
-                return btoa(strs.join(""));
-            };
+        this.count--;
+        return /** @type {number} */ (this.s)
+      }
+    }
 
-    class TokenErrorResponseError extends Error {
-        constructor({ title, message, messageCode, messageParams, }) {
-            super(message);
-            this.name = 'TokenErrorResponseError';
-            this.title = title;
-            this.messageCode = messageCode;
-            this.messageParams = messageParams;
+    class IntDiffOptRleDecoder extends Decoder {
+      /**
+       * @param {Uint8Array} uint8Array
+       */
+      constructor (uint8Array) {
+        super(uint8Array);
+        /**
+         * @type {number}
+         */
+        this.s = 0;
+        this.count = 0;
+        this.diff = 0;
+      }
+
+      /**
+       * @return {number}
+       */
+      read () {
+        if (this.count === 0) {
+          const diff = readVarInt(this);
+          // if the first bit is set, we read more data
+          const hasCount = diff & 1;
+          this.diff = floor(diff / 2); // shift >> 1
+          this.count = 1;
+          if (hasCount) {
+            this.count = readVarUint(this) + 2;
+          }
         }
+        this.s += this.diff;
+        this.count--;
+        return this.s
+      }
     }
 
-    function interactWithUser(userInteraction, req) {
-        return new Promise((resolve, reject) => {
-            const interactionProps = Object.assign(Object.assign({ submitLabel: 'Submit', cancelLabel: 'Cancel' }, req), { onSubmit: (res) => {
-                    userInteraction.next(undefined);
-                    resolve(res);
-                }, onCancel: () => {
-                    userInteraction.next(undefined);
-                    reject(new Dexie.AbortError('User cancelled'));
-                } });
-            userInteraction.next(interactionProps);
-            // Start subscribing for external updates to db.cloud.userInteraction, and if so, cancel this request.
-            /*const subscription = userInteraction.subscribe((currentInteractionProps) => {
-              if (currentInteractionProps !== interactionProps) {
-                if (subscription) subscription.unsubscribe();
-                if (!done) {
-                  reject(new Dexie.AbortError("User cancelled"));
-                }
-              }
-            });*/
-        });
+    class StringDecoder {
+      /**
+       * @param {Uint8Array} uint8Array
+       */
+      constructor (uint8Array) {
+        this.decoder = new UintOptRleDecoder(uint8Array);
+        this.str = readVarString(this.decoder);
+        /**
+         * @type {number}
+         */
+        this.spos = 0;
+      }
+
+      /**
+       * @return {string}
+       */
+      read () {
+        const end = this.spos + this.decoder.read();
+        const res = this.str.slice(this.spos, end);
+        this.spos = end;
+        return res
+      }
     }
-    function alertUser(userInteraction, title, ...alerts) {
-        return interactWithUser(userInteraction, {
-            type: 'message-alert',
-            title,
-            alerts,
+
+    function decodeYMessage(a) {
+        const decoder = new Decoder(a);
+        const type = readVarString(decoder);
+        if (type === 'outdated-server-rev') {
+            return { type };
+        }
+        if (type === 'y-complete-sync-done') {
+            return { type, yServerRev: readVarString(decoder) };
+        }
+        const table = readVarString(decoder);
+        const prop = readVarString(decoder);
+        switch (type) {
+            case 'u-ack':
+            case 'u-reject':
+                return {
+                    type,
+                    table,
+                    prop,
+                    i: Number(readBigUint64(decoder)),
+                };
+            default: {
+                const k = readAny(decoder);
+                switch (type) {
+                    case 'in-sync':
+                        return { type, table, prop, k };
+                    case 'aware':
+                        return {
+                            type,
+                            table,
+                            prop,
+                            k,
+                            u: readVarUint8Array(decoder),
+                        };
+                    case 'doc-open':
+                        return {
+                            type,
+                            table,
+                            prop,
+                            k,
+                            serverRev: readAny(decoder),
+                            sv: readAny(decoder),
+                        };
+                    case 'doc-close':
+                        return { type, table, prop, k };
+                    case 'sv':
+                        return {
+                            type,
+                            table,
+                            prop,
+                            k,
+                            sv: readVarUint8Array(decoder),
+                        };
+                    case 'u-c':
+                        return {
+                            type,
+                            table,
+                            prop,
+                            k,
+                            u: readVarUint8Array(decoder),
+                            i: Number(readBigUint64(decoder)),
+                        };
+                    case 'u-s':
+                        return {
+                            type,
+                            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) {
+        // 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
+        }
+        // Start running the machine. If the last stage is a sink, it will consume the data and never emit anything
+        // to us here...
+        for await (const chunk of result) { }
+    }
+
+    async function* consumeChunkedBinaryStream(source) {
+        let state = 0;
+        let sizeBuf = new Uint8Array(4);
+        let sizeBufPos = 0;
+        let bufs = [];
+        let len = 0;
+        for await (const chunk of source) {
+            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 concats;
+                            }
+                            else {
+                                yield chunk.slice(pos, pos + len);
+                            }
+                            pos += len;
+                            state = 0;
+                        }
+                        break;
+                }
+            }
+        }
+    }
+
+    function getFetchResponseBodyGenerator(res) {
+        return async function* () {
+            if (!res.body)
+                throw new Error("Response body is not readable");
+            const reader = res.body.getReader();
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        return;
+                    yield value;
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        };
+    }
+
+    //const hasSW = 'serviceWorker' in navigator;
+    let hasComplainedAboutSyncEvent = false;
+    function registerSyncEvent(db, purpose) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Send sync event to SW:
+                const sw = yield navigator.serviceWorker.ready;
+                if (purpose === "push" && sw.sync) {
+                    yield sw.sync.register(`dexie-cloud:${db.name}`);
+                }
+                if (sw.active) {
+                    // Use postMessage for pull syncs and for browsers not supporting sync event (Firefox, Safari).
+                    // Also chromium based browsers with sw.sync as a fallback for sleepy sync events not taking action for a while.
+                    sw.active.postMessage({
+                        type: 'dexie-cloud-sync',
+                        dbName: db.name,
+                        purpose
+                    });
+                }
+                else {
+                    throw new Error(`Failed to trigger sync - there's no active service worker`);
+                }
+                return;
+            }
+            catch (e) {
+                if (!hasComplainedAboutSyncEvent) {
+                    console.debug(`Dexie Cloud: Could not register sync event`, e);
+                    hasComplainedAboutSyncEvent = true;
+                }
+            }
+        });
+    }
+    function registerPeriodicSyncEvent(db) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                // Register periodicSync event to SW:
+                // @ts-ignore
+                const { periodicSync } = yield navigator.serviceWorker.ready;
+                if (periodicSync) {
+                    try {
+                        yield periodicSync.register(`dexie-cloud:${db.name}`, (_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.periodicSync);
+                        console.debug(`Dexie Cloud: Successfully registered periodicsync event for ${db.name}`);
+                    }
+                    catch (e) {
+                        console.debug(`Dexie Cloud: Failed to register periodic sync. Your PWA must be installed to allow background sync.`, e);
+                    }
+                }
+                else {
+                    console.debug(`Dexie Cloud: periodicSync not supported.`);
+                }
+            }
+            catch (e) {
+                console.debug(`Dexie Cloud: Could not register periodicSync for ${db.name}`, e);
+            }
+        });
+    }
+
+    function triggerSync(db, purpose) {
+        if (db.cloud.usingServiceWorker) {
+            console.debug('registering sync event');
+            registerSyncEvent(db, purpose);
+        }
+        else {
+            db.localSyncEvent.next({ purpose });
+        }
+    }
+
+    const hasArrayBufferFromBase64 = "fromBase64" in Uint8Array; // https://github.com/tc39/proposal-arraybuffer-base64;
+    const hasArrayBufferToBase64 = "toBase64" in Uint8Array.prototype; // https://github.com/tc39/proposal-arraybuffer-base64;
+    const b64decode = typeof Buffer !== "undefined"
+        ? (base64) => Buffer.from(base64, "base64") // Node
+        : hasArrayBufferFromBase64
+            ? // @ts-ignore: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/fromBase64
+                (base64) => Uint8Array.fromBase64(base64) // Modern javascript standard
+            : (base64) => {
+                // Legacy DOM workaround
+                const binary_string = atob(base64);
+                const len = binary_string.length;
+                const bytes = new Uint8Array(len);
+                for (var i = 0; i < len; i++) {
+                    bytes[i] = binary_string.charCodeAt(i);
+                }
+                return bytes;
+            };
+    const b64encode = typeof Buffer !== "undefined"
+        ? (b) => {
+            // Node
+            if (ArrayBuffer.isView(b)) {
+                return Buffer.from(b.buffer, b.byteOffset, b.byteLength).toString("base64");
+            }
+            else {
+                return Buffer.from(b).toString("base64");
+            }
+        }
+        : hasArrayBufferToBase64
+            ? (b) => {
+                // Uint8Array.prototype.toBase64 is available in modern browsers
+                const u8a = ArrayBuffer.isView(b) ? b : new Uint8Array(b);
+                // @ts-ignore: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toBase64
+                return u8a.toBase64();
+            }
+            : (b) => {
+                // Legacy DOM workaround
+                const u8a = ArrayBuffer.isView(b) ? b : new Uint8Array(b);
+                const CHUNK_SIZE = 0x1000;
+                const strs = [];
+                for (let i = 0, l = u8a.length; i < l; i += CHUNK_SIZE) {
+                    const chunk = u8a.subarray(i, i + CHUNK_SIZE);
+                    strs.push(String.fromCharCode.apply(null, chunk));
+                }
+                return btoa(strs.join(""));
+            };
+
+    class TokenErrorResponseError extends Error {
+        constructor({ title, message, messageCode, messageParams, }) {
+            super(message);
+            this.name = 'TokenErrorResponseError';
+            this.title = title;
+            this.messageCode = messageCode;
+            this.messageParams = messageParams;
+        }
+    }
+
+    function interactWithUser(userInteraction, req) {
+        return new Promise((resolve, reject) => {
+            const interactionProps = Object.assign(Object.assign({ submitLabel: 'Submit', cancelLabel: 'Cancel' }, req), { onSubmit: (res) => {
+                    userInteraction.next(undefined);
+                    resolve(res);
+                }, onCancel: () => {
+                    userInteraction.next(undefined);
+                    reject(new Dexie.AbortError('User cancelled'));
+                } });
+            userInteraction.next(interactionProps);
+            // Start subscribing for external updates to db.cloud.userInteraction, and if so, cancel this request.
+            /*const subscription = userInteraction.subscribe((currentInteractionProps) => {
+              if (currentInteractionProps !== interactionProps) {
+                if (subscription) subscription.unsubscribe();
+                if (!done) {
+                  reject(new Dexie.AbortError("User cancelled"));
+                }
+              }
+            });*/
+        });
+    }
+    function alertUser(userInteraction, title, ...alerts) {
+        return interactWithUser(userInteraction, {
+            type: 'message-alert',
+            title,
+            alerts,
             fields: {},
             submitLabel: 'OK',
             cancelLabel: null,
@@ -2535,10 +2987,17 @@
                 return true;
             if (mut.keys.length !== 1 || mut.changeSpecs.length !== 1)
                 return true;
+            // Check if this has PropModifications - if so, skip optimization
+            const changeSpecs = mut.changeSpecs[0];
+            if (Object.values(changeSpecs).some(v => typeof v === "object" && v && "@@propmod" in v)) {
+                return true; // Cannot optimize if any PropModification is present
+            }
             // Keep track of properties that aren't overlapped by later transactions
             const unoverlappedProps = new Set(Object.keys(mut.changeSpecs[0]));
             const strKey = '' + mut.keys[0];
             const keyCoverage = updateCoverage.get(strKey);
+            if (!keyCoverage)
+                return true; // No coverage info - cannot optimize
             for (let i = keyCoverage.length - 1; i >= 0; --i) {
                 const { txid, updateSpec } = keyCoverage[i];
                 if (txid === mut.txid)
@@ -3204,7 +3663,8 @@
                 return Object.assign({ $t: 'PropModification' }, propModification['@@propmod']);
             },
             revive: (_a) => {
-                var propModSpec = __rest(_a, ["$t"]) // keep the rest
+                var { $t } = _a, // strip '$t'
+                propModSpec = __rest(_a, ["$t"]) // keep the rest
                 ;
                 return new Dexie.PropModification(propModSpec);
             },
@@ -3381,1748 +3841,456 @@
                     const syncRes = TSON.parse(text);
                     return syncRes;
                 }
-            }
-        });
-    }
-
-    function modifyLocalObjectsWithNewUserId(syncifiedTables, currentUser, alreadySyncedRealms) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ignoredRealms = new Set(alreadySyncedRealms || []);
-            for (const table of syncifiedTables) {
-                if (table.name === "members") {
-                    // members
-                    yield table.toCollection().modify((member) => {
-                        if (!ignoredRealms.has(member.realmId) && (!member.userId || member.userId === UNAUTHORIZED_USER.userId)) {
-                            member.userId = currentUser.userId;
-                        }
-                    });
-                }
-                else if (table.name === "roles") ;
-                else if (table.name === "realms") {
-                    // realms
-                    yield table.toCollection().modify((realm) => {
-                        if (!ignoredRealms.has(realm.realmId) && (realm.owner === undefined || realm.owner === UNAUTHORIZED_USER.userId)) {
-                            realm.owner = currentUser.userId;
-                        }
-                    });
-                }
-                else {
-                    // application entities
-                    yield table.toCollection().modify((obj) => {
-                        if (!obj.realmId || !ignoredRealms.has(obj.realmId)) {
-                            if (!obj.owner || obj.owner === UNAUTHORIZED_USER.userId)
-                                obj.owner = currentUser.userId;
-                            if (!obj.realmId || obj.realmId === UNAUTHORIZED_USER.userId) {
-                                obj.realmId = currentUser.userId;
-                            }
-                        }
-                    });
-                }
-            }
-        });
-    }
-
-    function throwIfCancelled(cancelToken) {
-        if (cancelToken === null || cancelToken === void 0 ? void 0 : cancelToken.cancelled)
-            throw new Dexie.AbortError(`Operation was cancelled`);
-    }
-
-    /* Need this because navigator.onLine seems to say "false" when it is actually online.
-      This function relies initially on navigator.onLine but then uses online and offline events
-      which seem to be more reliable.
-    */
-    let isOnline = false;
-    if (typeof self !== 'undefined' && typeof navigator !== 'undefined') {
-        isOnline = navigator.onLine;
-        self.addEventListener('online', () => isOnline = true);
-        self.addEventListener('offline', () => isOnline = false);
-    }
-
-    function updateBaseRevs(db, schema, latestRevisions, serverRev) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield db.$baseRevs.bulkPut(Object.keys(schema)
-                .filter((table) => schema[table].markedForSync)
-                .map((tableName) => {
-                const lastClientRevOnPreviousServerRev = latestRevisions[tableName] || 0;
-                return {
-                    tableName,
-                    clientRev: lastClientRevOnPreviousServerRev + 1,
-                    serverRev,
-                };
-            }));
-            // Clean up baseRevs for tables that do not exist anymore or are no longer marked for sync
-            // Resolve #2168 by also cleaning up baseRevs for tables that are not marked for sync
-            yield db.$baseRevs.where('tableName').noneOf(Object.keys(schema).filter((table) => schema[table].markedForSync)).delete();
-        });
-    }
-
-    function getLatestRevisionsPerTable(clientChangeSet, lastRevisions = {}) {
-        for (const { table, muts } of clientChangeSet) {
-            const lastRev = muts.length > 0 ? muts[muts.length - 1].rev : null;
-            lastRevisions[table] = lastRev || lastRevisions[table] || 0;
-        }
-        return lastRevisions;
-    }
-
-    function bulkUpdate(table, keys, changeSpecs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const objs = yield table.bulkGet(keys);
-            const resultKeys = [];
-            const resultObjs = [];
-            keys.forEach((key, idx) => {
-                const obj = objs[idx];
-                if (obj) {
-                    for (const [keyPath, value] of Object.entries(changeSpecs[idx])) {
-                        if (keyPath === table.schema.primKey.keyPath) {
-                            if (Dexie.cmp(value, key) !== 0) {
-                                throw new Error(`Cannot change primary key`);
-                            }
-                        }
-                        else {
-                            Dexie.setByKeyPath(obj, keyPath, value);
-                        }
-                    }
-                    resultKeys.push(key);
-                    resultObjs.push(obj);
-                }
-            });
-            yield (table.schema.primKey.keyPath == null
-                ? table.bulkPut(resultObjs, resultKeys)
-                : table.bulkPut(resultObjs));
-        });
-    }
-
-    function applyServerChanges(changes, db) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.debug('Applying server changes', changes, Dexie.currentTransaction);
-            for (const { table: tableName, muts } of changes) {
-                if (!db.dx._allTables[tableName]) {
-                    console.debug(`Server sent changes for table ${tableName} that we don't have. Ignoring.`);
-                    continue;
-                }
-                const table = db.table(tableName);
-                const { primaryKey } = table.core.schema;
-                const keyDecoder = (key) => {
-                    switch (key[0]) {
-                        case '[':
-                            // Decode JSON array
-                            if (key.endsWith(']'))
-                                try {
-                                    // On server, array keys are transformed to JSON string representation
-                                    return JSON.parse(key);
-                                }
-                                catch (_a) { }
-                            return key;
-                        case '#':
-                            // Decode private ID (do the opposite from what's done in encodeIdsForServer())
-                            if (key.endsWith(':' + db.cloud.currentUserId)) {
-                                return key.substr(0, key.length - db.cloud.currentUserId.length - 1);
-                            }
-                            return key;
-                        default:
-                            return key;
-                    }
-                };
-                for (const mut of muts) {
-                    const keys = mut.keys.map(keyDecoder);
-                    switch (mut.type) {
-                        case 'insert':
-                            if (primaryKey.outbound) {
-                                yield table.bulkAdd(mut.values, keys);
-                            }
-                            else {
-                                keys.forEach((key, i) => {
-                                    // Make sure inbound keys are consistent
-                                    Dexie.setByKeyPath(mut.values[i], primaryKey.keyPath, key);
-                                });
-                                yield table.bulkAdd(mut.values);
-                            }
-                            break;
-                        case 'upsert':
-                            if (primaryKey.outbound) {
-                                yield table.bulkPut(mut.values, keys);
-                            }
-                            else {
-                                keys.forEach((key, i) => {
-                                    // Make sure inbound keys are consistent
-                                    Dexie.setByKeyPath(mut.values[i], primaryKey.keyPath, key);
-                                });
-                                yield table.bulkPut(mut.values);
-                            }
-                            break;
-                        case 'modify':
-                            if (keys.length === 1) {
-                                yield table.update(keys[0], mut.changeSpec);
-                            }
-                            else {
-                                yield table.where(':id').anyOf(keys).modify(mut.changeSpec);
-                            }
-                            break;
-                        case 'update':
-                            yield bulkUpdate(table, keys, mut.changeSpecs);
-                            break;
-                        case 'delete':
-                            yield table.bulkDelete(keys);
-                            break;
-                    }
-                }
-            }
-        });
-    }
-
-    const DEXIE_CLOUD_SYNCER_ID = 'dexie-cloud-syncer';
-
-    function listUpdatesSince(yTable, sinceIncluding) {
-        return yTable
-            .where('i')
-            .between(sinceIncluding, Infinity, true)
-            .toArray();
-    }
-
-    /**
-     * Utility module to work with key-value stores.
-     *
-     * @module map
-     */
-
-    /**
-     * Creates a new Map instance.
-     *
-     * @function
-     * @return {Map<any, any>}
-     *
-     * @function
-     */
-    const create$5 = () => new Map();
-
-    /**
-     * Copy a Map object into a fresh Map object.
-     *
-     * @function
-     * @template K,V
-     * @param {Map<K,V>} m
-     * @return {Map<K,V>}
-     */
-    const copy = m => {
-      const r = create$5();
-      m.forEach((v, k) => { r.set(k, v); });
-      return r
-    };
-
-    /**
-     * Get map property. Create T if property is undefined and set T on map.
-     *
-     * ```js
-     * const listeners = map.setIfUndefined(events, 'eventName', set.create)
-     * listeners.add(listener)
-     * ```
-     *
-     * @function
-     * @template {Map<any, any>} MAP
-     * @template {MAP extends Map<any,infer V> ? function():V : unknown} CF
-     * @param {MAP} map
-     * @param {MAP extends Map<infer K,any> ? K : unknown} key
-     * @param {CF} createT
-     * @return {ReturnType<CF>}
-     */
-    const setIfUndefined = (map, key, createT) => {
-      let set = map.get(key);
-      if (set === undefined) {
-        map.set(key, set = createT());
-      }
-      return set
-    };
-
-    /**
-     * Creates an Array and populates it with the content of all key-value pairs using the `f(value, key)` function.
-     *
-     * @function
-     * @template K
-     * @template V
-     * @template R
-     * @param {Map<K,V>} m
-     * @param {function(V,K):R} f
-     * @return {Array<R>}
-     */
-    const map = (m, f) => {
-      const res = [];
-      for (const [key, value] of m) {
-        res.push(f(value, key));
-      }
-      return res
-    };
-
-    /**
-     * Tests whether any key-value pairs pass the test implemented by `f(value, key)`.
-     *
-     * @todo should rename to some - similarly to Array.some
-     *
-     * @function
-     * @template K
-     * @template V
-     * @param {Map<K,V>} m
-     * @param {function(V,K):boolean} f
-     * @return {boolean}
-     */
-    const any = (m, f) => {
-      for (const [key, value] of m) {
-        if (f(value, key)) {
-          return true
-        }
-      }
-      return false
-    };
-
-    /**
-     * Utility module to work with sets.
-     *
-     * @module set
-     */
-
-    const create$4 = () => new Set();
-
-    /**
-     * Utility module to work with Arrays.
-     *
-     * @module array
-     */
-
-
-    /**
-     * Return the last element of an array. The element must exist
-     *
-     * @template L
-     * @param {ArrayLike<L>} arr
-     * @return {L}
-     */
-    const last = arr => arr[arr.length - 1];
-
-    /**
-     * Append elements from src to dest
-     *
-     * @template M
-     * @param {Array<M>} dest
-     * @param {Array<M>} src
-     */
-    const appendTo = (dest, src) => {
-      for (let i = 0; i < src.length; i++) {
-        dest.push(src[i]);
-      }
-    };
-
-    /**
-     * Transforms something array-like to an actual Array.
-     *
-     * @function
-     * @template T
-     * @param {ArrayLike<T>|Iterable<T>} arraylike
-     * @return {T}
-     */
-    const from = Array.from;
-
-    const isArray = Array.isArray;
-
-    /**
-     * Observable class prototype.
-     *
-     * @module observable
-     */
-
-
-    /**
-     * Handles named events.
-     * @experimental
-     *
-     * This is basically a (better typed) duplicate of Observable, which will replace Observable in the
-     * next release.
-     *
-     * @template {{[key in keyof EVENTS]: function(...any):void}} EVENTS
-     */
-    class ObservableV2 {
-      constructor () {
-        /**
-         * Some desc.
-         * @type {Map<string, Set<any>>}
-         */
-        this._observers = create$5();
-      }
-
-      /**
-       * @template {keyof EVENTS & string} NAME
-       * @param {NAME} name
-       * @param {EVENTS[NAME]} f
-       */
-      on (name, f) {
-        setIfUndefined(this._observers, /** @type {string} */ (name), create$4).add(f);
-        return f
-      }
-
-      /**
-       * @template {keyof EVENTS & string} NAME
-       * @param {NAME} name
-       * @param {EVENTS[NAME]} f
-       */
-      once (name, f) {
-        /**
-         * @param  {...any} args
-         */
-        const _f = (...args) => {
-          this.off(name, /** @type {any} */ (_f));
-          f(...args);
-        };
-        this.on(name, /** @type {any} */ (_f));
-      }
-
-      /**
-       * @template {keyof EVENTS & string} NAME
-       * @param {NAME} name
-       * @param {EVENTS[NAME]} f
-       */
-      off (name, f) {
-        const observers = this._observers.get(name);
-        if (observers !== undefined) {
-          observers.delete(f);
-          if (observers.size === 0) {
-            this._observers.delete(name);
-          }
-        }
-      }
-
-      /**
-       * Emit a named event. All registered event listeners that listen to the
-       * specified name will receive the event.
-       *
-       * @todo This should catch exceptions
-       *
-       * @template {keyof EVENTS & string} NAME
-       * @param {NAME} name The event name.
-       * @param {Parameters<EVENTS[NAME]>} args The arguments that are applied to the event listener.
-       */
-      emit (name, args) {
-        // copy all listeners to an array first to make sure that no event is emitted to listeners that are subscribed while the event handler is called.
-        return from((this._observers.get(name) || create$5()).values()).forEach(f => f(...args))
-      }
-
-      destroy () {
-        this._observers = create$5();
-      }
-    }
-
-    /* c8 ignore start */
-    /**
-     * Handles named events.
-     *
-     * @deprecated
-     * @template N
-     */
-    class Observable {
-      constructor () {
-        /**
-         * Some desc.
-         * @type {Map<N, any>}
-         */
-        this._observers = create$5();
-      }
-
-      /**
-       * @param {N} name
-       * @param {function} f
-       */
-      on (name, f) {
-        setIfUndefined(this._observers, name, create$4).add(f);
-      }
-
-      /**
-       * @param {N} name
-       * @param {function} f
-       */
-      once (name, f) {
-        /**
-         * @param  {...any} args
-         */
-        const _f = (...args) => {
-          this.off(name, _f);
-          f(...args);
-        };
-        this.on(name, _f);
-      }
-
-      /**
-       * @param {N} name
-       * @param {function} f
-       */
-      off (name, f) {
-        const observers = this._observers.get(name);
-        if (observers !== undefined) {
-          observers.delete(f);
-          if (observers.size === 0) {
-            this._observers.delete(name);
-          }
-        }
-      }
-
-      /**
-       * Emit a named event. All registered event listeners that listen to the
-       * specified name will receive the event.
-       *
-       * @todo This should catch exceptions
-       *
-       * @param {N} name The event name.
-       * @param {Array<any>} args The arguments that are applied to the event listener.
-       */
-      emit (name, args) {
-        // copy all listeners to an array first to make sure that no event is emitted to listeners that are subscribed while the event handler is called.
-        return from((this._observers.get(name) || create$5()).values()).forEach(f => f(...args))
-      }
-
-      destroy () {
-        this._observers = create$5();
-      }
-    }
-    /* c8 ignore end */
-
-    /**
-     * 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 */
-
-    /**
-     * Binary data constants.
-     *
-     * @module binary
-     */
-
-    /**
-     * n-th bit activated.
-     *
-     * @type {number}
-     */
-    const BIT1 = 1;
-    const BIT2 = 2;
-    const BIT3 = 4;
-    const BIT4 = 8;
-    const BIT6 = 32;
-    const BIT7 = 64;
-    const BIT8 = 128;
-    const BITS5 = 31;
-    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);
-
-    /**
-     * @param {string} s
-     * @return {string}
-     */
-    const toLowerCase = s => s.toLowerCase();
-
-    const trimLeftRegex = /^\s*/g;
-
-    /**
-     * @param {string} s
-     * @return {string}
-     */
-    const trimLeft = s => s.replace(trimLeftRegex, '');
-
-    const fromCamelCaseRegex = /([A-Z])/g;
-
-    /**
-     * @param {string} s
-     * @param {string} separator
-     * @return {string}
-     */
-    const fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, match => `${separator}${toLowerCase(match)}`));
-
-    /**
-     * @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 = [];
-      }
-    }
-
-    /**
-     * @function
-     * @return {Encoder}
-     */
-    const createEncoder = () => new Encoder();
-
-    /**
-     * The current length of the encoded data.
-     *
-     * @function
-     * @param {Encoder} encoder
-     * @return {number}
-     */
-    const length$1 = 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$1(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 one byte as an unsigned integer.
-     *
-     * @function
-     * @param {Encoder} encoder
-     * @param {number} num The number that is to be encoded.
-     */
-    const writeUint8 = write;
-
-    /**
-     * 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;
-
-    /**
-     * Write the content of another Encoder.
-     *
-     * @TODO: can be improved!
-     *        - Note: Should consider that when appending a lot of small Encoders, we should rather clone than referencing the old structure.
-     *                Encoders start with a rather big initial buffer.
-     *
-     * @function
-     * @param {Encoder} encoder The enUint8Arr
-     * @param {Encoder} append The BinaryEncoder to be written.
-     */
-    const writeBinaryEncoder = (encoder, append) => writeUint8Array(encoder, toUint8Array(append));
-
-    /**
-     * 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);
-
-    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);
-      }
-    };
-
-    /**
-     * Now come a few stateful encoder that have their own classes.
-     */
-
-    /**
-     * Basic Run Length Encoder - a basic compression implementation.
-     *
-     * Encodes [1,1,1,7] to [1,3,7,1] (3 times 1, 1 time 7). This encoder might do more harm than good if there are a lot of values that are not repeated.
-     *
-     * It was originally used for image compression. Cool .. article http://csbruce.com/cbm/transactor/pdfs/trans_v7_i06.pdf
-     *
-     * @note T must not be null!
-     *
-     * @template T
-     */
-    class RleEncoder extends Encoder {
-      /**
-       * @param {function(Encoder, T):void} writer
-       */
-      constructor (writer) {
-        super();
-        /**
-         * The writer
-         */
-        this.w = writer;
-        /**
-         * Current state
-         * @type {T|null}
-         */
-        this.s = null;
-        this.count = 0;
-      }
-
-      /**
-       * @param {T} v
-       */
-      write (v) {
-        if (this.s === v) {
-          this.count++;
-        } else {
-          if (this.count > 0) {
-            // flush counter, unless this is the first value (count = 0)
-            writeVarUint(this, this.count - 1); // since count is always > 0, we can decrement by one. non-standard encoding ftw
-          }
-          this.count = 1;
-          // write first value
-          this.w(this, v);
-          this.s = v;
-        }
-      }
-    }
-
-    /**
-     * @param {UintOptRleEncoder} encoder
-     */
-    const flushUintOptRleEncoder = encoder => {
-      if (encoder.count > 0) {
-        // flush counter, unless this is the first value (count = 0)
-        // case 1: just a single value. set sign to positive
-        // case 2: write several values. set sign to negative to indicate that there is a length coming
-        writeVarInt(encoder.encoder, encoder.count === 1 ? encoder.s : -encoder.s);
-        if (encoder.count > 1) {
-          writeVarUint(encoder.encoder, encoder.count - 2); // since count is always > 1, we can decrement by one. non-standard encoding ftw
-        }
-      }
-    };
-
-    /**
-     * Optimized Rle encoder that does not suffer from the mentioned problem of the basic Rle encoder.
-     *
-     * Internally uses VarInt encoder to write unsigned integers. If the input occurs multiple times, we write
-     * write it as a negative number. The UintOptRleDecoder then understands that it needs to read a count.
-     *
-     * Encodes [1,2,3,3,3] as [1,2,-3,3] (once 1, once 2, three times 3)
-     */
-    class UintOptRleEncoder {
-      constructor () {
-        this.encoder = new Encoder();
-        /**
-         * @type {number}
-         */
-        this.s = 0;
-        this.count = 0;
-      }
-
-      /**
-       * @param {number} v
-       */
-      write (v) {
-        if (this.s === v) {
-          this.count++;
-        } else {
-          flushUintOptRleEncoder(this);
-          this.count = 1;
-          this.s = v;
-        }
-      }
-
-      /**
-       * Flush the encoded state and transform this to a Uint8Array.
-       *
-       * Note that this should only be called once.
-       */
-      toUint8Array () {
-        flushUintOptRleEncoder(this);
-        return toUint8Array(this.encoder)
-      }
-    }
-
-    /**
-     * @param {IntDiffOptRleEncoder} encoder
-     */
-    const flushIntDiffOptRleEncoder = encoder => {
-      if (encoder.count > 0) {
-        //          31 bit making up the diff | wether to write the counter
-        // const encodedDiff = encoder.diff << 1 | (encoder.count === 1 ? 0 : 1)
-        const encodedDiff = encoder.diff * 2 + (encoder.count === 1 ? 0 : 1);
-        // flush counter, unless this is the first value (count = 0)
-        // case 1: just a single value. set first bit to positive
-        // case 2: write several values. set first bit to negative to indicate that there is a length coming
-        writeVarInt(encoder.encoder, encodedDiff);
-        if (encoder.count > 1) {
-          writeVarUint(encoder.encoder, encoder.count - 2); // since count is always > 1, we can decrement by one. non-standard encoding ftw
-        }
-      }
-    };
-
-    /**
-     * A combination of the IntDiffEncoder and the UintOptRleEncoder.
-     *
-     * The count approach is similar to the UintDiffOptRleEncoder, but instead of using the negative bitflag, it encodes
-     * in the LSB whether a count is to be read. Therefore this Encoder only supports 31 bit integers!
-     *
-     * Encodes [1, 2, 3, 2] as [3, 1, 6, -1] (more specifically [(1 << 1) | 1, (3 << 0) | 0, -1])
-     *
-     * Internally uses variable length encoding. Contrary to normal UintVar encoding, the first byte contains:
-     * * 1 bit that denotes whether the next value is a count (LSB)
-     * * 1 bit that denotes whether this value is negative (MSB - 1)
-     * * 1 bit that denotes whether to continue reading the variable length integer (MSB)
-     *
-     * Therefore, only five bits remain to encode diff ranges.
-     *
-     * Use this Encoder only when appropriate. In most cases, this is probably a bad idea.
-     */
-    class IntDiffOptRleEncoder {
-      constructor () {
-        this.encoder = new Encoder();
-        /**
-         * @type {number}
-         */
-        this.s = 0;
-        this.count = 0;
-        this.diff = 0;
-      }
-
-      /**
-       * @param {number} v
-       */
-      write (v) {
-        if (this.diff === v - this.s) {
-          this.s = v;
-          this.count++;
-        } else {
-          flushIntDiffOptRleEncoder(this);
-          this.count = 1;
-          this.diff = v - this.s;
-          this.s = v;
-        }
-      }
-
-      /**
-       * Flush the encoded state and transform this to a Uint8Array.
-       *
-       * Note that this should only be called once.
-       */
-      toUint8Array () {
-        flushIntDiffOptRleEncoder(this);
-        return toUint8Array(this.encoder)
-      }
+            }
+        });
     }
 
-    /**
-     * Optimized String Encoder.
-     *
-     * Encoding many small strings in a simple Encoder is not very efficient. The function call to decode a string takes some time and creates references that must be eventually deleted.
-     * In practice, when decoding several million small strings, the GC will kick in more and more often to collect orphaned string objects (or maybe there is another reason?).
-     *
-     * This string encoder solves the above problem. All strings are concatenated and written as a single string using a single encoding call.
-     *
-     * The lengths are encoded using a UintOptRleEncoder.
-     */
-    class StringEncoder {
-      constructor () {
-        /**
-         * @type {Array<string>}
-         */
-        this.sarr = [];
-        this.s = '';
-        this.lensE = new UintOptRleEncoder();
-      }
-
-      /**
-       * @param {string} string
-       */
-      write (string) {
-        this.s += string;
-        if (this.s.length > 19) {
-          this.sarr.push(this.s);
-          this.s = '';
-        }
-        this.lensE.write(string.length);
-      }
-
-      toUint8Array () {
-        const encoder = new Encoder();
-        this.sarr.push(this.s);
-        this.s = '';
-        writeVarString(encoder, this.sarr.join(''));
-        writeUint8Array(encoder, this.lensE.toUint8Array());
-        return toUint8Array(encoder)
-      }
+    function modifyLocalObjectsWithNewUserId(syncifiedTables, currentUser, alreadySyncedRealms) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ignoredRealms = new Set(alreadySyncedRealms || []);
+            for (const table of syncifiedTables) {
+                if (table.name === "members") {
+                    // members
+                    yield table.toCollection().modify((member) => {
+                        if (!ignoredRealms.has(member.realmId) && (!member.userId || member.userId === UNAUTHORIZED_USER.userId)) {
+                            member.userId = currentUser.userId;
+                        }
+                    });
+                }
+                else if (table.name === "roles") ;
+                else if (table.name === "realms") {
+                    // realms
+                    yield table.toCollection().modify((realm) => {
+                        if (!ignoredRealms.has(realm.realmId) && (realm.owner === undefined || realm.owner === UNAUTHORIZED_USER.userId)) {
+                            realm.owner = currentUser.userId;
+                        }
+                    });
+                }
+                else {
+                    // application entities
+                    yield table.toCollection().modify((obj) => {
+                        if (!obj.realmId || !ignoredRealms.has(obj.realmId)) {
+                            if (!obj.owner || obj.owner === UNAUTHORIZED_USER.userId)
+                                obj.owner = currentUser.userId;
+                            if (!obj.realmId || obj.realmId === UNAUTHORIZED_USER.userId) {
+                                obj.realmId = currentUser.userId;
+                            }
+                        }
+                    });
+                }
+            }
+        });
     }
 
-    /**
-     * Error helpers.
-     *
-     * @module error
-     */
-
-    /**
-     * @param {string} s
-     * @return {Error}
-     */
-    /* c8 ignore next */
-    const create$3 = s => new Error(s);
-
-    /**
-     * @throws {Error}
-     * @return {never}
-     */
-    /* c8 ignore next 3 */
-    const methodUnimplemented = () => {
-      throw create$3('Method unimplemented')
-    };
+    function throwIfCancelled(cancelToken) {
+        if (cancelToken === null || cancelToken === void 0 ? void 0 : cancelToken.cancelled)
+            throw new Dexie.AbortError(`Operation was cancelled`);
+    }
 
-    /**
-     * @throws {Error}
-     * @return {never}
-     */
-    /* c8 ignore next 3 */
-    const unexpectedCase = () => {
-      throw create$3('Unexpected case')
-    };
+    /* Need this because navigator.onLine seems to say "false" when it is actually online.
+      This function relies initially on navigator.onLine but then uses online and offline events
+      which seem to be more reliable.
+    */
+    let isOnline = false;
+    if (typeof self !== 'undefined' && typeof navigator !== 'undefined') {
+        isOnline = navigator.onLine;
+        self.addEventListener('online', () => isOnline = true);
+        self.addEventListener('offline', () => isOnline = false);
+    }
 
-    /**
-     * 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
-     */
+    function updateBaseRevs(db, schema, latestRevisions, serverRev) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield db.$baseRevs.bulkPut(Object.keys(schema)
+                .filter((table) => schema[table].markedForSync)
+                .map((tableName) => {
+                const lastClientRevOnPreviousServerRev = latestRevisions[tableName] || 0;
+                return {
+                    tableName,
+                    clientRev: lastClientRevOnPreviousServerRev + 1,
+                    serverRev,
+                };
+            }));
+            // Clean up baseRevs for tables that do not exist anymore or are no longer marked for sync
+            // Resolve #2168 by also cleaning up baseRevs for tables that are not marked for sync
+            yield db.$baseRevs.where('tableName').noneOf(Object.keys(schema).filter((table) => schema[table].markedForSync)).delete();
+        });
+    }
 
+    function getLatestRevisionsPerTable(clientChangeSet, lastRevisions = {}) {
+        for (const { table, muts } of clientChangeSet) {
+            const lastRev = muts.length > 0 ? muts[muts.length - 1].rev : null;
+            lastRevisions[table] = lastRev || lastRevisions[table] || 0;
+        }
+        return lastRevisions;
+    }
 
-    const errorUnexpectedEndOfArray = create$3('Unexpected end of array');
-    const errorIntegerOutOfRange = create$3('Integer out of Range');
+    function bulkUpdate(table, keys, changeSpecs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const objs = yield table.bulkGet(keys);
+            const resultKeys = [];
+            const resultObjs = [];
+            keys.forEach((key, idx) => {
+                const obj = objs[idx];
+                if (obj) {
+                    for (const [keyPath, value] of Object.entries(changeSpecs[idx])) {
+                        if (keyPath === table.schema.primKey.keyPath) {
+                            if (Dexie.cmp(value, key) !== 0) {
+                                throw new Error(`Cannot change primary key`);
+                            }
+                        }
+                        else {
+                            Dexie.setByKeyPath(obj, keyPath, value);
+                        }
+                    }
+                    resultKeys.push(key);
+                    resultObjs.push(obj);
+                }
+            });
+            yield (table.schema.primKey.keyPath == null
+                ? table.bulkPut(resultObjs, resultKeys)
+                : table.bulkPut(resultObjs));
+        });
+    }
 
-    /**
-     * 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 applyServerChanges(changes, db) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.debug('Applying server changes', changes, Dexie.currentTransaction);
+            for (const { table: tableName, muts } of changes) {
+                if (!db.dx._allTables[tableName]) {
+                    console.debug(`Server sent changes for table ${tableName} that we don't have. Ignoring.`);
+                    continue;
+                }
+                const table = db.table(tableName);
+                const { primaryKey } = table.core.schema;
+                const keyDecoder = (key) => {
+                    switch (key[0]) {
+                        case '[':
+                            // Decode JSON array
+                            if (key.endsWith(']'))
+                                try {
+                                    // On server, array keys are transformed to JSON string representation
+                                    return JSON.parse(key);
+                                }
+                                catch (_a) { }
+                            return key;
+                        case '#':
+                            // Decode private ID (do the opposite from what's done in encodeIdsForServer())
+                            if (key.endsWith(':' + db.cloud.currentUserId)) {
+                                return key.substr(0, key.length - db.cloud.currentUserId.length - 1);
+                            }
+                            return key;
+                        default:
+                            return key;
+                    }
+                };
+                for (const mut of muts) {
+                    const keys = mut.keys.map(keyDecoder);
+                    switch (mut.type) {
+                        case 'insert':
+                            if (primaryKey.outbound) {
+                                yield table.bulkAdd(mut.values, keys);
+                            }
+                            else {
+                                keys.forEach((key, i) => {
+                                    // Make sure inbound keys are consistent
+                                    Dexie.setByKeyPath(mut.values[i], primaryKey.keyPath, key);
+                                });
+                                yield table.bulkAdd(mut.values);
+                            }
+                            break;
+                        case 'upsert':
+                            if (primaryKey.outbound) {
+                                yield table.bulkPut(mut.values, keys);
+                            }
+                            else {
+                                keys.forEach((key, i) => {
+                                    // Make sure inbound keys are consistent
+                                    Dexie.setByKeyPath(mut.values[i], primaryKey.keyPath, key);
+                                });
+                                yield table.bulkPut(mut.values);
+                            }
+                            break;
+                        case 'modify':
+                            if (keys.length === 1) {
+                                yield table.update(keys[0], mut.changeSpec);
+                            }
+                            else {
+                                yield table.where(':id').anyOf(keys).modify(mut.changeSpec);
+                            }
+                            break;
+                        case 'update':
+                            yield bulkUpdate(table, keys, mut.changeSpecs);
+                            break;
+                        case 'delete':
+                            yield table.bulkDelete(keys);
+                            break;
+                    }
+                }
+            }
+        });
     }
 
-    /**
-     * @function
-     * @param {Uint8Array} uint8Array
-     * @return {Decoder}
-     */
-    const createDecoder = uint8Array => new Decoder(uint8Array);
+    const DEXIE_CLOUD_SYNCER_ID = 'dexie-cloud-syncer';
 
-    /**
-     * @function
-     * @param {Decoder} decoder
-     * @return {boolean}
-     */
-    const hasContent = decoder => decoder.pos !== decoder.arr.length;
+    function listUpdatesSince(yTable, sinceIncluding) {
+        return yTable
+            .where('i')
+            .between(sinceIncluding, Infinity, true)
+            .toArray();
+    }
 
     /**
-     * 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.
+     * Utility module to work with key-value stores.
      *
-     * @function
-     * @param {Decoder} decoder The decoder instance
-     * @param {number} len The length of bytes to read
-     * @return {Uint8Array}
+     * @module map
      */
-    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.
+     * Creates a new Map instance.
      *
      * @function
-     * @param {Decoder} decoder
-     * @return {Uint8Array}
-     */
-    const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint(decoder));
-
-    /**
-     * Read one byte as unsigned integer.
+     * @return {Map<any, any>}
+     *
      * @function
-     * @param {Decoder} decoder The decoder instance
-     * @return {number} Unsigned 8-bit integer
      */
-    const readUint8 = decoder => decoder.arr[decoder.pos++];
+    const create$3 = () => new Map();
 
     /**
-     * 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
+     * Copy a Map object into a fresh Map object.
      *
      * @function
-     * @param {Decoder} decoder
-     * @return {number} An unsigned integer.length
+     * @template K,V
+     * @param {Map<K,V>} m
+     * @return {Map<K,V>}
      */
-    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
+    const copy = m => {
+      const r = create$3();
+      m.forEach((v, k) => { r.set(k, v); });
+      return r
     };
 
     /**
-     * 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.
+     * Get map property. Create T if property is undefined and set T on map.
+     *
+     * ```js
+     * const listeners = map.setIfUndefined(events, 'eventName', set.create)
+     * listeners.add(listener)
+     * ```
      *
      * @function
-     * @param {Decoder} decoder
-     * @return {number} An unsigned integer.length
+     * @template {Map<any, any>} MAP
+     * @template {MAP extends Map<any,infer V> ? function():V : unknown} CF
+     * @param {MAP} map
+     * @param {MAP extends Map<infer K,any> ? K : unknown} key
+     * @param {CF} createT
+     * @return {ReturnType<CF>}
      */
-    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 */
+    const setIfUndefined = (map, key, createT) => {
+      let set = map.get(key);
+      if (set === undefined) {
+        map.set(key, set = createT());
       }
-      throw errorUnexpectedEndOfArray
+      return set
     };
 
     /**
-     * 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.
+     * Creates an Array and populates it with the content of all key-value pairs using the `f(value, key)` function.
      *
      * @function
-     * @param {Decoder} decoder
-     * @return {String} The read String.
+     * @template K
+     * @template V
+     * @template R
+     * @param {Map<K,V>} m
+     * @param {function(V,K):R} f
+     * @return {Array<R>}
      */
-    /* 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))
+    const map = (m, f) => {
+      const res = [];
+      for (const [key, value] of m) {
+        res.push(f(value, key));
       }
+      return res
     };
-    /* 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
+     * Tests whether any key-value pairs pass the test implemented by `f(value, key)`.
      *
-     * @function
-     * @param {Decoder} decoder
-     * @return {String} The read String
+     * @todo should rename to some - similarly to Array.some
      *
+     * @function
+     * @template K
+     * @template V
+     * @param {Map<K,V>} m
+     * @param {function(V,K):boolean} f
+     * @return {boolean}
      */
-    /* 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);
+    const any = (m, f) => {
+      for (const [key, value] of m) {
+        if (f(value, key)) {
+          return true
+        }
+      }
+      return false
+    };
 
     /**
-     * @param {Decoder} decoder
+     * Observable class prototype.
+     *
+     * @module observable
      */
-    const readFloat64 = decoder => readFromDataView(decoder, 8).getFloat64(0, false);
 
-    /**
-     * @param {Decoder} decoder
-     */
-    const readBigInt64 = decoder => /** @type {any} */ (readFromDataView(decoder, 8)).getBigInt64(0, false);
 
     /**
-     * @type {Array<function(Decoder):any>}
+     * Handles named events.
+     * @experimental
+     *
+     * This is basically a (better typed) duplicate of Observable, which will replace Observable in the
+     * next release.
+     *
+     * @template {{[key in keyof EVENTS]: function(...any):void}} EVENTS
      */
-    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);
+    class ObservableV2 {
+      constructor () {
         /**
-         * @type {Object<string,any>}
+         * Some desc.
+         * @type {Map<string, Set<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
-    ];
+        this._observers = create$3();
+      }
 
-    /**
-     * @param {Decoder} decoder
-     */
-    const readAny = decoder => readAnyLookupTable[127 - readUint8(decoder)](decoder);
+      /**
+       * @template {keyof EVENTS & string} NAME
+       * @param {NAME} name
+       * @param {EVENTS[NAME]} f
+       */
+      on (name, f) {
+        setIfUndefined(this._observers, /** @type {string} */ (name), create$5).add(f);
+        return f
+      }
 
-    /**
-     * T must not be null.
-     *
-     * @template T
-     */
-    class RleDecoder extends Decoder {
       /**
-       * @param {Uint8Array} uint8Array
-       * @param {function(Decoder):T} reader
+       * @template {keyof EVENTS & string} NAME
+       * @param {NAME} name
+       * @param {EVENTS[NAME]} f
        */
-      constructor (uint8Array, reader) {
-        super(uint8Array);
-        /**
-         * The reader
-         */
-        this.reader = reader;
+      once (name, f) {
         /**
-         * Current state
-         * @type {T|null}
+         * @param  {...any} args
          */
-        this.s = null;
-        this.count = 0;
+        const _f = (...args) => {
+          this.off(name, /** @type {any} */ (_f));
+          f(...args);
+        };
+        this.on(name, /** @type {any} */ (_f));
       }
 
-      read () {
-        if (this.count === 0) {
-          this.s = this.reader(this);
-          if (hasContent(this)) {
-            this.count = readVarUint(this) + 1; // see encoder implementation for the reason why this is incremented
-          } else {
-            this.count = -1; // read the current value forever
+      /**
+       * @template {keyof EVENTS & string} NAME
+       * @param {NAME} name
+       * @param {EVENTS[NAME]} f
+       */
+      off (name, f) {
+        const observers = this._observers.get(name);
+        if (observers !== undefined) {
+          observers.delete(f);
+          if (observers.size === 0) {
+            this._observers.delete(name);
           }
         }
-        this.count--;
-        return /** @type {T} */ (this.s)
       }
-    }
 
-    class UintOptRleDecoder extends Decoder {
       /**
-       * @param {Uint8Array} uint8Array
+       * Emit a named event. All registered event listeners that listen to the
+       * specified name will receive the event.
+       *
+       * @todo This should catch exceptions
+       *
+       * @template {keyof EVENTS & string} NAME
+       * @param {NAME} name The event name.
+       * @param {Parameters<EVENTS[NAME]>} args The arguments that are applied to the event listener.
        */
-      constructor (uint8Array) {
-        super(uint8Array);
+      emit (name, args) {
+        // copy all listeners to an array first to make sure that no event is emitted to listeners that are subscribed while the event handler is called.
+        return from((this._observers.get(name) || create$3()).values()).forEach(f => f(...args))
+      }
+
+      destroy () {
+        this._observers = create$3();
+      }
+    }
+
+    /* c8 ignore start */
+    /**
+     * Handles named events.
+     *
+     * @deprecated
+     * @template N
+     */
+    class Observable {
+      constructor () {
         /**
-         * @type {number}
+         * Some desc.
+         * @type {Map<N, any>}
          */
-        this.s = 0;
-        this.count = 0;
+        this._observers = create$3();
       }
 
-      read () {
-        if (this.count === 0) {
-          this.s = readVarInt(this);
-          // if the sign is negative, we read the count too, otherwise count is 1
-          const isNegative = isNegativeZero(this.s);
-          this.count = 1;
-          if (isNegative) {
-            this.s = -this.s;
-            this.count = readVarUint(this) + 2;
-          }
-        }
-        this.count--;
-        return /** @type {number} */ (this.s)
+      /**
+       * @param {N} name
+       * @param {function} f
+       */
+      on (name, f) {
+        setIfUndefined(this._observers, name, create$5).add(f);
       }
-    }
 
-    class IntDiffOptRleDecoder extends Decoder {
       /**
-       * @param {Uint8Array} uint8Array
+       * @param {N} name
+       * @param {function} f
        */
-      constructor (uint8Array) {
-        super(uint8Array);
+      once (name, f) {
         /**
-         * @type {number}
+         * @param  {...any} args
          */
-        this.s = 0;
-        this.count = 0;
-        this.diff = 0;
+        const _f = (...args) => {
+          this.off(name, _f);
+          f(...args);
+        };
+        this.on(name, _f);
       }
 
       /**
-       * @return {number}
+       * @param {N} name
+       * @param {function} f
        */
-      read () {
-        if (this.count === 0) {
-          const diff = readVarInt(this);
-          // if the first bit is set, we read more data
-          const hasCount = diff & 1;
-          this.diff = floor(diff / 2); // shift >> 1
-          this.count = 1;
-          if (hasCount) {
-            this.count = readVarUint(this) + 2;
+      off (name, f) {
+        const observers = this._observers.get(name);
+        if (observers !== undefined) {
+          observers.delete(f);
+          if (observers.size === 0) {
+            this._observers.delete(name);
           }
         }
-        this.s += this.diff;
-        this.count--;
-        return this.s
       }
-    }
 
-    class StringDecoder {
       /**
-       * @param {Uint8Array} uint8Array
+       * Emit a named event. All registered event listeners that listen to the
+       * specified name will receive the event.
+       *
+       * @todo This should catch exceptions
+       *
+       * @param {N} name The event name.
+       * @param {Array<any>} args The arguments that are applied to the event listener.
        */
-      constructor (uint8Array) {
-        this.decoder = new UintOptRleDecoder(uint8Array);
-        this.str = readVarString(this.decoder);
-        /**
-         * @type {number}
-         */
-        this.spos = 0;
+      emit (name, args) {
+        // copy all listeners to an array first to make sure that no event is emitted to listeners that are subscribed while the event handler is called.
+        return from((this._observers.get(name) || create$3()).values()).forEach(f => f(...args))
       }
 
-      /**
-       * @return {string}
-       */
-      read () {
-        const end = this.spos + this.decoder.read();
-        const res = this.str.slice(this.spos, end);
-        this.spos = end;
-        return res
+      destroy () {
+        this._observers = create$3();
       }
     }
+    /* c8 ignore end */
 
     /* eslint-env browser */
 
@@ -5303,10 +4471,10 @@
     const size = obj => keys(obj).length;
 
     /**
-     * @param {Object|undefined} obj
+     * @param {Object|null|undefined} obj
      */
     const isEmpty = obj => {
-      // eslint-disable-next-line
+      // eslint-disable-next-line no-unreachable-loop
       for (const _k in obj) {
         return false
       }
@@ -5314,8 +4482,9 @@
     };
 
     /**
-     * @param {Object<string,any>} obj
-     * @param {function(any,string):boolean} f
+     * @template {{ [key:string|number|symbol]: any }} T
+     * @param {T} obj
+     * @param {(v:T[keyof T],k:keyof T)=>boolean} f
      * @return {boolean}
      */
     const every = (obj, f) => {
@@ -5331,7 +4500,7 @@
      * Calls `Object.prototype.hasOwnProperty`.
      *
      * @param {any} obj
-     * @param {string|symbol} key
+     * @param {string|number|symbol} key
      * @return {boolean}
      */
     const hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
@@ -5367,6 +4536,12 @@
       return freeze(o)
     };
 
+    const EqualityTraitSymbol = Symbol('Equality');
+
+    /**
+     * @typedef {{ [EqualityTraitSymbol]:(other:EqualityTrait)=>boolean }} EqualityTrait
+     */
+
     /**
      * Common functions and function call helpers.
      *
@@ -5392,15 +4567,6 @@
       }
     };
 
-    /**
-     * @template T
-     *
-     * @param {T} a
-     * @param {T} b
-     * @return {boolean}
-     */
-    const equalityStrict = (a, b) => a === b;
-
     /* c8 ignore start */
 
     /**
@@ -5409,14 +4575,14 @@
      * @return {boolean}
      */
     const equalityDeep = (a, b) => {
-      if (a == null || b == null) {
-        return equalityStrict(a, b)
+      if (a === b) {
+        return true
       }
-      if (a.constructor !== b.constructor) {
+      if (a == null || b == null || a.constructor !== b.constructor) {
         return false
       }
-      if (a === b) {
-        return true
+      if (a[EqualityTraitSymbol] != null) {
+        return a[EqualityTraitSymbol](b)
       }
       switch (a.constructor) {
         case ArrayBuffer:
@@ -5512,7 +4678,7 @@
     const computeParams = () => {
       if (params === undefined) {
         if (isNode) {
-          params = create$5();
+          params = create$3();
           const pargs = process.argv;
           let currParamName = null;
           for (let i = 0; i < pargs.length; i++) {
@@ -5534,7 +4700,7 @@
           }
           // in ReactNative for example this would not be true (unless connected to the Remote Debugger)
         } else if (typeof location === 'object') {
-          params = create$5(); // eslint-disable-next-line no-undef
+          params = create$3(); // eslint-disable-next-line no-undef
           (location.search || '?').slice(1).split('&').forEach((kv) => {
             if (kv.length !== 0) {
               const [key, value] = kv.split('=');
@@ -5543,7 +4709,7 @@
             }
           });
         } else {
-          params = create$5();
+          params = create$3();
         }
       }
       return params
@@ -5650,8 +4816,6 @@
 
     /**
      * Return fresh symbol.
-     *
-     * @return {Symbol}
      */
     const create = Symbol;
 
@@ -5736,7 +4900,7 @@
       }
       const strBuilder = [];
       const styles = [];
-      const currentStyle = create$5();
+      const currentStyle = create$3();
       /**
        * @type {Array<string|Object|number>}
        */
@@ -5807,7 +4971,7 @@
       vconsoles.forEach((vc) => vc.print(args));
     };
 
-    const vconsoles = create$4();
+    const vconsoles = create$5();
 
     /**
      * Utility module to create and manipulate Iterators.
@@ -7024,7 +6188,7 @@
       /**
        * @type {Map<number, { i: number, refs: Array<Item | GC> }>}
        */
-      const clientRefs = create$5();
+      const clientRefs = create$3();
       const numOfStateUpdates = readVarUint(decoder.restDecoder);
       for (let i = 0; i < numOfStateUpdates; i++) {
         const numberOfStructs = readVarUint(decoder.restDecoder);
@@ -7524,7 +6688,7 @@
      * @param {Snapshot} snapshot
      */
     const splitSnapshotAffectedStructs = (transaction, snapshot) => {
-      const meta = setIfUndefined(transaction.meta, splitSnapshotAffectedStructs, create$4);
+      const meta = setIfUndefined(transaction.meta, splitSnapshotAffectedStructs, create$5);
       const store = transaction.doc.store;
       // check if we already split for this snapshot
       if (!meta.has(snapshot)) {
@@ -7901,7 +7065,7 @@
     const addChangedTypeToTransaction = (transaction, type, parentSub) => {
       const item = type._item;
       if (item === null || (item.id.clock < (transaction.beforeState.get(item.id.client) || 0) && !item.deleted)) {
-        setIfUndefined(transaction.changed, type, create$4).add(parentSub);
+        setIfUndefined(transaction.changed, type, create$5).add(parentSub);
       }
     };
 
@@ -8636,7 +7800,7 @@
       get keys () {
         if (this._keys === null) {
           if (this.transaction.doc._transactionCleanups.length === 0) {
-            throw create$3(errorComputeChanges)
+            throw create$4(errorComputeChanges)
           }
           const keys = new Map();
           const target = this.target;
@@ -8722,11 +7886,11 @@
         let changes = this._changes;
         if (changes === null) {
           if (this.transaction.doc._transactionCleanups.length === 0) {
-            throw create$3(errorComputeChanges)
+            throw create$4(errorComputeChanges)
           }
           const target = this.target;
-          const added = create$4();
-          const deleted = create$4();
+          const added = create$5();
+          const deleted = create$5();
           /**
            * @type {Array<{insert:Array<any>}|{delete:number}|{retain:number}>}
            */
@@ -9438,7 +8602,7 @@
       packJsonContent();
     };
 
-    const lengthExceeded = () => create$3('Length exceeded!');
+    const lengthExceeded = () => create$4('Length exceeded!');
 
     /**
      * @param {Transaction} transaction
@@ -10571,7 +9735,7 @@
       /**
        * @type {Map<string,ContentFormat>}
        */
-      const endFormats = create$5();
+      const endFormats = create$3();
       while (end && (!end.countable || end.deleted)) {
         if (!end.deleted && end.content.constructor === ContentFormat) {
           const cf = /** @type {ContentFormat} */ (end.content);
@@ -10656,7 +9820,7 @@
       transact(/** @type {Doc} */ (type.doc), transaction => {
         let start = /** @type {Item} */ (type._start);
         let end = type._start;
-        let startAttributes = create$5();
+        let startAttributes = create$3();
         const currentAttributes = copy(startAttributes);
         while (end) {
           if (end.deleted === false) {
@@ -11823,7 +10987,7 @@
           const pc = /** @type {Array<any>} */ (this._prelimContent);
           const index = ref === null ? 0 : pc.findIndex(el => el === ref) + 1;
           if (index === 0 && ref !== null) {
-            throw create$3('Reference item not found')
+            throw create$4('Reference item not found')
           }
           pc.splice(index, 0, ...content);
         }
@@ -14253,7 +13417,7 @@
      *
      * ==========================================================================
      *
-     * Version 4.2.1, Fri Nov 28 2025
+     * Version 4.2.2, Sat Dec 20 2025
      *
      * https://dexie.org
      *
@@ -14335,6 +13499,8 @@
         return doc;
     }
 
+    const { getByKeyPath } = Dexie.Dexie;
+
     let currentUpdateRow = null;
     function setCurrentUpdateRow(row) {
         currentUpdateRow = row;
@@ -14881,21 +14047,21 @@
                                 _c = chunks_1_1.value;
                                 _d = false;
                                 const chunk = _c;
-                                const decoder = new Decoder$1(chunk);
-                                while (hasContent$1(decoder)) {
-                                    switch (readUint8$1(decoder)) {
+                                const decoder = new Decoder(chunk);
+                                while (hasContent(decoder)) {
+                                    switch (readUint8(decoder)) {
                                         case BINSTREAM_TYPE_REALMID:
                                             yield __await(storeCollectedDocs(true));
-                                            currentRealmId = readVarString$1(decoder);
+                                            currentRealmId = readVarString(decoder);
                                             break;
                                         case BINSTREAM_TYPE_TABLE_AND_PROP:
                                             yield __await(storeCollectedDocs(false)); // still on same realm
-                                            currentTable = readVarString$1(decoder);
-                                            currentProp = readVarString$1(decoder);
+                                            currentTable = readVarString(decoder);
+                                            currentProp = readVarString(decoder);
                                             break;
                                         case BINSTREAM_TYPE_DOCUMENT: {
-                                            const k = readAny$1(decoder);
-                                            const u = readVarUint8Array$1(decoder);
+                                            const k = readAny(decoder);
+                                            const u = readVarUint8Array(decoder);
                                             docsToInsert.push({
                                                 k,
                                                 u,
@@ -16275,7 +15441,8 @@
             const cloudSchema = dexie.cloud.schema || (dexie.cloud.schema = {});
             const allPrefixes = new Set();
             Object.keys(storesClone).forEach(tableName => {
-                const schemaSrc = storesClone[tableName];
+                var _a;
+                const schemaSrc = (_a = storesClone[tableName]) === null || _a === void 0 ? void 0 : _a.trim();
                 const cloudTableSchema = cloudSchema[tableName] || (cloudSchema[tableName] = {});
                 if (schemaSrc != null) {
                     if (/^\@/.test(schemaSrc)) {
@@ -16316,7 +15483,8 @@
             // No support for guarding jobs. IE11, node.js, etc.
             return job();
         }
-        return navigator.locks.request(db.name + '|' + jobName, () => job());
+        // @ts-expect-error - LockManager callback type inference issue with generics
+        return navigator.locks.request(db.name + '|' + jobName, job);
     }
 
     function performInitialSync(db, cloudOptions, cloudSchema) {
@@ -17333,12 +16501,9 @@
         }
     }
 
-    var n,l$1,u$1,t$1,o$1,f$1={},e$1=[],c$1=/acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;function s$1(n,l){for(var u in l)n[u]=l[u];return n}function a$1(n){var l=n.parentNode;l&&l.removeChild(n);}function h(l,u,i){var t,o,r,f={};for(r in u)"key"==r?t=u[r]:"ref"==r?o=u[r]:f[r]=u[r];if(arguments.length>2&&(f.children=arguments.length>3?n.call(arguments,2):i),"function"==typeof l&&null!=l.defaultProps)for(r in l.defaultProps)void 0===f[r]&&(f[r]=l.defaultProps[r]);return v$1(l,f,t,o,null)}function v$1(n,i,t,o,r){var f={type:n,props:i,key:t,ref:o,__k:null,__:null,__b:0,__e:null,__d:void 0,__c:null,__h:null,constructor:void 0,__v:null==r?++u$1:r};return null==r&&null!=l$1.vnode&&l$1.vnode(f),f}function p$1(n){return n.children}function d$1(n,l){this.props=n,this.context=l;}function _$1(n,l){if(null==l)return n.__?_$1(n.__,n.__.__k.indexOf(n)+1):null;for(var u;l<n.__k.length;l++)if(null!=(u=n.__k[l])&&null!=u.__e)return u.__e;return "function"==typeof n.type?_$1(n):null}function k$1(n){var l,u;if(null!=(n=n.__)&&null!=n.__c){for(n.__e=n.__c.base=null,l=0;l<n.__k.length;l++)if(null!=(u=n.__k[l])&&null!=u.__e){n.__e=n.__c.base=u.__e;break}return k$1(n)}}function b$1(n){(!n.__d&&(n.__d=!0)&&t$1.push(n)&&!g$1.__r++||o$1!==l$1.debounceRendering)&&((o$1=l$1.debounceRendering)||setTimeout)(g$1);}function g$1(){for(var n;g$1.__r=t$1.length;)n=t$1.sort(function(n,l){return n.__v.__b-l.__v.__b}),t$1=[],n.some(function(n){var l,u,i,t,o,r;n.__d&&(o=(t=(l=n).__v).__e,(r=l.__P)&&(u=[],(i=s$1({},t)).__v=t.__v+1,j$1(r,t,i,l.__n,void 0!==r.ownerSVGElement,null!=t.__h?[o]:null,u,null==o?_$1(t):o,t.__h),z$1(u,t),t.__e!=o&&k$1(t)));});}function w$1(n,l,u,i,t,o,r,c,s,a){var h,y,d,k,b,g,w,x=i&&i.__k||e$1,C=x.length;for(u.__k=[],h=0;h<l.length;h++)if(null!=(k=u.__k[h]=null==(k=l[h])||"boolean"==typeof k?null:"string"==typeof k||"number"==typeof k||"bigint"==typeof k?v$1(null,k,null,null,k):Array.isArray(k)?v$1(p$1,{children:k},null,null,null):k.__b>0?v$1(k.type,k.props,k.key,null,k.__v):k)){if(k.__=u,k.__b=u.__b+1,null===(d=x[h])||d&&k.key==d.key&&k.type===d.type)x[h]=void 0;else for(y=0;y<C;y++){if((d=x[y])&&k.key==d.key&&k.type===d.type){x[y]=void 0;break}d=null;}j$1(n,k,d=d||f$1,t,o,r,c,s,a),b=k.__e,(y=k.ref)&&d.ref!=y&&(w||(w=[]),d.ref&&w.push(d.ref,null,k),w.push(y,k.__c||b,k)),null!=b?(null==g&&(g=b),"function"==typeof k.type&&k.__k===d.__k?k.__d=s=m$1(k,s,n):s=A(n,k,d,x,b,s),"function"==typeof u.type&&(u.__d=s)):s&&d.__e==s&&s.parentNode!=n&&(s=_$1(d));}for(u.__e=g,h=C;h--;)null!=x[h]&&("function"==typeof u.type&&null!=x[h].__e&&x[h].__e==u.__d&&(u.__d=_$1(i,h+1)),N(x[h],x[h]));if(w)for(h=0;h<w.length;h++)M(w[h],w[++h],w[++h]);}function m$1(n,l,u){for(var i,t=n.__k,o=0;t&&o<t.length;o++)(i=t[o])&&(i.__=n,l="function"==typeof i.type?m$1(i,l,u):A(u,i,i,t,i.__e,l));return l}function A(n,l,u,i,t,o){var r,f,e;if(void 0!==l.__d)r=l.__d,l.__d=void 0;else if(null==u||t!=o||null==t.parentNode)n:if(null==o||o.parentNode!==n)n.appendChild(t),r=null;else {for(f=o,e=0;(f=f.nextSibling)&&e<i.length;e+=2)if(f==t)break n;n.insertBefore(t,o),r=o;}return void 0!==r?r:t.nextSibling}function C(n,l,u,i,t){var o;for(o in u)"children"===o||"key"===o||o in l||H(n,o,null,u[o],i);for(o in l)t&&"function"!=typeof l[o]||"children"===o||"key"===o||"value"===o||"checked"===o||u[o]===l[o]||H(n,o,l[o],u[o],i);}function $(n,l,u){"-"===l[0]?n.setProperty(l,u):n[l]=null==u?"":"number"!=typeof u||c$1.test(l)?u:u+"px";}function H(n,l,u,i,t){var o;n:if("style"===l)if("string"==typeof u)n.style.cssText=u;else {if("string"==typeof i&&(n.style.cssText=i=""),i)for(l in i)u&&l in u||$(n.style,l,"");if(u)for(l in u)i&&u[l]===i[l]||$(n.style,l,u[l]);}else if("o"===l[0]&&"n"===l[1])o=l!==(l=l.replace(/Capture$/,"")),l=l.toLowerCase()in n?l.toLowerCase().slice(2):l.slice(2),n.l||(n.l={}),n.l[l+o]=u,u?i||n.addEventListener(l,o?T:I,o):n.removeEventListener(l,o?T:I,o);else if("dangerouslySetInnerHTML"!==l){if(t)l=l.replace(/xlink(H|:h)/,"h").replace(/sName$/,"s");else if("href"!==l&&"list"!==l&&"form"!==l&&"tabIndex"!==l&&"download"!==l&&l in n)try{n[l]=null==u?"":u;break n}catch(n){}"function"==typeof u||(null!=u&&(!1!==u||"a"===l[0]&&"r"===l[1])?n.setAttribute(l,u):n.removeAttribute(l));}}function I(n){this.l[n.type+!1](l$1.event?l$1.event(n):n);}function T(n){this.l[n.type+!0](l$1.event?l$1.event(n):n);}function j$1(n,u,i,t,o,r,f,e,c){var a,h,v,y,_,k,b,g,m,x,A,C,$,H=u.type;if(void 0!==u.constructor)return null;null!=i.__h&&(c=i.__h,e=u.__e=i.__e,u.__h=null,r=[e]),(a=l$1.__b)&&a(u);try{n:if("function"==typeof H){if(g=u.props,m=(a=H.contextType)&&t[a.__c],x=a?m?m.props.value:a.__:t,i.__c?b=(h=u.__c=i.__c).__=h.__E:("prototype"in H&&H.prototype.render?u.__c=h=new H(g,x):(u.__c=h=new d$1(g,x),h.constructor=H,h.render=O),m&&m.sub(h),h.props=g,h.state||(h.state={}),h.context=x,h.__n=t,v=h.__d=!0,h.__h=[]),null==h.__s&&(h.__s=h.state),null!=H.getDerivedStateFromProps&&(h.__s==h.state&&(h.__s=s$1({},h.__s)),s$1(h.__s,H.getDerivedStateFromProps(g,h.__s))),y=h.props,_=h.state,v)null==H.getDerivedStateFromProps&&null!=h.componentWillMount&&h.componentWillMount(),null!=h.componentDidMount&&h.__h.push(h.componentDidMount);else {if(null==H.getDerivedStateFromProps&&g!==y&&null!=h.componentWillReceiveProps&&h.componentWillReceiveProps(g,x),!h.__e&&null!=h.shouldComponentUpdate&&!1===h.shouldComponentUpdate(g,h.__s,x)||u.__v===i.__v){h.props=g,h.state=h.__s,u.__v!==i.__v&&(h.__d=!1),h.__v=u,u.__e=i.__e,u.__k=i.__k,u.__k.forEach(function(n){n&&(n.__=u);}),h.__h.length&&f.push(h);break n}null!=h.componentWillUpdate&&h.componentWillUpdate(g,h.__s,x),null!=h.componentDidUpdate&&h.__h.push(function(){h.componentDidUpdate(y,_,k);});}if(h.context=x,h.props=g,h.__v=u,h.__P=n,A=l$1.__r,C=0,"prototype"in H&&H.prototype.render)h.state=h.__s,h.__d=!1,A&&A(u),a=h.render(h.props,h.state,h.context);else do{h.__d=!1,A&&A(u),a=h.render(h.props,h.state,h.context),h.state=h.__s;}while(h.__d&&++C<25);h.state=h.__s,null!=h.getChildContext&&(t=s$1(s$1({},t),h.getChildContext())),v||null==h.getSnapshotBeforeUpdate||(k=h.getSnapshotBeforeUpdate(y,_)),$=null!=a&&a.type===p$1&&null==a.key?a.props.children:a,w$1(n,Array.isArray($)?$:[$],u,i,t,o,r,f,e,c),h.base=u.__e,u.__h=null,h.__h.length&&f.push(h),b&&(h.__E=h.__=null),h.__e=!1;}else null==r&&u.__v===i.__v?(u.__k=i.__k,u.__e=i.__e):u.__e=L(i.__e,u,i,t,o,r,f,c);(a=l$1.diffed)&&a(u);}catch(n){u.__v=null,(c||null!=r)&&(u.__e=e,u.__h=!!c,r[r.indexOf(e)]=null),l$1.__e(n,u,i);}}function z$1(n,u){l$1.__c&&l$1.__c(u,n),n.some(function(u){try{n=u.__h,u.__h=[],n.some(function(n){n.call(u);});}catch(n){l$1.__e(n,u.__v);}});}function L(l,u,i,t,o,r,e,c){var s,h,v,y=i.props,p=u.props,d=u.type,k=0;if("svg"===d&&(o=!0),null!=r)for(;k<r.length;k++)if((s=r[k])&&"setAttribute"in s==!!d&&(d?s.localName===d:3===s.nodeType)){l=s,r[k]=null;break}if(null==l){if(null===d)return document.createTextNode(p);l=o?document.createElementNS("http://www.w3.org/2000/svg",d):document.createElement(d,p.is&&p),r=null,c=!1;}if(null===d)y===p||c&&l.data===p||(l.data=p);else {if(r=r&&n.call(l.childNodes),h=(y=i.props||f$1).dangerouslySetInnerHTML,v=p.dangerouslySetInnerHTML,!c){if(null!=r)for(y={},k=0;k<l.attributes.length;k++)y[l.attributes[k].name]=l.attributes[k].value;(v||h)&&(v&&(h&&v.__html==h.__html||v.__html===l.innerHTML)||(l.innerHTML=v&&v.__html||""));}if(C(l,p,y,o,c),v)u.__k=[];else if(k=u.props.children,w$1(l,Array.isArray(k)?k:[k],u,i,t,o&&"foreignObject"!==d,r,e,r?r[0]:i.__k&&_$1(i,0),c),null!=r)for(k=r.length;k--;)null!=r[k]&&a$1(r[k]);c||("value"in p&&void 0!==(k=p.value)&&(k!==l.value||"progress"===d&&!k||"option"===d&&k!==y.value)&&H(l,"value",k,y.value,!1),"checked"in p&&void 0!==(k=p.checked)&&k!==l.checked&&H(l,"checked",k,y.checked,!1));}return l}function M(n,u,i){try{"function"==typeof n?n(u):n.current=u;}catch(n){l$1.__e(n,i);}}function N(n,u,i){var t,o;if(l$1.unmount&&l$1.unmount(n),(t=n.ref)&&(t.current&&t.current!==n.__e||M(t,null,u)),null!=(t=n.__c)){if(t.componentWillUnmount)try{t.componentWillUnmount();}catch(n){l$1.__e(n,u);}t.base=t.__P=null;}if(t=n.__k)for(o=0;o<t.length;o++)t[o]&&N(t[o],u,"function"!=typeof n.type);i||null==n.__e||a$1(n.__e),n.__e=n.__d=void 0;}function O(n,l,u){return this.constructor(n,u)}function P(u,i,t){var o,r,e;l$1.__&&l$1.__(u,i),r=(o="function"==typeof t)?null:t&&t.__k||i.__k,e=[],j$1(i,u=(!o&&t||i).__k=h(p$1,null,[u]),r||f$1,f$1,void 0!==i.ownerSVGElement,!o&&t?[t]:r?null:i.firstChild?n.call(i.childNodes):null,e,!o&&t?t:r?r.__e:i.firstChild,o),z$1(e,u);}n=e$1.slice,l$1={__e:function(n,l,u,i){for(var t,o,r;l=l.__;)if((t=l.__c)&&!t.__)try{if((o=t.constructor)&&null!=o.getDerivedStateFromError&&(t.setState(o.getDerivedStateFromError(n)),r=t.__d),null!=t.componentDidCatch&&(t.componentDidCatch(n,i||{}),r=t.__d),r)return t.__E=t}catch(l){n=l;}throw n}},u$1=0,d$1.prototype.setState=function(n,l){var u;u=null!=this.__s&&this.__s!==this.state?this.__s:this.__s=s$1({},this.state),"function"==typeof n&&(n=n(s$1({},u),this.props)),n&&s$1(u,n),null!=n&&this.__v&&(l&&this.__h.push(l),b$1(this));},d$1.prototype.forceUpdate=function(n){this.__v&&(this.__e=!0,n&&this.__h.push(n),b$1(this));},d$1.prototype.render=p$1,t$1=[],g$1.__r=0;
+    var n,l$1,u$1,i$1,r$1,o$1,e$1,f$1,c$1,s$1,a$1,p$1={},v$1=[],y=/acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i,w$1=Array.isArray;function d$1(n,l){for(var u in l)n[u]=l[u];return n}function g(n){n&&n.parentNode&&n.parentNode.removeChild(n);}function _$1(l,u,t){var i,r,o,e={};for(o in u)"key"==o?i=u[o]:"ref"==o?r=u[o]:e[o]=u[o];if(arguments.length>2&&(e.children=arguments.length>3?n.call(arguments,2):t),"function"==typeof l&&null!=l.defaultProps)for(o in l.defaultProps) void 0===e[o]&&(e[o]=l.defaultProps[o]);return m$1(l,e,i,r,null)}function m$1(n,t,i,r,o){var e={type:n,props:t,key:i,ref:r,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:null==o?++u$1:o,__i:-1,__u:0};return null==o&&null!=l$1.vnode&&l$1.vnode(e),e}function k$1(n){return n.children}function x(n,l){this.props=n,this.context=l;}function S(n,l){if(null==l)return n.__?S(n.__,n.__i+1):null;for(var u;l<n.__k.length;l++)if(null!=(u=n.__k[l])&&null!=u.__e)return u.__e;return "function"==typeof n.type?S(n):null}function C$1(n){var l,u;if(null!=(n=n.__)&&null!=n.__c){for(n.__e=n.__c.base=null,l=0;l<n.__k.length;l++)if(null!=(u=n.__k[l])&&null!=u.__e){n.__e=n.__c.base=u.__e;break}return C$1(n)}}function M(n){(!n.__d&&(n.__d=true)&&i$1.push(n)&&!$.__r++||r$1!=l$1.debounceRendering)&&((r$1=l$1.debounceRendering)||o$1)($);}function $(){for(var n,u,t,r,o,f,c,s=1;i$1.length;)i$1.length>s&&i$1.sort(e$1),n=i$1.shift(),s=i$1.length,n.__d&&(t=void 0,r=void 0,o=(r=(u=n).__v).__e,f=[],c=[],u.__P&&((t=d$1({},r)).__v=r.__v+1,l$1.vnode&&l$1.vnode(t),O(u.__P,t,r,u.__n,u.__P.namespaceURI,32&r.__u?[o]:null,f,null==o?S(r):o,!!(32&r.__u),c),t.__v=r.__v,t.__.__k[t.__i]=t,N(f,t,c),r.__e=r.__=null,t.__e!=o&&C$1(t)));$.__r=0;}function I(n,l,u,t,i,r,o,e,f,c,s){var a,h,y,w,d,g,_,m=t&&t.__k||v$1,b=l.length;for(f=P(u,l,m,f,b),a=0;a<b;a++)null!=(y=u.__k[a])&&(h=-1==y.__i?p$1:m[y.__i]||p$1,y.__i=a,g=O(n,y,h,i,r,o,e,f,c,s),w=y.__e,y.ref&&h.ref!=y.ref&&(h.ref&&B$1(h.ref,null,y),s.push(y.ref,y.__c||w,y)),null==d&&null!=w&&(d=w),(_=!!(4&y.__u))||h.__k===y.__k?f=A$1(y,f,n,_):"function"==typeof y.type&&void 0!==g?f=g:w&&(f=w.nextSibling),y.__u&=-7);return u.__e=d,f}function P(n,l,u,t,i){var r,o,e,f,c,s=u.length,a=s,h=0;for(n.__k=new Array(i),r=0;r<i;r++)null!=(o=l[r])&&"boolean"!=typeof o&&"function"!=typeof o?("string"==typeof o||"number"==typeof o||"bigint"==typeof o||o.constructor==String?o=n.__k[r]=m$1(null,o,null,null,null):w$1(o)?o=n.__k[r]=m$1(k$1,{children:o},null,null,null):null==o.constructor&&o.__b>0?o=n.__k[r]=m$1(o.type,o.props,o.key,o.ref?o.ref:null,o.__v):n.__k[r]=o,f=r+h,o.__=n,o.__b=n.__b+1,-1!=(c=o.__i=L(o,u,f,a))&&(a--,(e=u[c])&&(e.__u|=2)),null==e||null==e.__v?(-1==c&&(i>s?h--:i<s&&h++),"function"!=typeof o.type&&(o.__u|=4)):c!=f&&(c==f-1?h--:c==f+1?h++:(c>f?h--:h++,o.__u|=4))):n.__k[r]=null;if(a)for(r=0;r<s;r++)null!=(e=u[r])&&0==(2&e.__u)&&(e.__e==t&&(t=S(e)),D$1(e,e));return t}function A$1(n,l,u,t){var i,r;if("function"==typeof n.type){for(i=n.__k,r=0;i&&r<i.length;r++)i[r]&&(i[r].__=n,l=A$1(i[r],l,u,t));return l}n.__e!=l&&(t&&(l&&n.type&&!l.parentNode&&(l=S(n)),u.insertBefore(n.__e,l||null)),l=n.__e);do{l=l&&l.nextSibling;}while(null!=l&&8==l.nodeType);return l}function L(n,l,u,t){var i,r,o,e=n.key,f=n.type,c=l[u],s=null!=c&&0==(2&c.__u);if(null===c&&null==e||s&&e==c.key&&f==c.type)return u;if(t>(s?1:0))for(i=u-1,r=u+1;i>=0||r<l.length;)if(null!=(c=l[o=i>=0?i--:r++])&&0==(2&c.__u)&&e==c.key&&f==c.type)return o;return  -1}function T$1(n,l,u){"-"==l[0]?n.setProperty(l,null==u?"":u):n[l]=null==u?"":"number"!=typeof u||y.test(l)?u:u+"px";}function j$1(n,l,u,t,i){var r,o;n:if("style"==l)if("string"==typeof u)n.style.cssText=u;else {if("string"==typeof t&&(n.style.cssText=t=""),t)for(l in t)u&&l in u||T$1(n.style,l,"");if(u)for(l in u)t&&u[l]==t[l]||T$1(n.style,l,u[l]);}else if("o"==l[0]&&"n"==l[1])r=l!=(l=l.replace(f$1,"$1")),o=l.toLowerCase(),l=o in n||"onFocusOut"==l||"onFocusIn"==l?o.slice(2):l.slice(2),n.l||(n.l={}),n.l[l+r]=u,u?t?u.u=t.u:(u.u=c$1,n.addEventListener(l,r?a$1:s$1,r)):n.removeEventListener(l,r?a$1:s$1,r);else {if("http://www.w3.org/2000/svg"==i)l=l.replace(/xlink(H|:h)/,"h").replace(/sName$/,"s");else if("width"!=l&&"height"!=l&&"href"!=l&&"list"!=l&&"form"!=l&&"tabIndex"!=l&&"download"!=l&&"rowSpan"!=l&&"colSpan"!=l&&"role"!=l&&"popover"!=l&&l in n)try{n[l]=null==u?"":u;break n}catch(n){}"function"==typeof u||(null==u||false===u&&"-"!=l[4]?n.removeAttribute(l):n.setAttribute(l,"popover"==l&&1==u?"":u));}}function F(n){return function(u){if(this.l){var t=this.l[u.type+n];if(null==u.t)u.t=c$1++;else if(u.t<t.u)return;return t(l$1.event?l$1.event(u):u)}}}function O(n,u,t,i,r,o,e,f,c,s){var a,h,p,v,y,_,m,b,S,C,M,$,P,A,H,L,T,j=u.type;if(null!=u.constructor)return null;128&t.__u&&(c=!!(32&t.__u),o=[f=u.__e=t.__e]),(a=l$1.__b)&&a(u);n:if("function"==typeof j)try{if(b=u.props,S="prototype"in j&&j.prototype.render,C=(a=j.contextType)&&i[a.__c],M=a?C?C.props.value:a.__:i,t.__c?m=(h=u.__c=t.__c).__=h.__E:(S?u.__c=h=new j(b,M):(u.__c=h=new x(b,M),h.constructor=j,h.render=E),C&&C.sub(h),h.state||(h.state={}),h.__n=i,p=h.__d=!0,h.__h=[],h._sb=[]),S&&null==h.__s&&(h.__s=h.state),S&&null!=j.getDerivedStateFromProps&&(h.__s==h.state&&(h.__s=d$1({},h.__s)),d$1(h.__s,j.getDerivedStateFromProps(b,h.__s))),v=h.props,y=h.state,h.__v=u,p)S&&null==j.getDerivedStateFromProps&&null!=h.componentWillMount&&h.componentWillMount(),S&&null!=h.componentDidMount&&h.__h.push(h.componentDidMount);else {if(S&&null==j.getDerivedStateFromProps&&b!==v&&null!=h.componentWillReceiveProps&&h.componentWillReceiveProps(b,M),u.__v==t.__v||!h.__e&&null!=h.shouldComponentUpdate&&!1===h.shouldComponentUpdate(b,h.__s,M)){for(u.__v!=t.__v&&(h.props=b,h.state=h.__s,h.__d=!1),u.__e=t.__e,u.__k=t.__k,u.__k.some(function(n){n&&(n.__=u);}),$=0;$<h._sb.length;$++)h.__h.push(h._sb[$]);h._sb=[],h.__h.length&&e.push(h);break n}null!=h.componentWillUpdate&&h.componentWillUpdate(b,h.__s,M),S&&null!=h.componentDidUpdate&&h.__h.push(function(){h.componentDidUpdate(v,y,_);});}if(h.context=M,h.props=b,h.__P=n,h.__e=!1,P=l$1.__r,A=0,S){for(h.state=h.__s,h.__d=!1,P&&P(u),a=h.render(h.props,h.state,h.context),H=0;H<h._sb.length;H++)h.__h.push(h._sb[H]);h._sb=[];}else do{h.__d=!1,P&&P(u),a=h.render(h.props,h.state,h.context),h.state=h.__s;}while(h.__d&&++A<25);h.state=h.__s,null!=h.getChildContext&&(i=d$1(d$1({},i),h.getChildContext())),S&&!p&&null!=h.getSnapshotBeforeUpdate&&(_=h.getSnapshotBeforeUpdate(v,y)),L=a,null!=a&&a.type===k$1&&null==a.key&&(L=V(a.props.children)),f=I(n,w$1(L)?L:[L],u,t,i,r,o,e,f,c,s),h.base=u.__e,u.__u&=-161,h.__h.length&&e.push(h),m&&(h.__E=h.__=null);}catch(n){if(u.__v=null,c||null!=o)if(n.then){for(u.__u|=c?160:128;f&&8==f.nodeType&&f.nextSibling;)f=f.nextSibling;o[o.indexOf(f)]=null,u.__e=f;}else {for(T=o.length;T--;)g(o[T]);z$1(u);}else u.__e=t.__e,u.__k=t.__k,n.then||z$1(u);l$1.__e(n,u,t);}else null==o&&u.__v==t.__v?(u.__k=t.__k,u.__e=t.__e):f=u.__e=q(t.__e,u,t,i,r,o,e,c,s);return (a=l$1.diffed)&&a(u),128&u.__u?void 0:f}function z$1(n){n&&n.__c&&(n.__c.__e=true),n&&n.__k&&n.__k.forEach(z$1);}function N(n,u,t){for(var i=0;i<t.length;i++)B$1(t[i],t[++i],t[++i]);l$1.__c&&l$1.__c(u,n),n.some(function(u){try{n=u.__h,u.__h=[],n.some(function(n){n.call(u);});}catch(n){l$1.__e(n,u.__v);}});}function V(n){return "object"!=typeof n||null==n||n.__b&&n.__b>0?n:w$1(n)?n.map(V):d$1({},n)}function q(u,t,i,r,o,e,f,c,s){var a,h,v,y,d,_,m,b=i.props||p$1,k=t.props,x=t.type;if("svg"==x?o="http://www.w3.org/2000/svg":"math"==x?o="http://www.w3.org/1998/Math/MathML":o||(o="http://www.w3.org/1999/xhtml"),null!=e)for(a=0;a<e.length;a++)if((d=e[a])&&"setAttribute"in d==!!x&&(x?d.localName==x:3==d.nodeType)){u=d,e[a]=null;break}if(null==u){if(null==x)return document.createTextNode(k);u=document.createElementNS(o,x,k.is&&k),c&&(l$1.__m&&l$1.__m(t,e),c=false),e=null;}if(null==x)b===k||c&&u.data==k||(u.data=k);else {if(e=e&&n.call(u.childNodes),!c&&null!=e)for(b={},a=0;a<u.attributes.length;a++)b[(d=u.attributes[a]).name]=d.value;for(a in b)if(d=b[a],"children"==a);else if("dangerouslySetInnerHTML"==a)v=d;else if(!(a in k)){if("value"==a&&"defaultValue"in k||"checked"==a&&"defaultChecked"in k)continue;j$1(u,a,null,d,o);}for(a in k)d=k[a],"children"==a?y=d:"dangerouslySetInnerHTML"==a?h=d:"value"==a?_=d:"checked"==a?m=d:c&&"function"!=typeof d||b[a]===d||j$1(u,a,d,b[a],o);if(h)c||v&&(h.__html==v.__html||h.__html==u.innerHTML)||(u.innerHTML=h.__html),t.__k=[];else if(v&&(u.innerHTML=""),I("template"==t.type?u.content:u,w$1(y)?y:[y],t,i,r,"foreignObject"==x?"http://www.w3.org/1999/xhtml":o,e,f,e?e[0]:i.__k&&S(i,0),c,s),null!=e)for(a=e.length;a--;)g(e[a]);c||(a="value","progress"==x&&null==_?u.removeAttribute("value"):null!=_&&(_!==u[a]||"progress"==x&&!_||"option"==x&&_!=b[a])&&j$1(u,a,_,b[a],o),a="checked",null!=m&&m!=u[a]&&j$1(u,a,m,b[a],o));}return u}function B$1(n,u,t){try{if("function"==typeof n){var i="function"==typeof n.__u;i&&n.__u(),i&&null==u||(n.__u=n(u));}else n.current=u;}catch(n){l$1.__e(n,t);}}function D$1(n,u,t){var i,r;if(l$1.unmount&&l$1.unmount(n),(i=n.ref)&&(i.current&&i.current!=n.__e||B$1(i,null,u)),null!=(i=n.__c)){if(i.componentWillUnmount)try{i.componentWillUnmount();}catch(n){l$1.__e(n,u);}i.base=i.__P=null;}if(i=n.__k)for(r=0;r<i.length;r++)i[r]&&D$1(i[r],u,t||"function"!=typeof n.type);t||g(n.__e),n.__c=n.__=n.__e=void 0;}function E(n,l,u){return this.constructor(n,u)}function G(u,t,i){var r,o,e,f;t==document&&(t=document.documentElement),l$1.__&&l$1.__(u,t),o=(r="function"=="undefined")?null:t.__k,e=[],f=[],O(t,u=(t).__k=_$1(k$1,null,[u]),o||p$1,p$1,t.namespaceURI,o?null:t.firstChild?n.call(t.childNodes):null,e,o?o.__e:t.firstChild,r,f),N(e,u,f);}n=v$1.slice,l$1={__e:function(n,l,u,t){for(var i,r,o;l=l.__;)if((i=l.__c)&&!i.__)try{if((r=i.constructor)&&null!=r.getDerivedStateFromError&&(i.setState(r.getDerivedStateFromError(n)),o=i.__d),null!=i.componentDidCatch&&(i.componentDidCatch(n,t||{}),o=i.__d),o)return i.__E=i}catch(l){n=l;}throw n}},u$1=0,x.prototype.setState=function(n,l){var u;u=null!=this.__s&&this.__s!=this.state?this.__s:this.__s=d$1({},this.state),"function"==typeof n&&(n=n(d$1({},u),this.props)),n&&d$1(u,n),null!=n&&this.__v&&(l&&this._sb.push(l),M(this));},x.prototype.forceUpdate=function(n){this.__v&&(this.__e=true,n&&this.__h.push(n),M(this));},x.prototype.render=k$1,i$1=[],o$1="function"==typeof Promise?Promise.prototype.then.bind(Promise.resolve()):setTimeout,e$1=function(n,l){return n.__v.__b-l.__v.__b},$.__r=0,f$1=/(PointerCapture)$|Capture$/i,c$1=0,s$1=F(false),a$1=F(true);
 
     const Styles = {
-        Error: {
-            color: "red",
-        },
         Alert: {
             error: {
                 color: "red",
@@ -17457,13 +16622,13 @@
     };
 
     function Dialog({ children, className }) {
-        return (h("div", { className: `dexie-dialog ${className || ''}` },
-            h("div", { style: Styles.Darken }),
-            h("div", { style: Styles.DialogOuter },
-                h("div", { style: Styles.DialogInner }, children))));
+        return (_$1("div", { className: `dexie-dialog ${className || ''}` },
+            _$1("div", { style: Styles.Darken }),
+            _$1("div", { style: Styles.DialogOuter },
+                _$1("div", { style: Styles.DialogInner }, children))));
     }
 
-    var t,r,u,i,o=0,c=[],f=[],e=l$1.__b,a=l$1.__r,v=l$1.diffed,l=l$1.__c,m=l$1.unmount;function d(t,u){l$1.__h&&l$1.__h(r,t,o||u),o=0;var i=r.__H||(r.__H={__:[],__h:[]});return t>=i.__.length&&i.__.push({__V:f}),i.__[t]}function p(n){return o=1,y(z,n)}function y(n,u,i){var o=d(t++,2);if(o.t=n,!o.__c&&(o.__=[i?i(u):z(void 0,u),function(n){var t=o.__N?o.__N[0]:o.__[0],r=o.t(t,n);t!==r&&(o.__N=[r,o.__[1]],o.__c.setState({}));}],o.__c=r,!r.u)){r.u=!0;var c=r.shouldComponentUpdate;r.shouldComponentUpdate=function(n,t,r){if(!o.__c.__H)return !0;var u=o.__c.__H.__.filter(function(n){return n.__c});if(u.every(function(n){return !n.__N}))return !c||c.call(this,n,t,r);var i=!1;return u.forEach(function(n){if(n.__N){var t=n.__[0];n.__=n.__N,n.__N=void 0,t!==n.__[0]&&(i=!0);}}),!!i&&(!c||c.call(this,n,t,r))};}return o.__N||o.__}function s(u,i){var o=d(t++,4);!l$1.__s&&w(o.__H,i)&&(o.__=u,o.i=i,r.__h.push(o));}function _(n){return o=5,F(function(){return {current:n}},[])}function F(n,r){var u=d(t++,7);return w(u.__H,r)?(u.__V=n(),u.i=r,u.__h=n,u.__V):u.__}function b(){for(var t;t=c.shift();)if(t.__P&&t.__H)try{t.__H.__h.forEach(j),t.__H.__h.forEach(k),t.__H.__h=[];}catch(r){t.__H.__h=[],l$1.__e(r,t.__v);}}l$1.__b=function(n){r=null,e&&e(n);},l$1.__r=function(n){a&&a(n),t=0;var i=(r=n.__c).__H;i&&(u===r?(i.__h=[],r.__h=[],i.__.forEach(function(n){n.__N&&(n.__=n.__N),n.__V=f,n.__N=n.i=void 0;})):(i.__h.forEach(j),i.__h.forEach(k),i.__h=[])),u=r;},l$1.diffed=function(t){v&&v(t);var o=t.__c;o&&o.__H&&(o.__H.__h.length&&(1!==c.push(o)&&i===l$1.requestAnimationFrame||((i=l$1.requestAnimationFrame)||function(n){var t,r=function(){clearTimeout(u),g&&cancelAnimationFrame(t),setTimeout(n);},u=setTimeout(r,100);g&&(t=requestAnimationFrame(r));})(b)),o.__H.__.forEach(function(n){n.i&&(n.__H=n.i),n.__V!==f&&(n.__=n.__V),n.i=void 0,n.__V=f;})),u=r=null;},l$1.__c=function(t,r){r.some(function(t){try{t.__h.forEach(j),t.__h=t.__h.filter(function(n){return !n.__||k(n)});}catch(u){r.some(function(n){n.__h&&(n.__h=[]);}),r=[],l$1.__e(u,t.__v);}}),l&&l(t,r);},l$1.unmount=function(t){m&&m(t);var r,u=t.__c;u&&u.__H&&(u.__H.__.forEach(function(n){try{j(n);}catch(n){r=n;}}),r&&l$1.__e(r,u.__v));};var g="function"==typeof requestAnimationFrame;function j(n){var t=r,u=n.__c;"function"==typeof u&&(n.__c=void 0,u()),r=t;}function k(n){var t=r;n.__c=n.__(),r=t;}function w(n,t){return !n||n.length!==t.length||t.some(function(t,r){return t!==n[r]})}function z(n,t){return "function"==typeof t?t(n):t}
+    var t,r,u,i,o=0,f=[],c=l$1,e=c.__b,a=c.__r,v=c.diffed,l=c.__c,m=c.unmount,s=c.__;function p(n,t){c.__h&&c.__h(r,n,o||t),o=0;var u=r.__H||(r.__H={__:[],__h:[]});return n>=u.__.length&&u.__.push({}),u.__[n]}function d(n){return o=1,h(D,n)}function h(n,u,i){var o=p(t++,2);if(o.t=n,!o.__c&&(o.__=[D(void 0,u),function(n){var t=o.__N?o.__N[0]:o.__[0],r=o.t(t,n);t!==r&&(o.__N=[r,o.__[1]],o.__c.setState({}));}],o.__c=r,!r.__f)){var f=function(n,t,r){if(!o.__c.__H)return  true;var u=o.__c.__H.__.filter(function(n){return !!n.__c});if(u.every(function(n){return !n.__N}))return !c||c.call(this,n,t,r);var i=o.__c.props!==n;return u.forEach(function(n){if(n.__N){var t=n.__[0];n.__=n.__N,n.__N=void 0,t!==n.__[0]&&(i=true);}}),c&&c.call(this,n,t,r)||i};r.__f=true;var c=r.shouldComponentUpdate,e=r.componentWillUpdate;r.componentWillUpdate=function(n,t,r){if(this.__e){var u=c;c=void 0,f(n,t,r),c=u;}e&&e.call(this,n,t,r);},r.shouldComponentUpdate=f;}return o.__N||o.__}function _(n,u){var i=p(t++,4);!c.__s&&C(i.__H,u)&&(i.__=n,i.u=u,r.__h.push(i));}function A(n){return o=5,T(function(){return {current:n}},[])}function T(n,r){var u=p(t++,7);return C(u.__H,r)&&(u.__=n(),u.__H=r,u.__h=n),u.__}function j(){for(var n;n=f.shift();)if(n.__P&&n.__H)try{n.__H.__h.forEach(z),n.__H.__h.forEach(B),n.__H.__h=[];}catch(t){n.__H.__h=[],c.__e(t,n.__v);}}c.__b=function(n){r=null,e&&e(n);},c.__=function(n,t){n&&t.__k&&t.__k.__m&&(n.__m=t.__k.__m),s&&s(n,t);},c.__r=function(n){a&&a(n),t=0;var i=(r=n.__c).__H;i&&(u===r?(i.__h=[],r.__h=[],i.__.forEach(function(n){n.__N&&(n.__=n.__N),n.u=n.__N=void 0;})):(i.__h.forEach(z),i.__h.forEach(B),i.__h=[],t=0)),u=r;},c.diffed=function(n){v&&v(n);var t=n.__c;t&&t.__H&&(t.__H.__h.length&&(1!==f.push(t)&&i===c.requestAnimationFrame||((i=c.requestAnimationFrame)||w)(j)),t.__H.__.forEach(function(n){n.u&&(n.__H=n.u),n.u=void 0;})),u=r=null;},c.__c=function(n,t){t.some(function(n){try{n.__h.forEach(z),n.__h=n.__h.filter(function(n){return !n.__||B(n)});}catch(r){t.some(function(n){n.__h&&(n.__h=[]);}),t=[],c.__e(r,n.__v);}}),l&&l(n,t);},c.unmount=function(n){m&&m(n);var t,r=n.__c;r&&r.__H&&(r.__H.__.forEach(function(n){try{z(n);}catch(n){t=n;}}),r.__H=void 0,t&&c.__e(t,r.__v));};var k="function"==typeof requestAnimationFrame;function w(n){var t,r=function(){clearTimeout(u),k&&cancelAnimationFrame(t),setTimeout(n);},u=setTimeout(r,35);k&&(t=requestAnimationFrame(r));}function z(n){var t=r,u=n.__c;"function"==typeof u&&(n.__c=void 0,u()),r=t;}function B(n){var t=r;n.__c=n.__(),r=t;}function C(n,t){return !n||n.length!==t.length||t.some(function(t,r){return t!==n[r]})}function D(n,t){return "function"==typeof t?t(n):t}
 
     /** Resolve a message template with parameters.
      *
@@ -17485,19 +16650,19 @@
 
     const OTP_LENGTH = 8;
     function LoginDialog({ title, type, alerts, fields, submitLabel, cancelLabel, onCancel, onSubmit, }) {
-        const [params, setParams] = p({});
-        const firstFieldRef = _(null);
-        s(() => { var _a; return (_a = firstFieldRef.current) === null || _a === void 0 ? void 0 : _a.focus(); }, []);
-        return (h(Dialog, { className: "dxc-login-dlg" },
-            h(p$1, null,
-                h("h3", { style: Styles.WindowHeader }, title),
-                alerts.map((alert) => (h("p", { style: Styles.Alert[alert.type] }, resolveText(alert)))),
-                h("form", { onSubmit: (ev) => {
+        const [params, setParams] = d({});
+        const firstFieldRef = A(null);
+        _(() => { var _a; return (_a = firstFieldRef.current) === null || _a === void 0 ? void 0 : _a.focus(); }, []);
+        return (_$1(Dialog, { className: "dxc-login-dlg" },
+            _$1(k$1, null,
+                _$1("h3", { style: Styles.WindowHeader }, title),
+                alerts.map((alert) => (_$1("p", { style: Styles.Alert[alert.type] }, resolveText(alert)))),
+                _$1("form", { onSubmit: (ev) => {
                         ev.preventDefault();
                         onSubmit(params);
-                    } }, Object.entries(fields).map(([fieldName, { type, label, placeholder }], idx) => (h("label", { style: Styles.Label, key: idx },
+                    } }, Object.entries(fields).map(([fieldName, { type, label, placeholder }], idx) => (_$1("label", { style: Styles.Label, key: idx },
                     label ? `${label}: ` : '',
-                    h("input", { ref: idx === 0 ? firstFieldRef : undefined, type: type, name: fieldName, autoComplete: "on", style: Styles.Input, autoFocus: true, placeholder: placeholder, value: params[fieldName] || '', onInput: (ev) => {
+                    _$1("input", { ref: idx === 0 ? firstFieldRef : undefined, type: type, name: fieldName, autoComplete: "on", style: Styles.Input, autoFocus: true, placeholder: placeholder, value: params[fieldName] || '', onInput: (ev) => {
                             var _a;
                             const value = valueTransformer(type, (_a = ev.target) === null || _a === void 0 ? void 0 : _a['value']);
                             let updatedParams = Object.assign(Object.assign({}, params), { [fieldName]: value });
@@ -17507,10 +16672,10 @@
                                 onSubmit(updatedParams);
                             }
                         } })))))),
-            h("div", { style: Styles.ButtonsDiv },
-                h(p$1, null,
-                    h("button", { type: "submit", style: Styles.PrimaryButton, onClick: () => onSubmit(params) }, submitLabel),
-                    cancelLabel && (h("button", { style: Styles.Button, onClick: onCancel }, cancelLabel))))));
+            _$1("div", { style: Styles.ButtonsDiv },
+                _$1(k$1, null,
+                    _$1("button", { type: "submit", style: Styles.PrimaryButton, onClick: () => onSubmit(params) }, submitLabel),
+                    cancelLabel && (_$1("button", { style: Styles.Button, onClick: onCancel }, cancelLabel))))));
     }
     function valueTransformer(type, value) {
         switch (type) {
@@ -17523,7 +16688,7 @@
         }
     }
 
-    class LoginGui extends d$1 {
+    class LoginGui extends x {
         constructor(props) {
             super(props);
             this.observer = (userInteraction) => this.setState({ userInteraction });
@@ -17542,7 +16707,7 @@
             if (!userInteraction)
                 return null;
             //if (props.db.cloud.userInteraction.observers.length > 1) return null; // Someone else subscribes.
-            return h(LoginDialog, Object.assign({}, userInteraction));
+            return _$1(LoginDialog, Object.assign({}, userInteraction));
         }
     }
     function setupDefaultGUI(db) {
@@ -17550,13 +16715,13 @@
         const el = document.createElement('div');
         if (document.body) {
             document.body.appendChild(el);
-            P(h(LoginGui, { db: db.vip }), el);
+            G(_$1(LoginGui, { db: db.vip }), el);
         }
         else {
             addEventListener('DOMContentLoaded', () => {
                 if (!closed) {
                     document.body.appendChild(el);
-                    P(h(LoginGui, { db: db.vip }), el);
+                    G(_$1(LoginGui, { db: db.vip }), el);
                 }
             });
         }
@@ -18311,7 +17476,7 @@
         const syncComplete = new rxjs.Subject();
         dexie.cloud = {
             // @ts-ignore
-            version: "4.2.3",
+            version: "4.2.5",
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -18628,7 +17793,7 @@
         }
     }
     // @ts-ignore
-    dexieCloud.version = "4.2.3";
+    dexieCloud.version = "4.2.5";
     Dexie.Cloud = dexieCloud;
 
     exports.default = dexieCloud;