@kokimoki/app 1.13.0 → 1.14.0

package/dist/kokimoki.min.js

@@ -486,7 +486,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 var eventsExports = events.exports;
 var EventEmitter$1 = /*@__PURE__*/getDefaultExportFromCjs(eventsExports);
 
-const KOKIMOKI_APP_VERSION = "1.13.0";
+const KOKIMOKI_APP_VERSION = "1.14.0";
 
 /**
  * Utility module to work with key-value stores.
@@ -508,9 +508,9 @@ const create$5 = () => new Map();
  * Copy a Map object into a fresh Map object.
  *
  * @function
- * @template X,Y
- * @param {Map<X,Y>} m
- * @return {Map<X,Y>}
+ * @template K,V
+ * @param {Map<K,V>} m
+ * @return {Map<K,V>}
  */
 const copy = m => {
   const r = create$5();
@@ -527,12 +527,12 @@ const copy = m => {
  * ```
  *
  * @function
- * @template V,K
- * @template {Map<K,V>} MAP
+ * @template {Map<any, any>} MAP
+ * @template {MAP extends Map<any,infer V> ? function():V : unknown} CF
  * @param {MAP} map
- * @param {K} key
- * @param {function():V} createT
- * @return {V}
+ * @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);
@@ -640,44 +640,52 @@ const isArray = Array.isArray;
 
 /**
  * Handles named events.
+ * @experimental
+ *
+ * This is basically a (better typed) duplicate of Observable, which will replace Observable in the
+ * next release.
  *
- * @template N
+ * @template {{[key in keyof EVENTS]: function(...any):void}} EVENTS
  */
-class Observable {
+class ObservableV2 {
   constructor () {
     /**
      * Some desc.
-     * @type {Map<N, any>}
+     * @type {Map<string, Set<any>>}
      */
     this._observers = create$5();
   }
 
   /**
-   * @param {N} name
-   * @param {function} f
+   * @template {keyof EVENTS & string} NAME
+   * @param {NAME} name
+   * @param {EVENTS[NAME]} f
    */
   on (name, f) {
-    setIfUndefined(this._observers, name, create$4).add(f);
+    setIfUndefined(this._observers, /** @type {string} */ (name), create$4).add(f);
+    return f
   }
 
   /**
-   * @param {N} name
-   * @param {function} 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, _f);
+      this.off(name, /** @type {any} */ (_f));
       f(...args);
     };
-    this.on(name, _f);
+    this.on(name, /** @type {any} */ (_f));
   }
 
   /**
-   * @param {N} name
-   * @param {function} f
+   * @template {keyof EVENTS & string} NAME
+   * @param {NAME} name
+   * @param {EVENTS[NAME]} f
    */
   off (name, f) {
     const observers = this._observers.get(name);
@@ -695,8 +703,9 @@ class Observable {
    *
    * @todo This should catch exceptions
    *
-   * @param {N} name The event name.
-   * @param {Array<any>} args The arguments that are applied to the event listener.
+   * @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.
@@ -707,6 +716,7 @@ class Observable {
     this._observers = create$5();
   }
 }
+/* c8 ignore end */
 
 /**
  * Common Math expressions.
@@ -739,6 +749,46 @@ const max$3 = (a, b) => a > b ? a : b;
  */
 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$2(num) === num);
+
 /**
  * @param {string} s
  * @return {string}
@@ -807,342 +857,650 @@ if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
 }
 
 /**
- * Often used conditions.
+ * Efficient schema-less binary encoding with support for variable length encoding.
  *
- * @module conditions
- */
-
-/**
- * @template T
- * @param {T|null|undefined} v
- * @return {T|null}
- */
-/* c8 ignore next */
-const undefinedToNull = v => v === undefined ? null : v;
-
-/* eslint-env browser */
-
-/**
- * Isomorphic variable storage.
+ * Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.
  *
- * Uses LocalStorage in the browser and falls back to in-memory storage.
+ * 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.
  *
- * @module storage
+ * ```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
  */
 
-/* c8 ignore start */
-class VarStoragePolyfill {
-  constructor () {
-    this.map = new Map();
-  }
-
-  /**
-   * @param {string} key
-   * @param {any} newValue
-   */
-  setItem (key, newValue) {
-    this.map.set(key, newValue);
-  }
-
-  /**
-   * @param {string} key
-   */
-  getItem (key) {
-    return this.map.get(key)
-  }
-}
-/* c8 ignore stop */
 
 /**
- * @type {any}
+ * A BinaryEncoder handles the encoding to an Uint8Array.
  */
-let _localStorage = new VarStoragePolyfill();
-let usePolyfill = true;
-
-/* c8 ignore start */
-try {
-  // if the same-origin rule is violated, accessing localStorage might thrown an error
-  if (typeof localStorage !== 'undefined') {
-    _localStorage = localStorage;
-    usePolyfill = false;
+class Encoder {
+  constructor () {
+    this.cpos = 0;
+    this.cbuf = new Uint8Array(100);
+    /**
+     * @type {Array<Uint8Array>}
+     */
+    this.bufs = [];
   }
-} catch (e) { }
-/* c8 ignore stop */
+}
 
 /**
- * This is basically localStorage in browser, or a polyfill in nodejs
+ * @function
+ * @return {Encoder}
  */
-/* c8 ignore next */
-const varStorage = _localStorage;
+const createEncoder = () => new Encoder();
 
 /**
- * Utility functions for working with EcmaScript objects.
+ * The current length of the encoded data.
  *
- * @module object
+ * @function
+ * @param {Encoder} encoder
+ * @return {number}
  */
-
+const length = encoder => {
+  let len = encoder.cpos;
+  for (let i = 0; i < encoder.bufs.length; i++) {
+    len += encoder.bufs[i].length;
+  }
+  return len
+};
 
 /**
- * Object.assign
+ * Transform to Uint8Array.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @return {Uint8Array} The created ArrayBuffer.
  */
-const assign = Object.assign;
+const toUint8Array = encoder => {
+  const uint8arr = new Uint8Array(length(encoder));
+  let curPos = 0;
+  for (let i = 0; i < encoder.bufs.length; i++) {
+    const d = encoder.bufs[i];
+    uint8arr.set(d, curPos);
+    curPos += d.length;
+  }
+  uint8arr.set(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos), curPos);
+  return uint8arr
+};
 
 /**
- * @param {Object<string,any>} obj
+ * 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 keys = Object.keys;
+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$3(bufferLen, len) * 2);
+    encoder.cpos = 0;
+  }
+};
 
 /**
- * @template V
- * @param {{[k:string]:V}} obj
- * @param {function(V,string):any} f
+ * Write one byte to the encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {number} num The byte that is to be encoded.
  */
-const forEach$2 = (obj, f) => {
-  for (const key in obj) {
-    f(obj[key], key);
+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;
 };
 
 /**
- * @param {Object<string,any>} obj
- * @return {number}
+ * Write one byte as an unsigned integer.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {number} num The number that is to be encoded.
  */
-const length$1 = obj => keys(obj).length;
+const writeUint8 = write;
 
 /**
- * @param {Object|undefined} obj
+ * 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 isEmpty = obj => {
-  for (const _k in obj) {
-    return false
+const writeVarUint = (encoder, num) => {
+  while (num > BITS7) {
+    write(encoder, BIT8 | (BITS7 & num));
+    num = floor$2(num / 128); // shift >>> 7
   }
-  return true
+  write(encoder, BITS7 & num);
 };
 
 /**
- * @param {Object<string,any>} obj
- * @param {function(any,string):boolean} f
- * @return {boolean}
+ * 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 every = (obj, f) => {
-  for (const key in obj) {
-    if (!f(obj[key], key)) {
-      return false
-    }
+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$2(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$2(num / 128); // shift >>> 7
   }
-  return true
 };
 
 /**
- * Calls `Object.prototype.hasOwnProperty`.
- *
- * @param {any} obj
- * @param {string|symbol} key
- * @return {boolean}
+ * A cache to store strings temporarily
  */
-const hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+const _strBuffer = new Uint8Array(30000);
+const _maxStrBSize = _strBuffer.length / 3;
 
 /**
- * @param {Object<string,any>} a
- * @param {Object<string,any>} b
- * @return {boolean}
- */
-const equalFlat = (a, b) => a === b || (length$1(a) === length$1(b) && every(a, (val, key) => (val !== undefined || hasProperty(b, key)) && b[key] === val));
-
-/**
- * Common functions and function call helpers.
+ * Write a variable length string.
  *
- * @module function
+ * @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));
+  }
+};
 
 /**
- * Calls all functions in `fs` with args. Only throws after all functions were called.
+ * Write a variable length string.
  *
- * @param {Array<function>} fs
- * @param {Array<any>} args
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
  */
-const callAll = (fs, args, i = 0) => {
-  try {
-    for (; i < fs.length; i++) {
-      fs[i](...args);
-    }
-  } finally {
-    if (i < fs.length) {
-      callAll(fs, args, i + 1);
-    }
+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)));
   }
 };
 
 /**
- * @template A
+ * Write a variable length string.
  *
- * @param {A} a
- * @return {A}
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
  */
-const id = a => a;
+/* c8 ignore next */
+const writeVarString = (utf8TextEncoder && /** @type {any} */ (utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill;
 
 /**
- * @template V
- * @template {V} OPTS
+ * Append fixed-length Uint8Array to the encoder.
  *
- * @param {V} value
- * @param {Array<OPTS>} options
+ * @function
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
  */
-// @ts-ignore
-const isOneOf = (value, options) => options.includes(value);
+const writeUint8Array = (encoder, uint8Array) => {
+  const bufferLen = encoder.cbuf.length;
+  const cpos = encoder.cpos;
+  const leftCopyLen = min$2(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$3(bufferLen * 2, rightCopyLen));
+    // copy array
+    encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
+    encoder.cpos = rightCopyLen;
+  }
+};
 
 /**
- * Isomorphic module to work access the environment (query params, env variables).
+ * Append an Uint8Array to Encoder.
  *
- * @module map
+ * @function
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
  */
-
-
-/* c8 ignore next */
-// @ts-ignore
-const isNode = typeof process !== 'undefined' && process.release &&
-  /node|io\.js/.test(process.release.name);
+const writeVarUint8Array = (encoder, uint8Array) => {
+  writeVarUint(encoder, uint8Array.byteLength);
+  writeUint8Array(encoder, uint8Array);
+};
 
 /**
- * @type {Map<string,string>}
+ * 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}
  */
-let params;
-
-/* c8 ignore start */
-const computeParams = () => {
-  if (params === undefined) {
-    if (isNode) {
-      params = create$5();
-      const pargs = process.argv;
-      let currParamName = null;
-      for (let i = 0; i < pargs.length; i++) {
-        const parg = pargs[i];
-        if (parg[0] === '-') {
-          if (currParamName !== null) {
-            params.set(currParamName, '');
-          }
-          currParamName = parg;
-        } else {
-          if (currParamName !== null) {
-            params.set(currParamName, parg);
-            currParamName = null;
-          }
-        }
-      }
-      if (currParamName !== null) {
-        params.set(currParamName, '');
-      }
-      // 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
-      (location.search || '?').slice(1).split('&').forEach((kv) => {
-        if (kv.length !== 0) {
-          const [key, value] = kv.split('=');
-          params.set(`--${fromCamelCase(key, '-')}`, value);
-          params.set(`-${fromCamelCase(key, '-')}`, value);
-        }
-      });
-    } else {
-      params = create$5();
-    }
-  }
-  return params
+const writeOnDataView = (encoder, len) => {
+  verifyLen(encoder, len);
+  const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len);
+  encoder.cpos += len;
+  return dview
 };
-/* c8 ignore stop */
 
 /**
- * @param {string} name
- * @return {boolean}
+ * @param {Encoder} encoder
+ * @param {number} num
  */
-/* c8 ignore next */
-const hasParam = (name) => computeParams().has(name);
+const writeFloat32 = (encoder, num) => writeOnDataView(encoder, 4).setFloat32(0, num, false);
 
 /**
- * @param {string} name
- * @return {string|null}
+ * @param {Encoder} encoder
+ * @param {number} num
  */
-/* c8 ignore next 4 */
-const getVariable = (name) =>
-  isNode
-    ? undefinedToNull(process.env[name.toUpperCase()])
-    : undefinedToNull(varStorage.getItem(name));
+const writeFloat64 = (encoder, num) => writeOnDataView(encoder, 8).setFloat64(0, num, false);
 
 /**
- * @param {string} name
- * @return {boolean}
+ * @param {Encoder} encoder
+ * @param {bigint} num
  */
-/* c8 ignore next 2 */
-const hasConf = (name) =>
-  hasParam('--' + name) || getVariable(name) !== null;
-
-/* c8 ignore next */
-hasConf('production');
-
-/* c8 ignore next 2 */
-const forceColor = isNode &&
-  isOneOf(process.env.FORCE_COLOR, ['true', '1', '2']);
-
-/* c8 ignore start */
-const supportsColor = !hasParam('no-colors') &&
-  (!isNode || process.stdout.isTTY || forceColor) && (
-  !isNode || hasParam('color') || forceColor ||
-    getVariable('COLORTERM') !== null ||
-    (getVariable('TERM') || '').includes('color')
-);
-/* c8 ignore stop */
-
-/* eslint-env browser */
+const writeBigInt64 = (encoder, num) => /** @type {any} */ (writeOnDataView(encoder, 8)).setBigInt64(0, num, false);
 
+const floatTestBed = new DataView(new ArrayBuffer(4));
 /**
- * Binary data constants.
+ * Check if a number can be encoded as a 32 bit float.
  *
- * @module binary
+ * @param {number} num
+ * @return {boolean}
  */
+const isFloat32 = num => {
+  floatTestBed.setFloat32(0, num);
+  return floatTestBed.getFloat32(0) === num
+};
 
 /**
- * n-th bit activated.
+ * Encode data with efficient binary format.
  *
- * @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.
+ * 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.
  *
- * @module number
- */
-
-
-const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
-
-/* c8 ignore next */
-const isInteger = Number.isInteger || (num => typeof num === 'number' && isFinite(num) && floor$2(num) === num);
-
-/**
- * Error helpers.
+ * Encoding table:
  *
- * @module error
- */
-
-/**
- * @param {string} s
- * @return {Error}
- */
-/* c8 ignore next */
+ * | 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$2(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)
+  }
+}
+
+/**
+ * Error helpers.
+ *
+ * @module error
+ */
+
+/**
+ * @param {string} s
+ * @return {Error}
+ */
+/* c8 ignore next */
 const create$3 = s => new Error(s);
 
 /**
@@ -1244,7 +1602,7 @@ const hasContent = decoder => decoder.pos !== decoder.arr.length;
  * @return {Uint8Array}
  */
 const readUint8Array = (decoder, len) => {
-  const view = createUint8ArrayViewFromArrayBuffer(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+  const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
   decoder.pos += len;
   return view
 };
@@ -1576,717 +1934,418 @@ class StringDecoder {
     /**
      * @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
-  }
-}
-
-/**
- * Utility functions to work with buffers (Uint8Array).
- *
- * @module buffer
- */
-
-
-/**
- * @param {number} len
- */
-const createUint8ArrayFromLen = len => new Uint8Array(len);
-
-/**
- * Create Uint8Array with initial content from buffer
- *
- * @param {ArrayBuffer} buffer
- * @param {number} byteOffset
- * @param {number} length
- */
-const createUint8ArrayViewFromArrayBuffer = (buffer, byteOffset, length) => new Uint8Array(buffer, byteOffset, length);
-
-/**
- * Copy the content of an Uint8Array view to a new ArrayBuffer.
- *
- * @param {Uint8Array} uint8Array
- * @return {Uint8Array}
- */
-const copyUint8Array = uint8Array => {
-  const newBuf = createUint8ArrayFromLen(uint8Array.byteLength);
-  newBuf.set(uint8Array);
-  return newBuf
-};
-
-/**
- * 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 = encoder => {
-  let len = encoder.cpos;
-  for (let i = 0; i < encoder.bufs.length; i++) {
-    len += encoder.bufs[i].length;
+    this.spos = 0;
   }
-  return len
-};
 
-/**
- * Transform to Uint8Array.
- *
- * @function
- * @param {Encoder} encoder
- * @return {Uint8Array} The created ArrayBuffer.
- */
-const toUint8Array = encoder => {
-  const uint8arr = new Uint8Array(length(encoder));
-  let curPos = 0;
-  for (let i = 0; i < encoder.bufs.length; i++) {
-    const d = encoder.bufs[i];
-    uint8arr.set(d, curPos);
-    curPos += d.length;
+  /**
+   * @return {string}
+   */
+  read () {
+    const end = this.spos + this.decoder.read();
+    const res = this.str.slice(this.spos, end);
+    this.spos = end;
+    return res
   }
-  uint8arr.set(createUint8ArrayViewFromArrayBuffer(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(createUint8ArrayViewFromArrayBuffer(encoder.cbuf.buffer, 0, encoder.cpos));
-    encoder.cbuf = new Uint8Array(max$3(bufferLen, len) * 2);
-    encoder.cpos = 0;
-  }
-};
+/* eslint-env browser */
+
+const getRandomValues = crypto.getRandomValues.bind(crypto);
 
 /**
- * Write one byte to the encoder.
+ * Isomorphic module for true random numbers / buffers / uuids.
  *
- * @function
- * @param {Encoder} encoder
- * @param {number} num The byte that is to be encoded.
+ * Attention: falls back to Math.random if the browser does not support crypto.
+ *
+ * @module random
  */
-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;
-};
+
+
+const uint32 = () => getRandomValues(new Uint32Array(1))[0];
+
+// @ts-ignore
+const uuidv4Template = [1e7] + -1e3 + -4e3 + -8e3 + -1e11;
 
 /**
- * Write one byte as an unsigned integer.
- *
- * @function
- * @param {Encoder} encoder
- * @param {number} num The number that is to be encoded.
+ * @return {string}
  */
-const writeUint8 = write;
+const uuidv4 = () => uuidv4Template.replace(/[018]/g, /** @param {number} c */ c =>
+  (c ^ uint32() & 15 >> c / 4).toString(16)
+);
 
 /**
- * Write a variable length unsigned integer. Max encodable integer is 2^53.
+ * Utility helpers to work with promises.
  *
- * @function
- * @param {Encoder} encoder
- * @param {number} num The number that is to be encoded.
+ * @module promise
  */
-const writeVarUint = (encoder, num) => {
-  while (num > BITS7) {
-    write(encoder, BIT8 | (BITS7 & num));
-    num = floor$2(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.
+ * @template T
+ * @callback PromiseResolve
+ * @param {T|PromiseLike<T>} [result]
  */
-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$2(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$2(num / 128); // shift >>> 7
-  }
-};
 
 /**
- * A cache to store strings temporarily
+ * @template T
+ * @param {function(PromiseResolve<T>,function(Error):void):any} f
+ * @return {Promise<T>}
  */
-const _strBuffer = new Uint8Array(30000);
-const _maxStrBSize = _strBuffer.length / 3;
+const create$2 = f => /** @type {Promise<T>} */ (new Promise(f));
 
 /**
- * Write a variable length string.
+ * `Promise.all` wait for all promises in the array to resolve and return the result
+ * @template {unknown[] | []} PS
  *
- * @function
- * @param {Encoder} encoder
- * @param {String} str The string that is to be encoded.
+ * @param {PS} ps
+ * @return {Promise<{ -readonly [P in keyof PS]: Awaited<PS[P]> }>}
  */
-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));
-  }
-};
+Promise.all.bind(Promise);
 
 /**
- * Write a variable length string.
+ * Often used conditions.
  *
- * @function
- * @param {Encoder} encoder
- * @param {String} str The string that is to be encoded.
+ * @module conditions
  */
-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.
+ * @template T
+ * @param {T|null|undefined} v
+ * @return {T|null}
  */
 /* c8 ignore next */
-const writeVarString = (utf8TextEncoder && /** @type {any} */ (utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill;
+const undefinedToNull = v => v === undefined ? null : v;
+
+/* eslint-env browser */
 
 /**
- * Append fixed-length Uint8Array to the encoder.
+ * Isomorphic variable storage.
  *
- * @function
- * @param {Encoder} encoder
- * @param {Uint8Array} uint8Array
+ * Uses LocalStorage in the browser and falls back to in-memory storage.
+ *
+ * @module storage
  */
-const writeUint8Array = (encoder, uint8Array) => {
-  const bufferLen = encoder.cbuf.length;
-  const cpos = encoder.cpos;
-  const leftCopyLen = min$2(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$3(bufferLen * 2, rightCopyLen));
-    // copy array
-    encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
-    encoder.cpos = rightCopyLen;
+
+/* c8 ignore start */
+class VarStoragePolyfill {
+  constructor () {
+    this.map = new Map();
   }
-};
 
-/**
- * Append an Uint8Array to Encoder.
- *
- * @function
- * @param {Encoder} encoder
- * @param {Uint8Array} uint8Array
- */
-const writeVarUint8Array = (encoder, uint8Array) => {
-  writeVarUint(encoder, uint8Array.byteLength);
-  writeUint8Array(encoder, uint8Array);
-};
+  /**
+   * @param {string} key
+   * @param {any} newValue
+   */
+  setItem (key, newValue) {
+    this.map.set(key, newValue);
+  }
+
+  /**
+   * @param {string} key
+   */
+  getItem (key) {
+    return this.map.get(key)
+  }
+}
+/* c8 ignore stop */
 
 /**
- * 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}
+ * @type {any}
  */
-const writeOnDataView = (encoder, len) => {
-  verifyLen(encoder, len);
-  const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len);
-  encoder.cpos += len;
-  return dview
-};
+let _localStorage = new VarStoragePolyfill();
+let usePolyfill = true;
+
+/* c8 ignore start */
+try {
+  // if the same-origin rule is violated, accessing localStorage might thrown an error
+  if (typeof localStorage !== 'undefined' && localStorage) {
+    _localStorage = localStorage;
+    usePolyfill = false;
+  }
+} catch (e) { }
+/* c8 ignore stop */
 
 /**
- * @param {Encoder} encoder
- * @param {number} num
+ * This is basically localStorage in browser, or a polyfill in nodejs
  */
-const writeFloat32 = (encoder, num) => writeOnDataView(encoder, 4).setFloat32(0, num, false);
+/* c8 ignore next */
+const varStorage = _localStorage;
 
 /**
- * @param {Encoder} encoder
- * @param {number} num
+ * Utility functions for working with EcmaScript objects.
+ *
+ * @module object
  */
-const writeFloat64 = (encoder, num) => writeOnDataView(encoder, 8).setFloat64(0, num, false);
+
 
 /**
- * @param {Encoder} encoder
- * @param {bigint} num
+ * Object.assign
  */
-const writeBigInt64 = (encoder, num) => /** @type {any} */ (writeOnDataView(encoder, 8)).setBigInt64(0, num, false);
+const assign = Object.assign;
 
-const floatTestBed = new DataView(new ArrayBuffer(4));
 /**
- * Check if a number can be encoded as a 32 bit float.
- *
- * @param {number} num
- * @return {boolean}
+ * @param {Object<string,any>} obj
  */
-const isFloat32 = num => {
-  floatTestBed.setFloat32(0, num);
-  return floatTestBed.getFloat32(0) === num
-};
+const keys = Object.keys;
 
 /**
- * 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
+ * @template V
+ * @param {{[k:string]:V}} obj
+ * @param {function(V,string):any} f
  */
-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$2(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);
+const forEach$2 = (obj, f) => {
+  for (const key in obj) {
+    f(obj[key], key);
   }
 };
 
 /**
- * Now come a few stateful encoder that have their own classes.
+ * @param {Object<string,any>} obj
+ * @return {number}
  */
+const size = obj => keys(obj).length;
 
 /**
- * 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
+ * @param {Object|null|undefined} obj
  */
-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;
-    }
+const isEmpty = obj => {
+  // eslint-disable-next-line no-unreachable-loop
+  for (const _k in obj) {
+    return false
   }
-}
+  return true
+};
 
 /**
- * @param {UintOptRleEncoder} encoder
+ * @param {Object<string,any>} obj
+ * @param {function(any,string):boolean} f
+ * @return {boolean}
  */
-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
+const every = (obj, f) => {
+  for (const key in obj) {
+    if (!f(obj[key], key)) {
+      return false
     }
   }
+  return true
 };
 
 /**
- * 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.
+ * Calls `Object.prototype.hasOwnProperty`.
  *
- * Encodes [1,2,3,3,3] as [1,2,-3,3] (once 1, once 2, three times 3)
+ * @param {any} obj
+ * @param {string|symbol} key
+ * @return {boolean}
  */
-class UintOptRleEncoder {
-  constructor () {
-    this.encoder = new Encoder();
-    /**
-     * @type {number}
-     */
-    this.s = 0;
-    this.count = 0;
-  }
+const hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
 
-  /**
-   * @param {number} v
-   */
-  write (v) {
-    if (this.s === v) {
-      this.count++;
-    } else {
-      flushUintOptRleEncoder(this);
-      this.count = 1;
-      this.s = v;
+/**
+ * @param {Object<string,any>} a
+ * @param {Object<string,any>} b
+ * @return {boolean}
+ */
+const equalFlat = (a, b) => a === b || (size(a) === size(b) && every(a, (val, key) => (val !== undefined || hasProperty(b, key)) && b[key] === val));
+
+/**
+ * Make an object immutable. This hurts performance and is usually not needed if you perform good
+ * coding practices.
+ */
+const freeze = Object.freeze;
+
+/**
+ * Make an object and all its children immutable.
+ * This *really* hurts performance and is usually not needed if you perform good coding practices.
+ *
+ * @template {any} T
+ * @param {T} o
+ * @return {Readonly<T>}
+ */
+const deepFreeze = (o) => {
+  for (const key in o) {
+    const c = o[key];
+    if (typeof c === 'object' || typeof c === 'function') {
+      deepFreeze(o[key]);
     }
   }
+  return freeze(o)
+};
+
+/**
+ * Common functions and function call helpers.
+ *
+ * @module function
+ */
 
-  toUint8Array () {
-    flushUintOptRleEncoder(this);
-    return toUint8Array(this.encoder)
-  }
-}
 
 /**
- * @param {IntDiffOptRleEncoder} encoder
+ * Calls all functions in `fs` with args. Only throws after all functions were called.
+ *
+ * @param {Array<function>} fs
+ * @param {Array<any>} args
  */
-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
+const callAll = (fs, args, i = 0) => {
+  try {
+    for (; i < fs.length; i++) {
+      fs[i](...args);
+    }
+  } finally {
+    if (i < fs.length) {
+      callAll(fs, args, i + 1);
     }
   }
 };
 
 /**
- * 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])
+ * @template A
  *
- * 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)
+ * @param {A} a
+ * @return {A}
+ */
+const id = a => a;
+
+/**
+ * @template V
+ * @template {V} OPTS
  *
- * Therefore, only five bits remain to encode diff ranges.
+ * @param {V} value
+ * @param {Array<OPTS>} options
+ */
+// @ts-ignore
+const isOneOf = (value, options) => options.includes(value);
+
+/**
+ * Isomorphic module to work access the environment (query params, env variables).
  *
- * Use this Encoder only when appropriate. In most cases, this is probably a bad idea.
+ * @module environment
  */
-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;
-    }
-  }
 
-  toUint8Array () {
-    flushIntDiffOptRleEncoder(this);
-    return toUint8Array(this.encoder)
-  }
-}
+/* c8 ignore next 2 */
+// @ts-ignore
+const isNode = typeof process !== 'undefined' && process.release && /node|io\.js/.test(process.release.name) && Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
 
 /**
- * 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.
+ * @type {Map<string,string>}
  */
-class StringEncoder {
-  constructor () {
-    /**
-     * @type {Array<string>}
-     */
-    this.sarr = [];
-    this.s = '';
-    this.lensE = new UintOptRleEncoder();
-  }
+let params;
 
-  /**
-   * @param {string} string
-   */
-  write (string) {
-    this.s += string;
-    if (this.s.length > 19) {
-      this.sarr.push(this.s);
-      this.s = '';
+/* c8 ignore start */
+const computeParams = () => {
+  if (params === undefined) {
+    if (isNode) {
+      params = create$5();
+      const pargs = process.argv;
+      let currParamName = null;
+      for (let i = 0; i < pargs.length; i++) {
+        const parg = pargs[i];
+        if (parg[0] === '-') {
+          if (currParamName !== null) {
+            params.set(currParamName, '');
+          }
+          currParamName = parg;
+        } else {
+          if (currParamName !== null) {
+            params.set(currParamName, parg);
+            currParamName = null;
+          }
+        }
+      }
+      if (currParamName !== null) {
+        params.set(currParamName, '');
+      }
+      // 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
+      (location.search || '?').slice(1).split('&').forEach((kv) => {
+        if (kv.length !== 0) {
+          const [key, value] = kv.split('=');
+          params.set(`--${fromCamelCase(key, '-')}`, value);
+          params.set(`-${fromCamelCase(key, '-')}`, value);
+        }
+      });
+    } else {
+      params = create$5();
     }
-    this.lensE.write(string.length);
   }
+  return params
+};
+/* c8 ignore stop */
 
-  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)
-  }
-}
+/**
+ * @param {string} name
+ * @return {boolean}
+ */
+/* c8 ignore next */
+const hasParam = (name) => computeParams().has(name);
 
-/* eslint-env browser */
+/**
+ * @param {string} name
+ * @return {string|null}
+ */
+/* c8 ignore next 4 */
+const getVariable = (name) =>
+  isNode
+    ? undefinedToNull(process.env[name.toUpperCase().replaceAll('-', '_')])
+    : undefinedToNull(varStorage.getItem(name));
 
-const getRandomValues = crypto.getRandomValues.bind(crypto);
+/**
+ * @param {string} name
+ * @return {boolean}
+ */
+/* c8 ignore next 2 */
+const hasConf = (name) =>
+  hasParam('--' + name) || getVariable(name) !== null;
 
-const uint32 = () => getRandomValues(new Uint32Array(1))[0];
+/* c8 ignore next */
+hasConf('production');
 
-// @ts-ignore
-const uuidv4Template = [1e7] + -1e3 + -4e3 + -8e3 + -1e11;
-const uuidv4 = () => uuidv4Template.replace(/[018]/g, /** @param {number} c */ c =>
-  (c ^ uint32() & 15 >> c / 4).toString(16)
-);
+/* c8 ignore next 2 */
+const forceColor = isNode &&
+  isOneOf(process.env.FORCE_COLOR, ['true', '1', '2']);
 
+/* c8 ignore start */
 /**
- * Utility helpers to work with promises.
+ * Color is enabled by default if the terminal supports it.
  *
- * @module promise
+ * Explicitly enable color using `--color` parameter
+ * Disable color using `--no-color` parameter or using `NO_COLOR=1` environment variable.
+ * `FORCE_COLOR=1` enables color and takes precedence over all.
  */
-
+const supportsColor = forceColor || (
+  !hasParam('--no-colors') && // @todo deprecate --no-colors
+  !hasConf('no-color') &&
+  (!isNode || process.stdout.isTTY) && (
+    !isNode ||
+    hasParam('--color') ||
+    getVariable('COLORTERM') !== null ||
+    (getVariable('TERM') || '').includes('color')
+  )
+);
+/* c8 ignore stop */
 
 /**
- * @template T
- * @callback PromiseResolve
- * @param {T|PromiseLike<T>} [result]
+ * Utility functions to work with buffers (Uint8Array).
+ *
+ * @module buffer
  */
 
+
 /**
- * @template T
- * @param {function(PromiseResolve<T>,function(Error):void):any} f
- * @return {Promise<T>}
+ * @param {number} len
  */
-const create$2 = f => /** @type {Promise<T>} */ (new Promise(f));
+const createUint8ArrayFromLen = len => new Uint8Array(len);
 
 /**
- * `Promise.all` wait for all promises in the array to resolve and return the result
- * @template {unknown[] | []} PS
+ * Copy the content of an Uint8Array view to a new ArrayBuffer.
  *
- * @param {PS} ps
- * @return {Promise<{ -readonly [P in keyof PS]: Awaited<PS[P]> }>}
+ * @param {Uint8Array} uint8Array
+ * @return {Uint8Array}
  */
-Promise.all.bind(Promise);
+const copyUint8Array = uint8Array => {
+  const newBuf = createUint8ArrayFromLen(uint8Array.byteLength);
+  newBuf.set(uint8Array);
+  return newBuf
+};
 
 /**
  * Working with value pairs.
@@ -2336,8 +2395,6 @@ const mapToStyleString = m => map(m, (value, key) => `${key}:${value};`).join(''
 
 /**
  * Return fresh symbol.
- *
- * @return {Symbol}
  */
 const create = Symbol;
 
@@ -2353,17 +2410,36 @@ const UNCOLOR = create();
 
 /* c8 ignore start */
 /**
- * @param {Array<string|Symbol|Object|number>} args
- * @return {Array<string|object|number>}
+ * @param {Array<undefined|string|Symbol|Object|number|function():any>} args
+ * @return {Array<string|object|number|undefined>}
  */
 const computeNoColorLoggingArgs = args => {
+  if (args.length === 1 && args[0]?.constructor === Function) {
+    args = /** @type {Array<string|Symbol|Object|number>} */ (/** @type {[function]} */ (args)[0]());
+  }
+  const strBuilder = [];
   const logArgs = [];
   // try with formatting until we find something unsupported
   let i = 0;
   for (; i < args.length; i++) {
     const arg = args[i];
-    if (arg.constructor === String || arg.constructor === Number) ; else if (arg.constructor === Object) {
-      logArgs.push(JSON.stringify(arg));
+    if (arg === undefined) {
+      break
+    } else if (arg.constructor === String || arg.constructor === Number) {
+      strBuilder.push(arg);
+    } else if (arg.constructor === Object) {
+      break
+    }
+  }
+  if (i > 0) {
+    // create logArgs with what we have so far
+    logArgs.push(strBuilder.join(''));
+  }
+  // append the rest
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    if (!(arg instanceof Symbol)) {
+      logArgs.push(arg);
     }
   }
   return logArgs
@@ -2393,11 +2469,14 @@ const _browserStyleMap = {
 };
 
 /**
- * @param {Array<string|Symbol|Object|number>} args
+ * @param {Array<string|Symbol|Object|number|function():any>} args
  * @return {Array<string|object|number>}
  */
 /* c8 ignore start */
 const computeBrowserLoggingArgs = (args) => {
+  if (args.length === 1 && args[0]?.constructor === Function) {
+    args = /** @type {Array<string|Symbol|Object|number>} */ (/** @type {[function]} */ (args)[0]());
+  }
   const strBuilder = [];
   const styles = [];
   const currentStyle = create$5();
@@ -2414,6 +2493,9 @@ const computeBrowserLoggingArgs = (args) => {
     if (style !== undefined) {
       currentStyle.set(style.left, style.right);
     } else {
+      if (arg === undefined) {
+        break
+      }
       if (arg.constructor === String || arg.constructor === Number) {
         const style = mapToStyleString(currentStyle);
         if (i > 0 || style.length > 0) {
@@ -2452,9 +2534,19 @@ const computeLoggingArgs = supportsColor
 /**
  * @param {Array<string|Symbol|Object|number>} args
  */
-const print = (...args) => {
-  console.log(...computeLoggingArgs(args));
-  /* c8 ignore next */
+const print = (...args) => {
+  console.log(...computeLoggingArgs(args));
+  /* c8 ignore next */
+  vconsoles.forEach((vc) => vc.print(args));
+};
+
+/* c8 ignore start */
+/**
+ * @param {Array<string|Symbol|Object|number>} args
+ */
+const warn = (...args) => {
+  console.warn(...computeLoggingArgs(args));
+  args.unshift(ORANGE);
   vconsoles.forEach((vc) => vc.print(args));
 };
 
@@ -2551,9 +2643,12 @@ class DeleteSet {
 const iterateDeletedStructs = (transaction, ds, f) =>
   ds.clients.forEach((deletes, clientid) => {
     const structs = /** @type {Array<GC|Item>} */ (transaction.doc.store.clients.get(clientid));
-    for (let i = 0; i < deletes.length; i++) {
-      const del = deletes[i];
-      iterateStructs(transaction, structs, del.clock, del.len, f);
+    if (structs != null) {
+      const lastStruct = structs[structs.length - 1];
+      const clockState = lastStruct.id.clock + lastStruct.length;
+      for (let i = 0, del = deletes[i]; i < deletes.length && del.clock < clockState; del = deletes[++i]) {
+        iterateStructs(transaction, structs, del.clock, del.len, f);
+      }
     }
   });
 
@@ -2825,6 +2920,7 @@ const readAndApplyDeleteSet = (decoder, transaction, store) => {
  * @module Y
  */
 
+
 const generateNewClientId = uint32;
 
 /**
@@ -2838,11 +2934,27 @@ const generateNewClientId = uint32;
  * @property {boolean} [DocOpts.shouldLoad] Whether the document should be synced by the provider now. This is toggled to true when you call ydoc.load()
  */
 
+/**
+ * @typedef {Object} DocEvents
+ * @property {function(Doc):void} DocEvents.destroy
+ * @property {function(Doc):void} DocEvents.load
+ * @property {function(boolean, Doc):void} DocEvents.sync
+ * @property {function(Uint8Array, any, Doc, Transaction):void} DocEvents.update
+ * @property {function(Uint8Array, any, Doc, Transaction):void} DocEvents.updateV2
+ * @property {function(Doc):void} DocEvents.beforeAllTransactions
+ * @property {function(Transaction, Doc):void} DocEvents.beforeTransaction
+ * @property {function(Transaction, Doc):void} DocEvents.beforeObserverCalls
+ * @property {function(Transaction, Doc):void} DocEvents.afterTransaction
+ * @property {function(Transaction, Doc):void} DocEvents.afterTransactionCleanup
+ * @property {function(Doc, Array<Transaction>):void} DocEvents.afterAllTransactions
+ * @property {function({ loaded: Set<Doc>, added: Set<Doc>, removed: Set<Doc> }, Doc, Transaction):void} DocEvents.subdocs
+ */
+
 /**
  * A Yjs instance handles the state of shared data.
- * @extends Observable<string>
+ * @extends ObservableV2<DocEvents>
  */
-class Doc extends Observable {
+class Doc extends ObservableV2 {
   /**
    * @param {DocOpts} opts configuration
    */
@@ -2893,8 +3005,9 @@ class Doc extends Observable {
      * lost (with false as a parameter).
      */
     this.isSynced = false;
+    this.isDestroyed = false;
     /**
-     * Promise that resolves once the document has been loaded from a presistence provider.
+     * Promise that resolves once the document has been loaded from a persistence provider.
      */
     this.whenLoaded = create$2(resolve => {
       this.on('load', () => {
@@ -2919,8 +3032,8 @@ class Doc extends Observable {
         this.whenSynced = provideSyncedPromise();
       }
       this.isSynced = isSynced === undefined || isSynced === true;
-      if (!this.isLoaded) {
-        this.emit('load', []);
+      if (this.isSynced && !this.isLoaded) {
+        this.emit('load', [this]);
       }
     });
     /**
@@ -2941,7 +3054,7 @@ class Doc extends Observable {
   load () {
     const item = this._item;
     if (item !== null && !this.shouldLoad) {
-      transact(/** @type {any} */ (item.parent).doc, transaction => {
+      transact$1(/** @type {any} */ (item.parent).doc, transaction => {
         transaction.subdocsLoaded.add(this);
       }, null, true);
     }
@@ -2970,36 +3083,37 @@ class Doc extends Observable {
    * @public
    */
   transact (f, origin = null) {
-    return transact(this, f, origin)
+    return transact$1(this, f, origin)
   }
 
   /**
    * Define a shared data type.
    *
-   * Multiple calls of `y.get(name, TypeConstructor)` yield the same result
+   * Multiple calls of `ydoc.get(name, TypeConstructor)` yield the same result
    * and do not overwrite each other. I.e.
-   * `y.define(name, Y.Array) === y.define(name, Y.Array)`
+   * `ydoc.get(name, Y.Array) === ydoc.get(name, Y.Array)`
    *
-   * After this method is called, the type is also available on `y.share.get(name)`.
+   * After this method is called, the type is also available on `ydoc.share.get(name)`.
    *
    * *Best Practices:*
-   * Define all types right after the Yjs instance is created and store them in a separate object.
+   * Define all types right after the Y.Doc instance is created and store them in a separate object.
    * Also use the typed methods `getText(name)`, `getArray(name)`, ..
    *
+   * @template {typeof AbstractType<any>} Type
    * @example
-   *   const y = new Y(..)
+   *   const ydoc = new Y.Doc(..)
    *   const appState = {
-   *     document: y.getText('document')
-   *     comments: y.getArray('comments')
+   *     document: ydoc.getText('document')
+   *     comments: ydoc.getArray('comments')
    *   }
    *
    * @param {string} name
-   * @param {Function} TypeConstructor The constructor of the type definition. E.g. Y.Text, Y.Array, Y.Map, ...
-   * @return {AbstractType<any>} The created type. Constructed with TypeConstructor
+   * @param {Type} TypeConstructor The constructor of the type definition. E.g. Y.Text, Y.Array, Y.Map, ...
+   * @return {InstanceType<Type>} The created type. Constructed with TypeConstructor
    *
    * @public
    */
-  get (name, TypeConstructor = AbstractType) {
+  get (name, TypeConstructor = /** @type {any} */ (AbstractType)) {
     const type = setIfUndefined(this.share, name, () => {
       // @ts-ignore
       const t = new TypeConstructor();
@@ -3025,12 +3139,12 @@ class Doc extends Observable {
         t._length = type._length;
         this.share.set(name, t);
         t._integrate(this, null);
-        return t
+        return /** @type {InstanceType<Type>} */ (t)
       } else {
         throw new Error(`Type with the name ${name} has already been defined with a different constructor`)
       }
     }
-    return type
+    return /** @type {InstanceType<Type>} */ (type)
   }
 
   /**
@@ -3041,8 +3155,7 @@ class Doc extends Observable {
    * @public
    */
   getArray (name = '') {
-    // @ts-ignore
-    return this.get(name, YArray)
+    return /** @type {YArray<T>} */ (this.get(name, YArray))
   }
 
   /**
@@ -3052,7 +3165,6 @@ class Doc extends Observable {
    * @public
    */
   getText (name = '') {
-    // @ts-ignore
     return this.get(name, YText)
   }
 
@@ -3064,8 +3176,17 @@ class Doc extends Observable {
    * @public
    */
   getMap (name = '') {
-    // @ts-ignore
-    return this.get(name, YMap)
+    return /** @type {YMap<T>} */ (this.get(name, YMap))
+  }
+
+  /**
+   * @param {string} [name]
+   * @return {YXmlElement}
+   *
+   * @public
+   */
+  getXmlElement (name = '') {
+    return /** @type {YXmlElement<{[key:string]:string}>} */ (this.get(name, YXmlElement))
   }
 
   /**
@@ -3075,7 +3196,6 @@ class Doc extends Observable {
    * @public
    */
   getXmlFragment (name = '') {
-    // @ts-ignore
     return this.get(name, YXmlFragment)
   }
 
@@ -3104,6 +3224,7 @@ class Doc extends Observable {
    * Emit `destroy` event and unregister all event handlers.
    */
   destroy () {
+    this.isDestroyed = true;
     from(this.subdocs).forEach(subdoc => subdoc.destroy());
     const item = this._item;
     if (item !== null) {
@@ -3111,7 +3232,7 @@ class Doc extends Observable {
       const content = /** @type {ContentDoc} */ (item.content);
       content.doc = new Doc({ guid: this.guid, ...content.opts, shouldLoad: false });
       content.doc._item = item;
-      transact(/** @type {any} */ (item).parent.doc, transaction => {
+      transact$1(/** @type {any} */ (item).parent.doc, transaction => {
         const doc = content.doc;
         if (!item.deleted) {
           transaction.subdocsAdded.add(doc);
@@ -3119,26 +3240,11 @@ class Doc extends Observable {
         transaction.subdocsRemoved.add(this);
       }, null, true);
     }
-    this.emit('destroyed', [true]);
+    // @ts-ignore
+    this.emit('destroyed', [true]); // DEPRECATED!
     this.emit('destroy', [this]);
     super.destroy();
   }
-
-  /**
-   * @param {string} eventName
-   * @param {function(...any):any} f
-   */
-  on (eventName, f) {
-    super.on(eventName, f);
-  }
-
-  /**
-   * @param {string} eventName
-   * @param {function} f
-   */
-  off (eventName, f) {
-    super.off(eventName, f);
-  }
 }
 
 class DSDecoderV1 {
@@ -3579,7 +3685,7 @@ class UpdateEncoderV2 extends DSEncoderV2 {
      */
     this.keyMap = new Map();
     /**
-     * Refers to the next uniqe key-identifier to me used.
+     * Refers to the next unique key-identifier to me used.
      * See writeKey method for more information.
      *
      * @type {number}
@@ -3731,6 +3837,23 @@ class UpdateEncoderV2 extends DSEncoderV2 {
   }
 }
 
+/**
+ * @module encoding
+ */
+/*
+ * We use the first five bits in the info flag for determining the type of the struct.
+ *
+ * 0: GC
+ * 1: Item with Deleted content
+ * 2: Item with JSON content
+ * 3: Item with Binary content
+ * 4: Item with String content
+ * 5: Item with Embed content (for richtext content)
+ * 6: Item with Format content (a formatting marker for richtext content)
+ * 7: Item with Type
+ */
+
+
 /**
  * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
  * @param {Array<GC|Item>} structs All structs by `client`
@@ -3839,7 +3962,7 @@ const readClientsStructRefs = (decoder, doc) => {
           // @type {string|null}
           const struct = new Item(
             createID(client, clock),
-            null, // leftd
+            null, // left
             (info & BIT8) === BIT8 ? decoder.readLeftID() : null, // origin
             null, // right
             (info & BIT7) === BIT7 ? decoder.readRightID() : null, // right origin
@@ -3863,7 +3986,7 @@ const readClientsStructRefs = (decoder, doc) => {
 
           const struct = new Item(
             createID(client, clock),
-            null, // leftd
+            null, // left
             origin, // origin
             null, // right
             rightOrigin, // right origin
@@ -3896,7 +4019,7 @@ const readClientsStructRefs = (decoder, doc) => {
  * then we start emptying the stack.
  *
  * It is not possible to have circles: i.e. struct1 (from client1) depends on struct2 (from client2)
- * depends on struct3 (from client1). Therefore the max stack size is eqaul to `structReaders.length`.
+ * depends on struct3 (from client1). Therefore the max stack size is equal to `structReaders.length`.
  *
  * This method is implemented in a way so that we can resume computation if this update
  * causally depends on another update.
@@ -3935,7 +4058,7 @@ const integrateStructs = (transaction, store, clientsStructRefs) => {
     return nextStructsTarget
   };
   let curStructsTarget = getNextStructTarget();
-  if (curStructsTarget === null && stack.length === 0) {
+  if (curStructsTarget === null) {
     return null
   }
 
@@ -3964,14 +4087,14 @@ const integrateStructs = (transaction, store, clientsStructRefs) => {
   const addStackToRestSS = () => {
     for (const item of stack) {
       const client = item.id.client;
-      const unapplicableItems = clientsStructRefs.get(client);
-      if (unapplicableItems) {
+      const inapplicableItems = clientsStructRefs.get(client);
+      if (inapplicableItems) {
         // decrement because we weren't able to apply previous operation
-        unapplicableItems.i--;
-        restStructs.clients.set(client, unapplicableItems.refs.slice(unapplicableItems.i));
+        inapplicableItems.i--;
+        restStructs.clients.set(client, inapplicableItems.refs.slice(inapplicableItems.i));
         clientsStructRefs.delete(client);
-        unapplicableItems.i = 0;
-        unapplicableItems.refs = [];
+        inapplicableItems.i = 0;
+        inapplicableItems.refs = [];
       } else {
         // item was the last item on clientsStructRefs and the field was already cleared. Add item to restStructs and continue
         restStructs.clients.set(client, [item]);
@@ -4055,7 +4178,7 @@ const writeStructsFromTransaction = (encoder, transaction) => writeClientsStruct
 /**
  * Read and apply a document update.
  *
- * This function has the same effect as `applyUpdate` but accepts an decoder.
+ * This function has the same effect as `applyUpdate` but accepts a decoder.
  *
  * @param {decoding.Decoder} decoder
  * @param {Doc} ydoc
@@ -4065,7 +4188,7 @@ const writeStructsFromTransaction = (encoder, transaction) => writeClientsStruct
  * @function
  */
 const readUpdateV2 = (decoder, ydoc, transactionOrigin, structDecoder = new UpdateDecoderV2(decoder)) =>
-  transact(ydoc, transaction => {
+  transact$1(ydoc, transaction => {
     // force that transaction.local is set to non-local
     transaction.local = false;
     let retry = false;
@@ -4670,7 +4793,8 @@ const iterateStructs = (transaction, structs, clockStart, len, f) => {
  * possible. Here is an example to illustrate the advantages of bundling:
  *
  * @example
- * const map = y.define('map', YMap)
+ * const ydoc = new Y.Doc()
+ * const map = ydoc.getMap('map')
  * // Log content when change is triggered
  * map.observe(() => {
  *   console.log('change triggered')
@@ -4679,7 +4803,7 @@ const iterateStructs = (transaction, structs, clockStart, len, f) => {
  * map.set('a', 0) // => "change triggered"
  * map.set('b', 0) // => "change triggered"
  * // When put in a transaction, it will trigger the log after the transaction:
- * y.transact(() => {
+ * ydoc.transact(() => {
  *   map.set('a', 1)
  *   map.set('b', 1)
  * }) // => "change triggered"
@@ -4855,7 +4979,7 @@ const tryGcDeleteSet = (ds, store, gcFilter) => {
  */
 const tryMergeDeleteSet = (ds, store) => {
   // try to merge deleted / gc'd items
-  // merge from right to left for better efficiecy and so we don't miss any merge targets
+  // merge from right to left for better efficiency and so we don't miss any merge targets
   ds.clients.forEach((deleteItems, client) => {
     const structs = /** @type {Array<GC|Item>} */ (store.clients.get(client));
     for (let di = deleteItems.length - 1; di >= 0; di--) {
@@ -5025,7 +5149,7 @@ const cleanupTransactions = (transactionCleanups, i) => {
  *
  * @function
  */
-const transact = (doc, f, origin = null, local = true) => {
+const transact$1 = (doc, f, origin = null, local = true) => {
   const transactionCleanups = doc._transactionCleanups;
   let initialCall = false;
   /**
@@ -5720,8 +5844,8 @@ const getPathTo = (parent, child) => {
       let i = 0;
       let c = /** @type {AbstractType<any>} */ (child._item.parent)._start;
       while (c !== child._item && c !== null) {
-        if (!c.deleted) {
-          i++;
+        if (!c.deleted && c.countable) {
+          i += c.length;
         }
         c = c.right;
       }
@@ -5732,6 +5856,11 @@ const getPathTo = (parent, child) => {
   return path
 };
 
+/**
+ * https://docs.yjs.dev/getting-started/working-with-shared-types#caveats
+ */
+const warnPrematureAccess = () => { warn('Invalid access: Add Yjs type to a document before reading data.'); };
+
 const maxSearchMarker = 80;
 
 /**
@@ -5863,11 +5992,11 @@ const findMarker = (yarray, index) => {
   //   }
   // }
   // if (marker) {
-  //   if (window.lengthes == null) {
-  //     window.lengthes = []
-  //     window.getLengthes = () => window.lengthes.sort((a, b) => a - b)
+  //   if (window.lengths == null) {
+  //     window.lengths = []
+  //     window.getLengths = () => window.lengths.sort((a, b) => a - b)
   //   }
-  //   window.lengthes.push(marker.index - pindex)
+  //   window.lengths.push(marker.index - pindex)
   //   console.log('distance', marker.index - pindex, 'len', p && p.parent.length)
   // }
   if (marker !== null && abs$2(marker.index - pindex) < /** @type {YText|YArray<any>} */ (p.parent).length / maxSearchMarker) {
@@ -6014,6 +6143,10 @@ class AbstractType {
   }
 
   /**
+   * Makes a copy of this data type that can be included somewhere else.
+   *
+   * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
+   *
    * @return {AbstractType<EventType>}
    */
   clone () {
@@ -6102,6 +6235,7 @@ class AbstractType {
  * @function
  */
 const typeListSlice = (type, start, end) => {
+  type.doc ?? warnPrematureAccess();
   if (start < 0) {
     start = type._length + start;
   }
@@ -6137,6 +6271,7 @@ const typeListSlice = (type, start, end) => {
  * @function
  */
 const typeListToArray = type => {
+  type.doc ?? warnPrematureAccess();
   const cs = [];
   let n = type._start;
   while (n !== null) {
@@ -6152,7 +6287,7 @@ const typeListToArray = type => {
 };
 
 /**
- * Executes a provided function on once on overy element of this YArray.
+ * Executes a provided function on once on every element of this YArray.
  *
  * @param {AbstractType<any>} type
  * @param {function(any,number,any):void} f A function to execute on every element of this YArray.
@@ -6163,6 +6298,7 @@ const typeListToArray = type => {
 const typeListForEach = (type, f) => {
   let index = 0;
   let n = type._start;
+  type.doc ?? warnPrematureAccess();
   while (n !== null) {
     if (n.countable && !n.deleted) {
       const c = n.content.getContent();
@@ -6252,6 +6388,7 @@ const typeListCreateIterator = type => {
  * @function
  */
 const typeListGet = (type, index) => {
+  type.doc ?? warnPrematureAccess();
   const marker = findMarker(type, index);
   let n = type._start;
   if (marker !== null) {
@@ -6332,7 +6469,7 @@ const typeListInsertGenericsAfter = (transaction, parent, referenceItem, content
   packJsonContent();
 };
 
-const lengthExceeded = create$3('Length exceeded!');
+const lengthExceeded = () => create$3('Length exceeded!');
 
 /**
  * @param {Transaction} transaction
@@ -6345,7 +6482,7 @@ const lengthExceeded = create$3('Length exceeded!');
  */
 const typeListInsertGenerics = (transaction, parent, index, content) => {
   if (index > parent._length) {
-    throw lengthExceeded
+    throw lengthExceeded()
   }
   if (index === 0) {
     if (parent._searchMarker) {
@@ -6386,7 +6523,7 @@ const typeListInsertGenerics = (transaction, parent, index, content) => {
 
 /**
  * Pushing content is special as we generally want to push after the last item. So we don't have to update
- * the serach marker.
+ * the search marker.
  *
  * @param {Transaction} transaction
  * @param {AbstractType<any>} parent
@@ -6447,7 +6584,7 @@ const typeListDelete = (transaction, parent, index, length) => {
     n = n.right;
   }
   if (length > 0) {
-    throw lengthExceeded
+    throw lengthExceeded()
   }
   if (parent._searchMarker) {
     updateMarkerChanges(parent._searchMarker, startIndex, -startLength + length /* in case we remove the above exception */);
@@ -6492,6 +6629,8 @@ const typeMapSet = (transaction, parent, key, value) => {
       case Boolean:
       case Array:
       case String:
+      case Date:
+      case BigInt:
         content = new ContentAny([value]);
         break
       case Uint8Array:
@@ -6520,6 +6659,7 @@ const typeMapSet = (transaction, parent, key, value) => {
  * @function
  */
 const typeMapGet = (parent, key) => {
+  parent.doc ?? warnPrematureAccess();
   const val = parent._map.get(key);
   return val !== undefined && !val.deleted ? val.content.getContent()[val.length - 1] : undefined
 };
@@ -6536,6 +6676,7 @@ const typeMapGetAll = (parent) => {
    * @type {Object<string,any>}
    */
   const res = {};
+  parent.doc ?? warnPrematureAccess();
   parent._map.forEach((value, key) => {
     if (!value.deleted) {
       res[key] = value.content.getContent()[value.length - 1];
@@ -6553,38 +6694,62 @@ const typeMapGetAll = (parent) => {
  * @function
  */
 const typeMapHas = (parent, key) => {
+  parent.doc ?? warnPrematureAccess();
   const val = parent._map.get(key);
   return val !== undefined && !val.deleted
 };
 
 /**
- * @param {Map<string,Item>} map
+ * @param {AbstractType<any>} parent
+ * @param {Snapshot} snapshot
+ * @return {Object<string,Object<string,any>|number|null|Array<any>|string|Uint8Array|AbstractType<any>|undefined>}
+ *
+ * @private
+ * @function
+ */
+const typeMapGetAllSnapshot = (parent, snapshot) => {
+  /**
+   * @type {Object<string,any>}
+   */
+  const res = {};
+  parent._map.forEach((value, key) => {
+    /**
+     * @type {Item|null}
+     */
+    let v = value;
+    while (v !== null && (!snapshot.sv.has(v.id.client) || v.id.clock >= (snapshot.sv.get(v.id.client) || 0))) {
+      v = v.left;
+    }
+    if (v !== null && isVisible(v, snapshot)) {
+      res[key] = v.content.getContent()[v.length - 1];
+    }
+  });
+  return res
+};
+
+/**
+ * @param {AbstractType<any> & { _map: Map<string, Item> }} type
  * @return {IterableIterator<Array<any>>}
  *
  * @private
  * @function
  */
-const createMapIterator = map => iteratorFilter(map.entries(), /** @param {any} entry */ entry => !entry[1].deleted);
+const createMapIterator = type => {
+  type.doc ?? warnPrematureAccess();
+  return iteratorFilter(type._map.entries(), /** @param {any} entry */ entry => !entry[1].deleted)
+};
 
 /**
  * @module YArray
  */
 
+
 /**
  * Event that describes the changes on a YArray
  * @template T
  * @extends YEvent<YArray<T>>
  */
-class YArrayEvent extends YEvent {
-  /**
-   * @param {YArray<T>} yarray The changed type
-   * @param {Transaction} transaction The transaction object
-   */
-  constructor (yarray, transaction) {
-    super(yarray, transaction);
-    this._transaction = transaction;
-  }
-}
+class YArrayEvent extends YEvent {}
 
 /**
  * A shared Array implementation.
@@ -6645,6 +6810,10 @@ class YArray extends AbstractType {
   }
 
   /**
+   * Makes a copy of this data type that can be included somewhere else.
+   *
+   * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
+   *
    * @return {YArray<T>}
    */
   clone () {
@@ -6659,7 +6828,8 @@ class YArray extends AbstractType {
   }
 
   get length () {
-    return this._prelimContent === null ? this._length : this._prelimContent.length
+    this.doc ?? warnPrematureAccess();
+    return this._length
   }
 
   /**
@@ -6691,7 +6861,7 @@ class YArray extends AbstractType {
    */
   insert (index, content) {
     if (this.doc !== null) {
-      transact(this.doc, transaction => {
+      transact$1(this.doc, transaction => {
         typeListInsertGenerics(transaction, this, index, /** @type {any} */ (content));
       });
     } else {
@@ -6708,7 +6878,7 @@ class YArray extends AbstractType {
    */
   push (content) {
     if (this.doc !== null) {
-      transact(this.doc, transaction => {
+      transact$1(this.doc, transaction => {
         typeListPushGenerics(transaction, this, /** @type {any} */ (content));
       });
     } else {
@@ -6717,9 +6887,9 @@ class YArray extends AbstractType {
   }
 
   /**
-   * Preppends content to this YArray.
+   * Prepends content to this YArray.
    *
-   * @param {Array<T>} content Array of content to preppend.
+   * @param {Array<T>} content Array of content to prepend.
    */
   unshift (content) {
     this.insert(0, content);
@@ -6733,7 +6903,7 @@ class YArray extends AbstractType {
    */
   delete (index, length = 1) {
     if (this.doc !== null) {
-      transact(this.doc, transaction => {
+      transact$1(this.doc, transaction => {
         typeListDelete(transaction, this, index, length);
       });
     } else {
@@ -6761,7 +6931,8 @@ class YArray extends AbstractType {
   }
 
   /**
-   * Transforms this YArray to a JavaScript Array.
+   * Returns a portion of this YArray into a JavaScript Array selected
+   * from start to end (end not included).
    *
    * @param {number} [start]
    * @param {number} [end]
@@ -6794,7 +6965,7 @@ class YArray extends AbstractType {
   }
 
   /**
-   * Executes a provided function once on overy element of this YArray.
+   * Executes a provided function once on every element of this YArray.
    *
    * @param {function(T,number,YArray<T>):void} f A function to execute on every element of this YArray.
    */
@@ -6825,6 +6996,11 @@ class YArray extends AbstractType {
  */
 const readYArray = _decoder => new YArray();
 
+/**
+ * @module YMap
+ */
+
+
 /**
  * @template T
  * @extends YEvent<YMap<T>>
@@ -6847,7 +7023,7 @@ class YMapEvent extends YEvent {
  * A shared Map implementation.
  *
  * @extends AbstractType<YMapEvent<MapType>>
- * @implements {Iterable<MapType>}
+ * @implements {Iterable<[string, MapType]>}
  */
 class YMap extends AbstractType {
   /**
@@ -6895,6 +7071,10 @@ class YMap extends AbstractType {
   }
 
   /**
+   * Makes a copy of this data type that can be included somewhere else.
+   *
+   * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
+   *
    * @return {YMap<MapType>}
    */
   clone () {
@@ -6924,6 +7104,7 @@ class YMap extends AbstractType {
    * @return {Object<string,any>}
    */
   toJSON () {
+    this.doc ?? warnPrematureAccess();
     /**
      * @type {Object<string,MapType>}
      */
@@ -6943,7 +7124,7 @@ class YMap extends AbstractType {
    * @return {number}
    */
   get size () {
-    return [...createMapIterator(this._map)].length
+    return [...createMapIterator(this)].length
   }
 
   /**
@@ -6952,25 +7133,25 @@ class YMap extends AbstractType {
    * @return {IterableIterator<string>}
    */
   keys () {
-    return iteratorMap(createMapIterator(this._map), /** @param {any} v */ v => v[0])
+    return iteratorMap(createMapIterator(this), /** @param {any} v */ v => v[0])
   }
 
   /**
    * Returns the values for each element in the YMap Type.
    *
-   * @return {IterableIterator<any>}
+   * @return {IterableIterator<MapType>}
    */
   values () {
-    return iteratorMap(createMapIterator(this._map), /** @param {any} v */ v => v[1].content.getContent()[v[1].length - 1])
+    return iteratorMap(createMapIterator(this), /** @param {any} v */ v => v[1].content.getContent()[v[1].length - 1])
   }
 
   /**
    * Returns an Iterator of [key, value] pairs
    *
-   * @return {IterableIterator<any>}
+   * @return {IterableIterator<[string, MapType]>}
    */
   entries () {
-    return iteratorMap(createMapIterator(this._map), /** @param {any} v */ v => [v[0], v[1].content.getContent()[v[1].length - 1]])
+    return iteratorMap(createMapIterator(this), /** @param {any} v */ v => /** @type {any} */ ([v[0], v[1].content.getContent()[v[1].length - 1]]))
   }
 
   /**
@@ -6979,6 +7160,7 @@ class YMap extends AbstractType {
    * @param {function(MapType,string,YMap<MapType>):void} f A function to execute on every element of this YArray.
    */
   forEach (f) {
+    this.doc ?? warnPrematureAccess();
     this._map.forEach((item, key) => {
       if (!item.deleted) {
         f(item.content.getContent()[item.length - 1], key, this);
@@ -6989,7 +7171,7 @@ class YMap extends AbstractType {
   /**
    * Returns an Iterator of [key, value] pairs
    *
-   * @return {IterableIterator<any>}
+   * @return {IterableIterator<[string, MapType]>}
    */
   [Symbol.iterator] () {
     return this.entries()
@@ -7002,7 +7184,7 @@ class YMap extends AbstractType {
    */
   delete (key) {
     if (this.doc !== null) {
-      transact(this.doc, transaction => {
+      transact$1(this.doc, transaction => {
         typeMapDelete(transaction, this, key);
       });
     } else {
@@ -7020,7 +7202,7 @@ class YMap extends AbstractType {
    */
   set (key, value) {
     if (this.doc !== null) {
-      transact(this.doc, transaction => {
+      transact$1(this.doc, transaction => {
         typeMapSet(transaction, this, key, /** @type {any} */ (value));
       });
     } else {
@@ -7054,7 +7236,7 @@ class YMap extends AbstractType {
    */
   clear () {
     if (this.doc !== null) {
-      transact(this.doc, transaction => {
+      transact$1(this.doc, transaction => {
         this.forEach(function (_value, key, map) {
           typeMapDelete(transaction, map, key);
         });
@@ -7080,6 +7262,11 @@ class YMap extends AbstractType {
  */
 const readYMap = _decoder => new YMap();
 
+/**
+ * @module YText
+ */
+
+
 /**
  * @param {any} a
  * @param {any} b
@@ -7164,14 +7351,15 @@ const findNextPosition = (transaction, pos, count) => {
  * @param {Transaction} transaction
  * @param {AbstractType<any>} parent
  * @param {number} index
+ * @param {boolean} useSearchMarker
  * @return {ItemTextListPosition}
  *
  * @private
  * @function
  */
-const findPosition = (transaction, parent, index) => {
+const findPosition = (transaction, parent, index, useSearchMarker) => {
   const currentAttributes = new Map();
-  const marker = findMarker(parent, index);
+  const marker = useSearchMarker ? findMarker(parent, index) : null;
   if (marker) {
     const pos = new ItemTextListPosition(marker.p.left, marker.p, marker.index, currentAttributes);
     return findNextPosition(transaction, pos, index - marker.index)
@@ -7247,7 +7435,7 @@ const minimizeAttributeChanges = (currPos, attributes) => {
   while (true) {
     if (currPos.right === null) {
       break
-    } else if (currPos.right.deleted || (currPos.right.content.constructor === ContentFormat && equalAttrs(attributes[(/** @type {ContentFormat} */ (currPos.right.content)).key] || null, /** @type {ContentFormat} */ (currPos.right.content).value))) ; else {
+    } else if (currPos.right.deleted || (currPos.right.content.constructor === ContentFormat && equalAttrs(attributes[(/** @type {ContentFormat} */ (currPos.right.content)).key] ?? null, /** @type {ContentFormat} */ (currPos.right.content).value))) ; else {
       break
     }
     currPos.forward();
@@ -7271,7 +7459,7 @@ const insertAttributes = (transaction, parent, currPos, attributes) => {
   // insert format-start items
   for (const key in attributes) {
     const val = attributes[key];
-    const currentVal = currPos.currentAttributes.get(key) || null;
+    const currentVal = currPos.currentAttributes.get(key) ?? null;
     if (!equalAttrs(currentVal, val)) {
       // save negated attribute (set null if currentVal undefined)
       negatedAttributes.set(key, currentVal);
@@ -7433,12 +7621,12 @@ const cleanupFormattingGap = (transaction, start, curr, startAttributes, currAtt
       switch (content.constructor) {
         case ContentFormat: {
           const { key, value } = /** @type {ContentFormat} */ (content);
-          const startAttrValue = startAttributes.get(key) || null;
+          const startAttrValue = startAttributes.get(key) ?? null;
           if (endFormats.get(key) !== content || startAttrValue === value) {
             // Either this format is overwritten or it is not necessary because the attribute already existed.
             start.delete(transaction);
             cleanups++;
-            if (!reachedCurr && (currAttributes.get(key) || null) === value && startAttrValue !== value) {
+            if (!reachedCurr && (currAttributes.get(key) ?? null) === value && startAttrValue !== value) {
               if (startAttrValue === null) {
                 currAttributes.delete(key);
               } else {
@@ -7496,7 +7684,7 @@ const cleanupContextlessFormattingGap = (transaction, item) => {
  */
 const cleanupYTextFormatting = type => {
   let res = 0;
-  transact(/** @type {Doc} */ (type.doc), transaction => {
+  transact$1(/** @type {Doc} */ (type.doc), transaction => {
     let start = /** @type {Item} */ (type._start);
     let end = type._start;
     let startAttributes = create$5();
@@ -7521,7 +7709,7 @@ const cleanupYTextFormatting = type => {
 };
 
 /**
- * This will be called by the transction once the event handlers are called to potentially cleanup
+ * This will be called by the transaction once the event handlers are called to potentially cleanup
  * formatting attributes.
  *
  * @param {Transaction} transaction
@@ -7547,7 +7735,7 @@ const cleanupYTextAfterTransaction = transaction => {
     });
   }
   // cleanup in a new transaction
-  transact(doc, (t) => {
+  transact$1(doc, (t) => {
     iterateDeletedStructs(transaction, transaction.deleteSet, item => {
       if (item instanceof GC || !(/** @type {YText} */ (item.parent)._hasFormatting) || needFullCleanup.has(/** @type {YText} */ (item.parent))) {
         return
@@ -7611,7 +7799,7 @@ const deleteText = (transaction, currPos, length) => {
 
 /**
  * The Quill Delta format represents changes on a text document with
- * formatting information. For mor information visit {@link https://quilljs.com/docs/delta/|Quill Delta}
+ * formatting information. For more information visit {@link https://quilljs.com/docs/delta/|Quill Delta}
  *
  * @example
  *   {
@@ -7702,7 +7890,7 @@ class YTextEvent extends YEvent {
        * @type {Array<{insert?:string|object|AbstractType<any>, delete?:number, retain?:number, attributes?: Object<string,any>}>}
        */
       const delta = [];
-      transact(y, transaction => {
+      transact$1(y, transaction => {
         const currentAttributes = new Map(); // saves all current attributes for insert
         const oldAttributes = new Map();
         let item = this.target._start;
@@ -7813,12 +8001,12 @@ class YTextEvent extends YEvent {
               const { key, value } = /** @type {ContentFormat} */ (item.content);
               if (this.adds(item)) {
                 if (!this.deletes(item)) {
-                  const curVal = currentAttributes.get(key) || null;
+                  const curVal = currentAttributes.get(key) ?? null;
                   if (!equalAttrs(curVal, value)) {
                     if (action === 'retain') {
                       addOp();
                     }
-                    if (equalAttrs(value, (oldAttributes.get(key) || null))) {
+                    if (equalAttrs(value, (oldAttributes.get(key) ?? null))) {
                       delete attributes[key];
                     } else {
                       attributes[key] = value;
@@ -7829,7 +8017,7 @@ class YTextEvent extends YEvent {
                 }
               } else if (this.deletes(item)) {
                 oldAttributes.set(key, value);
-                const curVal = currentAttributes.get(key) || null;
+                const curVal = currentAttributes.get(key) ?? null;
                 if (!equalAttrs(curVal, value)) {
                   if (action === 'retain') {
                     addOp();
@@ -7919,6 +8107,7 @@ class YText extends AbstractType {
    * @type {number}
    */
   get length () {
+    this.doc ?? warnPrematureAccess();
     return this._length
   }
 
@@ -7941,6 +8130,10 @@ class YText extends AbstractType {
   }
 
   /**
+   * Makes a copy of this data type that can be included somewhere else.
+   *
+   * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
+   *
    * @return {YText}
    */
   clone () {
@@ -7971,6 +8164,7 @@ class YText extends AbstractType {
    * @public
    */
   toString () {
+    this.doc ?? warnPrematureAccess();
     let str = '';
     /**
      * @type {Item|null}
@@ -7998,7 +8192,7 @@ class YText extends AbstractType {
   /**
    * Apply a {@link Delta} on this shared YText type.
    *
-   * @param {any} delta The changes to apply on this element.
+   * @param {Array<any>} delta The changes to apply on this element.
    * @param {object}  opts
    * @param {boolean} [opts.sanitize] Sanitize input delta. Removes ending newlines if set to true.
    *
@@ -8007,7 +8201,7 @@ class YText extends AbstractType {
    */
   applyDelta (delta, { sanitize = true } = {}) {
     if (this.doc !== null) {
-      transact(this.doc, transaction => {
+      transact$1(this.doc, transaction => {
         const currPos = new ItemTextListPosition(null, this._start, 0, new Map());
         for (let i = 0; i < delta.length; i++) {
           const op = delta[i];
@@ -8044,6 +8238,7 @@ class YText extends AbstractType {
    * @public
    */
   toDelta (snapshot, prevSnapshot, computeYChange) {
+    this.doc ?? warnPrematureAccess();
     /**
      * @type{Array<any>}
      */
@@ -8132,7 +8327,7 @@ class YText extends AbstractType {
     if (snapshot || prevSnapshot) {
       // snapshots are merged again after the transaction, so we need to keep the
       // transaction alive until we are done
-      transact(doc, transaction => {
+      transact$1(doc, transaction => {
         if (snapshot) {
           splitSnapshotAffectedStructs(transaction, snapshot);
         }
@@ -8163,8 +8358,8 @@ class YText extends AbstractType {
     }
     const y = this.doc;
     if (y !== null) {
-      transact(y, transaction => {
-        const pos = findPosition(transaction, this, index);
+      transact$1(y, transaction => {
+        const pos = findPosition(transaction, this, index, !attributes);
         if (!attributes) {
           attributes = {};
           // @ts-ignore
@@ -8182,20 +8377,20 @@ class YText extends AbstractType {
    *
    * @param {number} index The index to insert the embed at.
    * @param {Object | AbstractType<any>} embed The Object that represents the embed.
-   * @param {TextAttributes} attributes Attribute information to apply on the
+   * @param {TextAttributes} [attributes] Attribute information to apply on the
    *                                    embed
    *
    * @public
    */
-  insertEmbed (index, embed, attributes = {}) {
+  insertEmbed (index, embed, attributes) {
     const y = this.doc;
     if (y !== null) {
-      transact(y, transaction => {
-        const pos = findPosition(transaction, this, index);
-        insertText(transaction, this, pos, embed, attributes);
+      transact$1(y, transaction => {
+        const pos = findPosition(transaction, this, index, !attributes);
+        insertText(transaction, this, pos, embed, attributes || {});
       });
     } else {
-      /** @type {Array<function>} */ (this._pending).push(() => this.insertEmbed(index, embed, attributes));
+      /** @type {Array<function>} */ (this._pending).push(() => this.insertEmbed(index, embed, attributes || {}));
     }
   }
 
@@ -8213,8 +8408,8 @@ class YText extends AbstractType {
     }
     const y = this.doc;
     if (y !== null) {
-      transact(y, transaction => {
-        deleteText(transaction, findPosition(transaction, this, index), length);
+      transact$1(y, transaction => {
+        deleteText(transaction, findPosition(transaction, this, index, true), length);
       });
     } else {
       /** @type {Array<function>} */ (this._pending).push(() => this.delete(index, length));
@@ -8237,8 +8432,8 @@ class YText extends AbstractType {
     }
     const y = this.doc;
     if (y !== null) {
-      transact(y, transaction => {
-        const pos = findPosition(transaction, this, index);
+      transact$1(y, transaction => {
+        const pos = findPosition(transaction, this, index, false);
         if (pos.right === null) {
           return
         }
@@ -8260,7 +8455,7 @@ class YText extends AbstractType {
    */
   removeAttribute (attributeName) {
     if (this.doc !== null) {
-      transact(this.doc, transaction => {
+      transact$1(this.doc, transaction => {
         typeMapDelete(transaction, this, attributeName);
       });
     } else {
@@ -8280,7 +8475,7 @@ class YText extends AbstractType {
    */
   setAttribute (attributeName, attributeValue) {
     if (this.doc !== null) {
-      transact(this.doc, transaction => {
+      transact$1(this.doc, transaction => {
         typeMapSet(transaction, this, attributeName, attributeValue);
       });
     } else {
@@ -8337,6 +8532,7 @@ const readYText = _decoder => new YText();
  * @module YXml
  */
 
+
 /**
  * Define the elements to which a set of CSS queries apply.
  * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors|CSS_Selectors}
@@ -8380,6 +8576,7 @@ class YXmlTreeWalker {
      */
     this._currentNode = /** @type {Item} */ (root._start);
     this._firstCall = true;
+    root.doc ?? warnPrematureAccess();
   }
 
   [Symbol.iterator] () {
@@ -8408,8 +8605,12 @@ class YXmlTreeWalker {
         } else {
           // walk right or up in the tree
           while (n !== null) {
-            if (n.right !== null) {
-              n = n.right;
+            /**
+             * @type {Item | null}
+             */
+            const nxt = n.next;
+            if (nxt !== null) {
+              n = nxt;
               break
             } else if (n.parent === this._root) {
               n = null;
@@ -8477,6 +8678,10 @@ class YXmlFragment extends AbstractType {
   }
 
   /**
+   * Makes a copy of this data type that can be included somewhere else.
+   *
+   * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
+   *
    * @return {YXmlFragment}
    */
   clone () {
@@ -8487,6 +8692,7 @@ class YXmlFragment extends AbstractType {
   }
 
   get length () {
+    this.doc ?? warnPrematureAccess();
     return this._prelimContent === null ? this._length : this._prelimContent.length
   }
 
@@ -8619,7 +8825,7 @@ class YXmlFragment extends AbstractType {
    */
   insert (index, content) {
     if (this.doc !== null) {
-      transact(this.doc, transaction => {
+      transact$1(this.doc, transaction => {
         typeListInsertGenerics(transaction, this, index, content);
       });
     } else {
@@ -8640,7 +8846,7 @@ class YXmlFragment extends AbstractType {
    */
   insertAfter (ref, content) {
     if (this.doc !== null) {
-      transact(this.doc, transaction => {
+      transact$1(this.doc, transaction => {
         const refItem = (ref && ref instanceof AbstractType) ? ref._item : ref;
         typeListInsertGenericsAfter(transaction, this, refItem, content);
       });
@@ -8662,7 +8868,7 @@ class YXmlFragment extends AbstractType {
    */
   delete (index, length = 1) {
     if (this.doc !== null) {
-      transact(this.doc, transaction => {
+      transact$1(this.doc, transaction => {
         typeListDelete(transaction, this, index, length);
       });
     } else {
@@ -8690,9 +8896,9 @@ class YXmlFragment extends AbstractType {
   }
 
   /**
-   * Preppends content to this YArray.
+   * Prepends content to this YArray.
    *
-   * @param {Array<YXmlElement|YXmlText>} content Array of content to preppend.
+   * @param {Array<YXmlElement|YXmlText>} content Array of content to prepend.
    */
   unshift (content) {
     this.insert(0, content);
@@ -8709,7 +8915,8 @@ class YXmlFragment extends AbstractType {
   }
 
   /**
-   * Transforms this YArray to a JavaScript Array.
+   * Returns a portion of this YXmlFragment into a JavaScript Array selected
+   * from start to end (end not included).
    *
    * @param {number} [start]
    * @param {number} [end]
@@ -8720,7 +8927,7 @@ class YXmlFragment extends AbstractType {
   }
 
   /**
-   * Executes a provided function on once on overy child element.
+   * Executes a provided function on once on every child element.
    *
    * @param {function(YXmlElement|YXmlText,number, typeof self):void} f A function to execute on every element of this YArray.
    */
@@ -8756,7 +8963,7 @@ const readYXmlFragment = _decoder => new YXmlFragment();
 
 /**
  * An YXmlElement imitates the behavior of a
- * {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}.
+ * https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element
  *
  * * An YXmlElement has attributes (key value pairs)
  * * An YXmlElement has childElements that must inherit from YXmlElement
@@ -8817,6 +9024,10 @@ class YXmlElement extends YXmlFragment {
   }
 
   /**
+   * Makes a copy of this data type that can be included somewhere else.
+   *
+   * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
+   *
    * @return {YXmlElement<KV>}
    */
   clone () {
@@ -8871,7 +9082,7 @@ class YXmlElement extends YXmlFragment {
    */
   removeAttribute (attributeName) {
     if (this.doc !== null) {
-      transact(this.doc, transaction => {
+      transact$1(this.doc, transaction => {
         typeMapDelete(transaction, this, attributeName);
       });
     } else {
@@ -8891,7 +9102,7 @@ class YXmlElement extends YXmlFragment {
    */
   setAttribute (attributeName, attributeValue) {
     if (this.doc !== null) {
-      transact(this.doc, transaction => {
+      transact$1(this.doc, transaction => {
         typeMapSet(transaction, this, attributeName, attributeValue);
       });
     } else {
@@ -8929,12 +9140,13 @@ class YXmlElement extends YXmlFragment {
   /**
    * Returns all attribute name/value pairs in a JSON Object.
    *
+   * @param {Snapshot} [snapshot]
    * @return {{ [Key in Extract<keyof KV,string>]?: KV[Key]}} A JSON Object that describes the attributes.
    *
    * @public
    */
-  getAttributes () {
-    return /** @type {any} */ (typeMapGetAll(this))
+  getAttributes (snapshot) {
+    return /** @type {any} */ (snapshot ? typeMapGetAllSnapshot(this, snapshot) : typeMapGetAll(this))
   }
 
   /**
@@ -9001,7 +9213,7 @@ class YXmlEvent extends YEvent {
    * @param {YXmlElement|YXmlText|YXmlFragment} target The target on which the event is created.
    * @param {Set<string|null>} subs The set of changed attributes. `null` is included if the
    *                   child list changed.
-   * @param {Transaction} transaction The transaction instance with wich the
+   * @param {Transaction} transaction The transaction instance with which the
    *                                  change was created.
    */
   constructor (target, subs, transaction) {
@@ -9052,6 +9264,10 @@ class YXmlHook extends YMap {
   }
 
   /**
+   * Makes a copy of this data type that can be included somewhere else.
+   *
+   * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
+   *
    * @return {YXmlHook}
    */
   clone () {
@@ -9142,6 +9358,10 @@ class YXmlText extends YText {
   }
 
   /**
+   * Makes a copy of this data type that can be included somewhere else.
+   *
+   * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
+   *
    * @return {YXmlText}
    */
   clone () {
@@ -9253,7 +9473,7 @@ class AbstractStruct {
    * This method is already assuming that `this.id.clock + this.length === this.id.clock`.
    * Also this method does *not* remove right from StructStore!
    * @param {AbstractStruct} right
-   * @return {boolean} wether this merged with right
+   * @return {boolean} whether this merged with right
    */
   mergeWith (right) {
     return false
@@ -9956,6 +10176,8 @@ const readContentJSON = decoder => {
   return new ContentJSON(cs)
 };
 
+const isDevMode = getVariable('node_env') === 'development';
+
 class ContentAny {
   /**
    * @param {Array<any>} arr
@@ -9965,6 +10187,7 @@ class ContentAny {
      * @type {Array<any>}
      */
     this.arr = arr;
+    isDevMode && deepFreeze(arr);
   }
 
   /**
@@ -10525,14 +10748,12 @@ class Item extends AbstractStruct {
     }
     if ((this.left && this.left.constructor === GC) || (this.right && this.right.constructor === GC)) {
       this.parent = null;
-    }
-    // only set parent if this shouldn't be garbage collected
-    if (!this.parent) {
+    } else if (!this.parent) {
+      // only set parent if this shouldn't be garbage collected
       if (this.left && this.left.constructor === Item) {
         this.parent = this.left.parent;
         this.parentSub = this.left.parentSub;
-      }
-      if (this.right && this.right.constructor === Item) {
+      } else if (this.right && this.right.constructor === Item) {
         this.parent = this.right.parent;
         this.parentSub = this.right.parentSub;
       }
@@ -10913,6 +11134,7 @@ class Skip extends AbstractStruct {
 
 /** eslint-env browser */
 
+
 const glo = /** @type {any} */ (typeof globalThis !== 'undefined'
   ? globalThis
   : typeof window !== 'undefined'
@@ -10941,67 +11163,86 @@ if (glo[importIdentifier] === true) {
 }
 glo[importIdentifier] = true;
 
-const t=Symbol();const s$1=Object.getPrototypeOf,c$1=new WeakMap,l$1=e=>e&&(c$1.has(e)?c$1.get(e):s$1(e)===Object.prototype||s$1(e)===Array.prototype),y=e=>l$1(e)&&e[t]||null,h=(e,t=!0)=>{c$1.set(e,t);};
+/* eslint @typescript-eslint/no-explicit-any: off */
+// symbols
+const GET_ORIGINAL_SYMBOL = Symbol();
+// get object prototype
+const getProto$2 = Object.getPrototypeOf;
+const objectsToTrack = new WeakMap();
+// check if obj is a plain object or an array
+const isObjectToTrack = (obj) => obj &&
+    (objectsToTrack.has(obj)
+        ? objectsToTrack.get(obj)
+        : getProto$2(obj) === Object.prototype || getProto$2(obj) === Array.prototype);
+/**
+ * Unwrap proxy to get the original object.
+ *
+ * Used to retrieve the original object used to create the proxy instance with `createProxy`.
+ *
+ * @param {Proxy<object>} obj -  The proxy wrapper of the originial object.
+ * @returns {object | null} - Return either the unwrapped object if exists.
+ *
+ * @example
+ * import { createProxy, getUntracked } from 'proxy-compare';
+ *
+ * const original = { a: "1", c: "2", d: { e: "3" } };
+ * const affected = new WeakMap();
+ *
+ * const proxy = createProxy(original, affected);
+ * const originalFromProxy = getUntracked(proxy)
+ *
+ * Object.is(original, originalFromProxy) // true
+ * isChanged(original, originalFromProxy, affected) // false
+ */
+const getUntracked = (obj) => {
+    if (isObjectToTrack(obj)) {
+        return obj[GET_ORIGINAL_SYMBOL] || null;
+    }
+    return null;
+};
 
 const isObject = (x) => typeof x === "object" && x !== null;
-const proxyStateMap = /* @__PURE__ */ new WeakMap();
-const refSet = /* @__PURE__ */ new WeakSet();
-const buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) => new Proxy(target, handler), canProxy = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer), defaultHandlePromise = (promise) => {
-  switch (promise.status) {
-    case "fulfilled":
-      return promise.value;
-    case "rejected":
-      throw promise.reason;
-    default:
-      throw promise;
-  }
-}, snapCache = /* @__PURE__ */ new WeakMap(), createSnapshot = (target, version, handlePromise = defaultHandlePromise) => {
-  const cache = snapCache.get(target);
-  if ((cache == null ? void 0 : cache[0]) === version) {
-    return cache[1];
-  }
-  const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
-  h(snap, true);
-  snapCache.set(target, [version, snap]);
-  Reflect.ownKeys(target).forEach((key) => {
-    if (Object.getOwnPropertyDescriptor(snap, key)) {
-      return;
+const canProxyDefault = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer) && !(x instanceof Promise);
+const createHandlerDefault = (isInitializing, addPropListener, removePropListener, notifyUpdate) => ({
+  deleteProperty(target, prop) {
+    const prevValue = Reflect.get(target, prop);
+    removePropListener(prop);
+    const deleted = Reflect.deleteProperty(target, prop);
+    if (deleted) {
+      notifyUpdate(["delete", [prop], prevValue]);
+    }
+    return deleted;
+  },
+  set(target, prop, value, receiver) {
+    const hasPrevValue = !isInitializing() && Reflect.has(target, prop);
+    const prevValue = Reflect.get(target, prop, receiver);
+    if (hasPrevValue && (objectIs(prevValue, value) || proxyCache.has(value) && objectIs(prevValue, proxyCache.get(value)))) {
+      return true;
     }
-    const value = Reflect.get(target, key);
-    const { enumerable } = Reflect.getOwnPropertyDescriptor(
-      target,
-      key
-    );
-    const desc = {
-      value,
-      enumerable,
-      // This is intentional to avoid copying with proxy-compare.
-      // It's still non-writable, so it avoids assigning a value.
-      configurable: true
-    };
-    if (refSet.has(value)) {
-      h(value, false);
-    } else if (value instanceof Promise) {
-      delete desc.value;
-      desc.get = () => handlePromise(value);
-    } else if (proxyStateMap.has(value)) {
-      const [target2, ensureVersion] = proxyStateMap.get(
-        value
-      );
-      desc.value = createSnapshot(
-        target2,
-        ensureVersion(),
-        handlePromise
-      );
+    removePropListener(prop);
+    if (isObject(value)) {
+      value = getUntracked(value) || value;
     }
-    Object.defineProperty(snap, key, desc);
-  });
-  return Object.preventExtensions(snap);
-}, proxyCache = /* @__PURE__ */ new WeakMap(), versionHolder = [1, 1], proxyFunction = (initialObject) => {
-  if (!isObject(initialObject)) {
+    const nextValue = !proxyStateMap.has(value) && canProxy(value) ? proxy(value) : value;
+    addPropListener(prop, nextValue);
+    Reflect.set(target, prop, nextValue, receiver);
+    notifyUpdate(["set", [prop], value, prevValue]);
+    return true;
+  }
+});
+const proxyStateMap = /* @__PURE__ */ new WeakMap();
+const refSet = /* @__PURE__ */ new WeakSet();
+const versionHolder = [1, 1];
+const proxyCache = /* @__PURE__ */ new WeakMap();
+let objectIs = Object.is;
+let newProxy = (target, handler) => new Proxy(target, handler);
+let canProxy = canProxyDefault;
+let createHandler = createHandlerDefault;
+function proxy(baseObject = {}) {
+  if (!isObject(baseObject)) {
     throw new Error("object required");
   }
-  const found = proxyCache.get(initialObject);
+  const found = proxyCache.get(baseObject);
   if (found) {
     return found;
   }
@@ -11032,15 +11273,18 @@ const buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) =
     notifyUpdate(newOp, nextVersion);
   };
   const propProxyStates = /* @__PURE__ */ new Map();
-  const addPropListener = (prop, propProxyState) => {
-    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && propProxyStates.has(prop)) {
-      throw new Error("prop listener already exists");
-    }
-    if (listeners.size) {
-      const remove = propProxyState[3](createPropListener(prop));
-      propProxyStates.set(prop, [propProxyState, remove]);
-    } else {
-      propProxyStates.set(prop, [propProxyState]);
+  const addPropListener = (prop, propValue) => {
+    const propProxyState = !refSet.has(propValue) && proxyStateMap.get(propValue);
+    if (propProxyState) {
+      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && propProxyStates.has(prop)) {
+        throw new Error("prop listener already exists");
+      }
+      if (listeners.size) {
+        const remove = propProxyState[2](createPropListener(prop));
+        propProxyStates.set(prop, [propProxyState, remove]);
+      } else {
+        propProxyStates.set(prop, [propProxyState]);
+      }
     }
   };
   const removePropListener = (prop) => {
@@ -11058,7 +11302,7 @@ const buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) =
         if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && prevRemove) {
           throw new Error("remove already exists");
         }
-        const remove = propProxyState[3](createPropListener(prop));
+        const remove = propProxyState[2](createPropListener(prop));
         propProxyStates.set(prop, [propProxyState, remove]);
       });
     }
@@ -11075,93 +11319,28 @@ const buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) =
     };
     return removeListener;
   };
-  const baseObject = Array.isArray(initialObject) ? [] : Object.create(Object.getPrototypeOf(initialObject));
-  const handler = {
-    deleteProperty(target, prop) {
-      const prevValue = Reflect.get(target, prop);
-      removePropListener(prop);
-      const deleted = Reflect.deleteProperty(target, prop);
-      if (deleted) {
-        notifyUpdate(["delete", [prop], prevValue]);
-      }
-      return deleted;
-    },
-    set(target, prop, value, receiver) {
-      const hasPrevValue = Reflect.has(target, prop);
-      const prevValue = Reflect.get(target, prop, receiver);
-      if (hasPrevValue && (objectIs(prevValue, value) || proxyCache.has(value) && objectIs(prevValue, proxyCache.get(value)))) {
-        return true;
-      }
-      removePropListener(prop);
-      if (isObject(value)) {
-        value = y(value) || value;
-      }
-      let nextValue = value;
-      if (value instanceof Promise) {
-        value.then((v) => {
-          value.status = "fulfilled";
-          value.value = v;
-          notifyUpdate(["resolve", [prop], v]);
-        }).catch((e) => {
-          value.status = "rejected";
-          value.reason = e;
-          notifyUpdate(["reject", [prop], e]);
-        });
-      } else {
-        if (!proxyStateMap.has(value) && canProxy(value)) {
-          nextValue = proxyFunction(value);
-        }
-        const childProxyState = !refSet.has(nextValue) && proxyStateMap.get(nextValue);
-        if (childProxyState) {
-          addPropListener(prop, childProxyState);
-        }
-      }
-      Reflect.set(target, prop, nextValue, receiver);
-      notifyUpdate(["set", [prop], value, prevValue]);
-      return true;
-    }
-  };
+  let initializing = true;
+  const handler = createHandler(
+    () => initializing,
+    addPropListener,
+    removePropListener,
+    notifyUpdate
+  );
   const proxyObject = newProxy(baseObject, handler);
-  proxyCache.set(initialObject, proxyObject);
-  const proxyState = [
-    baseObject,
-    ensureVersion,
-    createSnapshot,
-    addListener
-  ];
+  proxyCache.set(baseObject, proxyObject);
+  const proxyState = [baseObject, ensureVersion, addListener];
   proxyStateMap.set(proxyObject, proxyState);
-  Reflect.ownKeys(initialObject).forEach((key) => {
+  Reflect.ownKeys(baseObject).forEach((key) => {
     const desc = Object.getOwnPropertyDescriptor(
-      initialObject,
+      baseObject,
       key
     );
-    if ("value" in desc) {
-      proxyObject[key] = initialObject[key];
-      delete desc.value;
-      delete desc.writable;
+    if ("value" in desc && desc.writable) {
+      proxyObject[key] = baseObject[key];
     }
-    Object.defineProperty(baseObject, key, desc);
   });
+  initializing = false;
   return proxyObject;
-}) => [
-  // public functions
-  proxyFunction,
-  // shared state
-  proxyStateMap,
-  refSet,
-  // internal things
-  objectIs,
-  newProxy,
-  canProxy,
-  defaultHandlePromise,
-  snapCache,
-  createSnapshot,
-  proxyCache,
-  versionHolder
-];
-const [defaultProxyFunction] = buildProxyFunction();
-function proxy(initialObject = {}) {
-  return defaultProxyFunction(initialObject);
 }
 function getVersion(proxyObject) {
   const proxyState = proxyStateMap.get(proxyObject);
@@ -11174,7 +11353,7 @@ function subscribe(proxyObject, callback, notifyInSync) {
   }
   let promise;
   const ops = [];
-  const addListener = proxyState[3];
+  const addListener = proxyState[2];
   let isListenerActive = false;
   const listener = (op) => {
     ops.push(op);
@@ -11244,9 +11423,354 @@ var fastDeepEqual = function equal(a, b) {
   return a!==a && b!==b;
 };
 
-var r = /*@__PURE__*/getDefaultExportFromCjs(fastDeepEqual);
+var deepEqual = /*@__PURE__*/getDefaultExportFromCjs(fastDeepEqual);
+
+const parseProxyOps = (ops) => {
+    const arrayOps = ops.flatMap((op) => {
+        if (op[0] === 'resolve' || op[0] === 'reject')
+            return [];
+        const index = Number(op[1][op[1].length - 1]);
+        if (!Number.isFinite(index))
+            return [];
+        return [[op[0], index, op[2], op[3]]];
+    });
+    const findCorrespondingInsert = (startOpIndex, startArrayIndex) => {
+        let s = 0;
+        let noInsert = null;
+        while (startOpIndex + s + 1 < arrayOps.length) {
+            if ((arrayOps[startOpIndex + s + 1][0] === 'set' ||
+                arrayOps[startOpIndex + s + 1][0] === 'insert') &&
+                arrayOps[startOpIndex + s + 1][1] < startArrayIndex &&
+                arrayOps[startOpIndex + s + 1][3] === arrayOps[startOpIndex][2]) {
+                return s + 1;
+            }
+            if (noInsert === null &&
+                (arrayOps[startOpIndex + s + 1][0] === 'set' ||
+                    arrayOps[startOpIndex + s + 1][0] === 'insert') &&
+                arrayOps[startOpIndex + s + 1][1] === startArrayIndex - (s + 1) &&
+                arrayOps[startOpIndex + s + 1][3] === undefined) {
+                s += 1;
+            }
+            else if (noInsert === null &&
+                startOpIndex + s + 1 < arrayOps.length &&
+                arrayOps[startOpIndex + s + 1][0] === 'set' &&
+                arrayOps[startOpIndex + s + 1][3] !== undefined) {
+                noInsert = [startOpIndex + s + 1, arrayOps[startOpIndex + s + 1][1]];
+                s += 1;
+            }
+            else if (noInsert !== null &&
+                arrayOps[startOpIndex + s + 1][0] === 'set' &&
+                arrayOps[startOpIndex + s + 1][1] ===
+                    noInsert[1] + (s + 1 - noInsert[0]) &&
+                arrayOps[startOpIndex + s + 1][3] !== undefined) {
+                s += 1;
+            }
+            else {
+                return null;
+            }
+        }
+        return null;
+    };
+    const findContinuousDelete = (startOpIndex, startArrayIndex) => {
+        let d = 0;
+        while (startOpIndex + d + 1 < arrayOps.length &&
+            arrayOps[startOpIndex + d + 1][0] === 'delete' &&
+            arrayOps[startOpIndex + d + 1][1] === startArrayIndex - (d + 1)) {
+            d += 1;
+        }
+        return d;
+    };
+    let i = 0;
+    while (i < arrayOps.length) {
+        if ((arrayOps[i][0] === 'set' || arrayOps[i][0] === 'insert') &&
+            arrayOps[i][3] === undefined) {
+            const startArrayIndex = arrayOps[i][1];
+            const s = findCorrespondingInsert(i, startArrayIndex);
+            if (s !== null) {
+                const newArrayOp = [
+                    'insert',
+                    arrayOps[i + s][1],
+                    arrayOps[i + s][2],
+                    undefined,
+                ];
+                arrayOps.splice(i + s, 1, newArrayOp);
+                arrayOps.splice(i, 1);
+            }
+            else {
+                i += 1;
+            }
+        }
+        else if (i > 0 && arrayOps[i][0] === 'delete') {
+            const startArrayIndex = arrayOps[i][1];
+            const d = findContinuousDelete(i, startArrayIndex);
+            if (arrayOps[i - 1][0] === 'set' &&
+                arrayOps[i - 1][1] === startArrayIndex - (d + 1) &&
+                arrayOps[i - 1][2] === arrayOps[i][2]) {
+                const newArrayOp = [
+                    'delete',
+                    startArrayIndex - (d + 1),
+                    arrayOps[i - 1][3],
+                    undefined,
+                ];
+                arrayOps.splice(i - 1, 2);
+                arrayOps.splice(i - 1 + d, 0, newArrayOp);
+                i -= 1;
+            }
+            else {
+                i += 1;
+            }
+        }
+        else {
+            i += 1;
+        }
+    }
+    return arrayOps;
+};
 
-const o=e=>"object"==typeof e&&null!==e&&void 0!==getVersion(e),s=e=>Array.isArray(e)&&void 0!==getVersion(e),i=(e,t,n)=>{e?e.transact(n,t.transactionOrigin):n();},c=e=>{if(s(e)){const t=new YArray;return t.insert(0,e.map(c).filter(e=>null!=e)),t}if(o(e)){const t=new YMap;return Object.entries(e).forEach(([e,n])=>{const r=c(n);void 0!==r&&t.set(e,r);}),t}if(null===(t=e)||"string"==typeof t||"number"==typeof t||"boolean"==typeof t)return e;var t;},l=e=>e instanceof AbstractType?e.toJSON():e,a=(e,t,r)=>{let o=e,s=t;for(let e=0;e<r.length;e+=1){const t=r[e];if(s instanceof YMap){if(!o)break;o=o[t],s=s.get(t);}else if(s instanceof YArray){if(!o)break;const e=Number(t);o=o[t],s=s.get(e);}else o=null,s=null;}return {p:o,y:s}};function f(t,c,f={}){!s(t)||c instanceof YArray||"production"!=="production",!o(t)||s(t)||c instanceof YMap||"production"!=="production",function(e,t){o(e)&&t instanceof YMap&&t.forEach((t,n)=>{r(e[n],l(t))||(e[n]=l(t));}),s(e)&&t instanceof YArray&&t.forEach((t,n)=>{r(e[n],l(t))||u(t,e,n);});}(t,c),function(e,t,c){i(t.doc,c,()=>{o(e)&&t instanceof YMap&&Object.entries(e).forEach(([e,n])=>{const o=t.get(e);r(n,l(o))||p(n,t,e);}),s(e)&&t instanceof YArray&&e.forEach((e,n)=>{const o=t.get(n);r(e,l(o))||p(e,t,n);});});}(t,c,f),s(t)&&c instanceof YArray&&t.splice(c.length);const y=function(t,o,s){return subscribe(t,e=>{i(o.doc,s,()=>{e.forEach(s=>{const i=s[1].slice(0,-1),c=s[1][s[1].length-1],f=a(t,o,i);if(f.y instanceof YMap){if("delete"===s[0])f.y.delete(c);else if("set"===s[0]){const e=f.p[c],t=f.y.get(c);r(l(t),e)||p(e,f.y,c);}}else if(f.y instanceof YArray){if(r(l(f.y),f.p))return;(e=>{const t=e.flatMap(e=>{if("resolve"===e[0]||"reject"===e[0])return [];const t=Number(e[1][e[1].length-1]);return Number.isFinite(t)?[[e[0],t,e[2],e[3]]]:[]}),n=(e,n)=>{let r=0,o=null;for(;e+r+1<t.length;){if(("set"===t[e+r+1][0]||"insert"===t[e+r+1][0])&&t[e+r+1][1]<n&&t[e+r+1][3]===t[e][2])return r+1;if(null!==o||"set"!==t[e+r+1][0]&&"insert"!==t[e+r+1][0]||t[e+r+1][1]!==n-(r+1)||void 0!==t[e+r+1][3])if(null===o&&e+r+1<t.length&&"set"===t[e+r+1][0]&&void 0!==t[e+r+1][3])o=[e+r+1,t[e+r+1][1]],r+=1;else {if(null===o||"set"!==t[e+r+1][0]||t[e+r+1][1]!==o[1]+(r+1-o[0])||void 0===t[e+r+1][3])return null;r+=1;}else r+=1;}return null},r=(e,n)=>{let r=0;for(;e+r+1<t.length&&"delete"===t[e+r+1][0]&&t[e+r+1][1]===n-(r+1);)r+=1;return r};let o=0;for(;o<t.length;)if("set"!==t[o][0]&&"insert"!==t[o][0]||void 0!==t[o][3])if(o>0&&"delete"===t[o][0]){const e=t[o][1],n=r(o,e);if("set"===t[o-1][0]&&t[o-1][1]===e-(n+1)&&t[o-1][2]===t[o][2]){const r=["delete",e-(n+1),t[o-1][3],void 0];t.splice(o-1,2),t.splice(o-1+n,0,r),o-=1;}else o+=1;}else o+=1;else {const e=n(o,t[o][1]);null!==e?(t.splice(o+e,1,["insert",t[o+e][1],t[o+e][2],void 0]),t.splice(o,1)):o+=1;}return t})(e).forEach(e=>{const t=e[1];if("delete"===e[0])return void(f.y.length>t&&f.y.delete(t,1));const n=f.p[t];void 0!==n&&("set"===e[0]?(f.y.length>t&&f.y.delete(t,1),p(n,f.y,t)):"insert"===e[0]&&p(n,f.y,t));});}});});})}(t,c,f),d=function(e,t){const o=o=>{o.forEach(o=>{const s=a(t,e,o.path);if(s.y instanceof YMap)o.changes.keys.forEach((e,t)=>{"delete"===e.action?delete s.p[t]:u(s.y.get(t),s.p,t);});else if(s.y instanceof YArray){if(r(s.p,l(s.y)))return;let e=0;o.changes.delta.forEach(t=>{t.retain&&(e+=t.retain),t.delete&&s.p.splice(e,t.delete),t.insert&&(Array.isArray(t.insert)?t.insert.forEach((t,n)=>{u(t,s.p,e+n);}):u(t.insert,s.p,e),e+=t.insert.length);});}});};return e.observeDeep(o),()=>{e.unobserveDeep(o);}}(c,t);return ()=>{y(),d();}}function p(e,t,r){const o=c(e);void 0!==o||"production"==="production"?t instanceof YMap&&"string"==typeof r?t.set(r,o):t instanceof YArray&&"number"==typeof r&&t.insert(r,[o]):console.warn("unsupported p type",e);}function u(e,t,n){o(t)&&"string"==typeof n?t[n]=l(e):s(t)&&"number"==typeof n&&t.splice(n,0,l(e));}
+/* eslint @typescript-eslint/no-explicit-any: "off" */
+const isProxyObject = (x) => typeof x === 'object' && x !== null && getVersion(x) !== undefined;
+const isProxyArray = (x) => Array.isArray(x) && getVersion(x) !== undefined;
+const isPrimitiveMapValue = (v) => v === null ||
+    typeof v === 'string' ||
+    typeof v === 'number' ||
+    typeof v === 'boolean';
+const transact = (doc, opts, fn) => {
+    if (doc) {
+        doc.transact(fn, opts.transactionOrigin);
+    }
+    else {
+        fn();
+    }
+};
+const toYValue = (val) => {
+    if (isProxyArray(val)) {
+        const arr = new YArray();
+        arr.insert(0, val.map(toYValue).filter((v) => v !== undefined && v !== null));
+        return arr;
+    }
+    if (isProxyObject(val)) {
+        const map = new YMap();
+        Object.entries(val).forEach(([key, value]) => {
+            const v = toYValue(value);
+            if (v !== undefined) {
+                map.set(key, v);
+            }
+        });
+        return map;
+    }
+    if (isPrimitiveMapValue(val)) {
+        return val;
+    }
+    return undefined;
+};
+const toJSON = (yv) => {
+    if (yv instanceof AbstractType) {
+        return yv.toJSON();
+    }
+    return yv;
+};
+const getNestedValues = (p, y, path) => {
+    let pv = p;
+    let yv = y;
+    for (let i = 0; i < path.length; i += 1) {
+        const k = path[i];
+        if (yv instanceof YMap) {
+            // child may already be deleted
+            if (!pv)
+                break;
+            pv = pv[k];
+            yv = yv.get(k);
+        }
+        else if (yv instanceof YArray) {
+            // child may already be deleted
+            if (!pv)
+                break;
+            const index = Number(k);
+            pv = pv[k];
+            yv = yv.get(index);
+        }
+        else {
+            pv = null;
+            yv = null;
+        }
+    }
+    return { p: pv, y: yv };
+};
+function bind$1(p, y, opts = {}) {
+    if (isProxyArray(p) && !(y instanceof YArray)) ;
+    if (isProxyObject(p) && !isProxyArray(p) && !(y instanceof YMap)) ;
+    // initialize from y
+    initializeFromY(p, y);
+    // initialize from p
+    initializeFromP(p, y, opts);
+    if (isProxyArray(p) && y instanceof YArray) {
+        p.splice(y.length);
+    }
+    // subscribe p
+    const unsubscribeP = subscribeP(p, y, opts);
+    // subscribe y
+    const unsubscribeY = subscribeY(y, p);
+    return () => {
+        unsubscribeP();
+        unsubscribeY();
+    };
+}
+function initializeFromP(p, y, opts) {
+    transact(y.doc, opts, () => {
+        if (isProxyObject(p) && y instanceof YMap) {
+            Object.entries(p).forEach(([k, pv]) => {
+                const yv = y.get(k);
+                if (!deepEqual(pv, toJSON(yv))) {
+                    insertPValueToY(pv, y, k);
+                }
+            });
+        }
+        if (isProxyArray(p) && y instanceof YArray) {
+            p.forEach((pv, i) => {
+                const yv = y.get(i);
+                if (!deepEqual(pv, toJSON(yv))) {
+                    insertPValueToY(pv, y, i);
+                }
+            });
+        }
+    });
+}
+function initializeFromY(p, y) {
+    if (isProxyObject(p) && y instanceof YMap) {
+        y.forEach((yv, k) => {
+            if (!deepEqual(p[k], toJSON(yv))) {
+                p[k] = toJSON(yv);
+            }
+        });
+    }
+    if (isProxyArray(p) && y instanceof YArray) {
+        y.forEach((yv, i) => {
+            if (!deepEqual(p[i], toJSON(yv))) {
+                insertYValueToP(yv, p, i);
+            }
+        });
+    }
+}
+function insertPValueToY(pv, y, k) {
+    const yv = toYValue(pv);
+    if (yv === undefined && "production" !== 'production') {
+        console.warn('unsupported p type', pv);
+        return;
+    }
+    if (y instanceof YMap && typeof k === 'string') {
+        y.set(k, yv);
+    }
+    else if (y instanceof YArray && typeof k === 'number') {
+        y.insert(k, [yv]);
+    }
+}
+function insertYValueToP(yv, p, k) {
+    if (isProxyObject(p) && typeof k === 'string') {
+        p[k] = toJSON(yv);
+    }
+    else if (isProxyArray(p) && typeof k === 'number') {
+        p.splice(k, 0, toJSON(yv));
+    }
+}
+function subscribeP(p, y, opts) {
+    return subscribe(p, (ops) => {
+        transact(y.doc, opts, () => {
+            ops.forEach((op) => {
+                const path = op[1].slice(0, -1);
+                const k = op[1][op[1].length - 1];
+                const parent = getNestedValues(p, y, path);
+                if (parent.y instanceof YMap) {
+                    if (op[0] === 'delete') {
+                        parent.y.delete(k);
+                    }
+                    else if (op[0] === 'set') {
+                        const pv = parent.p[k];
+                        const yv = parent.y.get(k);
+                        if (!deepEqual(toJSON(yv), pv)) {
+                            insertPValueToY(pv, parent.y, k);
+                        }
+                    }
+                }
+                else if (parent.y instanceof YArray) {
+                    if (deepEqual(toJSON(parent.y), parent.p)) {
+                        return;
+                    }
+                    const arrayOps = parseProxyOps(ops);
+                    arrayOps.forEach((aOp) => {
+                        const i = aOp[1];
+                        if (aOp[0] === 'delete') {
+                            if (parent.y.length > i) {
+                                parent.y.delete(i, 1);
+                            }
+                            return;
+                        }
+                        const pv = parent.p[i];
+                        if (pv === undefined) {
+                            return;
+                        }
+                        if (aOp[0] === 'set') {
+                            if (parent.y.length > i) {
+                                parent.y.delete(i, 1);
+                            }
+                            insertPValueToY(pv, parent.y, i);
+                        }
+                        else if (aOp[0] === 'insert') {
+                            insertPValueToY(pv, parent.y, i);
+                        }
+                    });
+                }
+            });
+        });
+    });
+}
+function subscribeY(y, p) {
+    const observer = (events) => {
+        events.forEach((event) => {
+            const path = event.path;
+            const parent = getNestedValues(p, y, path);
+            if (parent.y instanceof YMap) {
+                event.changes.keys.forEach((item, k) => {
+                    if (item.action === 'delete') {
+                        delete parent.p[k];
+                    }
+                    else {
+                        const yv = parent.y.get(k);
+                        insertYValueToP(yv, parent.p, k);
+                    }
+                });
+            }
+            else if (parent.y instanceof YArray) {
+                if (deepEqual(parent.p, toJSON(parent.y))) {
+                    return;
+                }
+                let retain = 0;
+                event.changes.delta.forEach((item) => {
+                    if (item.retain) {
+                        retain += item.retain;
+                    }
+                    if (item.delete) {
+                        parent.p.splice(retain, item.delete);
+                    }
+                    if (item.insert) {
+                        if (Array.isArray(item.insert)) {
+                            item.insert.forEach((yv, i) => {
+                                insertYValueToP(yv, parent.p, retain + i);
+                            });
+                        }
+                        else {
+                            insertYValueToP(item.insert, parent.p, retain);
+                        }
+                        retain += item.insert.length;
+                    }
+                });
+            }
+        });
+    };
+    y.observeDeep(observer);
+    return () => {
+        y.unobserveDeep(observer);
+    };
+}
 
 class KokimokiTransaction {
     // private _clones = new Map<
@@ -11267,7 +11791,7 @@ class KokimokiTransaction {
             applyUpdate(docClone, encodeStateAsUpdate(store.doc));
             // Set up proxy
             const proxyClone = proxy();
-            const unbindProxy = f(proxyClone, docRoot);
+            const unbindProxy = bind$1(proxyClone, docRoot);
             this._proxies.push(proxyClone);
             this._unbindProxies.push(unbindProxy);
             // Listen for updates
@@ -11413,7 +11937,7 @@ class KokimokiStore {
         // Construct proxy object
         this.proxy = proxy(); //T["defaultValue"];
         // @ts-ignore
-        f(this.proxy, this.docRoot);
+        bind$1(this.proxy, this.docRoot);
         // // Create root proxy
         // const store = this;
         // // @ts-ignore