@kritzel/engine 0.4.31

package/dist/cjs/index.cjs.js

@@ -0,0 +1,4232 @@
+'use strict';
+
+var engine_constants = require('./engine.constants-CakmdKMW.js');
+var Y = require('yjs');
+var yIndexeddb = require('y-indexeddb');
+var yWebsocket = require('y-websocket');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var Y__namespace = /*#__PURE__*/_interopNamespace(Y);
+
+class KritzelToolConfigHelper {
+    static getToolConfig(tool) {
+        switch (tool?.toolType) {
+            case 'selection':
+                return 'getToolConfig' in tool && typeof tool.getToolConfig === 'function'
+                    ? tool.getToolConfig()
+                    : null;
+            case 'brush':
+                return {
+                    type: 'brush',
+                    colorProperty: 'color',
+                    sizeProperty: 'size',
+                    opacityProperty: 'opacity',
+                    paletteSource: 'palette',
+                    sizesSource: 'sizes',
+                    controls: [
+                        { type: 'stroke-size', propertyName: 'size' },
+                    ],
+                };
+            case 'line':
+                return {
+                    type: 'line',
+                    colorProperty: 'color',
+                    sizeProperty: 'size',
+                    opacityProperty: 'opacity',
+                    paletteSource: 'palette',
+                    sizesSource: 'sizes',
+                    controls: [
+                        { type: 'stroke-size', propertyName: 'size' },
+                        { type: 'line-endings', propertyName: 'arrows', additionalProps: {} },
+                    ],
+                };
+            case 'shape':
+                return {
+                    type: 'shape',
+                    colorProperty: 'strokeColor',
+                    sizeProperty: 'strokeWidth',
+                    opacityProperty: 'opacity',
+                    paletteSource: 'palette',
+                    sizesSource: 'sizes',
+                    controls: [
+                        { type: 'stroke-size', propertyName: 'strokeWidth' },
+                        { type: 'shape-fill', propertyName: 'fillColor', additionalProps: {} },
+                    ],
+                };
+            case 'text':
+                return {
+                    type: 'text',
+                    colorProperty: 'fontColor',
+                    sizeProperty: 'fontSize',
+                    opacityProperty: 'opacity',
+                    paletteSource: 'palette',
+                    sizesSource: 'sizes',
+                    controls: [
+                        { type: 'font-size', propertyName: 'fontSize', additionalProps: {} },
+                        { type: 'font-family', propertyName: 'fontFamily' },
+                    ],
+                };
+            default:
+                return null;
+        }
+    }
+}
+
+/**
+ * Common Math expressions.
+ *
+ * @module math
+ */
+
+const floor$2 = Math.floor;
+
+/**
+ * @function
+ * @param {number} a
+ * @param {number} b
+ * @return {number} The smaller element of a and b
+ */
+const min$2 = (a, b) => a < b ? a : b;
+
+/**
+ * @function
+ * @param {number} a
+ * @param {number} b
+ * @return {number} The bigger element of a and b
+ */
+const max$2 = (a, b) => a > b ? a : b;
+
+/* eslint-env browser */
+
+const BIT8$2 = 128;
+const BITS7$2 = 127;
+
+/**
+ * Utility helpers for working with numbers.
+ *
+ * @module number
+ */
+
+
+const MAX_SAFE_INTEGER$2 = Number.MAX_SAFE_INTEGER;
+
+/**
+ * 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.
+ */
+let Encoder$1 = class Encoder {
+  constructor () {
+    this.cpos = 0;
+    this.cbuf = new Uint8Array(100);
+    /**
+     * @type {Array<Uint8Array>}
+     */
+    this.bufs = [];
+  }
+};
+
+/**
+ * @function
+ * @return {Encoder}
+ */
+const createEncoder$1 = () => new Encoder$1();
+
+/**
+ * The current length of the encoded data.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @return {number}
+ */
+const length$2 = encoder => {
+  let len = encoder.cpos;
+  for (let i = 0; i < encoder.bufs.length; i++) {
+    len += encoder.bufs[i].length;
+  }
+  return len
+};
+
+/**
+ * Transform to Uint8Array.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @return {Uint8Array<ArrayBuffer>} The created ArrayBuffer.
+ */
+const toUint8Array$1 = encoder => {
+  const uint8arr = new Uint8Array(length$2(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
+};
+
+/**
+ * Write one byte to the encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {number} num The byte that is to be encoded.
+ */
+const write$2 = (encoder, num) => {
+  const bufferLen = encoder.cbuf.length;
+  if (encoder.cpos === bufferLen) {
+    encoder.bufs.push(encoder.cbuf);
+    encoder.cbuf = new Uint8Array(bufferLen * 2);
+    encoder.cpos = 0;
+  }
+  encoder.cbuf[encoder.cpos++] = num;
+};
+
+/**
+ * Write a variable length unsigned integer. Max encodable integer is 2^53.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {number} num The number that is to be encoded.
+ */
+const writeVarUint$2 = (encoder, num) => {
+  while (num > BITS7$2) {
+    write$2(encoder, BIT8$2 | (BITS7$2 & num));
+    num = floor$2(num / 128); // shift >>> 7
+  }
+  write$2(encoder, BITS7$2 & num);
+};
+
+/**
+ * Append fixed-length Uint8Array to the encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
+ */
+const writeUint8Array$2 = (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$2(bufferLen * 2, rightCopyLen));
+    // copy array
+    encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
+    encoder.cpos = rightCopyLen;
+  }
+};
+
+/**
+ * Append an Uint8Array to Encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
+ */
+const writeVarUint8Array$2 = (encoder, uint8Array) => {
+  writeVarUint$2(encoder, uint8Array.byteLength);
+  writeUint8Array$2(encoder, uint8Array);
+};
+
+/**
+ * Error helpers.
+ *
+ * @module error
+ */
+
+/**
+ * @param {string} s
+ * @return {Error}
+ */
+/* c8 ignore next */
+const create$4 = s => new Error(s);
+
+/**
+ * Efficient schema-less binary decoding with support for variable length encoding.
+ *
+ * Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.
+ *
+ * Encodes numbers in little-endian order (least to most significant byte order)
+ * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
+ * which is also used in Protocol Buffers.
+ *
+ * ```js
+ * // encoding step
+ * const encoder = encoding.createEncoder()
+ * encoding.writeVarUint(encoder, 256)
+ * encoding.writeVarString(encoder, 'Hello world!')
+ * const buf = encoding.toUint8Array(encoder)
+ * ```
+ *
+ * ```js
+ * // decoding step
+ * const decoder = decoding.createDecoder(buf)
+ * decoding.readVarUint(decoder) // => 256
+ * decoding.readVarString(decoder) // => 'Hello world!'
+ * decoding.hasContent(decoder) // => false - all data is read
+ * ```
+ *
+ * @module decoding
+ */
+
+
+const errorUnexpectedEndOfArray$2 = create$4('Unexpected end of array');
+const errorIntegerOutOfRange$2 = create$4('Integer out of Range');
+
+/**
+ * A Decoder handles the decoding of an Uint8Array.
+ * @template {ArrayBufferLike} [Buf=ArrayBufferLike]
+ */
+let Decoder$1 = class Decoder {
+  /**
+   * @param {Uint8Array<Buf>} uint8Array Binary data to decode
+   */
+  constructor (uint8Array) {
+    /**
+     * Decoding target.
+     *
+     * @type {Uint8Array<Buf>}
+     */
+    this.arr = uint8Array;
+    /**
+     * Current decoding position.
+     *
+     * @type {number}
+     */
+    this.pos = 0;
+  }
+};
+
+/**
+ * @function
+ * @template {ArrayBufferLike} Buf
+ * @param {Uint8Array<Buf>} uint8Array
+ * @return {Decoder<Buf>}
+ */
+const createDecoder$1 = uint8Array => new Decoder$1(uint8Array);
+
+/**
+ * Create an Uint8Array view of the next `len` bytes and advance the position by `len`.
+ *
+ * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+ *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+ *
+ * @function
+ * @template {ArrayBufferLike} Buf
+ * @param {Decoder<Buf>} decoder The decoder instance
+ * @param {number} len The length of bytes to read
+ * @return {Uint8Array<Buf>}
+ */
+const readUint8Array$2 = (decoder, len) => {
+  const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+  decoder.pos += len;
+  return view
+};
+
+/**
+ * Read variable length Uint8Array.
+ *
+ * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+ *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+ *
+ * @function
+ * @template {ArrayBufferLike} Buf
+ * @param {Decoder<Buf>} decoder
+ * @return {Uint8Array<Buf>}
+ */
+const readVarUint8Array$2 = decoder => readUint8Array$2(decoder, readVarUint$2(decoder));
+
+/**
+ * Read unsigned integer (32bit) with variable length.
+ * 1/8th of the storage is used as encoding overhead.
+ *  * numbers < 2^7 is stored in one bytlength
+ *  * numbers < 2^14 is stored in two bylength
+ *
+ * @function
+ * @param {Decoder} decoder
+ * @return {number} An unsigned integer.length
+ */
+const readVarUint$2 = decoder => {
+  let num = 0;
+  let mult = 1;
+  const len = decoder.arr.length;
+  while (decoder.pos < len) {
+    const r = decoder.arr[decoder.pos++];
+    // num = num | ((r & binary.BITS7) << len)
+    num = num + (r & BITS7$2) * mult; // shift $r << (7*#iterations) and add it to num
+    mult *= 128; // next iteration, shift 7 "more" to the left
+    if (r < BIT8$2) {
+      return num
+    }
+    /* c8 ignore start */
+    if (num > MAX_SAFE_INTEGER$2) {
+      throw errorIntegerOutOfRange$2
+    }
+    /* c8 ignore stop */
+  }
+  throw errorUnexpectedEndOfArray$2
+};
+
+/**
+ * BroadcastChannel sync provider for cross-tab synchronization
+ * This is a lightweight alternative to y-webrtc for browser-tab-only sync
+ */
+class BroadcastSyncProvider {
+    static type = 'local';
+    type = 'local';
+    doc;
+    channel;
+    _synced = false;
+    constructor(docName, doc, _options) {
+        this.doc = doc;
+        this.channel = new BroadcastChannel(docName);
+        // Handle incoming messages from other tabs
+        this.channel.onmessage = (event) => {
+            this.handleMessage(event.data);
+        };
+        // Listen to document updates and broadcast them
+        this.doc.on('update', this.handleDocUpdate);
+        // Send initial sync request
+        this.broadcastSync();
+        // Mark as synced after a short delay (to receive any pending updates)
+        setTimeout(() => {
+            this._synced = true;
+        }, 100);
+        if (!_options?.quiet) {
+            console.info(`BroadcastChannel Provider initialized: ${docName}`);
+        }
+    }
+    handleDocUpdate = (update, origin) => {
+        // Don't broadcast updates that came from other tabs (to prevent loops)
+        if (origin !== this) {
+            const encoder = createEncoder$1();
+            writeVarUint$2(encoder, 0); // Message type: sync update
+            writeVarUint8Array$2(encoder, update);
+            this.channel.postMessage(toUint8Array$1(encoder));
+        }
+    };
+    handleMessage(message) {
+        const decoder = createDecoder$1(new Uint8Array(message));
+        const messageType = readVarUint$2(decoder);
+        switch (messageType) {
+            case 0: // Sync update
+                const update = readVarUint8Array$2(decoder);
+                Y__namespace.applyUpdate(this.doc, update, this);
+                break;
+            case 1: // Sync request
+                this.broadcastSync();
+                break;
+            case 2: // Sync response
+                const stateVector = readVarUint8Array$2(decoder);
+                const updateResponse = Y__namespace.encodeStateAsUpdate(this.doc, stateVector);
+                if (updateResponse.length > 0) {
+                    const encoder = createEncoder$1();
+                    writeVarUint$2(encoder, 0); // Send as regular update
+                    writeVarUint8Array$2(encoder, updateResponse);
+                    this.channel.postMessage(toUint8Array$1(encoder));
+                }
+                break;
+        }
+    }
+    broadcastSync() {
+        // Broadcast our current state vector to request missing updates
+        const encoder = createEncoder$1();
+        writeVarUint$2(encoder, 2); // Message type: sync response
+        writeVarUint8Array$2(encoder, Y__namespace.encodeStateVector(this.doc));
+        this.channel.postMessage(toUint8Array$1(encoder));
+    }
+    async connect() {
+        // Wait for initial sync to complete
+        if (this._synced) {
+            return;
+        }
+        return new Promise((resolve) => {
+            const checkSync = () => {
+                if (this._synced) {
+                    resolve();
+                }
+                else {
+                    setTimeout(checkSync, 50);
+                }
+            };
+            checkSync();
+        });
+    }
+    disconnect() {
+        // BroadcastChannel doesn't have explicit disconnect
+    }
+    async reconnect() {
+        this.disconnect();
+        return this.connect();
+    }
+    destroy() {
+        this.doc.off('update', this.handleDocUpdate);
+        this.channel.close();
+    }
+}
+
+/**
+ * Module-scoped cache that survives component removal and remounting
+ * within the same JS runtime. Cleared on page reload.
+ */
+const sessionCache = new Map();
+/**
+ * In-memory sync provider for session-scoped persistence.
+ *
+ * State survives the component being removed from the DOM and later
+ * re-added within the same page session, but is lost on page reload.
+ * Intended for documentation demos where durable IndexedDB persistence
+ * is not desired.
+ */
+class InMemorySyncProvider {
+    static type = 'local';
+    type = 'local';
+    doc;
+    cacheKey;
+    isConnected = false;
+    constructor(docName, doc, options) {
+        this.doc = doc;
+        this.cacheKey = options?.name ?? docName;
+    }
+    handleUpdate = (_update, origin) => {
+        // Skip updates that originated from connect() rehydration to avoid a
+        // redundant re-encode of the state we just applied.
+        if (origin === this) {
+            return;
+        }
+        sessionCache.set(this.cacheKey, Y__namespace.encodeStateAsUpdate(this.doc));
+    };
+    async connect() {
+        if (this.isConnected) {
+            return;
+        }
+        const cached = sessionCache.get(this.cacheKey);
+        if (cached) {
+            Y__namespace.applyUpdate(this.doc, cached, this);
+        }
+        this.doc.on('update', this.handleUpdate);
+        this.isConnected = true;
+    }
+    disconnect() {
+        this.isConnected = false;
+    }
+    async reconnect() {
+        this.disconnect();
+        return this.connect();
+    }
+    destroy() {
+        this.doc.off('update', this.handleUpdate);
+        this.isConnected = false;
+    }
+    /**
+     * Clears the in-memory cache.
+     *
+     * @param name - If provided, only the entry with this cache key is removed.
+     *               If omitted, all entries are cleared.
+     */
+    static clear(name) {
+        if (name !== undefined) {
+            sessionCache.delete(name);
+        }
+        else {
+            sessionCache.clear();
+        }
+    }
+}
+
+/**
+ * IndexedDB sync provider for local persistence
+ */
+class IndexedDBSyncProvider {
+    static type = 'local';
+    type = 'local';
+    provider;
+    isConnected = false;
+    constructor(docName, doc, options) {
+        const dbName = options?.name || docName;
+        this.provider = new yIndexeddb.IndexeddbPersistence(dbName, doc);
+    }
+    async connect() {
+        if (this.isConnected) {
+            return;
+        }
+        return new Promise(resolve => {
+            this.provider.on('synced', () => {
+                this.isConnected = true;
+                resolve();
+            });
+        });
+    }
+    disconnect() {
+        // IndexedDB doesn't need explicit disconnect
+        this.isConnected = false;
+    }
+    async reconnect() {
+        this.disconnect();
+        return this.connect();
+    }
+    destroy() {
+        if (this.provider) {
+            this.provider.destroy();
+        }
+        this.isConnected = false;
+    }
+}
+
+/**
+ * WebSocket sync provider for real-time collaboration
+ */
+class WebSocketSyncProvider {
+    static type = 'network';
+    type = 'network';
+    provider;
+    isConnected = false;
+    _quiet = false;
+    get awareness() {
+        return this.provider.awareness;
+    }
+    get rawProvider() {
+        return this.provider;
+    }
+    constructor(docName, doc, options) {
+        const url = options?.url || 'ws://localhost:1234';
+        const roomName = options?.roomName || docName;
+        this.provider = new yWebsocket.WebsocketProvider(url, roomName, doc, {
+            params: options?.params,
+            protocols: options?.protocols,
+            WebSocketPolyfill: options?.WebSocketPolyfill,
+            awareness: options?.awareness,
+            maxBackoffTime: options?.maxBackoffTime,
+            disableBc: true,
+        });
+        this._quiet = options?.quiet ?? false;
+        this.setupEventListeners();
+        if (!this._quiet) {
+            console.info(`WebSocket Provider initialized: ${url}/${roomName}`);
+        }
+    }
+    /**
+     * Static factory method for creating WebSocketSyncProvider with configuration options
+     * Returns a ProviderFactory that can be used in sync configuration
+     */
+    static with(options) {
+        return {
+            type: 'network',
+            create: (docName, doc, runtimeOptions) => {
+                const mergedOptions = runtimeOptions ? { ...options, ...runtimeOptions } : options;
+                return new WebSocketSyncProvider(docName, doc, mergedOptions);
+            },
+        };
+    }
+    setupEventListeners() {
+        this.provider.on('status', ({ status }) => {
+            if (status === 'connected') {
+                this.isConnected = true;
+                if (!this._quiet) {
+                    console.info('WebSocket connected');
+                }
+            }
+            else if (status === 'disconnected') {
+                this.isConnected = false;
+                if (!this._quiet) {
+                    console.info('WebSocket disconnected');
+                }
+            }
+        });
+        this.provider.on('sync', (synced) => {
+            if (synced && !this._quiet) {
+                console.info('WebSocket synced');
+            }
+        });
+    }
+    async connect() {
+        if (this.isConnected) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('WebSocket connection timeout'));
+            }, 10000); // 10 second timeout
+            const statusHandler = ({ status }) => {
+                if (status === 'connected') {
+                    clearTimeout(timeout);
+                    this.provider.off('status', statusHandler);
+                    this.isConnected = true;
+                    resolve();
+                }
+            };
+            this.provider.on('status', statusHandler);
+            // If already connected, resolve immediately
+            if (this.provider.wsconnected) {
+                clearTimeout(timeout);
+                this.provider.off('status', statusHandler);
+                this.isConnected = true;
+                resolve();
+            }
+        });
+    }
+    disconnect() {
+        if (this.provider) {
+            this.provider.disconnect();
+        }
+        this.isConnected = false;
+    }
+    async reconnect() {
+        this.disconnect();
+        return this.connect();
+    }
+    destroy() {
+        if (this.provider) {
+            this.provider.destroy();
+        }
+        this.isConnected = false;
+    }
+}
+
+/**
+ * Common Math expressions.
+ *
+ * @module math
+ */
+
+const floor$1 = Math.floor;
+
+/**
+ * @function
+ * @param {number} a
+ * @param {number} b
+ * @return {number} The smaller element of a and b
+ */
+const min$1 = (a, b) => a < b ? a : b;
+
+/**
+ * @function
+ * @param {number} a
+ * @param {number} b
+ * @return {number} The bigger element of a and b
+ */
+const max$1 = (a, b) => a > b ? a : b;
+
+/* eslint-env browser */
+
+const BIT8$1 = 128;
+const BITS7$1 = 127;
+
+/**
+ * Utility helpers for working with numbers.
+ *
+ * @module number
+ */
+
+
+const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER;
+
+/**
+ * @param {string} str
+ * @return {Uint8Array}
+ */
+const _encodeUtf8Polyfill$1 = str => {
+  const encodedString = unescape(encodeURIComponent(str));
+  const len = encodedString.length;
+  const buf = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    buf[i] = /** @type {number} */ (encodedString.codePointAt(i));
+  }
+  return buf
+};
+
+/* c8 ignore next */
+const utf8TextEncoder$1 = /** @type {TextEncoder} */ (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null);
+
+/**
+ * @param {string} str
+ * @return {Uint8Array}
+ */
+const _encodeUtf8Native$1 = str => utf8TextEncoder$1.encode(str);
+
+/**
+ * @param {string} str
+ * @return {Uint8Array}
+ */
+/* c8 ignore next */
+const encodeUtf8$1 = utf8TextEncoder$1 ? _encodeUtf8Native$1 : _encodeUtf8Polyfill$1;
+
+/* c8 ignore next */
+let utf8TextDecoder$1 = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+
+/* c8 ignore start */
+if (utf8TextDecoder$1 && utf8TextDecoder$1.decode(new Uint8Array()).length === 1) {
+  // Safari doesn't handle BOM correctly.
+  // This fixes a bug in Safari 13.0.5 where it produces a BOM the first time it is called.
+  // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the first call and
+  // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the second call
+  // Another issue is that from then on no BOM chars are recognized anymore
+  /* c8 ignore next */
+  utf8TextDecoder$1 = null;
+}
+
+/**
+ * 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
+ */
+
+
+/**
+ * Write one byte to the encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {number} num The byte that is to be encoded.
+ */
+const write$1 = (encoder, num) => {
+  const bufferLen = encoder.cbuf.length;
+  if (encoder.cpos === bufferLen) {
+    encoder.bufs.push(encoder.cbuf);
+    encoder.cbuf = new Uint8Array(bufferLen * 2);
+    encoder.cpos = 0;
+  }
+  encoder.cbuf[encoder.cpos++] = num;
+};
+
+/**
+ * Write a variable length unsigned integer. Max encodable integer is 2^53.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {number} num The number that is to be encoded.
+ */
+const writeVarUint$1 = (encoder, num) => {
+  while (num > BITS7$1) {
+    write$1(encoder, BIT8$1 | (BITS7$1 & num));
+    num = floor$1(num / 128); // shift >>> 7
+  }
+  write$1(encoder, BITS7$1 & num);
+};
+
+/**
+ * A cache to store strings temporarily
+ */
+const _strBuffer$1 = new Uint8Array(30000);
+const _maxStrBSize$1 = _strBuffer$1.length / 3;
+
+/**
+ * Write a variable length string.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
+ */
+const _writeVarStringNative$1 = (encoder, str) => {
+  if (str.length < _maxStrBSize$1) {
+    // We can encode the string into the existing buffer
+    /* c8 ignore next */
+    const written = utf8TextEncoder$1.encodeInto(str, _strBuffer$1).written || 0;
+    writeVarUint$1(encoder, written);
+    for (let i = 0; i < written; i++) {
+      write$1(encoder, _strBuffer$1[i]);
+    }
+  } else {
+    writeVarUint8Array$1(encoder, encodeUtf8$1(str));
+  }
+};
+
+/**
+ * Write a variable length string.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
+ */
+const _writeVarStringPolyfill$1 = (encoder, str) => {
+  const encodedString = unescape(encodeURIComponent(str));
+  const len = encodedString.length;
+  writeVarUint$1(encoder, len);
+  for (let i = 0; i < len; i++) {
+    write$1(encoder, /** @type {number} */ (encodedString.codePointAt(i)));
+  }
+};
+
+/**
+ * Write a variable length string.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
+ */
+/* c8 ignore next */
+const writeVarString$1 = (utf8TextEncoder$1 && /** @type {any} */ (utf8TextEncoder$1).encodeInto) ? _writeVarStringNative$1 : _writeVarStringPolyfill$1;
+
+/**
+ * Append fixed-length Uint8Array to the encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
+ */
+const writeUint8Array$1 = (encoder, uint8Array) => {
+  const bufferLen = encoder.cbuf.length;
+  const cpos = encoder.cpos;
+  const leftCopyLen = min$1(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$1(bufferLen * 2, rightCopyLen));
+    // copy array
+    encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
+    encoder.cpos = rightCopyLen;
+  }
+};
+
+/**
+ * Append an Uint8Array to Encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
+ */
+const writeVarUint8Array$1 = (encoder, uint8Array) => {
+  writeVarUint$1(encoder, uint8Array.byteLength);
+  writeUint8Array$1(encoder, uint8Array);
+};
+
+/**
+ * Error helpers.
+ *
+ * @module error
+ */
+
+/**
+ * @param {string} s
+ * @return {Error}
+ */
+/* c8 ignore next */
+const create$3 = s => new Error(s);
+
+/**
+ * Efficient schema-less binary decoding with support for variable length encoding.
+ *
+ * Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.
+ *
+ * Encodes numbers in little-endian order (least to most significant byte order)
+ * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
+ * which is also used in Protocol Buffers.
+ *
+ * ```js
+ * // encoding step
+ * const encoder = encoding.createEncoder()
+ * encoding.writeVarUint(encoder, 256)
+ * encoding.writeVarString(encoder, 'Hello world!')
+ * const buf = encoding.toUint8Array(encoder)
+ * ```
+ *
+ * ```js
+ * // decoding step
+ * const decoder = decoding.createDecoder(buf)
+ * decoding.readVarUint(decoder) // => 256
+ * decoding.readVarString(decoder) // => 'Hello world!'
+ * decoding.hasContent(decoder) // => false - all data is read
+ * ```
+ *
+ * @module decoding
+ */
+
+
+const errorUnexpectedEndOfArray$1 = create$3('Unexpected end of array');
+const errorIntegerOutOfRange$1 = create$3('Integer out of Range');
+
+/**
+ * Create an Uint8Array view of the next `len` bytes and advance the position by `len`.
+ *
+ * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+ *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+ *
+ * @function
+ * @param {Decoder} decoder The decoder instance
+ * @param {number} len The length of bytes to read
+ * @return {Uint8Array}
+ */
+const readUint8Array$1 = (decoder, len) => {
+  const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+  decoder.pos += len;
+  return view
+};
+
+/**
+ * Read variable length Uint8Array.
+ *
+ * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+ *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+ *
+ * @function
+ * @param {Decoder} decoder
+ * @return {Uint8Array}
+ */
+const readVarUint8Array$1 = decoder => readUint8Array$1(decoder, readVarUint$1(decoder));
+
+/**
+ * Read one byte as unsigned integer.
+ * @function
+ * @param {Decoder} decoder The decoder instance
+ * @return {number} Unsigned 8-bit integer
+ */
+const readUint8$1 = decoder => decoder.arr[decoder.pos++];
+
+/**
+ * Read unsigned integer (32bit) with variable length.
+ * 1/8th of the storage is used as encoding overhead.
+ *  * numbers < 2^7 is stored in one bytlength
+ *  * numbers < 2^14 is stored in two bylength
+ *
+ * @function
+ * @param {Decoder} decoder
+ * @return {number} An unsigned integer.length
+ */
+const readVarUint$1 = decoder => {
+  let num = 0;
+  let mult = 1;
+  const len = decoder.arr.length;
+  while (decoder.pos < len) {
+    const r = decoder.arr[decoder.pos++];
+    // num = num | ((r & binary.BITS7) << len)
+    num = num + (r & BITS7$1) * mult; // shift $r << (7*#iterations) and add it to num
+    mult *= 128; // next iteration, shift 7 "more" to the left
+    if (r < BIT8$1) {
+      return num
+    }
+    /* c8 ignore start */
+    if (num > MAX_SAFE_INTEGER$1) {
+      throw errorIntegerOutOfRange$1
+    }
+    /* c8 ignore stop */
+  }
+  throw errorUnexpectedEndOfArray$1
+};
+
+/**
+ * We don't test this function anymore as we use native decoding/encoding by default now.
+ * Better not modify this anymore..
+ *
+ * Transforming utf8 to a string is pretty expensive. The code performs 10x better
+ * when String.fromCodePoint is fed with all characters as arguments.
+ * But most environments have a maximum number of arguments per functions.
+ * For effiency reasons we apply a maximum of 10000 characters at once.
+ *
+ * @function
+ * @param {Decoder} decoder
+ * @return {String} The read String.
+ */
+/* c8 ignore start */
+const _readVarStringPolyfill$1 = decoder => {
+  let remainingLen = readVarUint$1(decoder);
+  if (remainingLen === 0) {
+    return ''
+  } else {
+    let encodedString = String.fromCodePoint(readUint8$1(decoder)); // remember to decrease remainingLen
+    if (--remainingLen < 100) { // do not create a Uint8Array for small strings
+      while (remainingLen--) {
+        encodedString += String.fromCodePoint(readUint8$1(decoder));
+      }
+    } else {
+      while (remainingLen > 0) {
+        const nextLen = remainingLen < 10000 ? remainingLen : 10000;
+        // this is dangerous, we create a fresh array view from the existing buffer
+        const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen);
+        decoder.pos += nextLen;
+        // Starting with ES5.1 we can supply a generic array-like object as arguments
+        encodedString += String.fromCodePoint.apply(null, /** @type {any} */ (bytes));
+        remainingLen -= nextLen;
+      }
+    }
+    return decodeURIComponent(escape(encodedString))
+  }
+};
+/* c8 ignore stop */
+
+/**
+ * @function
+ * @param {Decoder} decoder
+ * @return {String} The read String
+ */
+const _readVarStringNative$1 = decoder =>
+  /** @type any */ (utf8TextDecoder$1).decode(readVarUint8Array$1(decoder));
+
+/**
+ * Read string of variable length
+ * * varUint is used to store the length of the string
+ *
+ * @function
+ * @param {Decoder} decoder
+ * @return {String} The read String
+ *
+ */
+/* c8 ignore next */
+const readVarString$1 = utf8TextDecoder$1 ? _readVarStringNative$1 : _readVarStringPolyfill$1;
+
+var AuthMessageType;
+(function (AuthMessageType) {
+    AuthMessageType[AuthMessageType["Token"] = 0] = "Token";
+    AuthMessageType[AuthMessageType["PermissionDenied"] = 1] = "PermissionDenied";
+    AuthMessageType[AuthMessageType["Authenticated"] = 2] = "Authenticated";
+})(AuthMessageType || (AuthMessageType = {}));
+const writeAuthentication = (encoder, auth) => {
+    writeVarUint$1(encoder, AuthMessageType.Token);
+    writeVarString$1(encoder, auth);
+};
+const readAuthMessage = (decoder, sendToken, permissionDeniedHandler, authenticatedHandler) => {
+    switch (readVarUint$1(decoder)) {
+        case AuthMessageType.Token: {
+            sendToken();
+            break;
+        }
+        case AuthMessageType.PermissionDenied: {
+            permissionDeniedHandler(readVarString$1(decoder));
+            break;
+        }
+        case AuthMessageType.Authenticated: {
+            authenticatedHandler(readVarString$1(decoder));
+            break;
+        }
+    }
+};
+
+const awarenessStatesToArray = (states) => {
+    return Array.from(states.entries()).map(([key, value]) => {
+        return {
+            clientId: key,
+            ...value,
+        };
+    });
+};
+
+/**
+ * State of the WebSocket connection.
+ * https://developer.mozilla.org/de/docs/Web/API/WebSocket/readyState
+ */
+var WsReadyStates;
+(function (WsReadyStates) {
+    WsReadyStates[WsReadyStates["Connecting"] = 0] = "Connecting";
+    WsReadyStates[WsReadyStates["Open"] = 1] = "Open";
+    WsReadyStates[WsReadyStates["Closing"] = 2] = "Closing";
+    WsReadyStates[WsReadyStates["Closed"] = 3] = "Closed";
+})(WsReadyStates || (WsReadyStates = {}));
+
+function applyDefaults(options) {
+    if (!options) {
+        options = {};
+    }
+    return {
+        delay: (options.delay === undefined) ? 200 : options.delay,
+        initialDelay: (options.initialDelay === undefined) ? 0 : options.initialDelay,
+        minDelay: (options.minDelay === undefined) ? 0 : options.minDelay,
+        maxDelay: (options.maxDelay === undefined) ? 0 : options.maxDelay,
+        factor: (options.factor === undefined) ? 0 : options.factor,
+        maxAttempts: (options.maxAttempts === undefined) ? 3 : options.maxAttempts,
+        timeout: (options.timeout === undefined) ? 0 : options.timeout,
+        jitter: (options.jitter === true),
+        initialJitter: (options.initialJitter === true),
+        handleError: (options.handleError === undefined) ? null : options.handleError,
+        handleTimeout: (options.handleTimeout === undefined) ? null : options.handleTimeout,
+        beforeAttempt: (options.beforeAttempt === undefined) ? null : options.beforeAttempt,
+        calculateDelay: (options.calculateDelay === undefined) ? null : options.calculateDelay
+    };
+}
+async function sleep(delay) {
+    return new Promise((resolve) => setTimeout(resolve, delay));
+}
+function defaultCalculateDelay(context, options) {
+    let delay = options.delay;
+    if (delay === 0) {
+        // no delay between attempts
+        return 0;
+    }
+    if (options.factor) {
+        delay *= Math.pow(options.factor, context.attemptNum - 1);
+        if (options.maxDelay !== 0) {
+            delay = Math.min(delay, options.maxDelay);
+        }
+    }
+    if (options.jitter) {
+        // Jitter will result in a random value between `minDelay` and
+        // calculated delay for a given attempt.
+        // See https://www.awsarchitectureblog.com/2015/03/backoff.html
+        // We're using the "full jitter" strategy.
+        const min = Math.ceil(options.minDelay);
+        const max = Math.floor(delay);
+        delay = Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    return Math.round(delay);
+}
+async function retry(attemptFunc, attemptOptions) {
+    const options = applyDefaults(attemptOptions);
+    for (const prop of [
+        'delay',
+        'initialDelay',
+        'minDelay',
+        'maxDelay',
+        'maxAttempts',
+        'timeout'
+    ]) {
+        const value = options[prop];
+        if (!Number.isInteger(value) || (value < 0)) {
+            throw new Error(`Value for ${prop} must be an integer greater than or equal to 0`);
+        }
+    }
+    if ((options.factor.constructor !== Number) || (options.factor < 0)) {
+        throw new Error(`Value for factor must be a number greater than or equal to 0`);
+    }
+    if (options.delay < options.minDelay) {
+        throw new Error(`delay cannot be less than minDelay (delay: ${options.delay}, minDelay: ${options.minDelay}`);
+    }
+    const context = {
+        attemptNum: 0,
+        attemptsRemaining: options.maxAttempts ? options.maxAttempts : -1,
+        aborted: false,
+        abort() {
+            context.aborted = true;
+        }
+    };
+    const calculateDelay = options.calculateDelay || defaultCalculateDelay;
+    async function makeAttempt() {
+        if (options.beforeAttempt) {
+            options.beforeAttempt(context, options);
+        }
+        if (context.aborted) {
+            const err = new Error(`Attempt aborted`);
+            err.code = 'ATTEMPT_ABORTED';
+            throw err;
+        }
+        const onError = async (err) => {
+            if (options.handleError) {
+                await options.handleError(err, context, options);
+            }
+            if (context.aborted || (context.attemptsRemaining === 0)) {
+                throw err;
+            }
+            // We are about to try again so increment attempt number
+            context.attemptNum++;
+            const delay = calculateDelay(context, options);
+            if (delay) {
+                await sleep(delay);
+            }
+            return makeAttempt();
+        };
+        if (context.attemptsRemaining > 0) {
+            context.attemptsRemaining--;
+        }
+        if (options.timeout) {
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    if (options.handleTimeout) {
+                        // If calling handleTimeout throws an error that is not wrapped in a promise
+                        // we want to catch the error and reject.
+                        try {
+                            resolve(options.handleTimeout(context, options));
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                    }
+                    else {
+                        const err = new Error(`Retry timeout (attemptNum: ${context.attemptNum}, timeout: ${options.timeout})`);
+                        err.code = 'ATTEMPT_TIMEOUT';
+                        reject(err);
+                    }
+                }, options.timeout);
+                attemptFunc(context, options).then((result) => {
+                    clearTimeout(timer);
+                    resolve(result);
+                }).catch((err) => {
+                    clearTimeout(timer);
+                    // Calling resolve with a Promise that rejects here will result
+                    // in an unhandled rejection. Calling `reject` with errors
+                    // does not result in an unhandled rejection
+                    onError(err).then(resolve).catch(reject);
+                });
+            });
+        }
+        else {
+            // No timeout provided so wait indefinitely for the returned promise
+            // to be resolved.
+            return attemptFunc(context, options).catch(onError);
+        }
+    }
+    const initialDelay = options.calculateDelay
+        ? options.calculateDelay(context, options)
+        : options.initialDelay;
+    if (initialDelay) {
+        await sleep(initialDelay);
+    }
+    if (context.attemptNum < 1 && options.initialJitter) {
+        const delay = calculateDelay(context, options);
+        if (delay) {
+            await sleep(delay);
+        }
+    }
+    return makeAttempt();
+}
+
+/**
+ * Common Math expressions.
+ *
+ * @module math
+ */
+
+const floor = Math.floor;
+
+/**
+ * @function
+ * @param {number} a
+ * @param {number} b
+ * @return {number} The smaller element of a and b
+ */
+const min = (a, b) => a < b ? a : b;
+
+/**
+ * @function
+ * @param {number} a
+ * @param {number} b
+ * @return {number} The bigger element of a and b
+ */
+const max = (a, b) => a > b ? a : b;
+
+/* eslint-env browser */
+
+const BIT7 = 64;
+const BIT8 = 128;
+const BITS6 = 63;
+const BITS7 = 127;
+
+/**
+ * Utility helpers for working with numbers.
+ *
+ * @module number
+ */
+
+
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+
+/**
+ * Utility module to work with sets.
+ *
+ * @module set
+ */
+
+const create$2 = () => new Set();
+
+/**
+ * Utility module to work with Arrays.
+ *
+ * @module array
+ */
+
+
+/**
+ * Transforms something array-like to an actual Array.
+ *
+ * @function
+ * @template T
+ * @param {ArrayLike<T>|Iterable<T>} arraylike
+ * @return {T}
+ */
+const from = Array.from;
+
+/**
+ * @param {string} str
+ * @return {Uint8Array}
+ */
+const _encodeUtf8Polyfill = str => {
+  const encodedString = unescape(encodeURIComponent(str));
+  const len = encodedString.length;
+  const buf = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    buf[i] = /** @type {number} */ (encodedString.codePointAt(i));
+  }
+  return buf
+};
+
+/* c8 ignore next */
+const utf8TextEncoder = /** @type {TextEncoder} */ (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null);
+
+/**
+ * @param {string} str
+ * @return {Uint8Array}
+ */
+const _encodeUtf8Native = str => utf8TextEncoder.encode(str);
+
+/**
+ * @param {string} str
+ * @return {Uint8Array}
+ */
+/* c8 ignore next */
+const encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
+
+/* c8 ignore next */
+let utf8TextDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+
+/* c8 ignore start */
+if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
+  // Safari doesn't handle BOM correctly.
+  // This fixes a bug in Safari 13.0.5 where it produces a BOM the first time it is called.
+  // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the first call and
+  // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the second call
+  // Another issue is that from then on no BOM chars are recognized anymore
+  /* c8 ignore next */
+  utf8TextDecoder = null;
+}
+
+/**
+ * Efficient schema-less binary encoding with support for variable length encoding.
+ *
+ * Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.
+ *
+ * Encodes numbers in little-endian order (least to most significant byte order)
+ * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
+ * which is also used in Protocol Buffers.
+ *
+ * ```js
+ * // encoding step
+ * const encoder = encoding.createEncoder()
+ * encoding.writeVarUint(encoder, 256)
+ * encoding.writeVarString(encoder, 'Hello world!')
+ * const buf = encoding.toUint8Array(encoder)
+ * ```
+ *
+ * ```js
+ * // decoding step
+ * const decoder = decoding.createDecoder(buf)
+ * decoding.readVarUint(decoder) // => 256
+ * decoding.readVarString(decoder) // => 'Hello world!'
+ * decoding.hasContent(decoder) // => false - all data is read
+ * ```
+ *
+ * @module encoding
+ */
+
+
+/**
+ * A BinaryEncoder handles the encoding to an Uint8Array.
+ */
+class Encoder {
+  constructor () {
+    this.cpos = 0;
+    this.cbuf = new Uint8Array(100);
+    /**
+     * @type {Array<Uint8Array>}
+     */
+    this.bufs = [];
+  }
+}
+
+/**
+ * @function
+ * @return {Encoder}
+ */
+const createEncoder = () => new Encoder();
+
+/**
+ * The current length of the encoded data.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @return {number}
+ */
+const length$1 = encoder => {
+  let len = encoder.cpos;
+  for (let i = 0; i < encoder.bufs.length; i++) {
+    len += encoder.bufs[i].length;
+  }
+  return len
+};
+
+/**
+ * Transform to Uint8Array.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @return {Uint8Array} The created ArrayBuffer.
+ */
+const toUint8Array = encoder => {
+  const uint8arr = new Uint8Array(length$1(encoder));
+  let curPos = 0;
+  for (let i = 0; i < encoder.bufs.length; i++) {
+    const d = encoder.bufs[i];
+    uint8arr.set(d, curPos);
+    curPos += d.length;
+  }
+  uint8arr.set(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos), curPos);
+  return uint8arr
+};
+
+/**
+ * Write one byte to the encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {number} num The byte that is to be encoded.
+ */
+const write = (encoder, num) => {
+  const bufferLen = encoder.cbuf.length;
+  if (encoder.cpos === bufferLen) {
+    encoder.bufs.push(encoder.cbuf);
+    encoder.cbuf = new Uint8Array(bufferLen * 2);
+    encoder.cpos = 0;
+  }
+  encoder.cbuf[encoder.cpos++] = num;
+};
+
+/**
+ * Write a variable length unsigned integer. Max encodable integer is 2^53.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {number} num The number that is to be encoded.
+ */
+const writeVarUint = (encoder, num) => {
+  while (num > BITS7) {
+    write(encoder, BIT8 | (BITS7 & num));
+    num = floor(num / 128); // shift >>> 7
+  }
+  write(encoder, BITS7 & num);
+};
+
+/**
+ * A cache to store strings temporarily
+ */
+const _strBuffer = new Uint8Array(30000);
+const _maxStrBSize = _strBuffer.length / 3;
+
+/**
+ * Write a variable length string.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
+ */
+const _writeVarStringNative = (encoder, str) => {
+  if (str.length < _maxStrBSize) {
+    // We can encode the string into the existing buffer
+    /* c8 ignore next */
+    const written = utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
+    writeVarUint(encoder, written);
+    for (let i = 0; i < written; i++) {
+      write(encoder, _strBuffer[i]);
+    }
+  } else {
+    writeVarUint8Array(encoder, encodeUtf8(str));
+  }
+};
+
+/**
+ * Write a variable length string.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
+ */
+const _writeVarStringPolyfill = (encoder, str) => {
+  const encodedString = unescape(encodeURIComponent(str));
+  const len = encodedString.length;
+  writeVarUint(encoder, len);
+  for (let i = 0; i < len; i++) {
+    write(encoder, /** @type {number} */ (encodedString.codePointAt(i)));
+  }
+};
+
+/**
+ * Write a variable length string.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
+ */
+/* c8 ignore next */
+const writeVarString = (utf8TextEncoder && /** @type {any} */ (utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill;
+
+/**
+ * Append fixed-length Uint8Array to the encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
+ */
+const writeUint8Array = (encoder, uint8Array) => {
+  const bufferLen = encoder.cbuf.length;
+  const cpos = encoder.cpos;
+  const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
+  const rightCopyLen = uint8Array.length - leftCopyLen;
+  encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
+  encoder.cpos += leftCopyLen;
+  if (rightCopyLen > 0) {
+    // Still something to write, write right half..
+    // Append new buffer
+    encoder.bufs.push(encoder.cbuf);
+    // must have at least size of remaining buffer
+    encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
+    // copy array
+    encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
+    encoder.cpos = rightCopyLen;
+  }
+};
+
+/**
+ * Append an Uint8Array to Encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
+ */
+const writeVarUint8Array = (encoder, uint8Array) => {
+  writeVarUint(encoder, uint8Array.byteLength);
+  writeUint8Array(encoder, uint8Array);
+};
+
+/**
+ * Error helpers.
+ *
+ * @module error
+ */
+
+/**
+ * @param {string} s
+ * @return {Error}
+ */
+/* c8 ignore next */
+const create$1 = s => new Error(s);
+
+/**
+ * Efficient schema-less binary decoding with support for variable length encoding.
+ *
+ * Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.
+ *
+ * Encodes numbers in little-endian order (least to most significant byte order)
+ * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
+ * which is also used in Protocol Buffers.
+ *
+ * ```js
+ * // encoding step
+ * const encoder = encoding.createEncoder()
+ * encoding.writeVarUint(encoder, 256)
+ * encoding.writeVarString(encoder, 'Hello world!')
+ * const buf = encoding.toUint8Array(encoder)
+ * ```
+ *
+ * ```js
+ * // decoding step
+ * const decoder = decoding.createDecoder(buf)
+ * decoding.readVarUint(decoder) // => 256
+ * decoding.readVarString(decoder) // => 'Hello world!'
+ * decoding.hasContent(decoder) // => false - all data is read
+ * ```
+ *
+ * @module decoding
+ */
+
+
+const errorUnexpectedEndOfArray = create$1('Unexpected end of array');
+const errorIntegerOutOfRange = create$1('Integer out of Range');
+
+/**
+ * A Decoder handles the decoding of an Uint8Array.
+ */
+class Decoder {
+  /**
+   * @param {Uint8Array} uint8Array Binary data to decode
+   */
+  constructor (uint8Array) {
+    /**
+     * Decoding target.
+     *
+     * @type {Uint8Array}
+     */
+    this.arr = uint8Array;
+    /**
+     * Current decoding position.
+     *
+     * @type {number}
+     */
+    this.pos = 0;
+  }
+}
+
+/**
+ * @function
+ * @param {Uint8Array} uint8Array
+ * @return {Decoder}
+ */
+const createDecoder = uint8Array => new Decoder(uint8Array);
+
+/**
+ * Create an Uint8Array view of the next `len` bytes and advance the position by `len`.
+ *
+ * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+ *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+ *
+ * @function
+ * @param {Decoder} decoder The decoder instance
+ * @param {number} len The length of bytes to read
+ * @return {Uint8Array}
+ */
+const readUint8Array = (decoder, len) => {
+  const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+  decoder.pos += len;
+  return view
+};
+
+/**
+ * Read variable length Uint8Array.
+ *
+ * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+ *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+ *
+ * @function
+ * @param {Decoder} decoder
+ * @return {Uint8Array}
+ */
+const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint(decoder));
+
+/**
+ * Read one byte as unsigned integer.
+ * @function
+ * @param {Decoder} decoder The decoder instance
+ * @return {number} Unsigned 8-bit integer
+ */
+const readUint8 = decoder => decoder.arr[decoder.pos++];
+
+/**
+ * Read unsigned integer (32bit) with variable length.
+ * 1/8th of the storage is used as encoding overhead.
+ *  * numbers < 2^7 is stored in one bytlength
+ *  * numbers < 2^14 is stored in two bylength
+ *
+ * @function
+ * @param {Decoder} decoder
+ * @return {number} An unsigned integer.length
+ */
+const readVarUint = decoder => {
+  let num = 0;
+  let mult = 1;
+  const len = decoder.arr.length;
+  while (decoder.pos < len) {
+    const r = decoder.arr[decoder.pos++];
+    // num = num | ((r & binary.BITS7) << len)
+    num = num + (r & BITS7) * mult; // shift $r << (7*#iterations) and add it to num
+    mult *= 128; // next iteration, shift 7 "more" to the left
+    if (r < BIT8) {
+      return num
+    }
+    /* c8 ignore start */
+    if (num > MAX_SAFE_INTEGER) {
+      throw errorIntegerOutOfRange
+    }
+    /* c8 ignore stop */
+  }
+  throw errorUnexpectedEndOfArray
+};
+
+/**
+ * Read signed integer (32bit) with variable length.
+ * 1/8th of the storage is used as encoding overhead.
+ *  * numbers < 2^7 is stored in one bytlength
+ *  * numbers < 2^14 is stored in two bylength
+ * @todo This should probably create the inverse ~num if number is negative - but this would be a breaking change.
+ *
+ * @function
+ * @param {Decoder} decoder
+ * @return {number} An unsigned integer.length
+ */
+const readVarInt = decoder => {
+  let r = decoder.arr[decoder.pos++];
+  let num = r & BITS6;
+  let mult = 64;
+  const sign = (r & BIT7) > 0 ? -1 : 1;
+  if ((r & BIT8) === 0) {
+    // don't continue reading
+    return sign * num
+  }
+  const len = decoder.arr.length;
+  while (decoder.pos < len) {
+    r = decoder.arr[decoder.pos++];
+    // num = num | ((r & binary.BITS7) << len)
+    num = num + (r & BITS7) * mult;
+    mult *= 128;
+    if (r < BIT8) {
+      return sign * num
+    }
+    /* c8 ignore start */
+    if (num > MAX_SAFE_INTEGER) {
+      throw errorIntegerOutOfRange
+    }
+    /* c8 ignore stop */
+  }
+  throw errorUnexpectedEndOfArray
+};
+
+/**
+ * We don't test this function anymore as we use native decoding/encoding by default now.
+ * Better not modify this anymore..
+ *
+ * Transforming utf8 to a string is pretty expensive. The code performs 10x better
+ * when String.fromCodePoint is fed with all characters as arguments.
+ * But most environments have a maximum number of arguments per functions.
+ * For effiency reasons we apply a maximum of 10000 characters at once.
+ *
+ * @function
+ * @param {Decoder} decoder
+ * @return {String} The read String.
+ */
+/* c8 ignore start */
+const _readVarStringPolyfill = decoder => {
+  let remainingLen = readVarUint(decoder);
+  if (remainingLen === 0) {
+    return ''
+  } else {
+    let encodedString = String.fromCodePoint(readUint8(decoder)); // remember to decrease remainingLen
+    if (--remainingLen < 100) { // do not create a Uint8Array for small strings
+      while (remainingLen--) {
+        encodedString += String.fromCodePoint(readUint8(decoder));
+      }
+    } else {
+      while (remainingLen > 0) {
+        const nextLen = remainingLen < 10000 ? remainingLen : 10000;
+        // this is dangerous, we create a fresh array view from the existing buffer
+        const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen);
+        decoder.pos += nextLen;
+        // Starting with ES5.1 we can supply a generic array-like object as arguments
+        encodedString += String.fromCodePoint.apply(null, /** @type {any} */ (bytes));
+        remainingLen -= nextLen;
+      }
+    }
+    return decodeURIComponent(escape(encodedString))
+  }
+};
+/* c8 ignore stop */
+
+/**
+ * @function
+ * @param {Decoder} decoder
+ * @return {String} The read String
+ */
+const _readVarStringNative = decoder =>
+  /** @type any */ (utf8TextDecoder).decode(readVarUint8Array(decoder));
+
+/**
+ * Read string of variable length
+ * * varUint is used to store the length of the string
+ *
+ * @function
+ * @param {Decoder} decoder
+ * @return {String} The read String
+ *
+ */
+/* c8 ignore next */
+const readVarString = utf8TextDecoder ? _readVarStringNative : _readVarStringPolyfill;
+
+/**
+ * Look ahead and read varString without incrementing position
+ *
+ * @function
+ * @param {Decoder} decoder
+ * @return {string}
+ */
+const peekVarString = decoder => {
+  const pos = decoder.pos;
+  const s = readVarString(decoder);
+  decoder.pos = pos;
+  return s
+};
+
+/**
+ * Utility module to work with time.
+ *
+ * @module time
+ */
+
+
+/**
+ * Return current unix time.
+ *
+ * @return {number}
+ */
+const getUnixTime = Date.now;
+
+/**
+ * Utility module to work with key-value stores.
+ *
+ * @module map
+ */
+
+/**
+ * Creates a new Map instance.
+ *
+ * @function
+ * @return {Map<any, any>}
+ *
+ * @function
+ */
+const create = () => new Map();
+
+/**
+ * Get map property. Create T if property is undefined and set T on map.
+ *
+ * ```js
+ * const listeners = map.setIfUndefined(events, 'eventName', set.create)
+ * listeners.add(listener)
+ * ```
+ *
+ * @function
+ * @template {Map<any, any>} MAP
+ * @template {MAP extends Map<any,infer V> ? function():V : unknown} CF
+ * @param {MAP} map
+ * @param {MAP extends Map<infer K,any> ? K : unknown} key
+ * @param {CF} createT
+ * @return {ReturnType<CF>}
+ */
+const setIfUndefined = (map, key, createT) => {
+  let set = map.get(key);
+  if (set === undefined) {
+    map.set(key, set = createT());
+  }
+  return set
+};
+
+/**
+ * Observable class prototype.
+ *
+ * @module observable
+ */
+
+
+/* c8 ignore start */
+/**
+ * Handles named events.
+ *
+ * @deprecated
+ * @template N
+ */
+class Observable {
+  constructor () {
+    /**
+     * Some desc.
+     * @type {Map<N, any>}
+     */
+    this._observers = create();
+  }
+
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  on (name, f) {
+    setIfUndefined(this._observers, name, create$2).add(f);
+  }
+
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  once (name, f) {
+    /**
+     * @param  {...any} args
+     */
+    const _f = (...args) => {
+      this.off(name, _f);
+      f(...args);
+    };
+    this.on(name, _f);
+  }
+
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  off (name, f) {
+    const observers = this._observers.get(name);
+    if (observers !== undefined) {
+      observers.delete(f);
+      if (observers.size === 0) {
+        this._observers.delete(name);
+      }
+    }
+  }
+
+  /**
+   * Emit a named event. All registered event listeners that listen to the
+   * specified name will receive the event.
+   *
+   * @todo This should catch exceptions
+   *
+   * @param {N} name The event name.
+   * @param {Array<any>} args The arguments that are applied to the event listener.
+   */
+  emit (name, args) {
+    // copy all listeners to an array first to make sure that no event is emitted to listeners that are subscribed while the event handler is called.
+    return from((this._observers.get(name) || create()).values()).forEach(f => f(...args))
+  }
+
+  destroy () {
+    this._observers = create();
+  }
+}
+/* c8 ignore end */
+
+/**
+ * Utility functions for working with EcmaScript objects.
+ *
+ * @module object
+ */
+
+
+/**
+ * @param {Object<string,any>} obj
+ */
+const keys = Object.keys;
+
+/**
+ * @deprecated use object.size instead
+ * @param {Object<string,any>} obj
+ * @return {number}
+ */
+const length = obj => keys(obj).length;
+
+/**
+ * Calls `Object.prototype.hasOwnProperty`.
+ *
+ * @param {any} obj
+ * @param {string|symbol} key
+ * @return {boolean}
+ */
+const hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+
+/**
+ * Common functions and function call helpers.
+ *
+ * @module function
+ */
+
+
+/**
+ * @template T
+ *
+ * @param {T} a
+ * @param {T} b
+ * @return {boolean}
+ */
+const equalityStrict = (a, b) => a === b;
+
+/* c8 ignore start */
+
+/**
+ * @param {any} a
+ * @param {any} b
+ * @return {boolean}
+ */
+const equalityDeep = (a, b) => {
+  if (a == null || b == null) {
+    return equalityStrict(a, b)
+  }
+  if (a.constructor !== b.constructor) {
+    return false
+  }
+  if (a === b) {
+    return true
+  }
+  switch (a.constructor) {
+    case ArrayBuffer:
+      a = new Uint8Array(a);
+      b = new Uint8Array(b);
+    // eslint-disable-next-line no-fallthrough
+    case Uint8Array: {
+      if (a.byteLength !== b.byteLength) {
+        return false
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+          return false
+        }
+      }
+      break
+    }
+    case Set: {
+      if (a.size !== b.size) {
+        return false
+      }
+      for (const value of a) {
+        if (!b.has(value)) {
+          return false
+        }
+      }
+      break
+    }
+    case Map: {
+      if (a.size !== b.size) {
+        return false
+      }
+      for (const key of a.keys()) {
+        if (!b.has(key) || !equalityDeep(a.get(key), b.get(key))) {
+          return false
+        }
+      }
+      break
+    }
+    case Object:
+      if (length(a) !== length(b)) {
+        return false
+      }
+      for (const key in a) {
+        if (!hasProperty(a, key) || !equalityDeep(a[key], b[key])) {
+          return false
+        }
+      }
+      break
+    case Array:
+      if (a.length !== b.length) {
+        return false
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (!equalityDeep(a[i], b[i])) {
+          return false
+        }
+      }
+      break
+    default:
+      return false
+  }
+  return true
+};
+
+/**
+ * @module awareness-protocol
+ */
+
+
+const outdatedTimeout = 30000;
+
+/**
+ * @typedef {Object} MetaClientState
+ * @property {number} MetaClientState.clock
+ * @property {number} MetaClientState.lastUpdated unix timestamp
+ */
+
+/**
+ * The Awareness class implements a simple shared state protocol that can be used for non-persistent data like awareness information
+ * (cursor, username, status, ..). Each client can update its own local state and listen to state changes of
+ * remote clients. Every client may set a state of a remote peer to `null` to mark the client as offline.
+ *
+ * Each client is identified by a unique client id (something we borrow from `doc.clientID`). A client can override
+ * its own state by propagating a message with an increasing timestamp (`clock`). If such a message is received, it is
+ * applied if the known state of that client is older than the new state (`clock < newClock`). If a client thinks that
+ * a remote client is offline, it may propagate a message with
+ * `{ clock: currentClientClock, state: null, client: remoteClient }`. If such a
+ * message is received, and the known clock of that client equals the received clock, it will override the state with `null`.
+ *
+ * Before a client disconnects, it should propagate a `null` state with an updated clock.
+ *
+ * Awareness states must be updated every 30 seconds. Otherwise the Awareness instance will delete the client state.
+ *
+ * @extends {Observable<string>}
+ */
+class Awareness extends Observable {
+  /**
+   * @param {Y.Doc} doc
+   */
+  constructor (doc) {
+    super();
+    this.doc = doc;
+    /**
+     * @type {number}
+     */
+    this.clientID = doc.clientID;
+    /**
+     * Maps from client id to client state
+     * @type {Map<number, Object<string, any>>}
+     */
+    this.states = new Map();
+    /**
+     * @type {Map<number, MetaClientState>}
+     */
+    this.meta = new Map();
+    this._checkInterval = /** @type {any} */ (setInterval(() => {
+      const now = getUnixTime();
+      if (this.getLocalState() !== null && (outdatedTimeout / 2 <= now - /** @type {{lastUpdated:number}} */ (this.meta.get(this.clientID)).lastUpdated)) {
+        // renew local clock
+        this.setLocalState(this.getLocalState());
+      }
+      /**
+       * @type {Array<number>}
+       */
+      const remove = [];
+      this.meta.forEach((meta, clientid) => {
+        if (clientid !== this.clientID && outdatedTimeout <= now - meta.lastUpdated && this.states.has(clientid)) {
+          remove.push(clientid);
+        }
+      });
+      if (remove.length > 0) {
+        removeAwarenessStates(this, remove, 'timeout');
+      }
+    }, floor(outdatedTimeout / 10)));
+    doc.on('destroy', () => {
+      this.destroy();
+    });
+    this.setLocalState({});
+  }
+
+  destroy () {
+    this.emit('destroy', [this]);
+    this.setLocalState(null);
+    super.destroy();
+    clearInterval(this._checkInterval);
+  }
+
+  /**
+   * @return {Object<string,any>|null}
+   */
+  getLocalState () {
+    return this.states.get(this.clientID) || null
+  }
+
+  /**
+   * @param {Object<string,any>|null} state
+   */
+  setLocalState (state) {
+    const clientID = this.clientID;
+    const currLocalMeta = this.meta.get(clientID);
+    const clock = currLocalMeta === undefined ? 0 : currLocalMeta.clock + 1;
+    const prevState = this.states.get(clientID);
+    if (state === null) {
+      this.states.delete(clientID);
+    } else {
+      this.states.set(clientID, state);
+    }
+    this.meta.set(clientID, {
+      clock,
+      lastUpdated: getUnixTime()
+    });
+    const added = [];
+    const updated = [];
+    const filteredUpdated = [];
+    const removed = [];
+    if (state === null) {
+      removed.push(clientID);
+    } else if (prevState == null) {
+      if (state != null) {
+        added.push(clientID);
+      }
+    } else {
+      updated.push(clientID);
+      if (!equalityDeep(prevState, state)) {
+        filteredUpdated.push(clientID);
+      }
+    }
+    if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) {
+      this.emit('change', [{ added, updated: filteredUpdated, removed }, 'local']);
+    }
+    this.emit('update', [{ added, updated, removed }, 'local']);
+  }
+
+  /**
+   * @param {string} field
+   * @param {any} value
+   */
+  setLocalStateField (field, value) {
+    const state = this.getLocalState();
+    if (state !== null) {
+      this.setLocalState({
+        ...state,
+        [field]: value
+      });
+    }
+  }
+
+  /**
+   * @return {Map<number,Object<string,any>>}
+   */
+  getStates () {
+    return this.states
+  }
+}
+
+/**
+ * Mark (remote) clients as inactive and remove them from the list of active peers.
+ * This change will be propagated to remote clients.
+ *
+ * @param {Awareness} awareness
+ * @param {Array<number>} clients
+ * @param {any} origin
+ */
+const removeAwarenessStates = (awareness, clients, origin) => {
+  const removed = [];
+  for (let i = 0; i < clients.length; i++) {
+    const clientID = clients[i];
+    if (awareness.states.has(clientID)) {
+      awareness.states.delete(clientID);
+      if (clientID === awareness.clientID) {
+        const curMeta = /** @type {MetaClientState} */ (awareness.meta.get(clientID));
+        awareness.meta.set(clientID, {
+          clock: curMeta.clock + 1,
+          lastUpdated: getUnixTime()
+        });
+      }
+      removed.push(clientID);
+    }
+  }
+  if (removed.length > 0) {
+    awareness.emit('change', [{ added: [], updated: [], removed }, origin]);
+    awareness.emit('update', [{ added: [], updated: [], removed }, origin]);
+  }
+};
+
+/**
+ * @param {Awareness} awareness
+ * @param {Array<number>} clients
+ * @return {Uint8Array}
+ */
+const encodeAwarenessUpdate = (awareness, clients, states = awareness.states) => {
+  const len = clients.length;
+  const encoder = createEncoder();
+  writeVarUint(encoder, len);
+  for (let i = 0; i < len; i++) {
+    const clientID = clients[i];
+    const state = states.get(clientID) || null;
+    const clock = /** @type {MetaClientState} */ (awareness.meta.get(clientID)).clock;
+    writeVarUint(encoder, clientID);
+    writeVarUint(encoder, clock);
+    writeVarString(encoder, JSON.stringify(state));
+  }
+  return toUint8Array(encoder)
+};
+
+/**
+ * @param {Awareness} awareness
+ * @param {Uint8Array} update
+ * @param {any} origin This will be added to the emitted change event
+ */
+const applyAwarenessUpdate = (awareness, update, origin) => {
+  const decoder = createDecoder(update);
+  const timestamp = getUnixTime();
+  const added = [];
+  const updated = [];
+  const filteredUpdated = [];
+  const removed = [];
+  const len = readVarUint(decoder);
+  for (let i = 0; i < len; i++) {
+    const clientID = readVarUint(decoder);
+    let clock = readVarUint(decoder);
+    const state = JSON.parse(readVarString(decoder));
+    const clientMeta = awareness.meta.get(clientID);
+    const prevState = awareness.states.get(clientID);
+    const currClock = clientMeta === undefined ? 0 : clientMeta.clock;
+    if (currClock < clock || (currClock === clock && state === null && awareness.states.has(clientID))) {
+      if (state === null) {
+        // never let a remote client remove this local state
+        if (clientID === awareness.clientID && awareness.getLocalState() != null) {
+          // remote client removed the local state. Do not remote state. Broadcast a message indicating
+          // that this client still exists by increasing the clock
+          clock++;
+        } else {
+          awareness.states.delete(clientID);
+        }
+      } else {
+        awareness.states.set(clientID, state);
+      }
+      awareness.meta.set(clientID, {
+        clock,
+        lastUpdated: timestamp
+      });
+      if (clientMeta === undefined && state !== null) {
+        added.push(clientID);
+      } else if (clientMeta !== undefined && state === null) {
+        removed.push(clientID);
+      } else if (state !== null) {
+        if (!equalityDeep(state, prevState)) {
+          filteredUpdated.push(clientID);
+        }
+        updated.push(clientID);
+      }
+    }
+  }
+  if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) {
+    awareness.emit('change', [{
+      added, updated: filteredUpdated, removed
+    }, origin]);
+  }
+  if (added.length > 0 || updated.length > 0 || removed.length > 0) {
+    awareness.emit('update', [{
+      added, updated, removed
+    }, origin]);
+  }
+};
+
+class EventEmitter {
+    constructor() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+        this.callbacks = {};
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    on(event, fn) {
+        if (!this.callbacks[event]) {
+            this.callbacks[event] = [];
+        }
+        this.callbacks[event].push(fn);
+        return this;
+    }
+    emit(event, ...args) {
+        const callbacks = this.callbacks[event];
+        if (callbacks) {
+            callbacks.forEach((callback) => callback.apply(this, args));
+        }
+        return this;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    off(event, fn) {
+        const callbacks = this.callbacks[event];
+        if (callbacks) {
+            if (fn) {
+                this.callbacks[event] = callbacks.filter((callback) => callback !== fn);
+            }
+            else {
+                delete this.callbacks[event];
+            }
+        }
+        return this;
+    }
+    removeAllListeners() {
+        this.callbacks = {};
+    }
+}
+
+class IncomingMessage {
+    constructor(data) {
+        this.data = data;
+        this.encoder = createEncoder();
+        this.decoder = createDecoder(new Uint8Array(this.data));
+    }
+    peekVarString() {
+        return peekVarString(this.decoder);
+    }
+    readVarUint() {
+        return readVarUint(this.decoder);
+    }
+    readVarString() {
+        return readVarString(this.decoder);
+    }
+    readVarUint8Array() {
+        return readVarUint8Array(this.decoder);
+    }
+    writeVarUint(type) {
+        return writeVarUint(this.encoder, type);
+    }
+    writeVarString(string) {
+        return writeVarString(this.encoder, string);
+    }
+    writeVarUint8Array(data) {
+        return writeVarUint8Array(this.encoder, data);
+    }
+    length() {
+        return length$1(this.encoder);
+    }
+}
+
+var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["Sync"] = 0] = "Sync";
+    MessageType[MessageType["Awareness"] = 1] = "Awareness";
+    MessageType[MessageType["Auth"] = 2] = "Auth";
+    MessageType[MessageType["QueryAwareness"] = 3] = "QueryAwareness";
+    MessageType[MessageType["Stateless"] = 5] = "Stateless";
+    MessageType[MessageType["CLOSE"] = 7] = "CLOSE";
+    MessageType[MessageType["SyncStatus"] = 8] = "SyncStatus";
+})(MessageType || (MessageType = {}));
+var WebSocketStatus;
+(function (WebSocketStatus) {
+    WebSocketStatus["Connecting"] = "connecting";
+    WebSocketStatus["Connected"] = "connected";
+    WebSocketStatus["Disconnected"] = "disconnected";
+})(WebSocketStatus || (WebSocketStatus = {}));
+
+class OutgoingMessage {
+    constructor() {
+        this.encoder = createEncoder();
+    }
+    get(args) {
+        return args.encoder;
+    }
+    toUint8Array() {
+        return toUint8Array(this.encoder);
+    }
+}
+
+class CloseMessage extends OutgoingMessage {
+    constructor() {
+        super(...arguments);
+        this.type = MessageType.CLOSE;
+        this.description = "Ask the server to close the connection";
+    }
+    get(args) {
+        writeVarString(this.encoder, args.documentName);
+        writeVarUint(this.encoder, this.type);
+        return this.encoder;
+    }
+}
+
+class HocuspocusProviderWebsocket extends EventEmitter {
+    constructor(configuration) {
+        super();
+        this.messageQueue = [];
+        this.configuration = {
+            url: "",
+            autoConnect: true,
+            preserveTrailingSlash: false,
+            // @ts-ignore
+            document: undefined,
+            WebSocketPolyfill: undefined,
+            // TODO: this should depend on awareness.outdatedTime
+            messageReconnectTimeout: 30000,
+            // 1 second
+            delay: 1000,
+            // instant
+            initialDelay: 0,
+            // double the delay each time
+            factor: 2,
+            // unlimited retries
+            maxAttempts: 0,
+            // wait at least 1 second
+            minDelay: 1000,
+            // at least every 30 seconds
+            maxDelay: 30000,
+            // randomize
+            jitter: true,
+            // retry forever
+            timeout: 0,
+            onOpen: () => null,
+            onConnect: () => null,
+            onMessage: () => null,
+            onOutgoingMessage: () => null,
+            onStatus: () => null,
+            onDisconnect: () => null,
+            onClose: () => null,
+            onDestroy: () => null,
+            onAwarenessUpdate: () => null,
+            onAwarenessChange: () => null,
+            handleTimeout: null,
+            providerMap: new Map(),
+        };
+        this.webSocket = null;
+        this.webSocketHandlers = {};
+        this.shouldConnect = true;
+        this.status = WebSocketStatus.Disconnected;
+        this.lastMessageReceived = 0;
+        this.identifier = 0;
+        this.intervals = {
+            connectionChecker: null,
+        };
+        this.connectionAttempt = null;
+        this.receivedOnOpenPayload = undefined;
+        this.closeTries = 0;
+        this.setConfiguration(configuration);
+        this.configuration.WebSocketPolyfill = configuration.WebSocketPolyfill
+            ? configuration.WebSocketPolyfill
+            : WebSocket;
+        this.on("open", this.configuration.onOpen);
+        this.on("open", this.onOpen.bind(this));
+        this.on("connect", this.configuration.onConnect);
+        this.on("message", this.configuration.onMessage);
+        this.on("outgoingMessage", this.configuration.onOutgoingMessage);
+        this.on("status", this.configuration.onStatus);
+        this.on("disconnect", this.configuration.onDisconnect);
+        this.on("close", this.configuration.onClose);
+        this.on("destroy", this.configuration.onDestroy);
+        this.on("awarenessUpdate", this.configuration.onAwarenessUpdate);
+        this.on("awarenessChange", this.configuration.onAwarenessChange);
+        this.on("close", this.onClose.bind(this));
+        this.on("message", this.onMessage.bind(this));
+        this.intervals.connectionChecker = setInterval(this.checkConnection.bind(this), this.configuration.messageReconnectTimeout / 10);
+        if (this.shouldConnect) {
+            this.connect();
+        }
+    }
+    async onOpen(event) {
+        this.status = WebSocketStatus.Connected;
+        this.emit("status", { status: WebSocketStatus.Connected });
+        this.cancelWebsocketRetry = undefined;
+        this.receivedOnOpenPayload = event;
+    }
+    attach(provider) {
+        this.configuration.providerMap.set(provider.configuration.name, provider);
+        if (this.status === WebSocketStatus.Disconnected && this.shouldConnect) {
+            this.connect();
+        }
+        if (this.receivedOnOpenPayload &&
+            this.status === WebSocketStatus.Connected) {
+            provider.onOpen(this.receivedOnOpenPayload);
+        }
+    }
+    detach(provider) {
+        if (this.configuration.providerMap.has(provider.configuration.name)) {
+            provider.send(CloseMessage, {
+                documentName: provider.configuration.name,
+            });
+            this.configuration.providerMap.delete(provider.configuration.name);
+        }
+    }
+    setConfiguration(configuration = {}) {
+        this.configuration = { ...this.configuration, ...configuration };
+        if (!this.configuration.autoConnect) {
+            this.shouldConnect = false;
+        }
+    }
+    async connect() {
+        if (this.status === WebSocketStatus.Connected) {
+            return;
+        }
+        // Always cancel any previously initiated connection retryer instances
+        if (this.cancelWebsocketRetry) {
+            this.cancelWebsocketRetry();
+            this.cancelWebsocketRetry = undefined;
+        }
+        this.receivedOnOpenPayload = undefined;
+        this.shouldConnect = true;
+        const abortableRetry = () => {
+            let cancelAttempt = false;
+            const retryPromise = retry(this.createWebSocketConnection.bind(this), {
+                delay: this.configuration.delay,
+                initialDelay: this.configuration.initialDelay,
+                factor: this.configuration.factor,
+                maxAttempts: this.configuration.maxAttempts,
+                minDelay: this.configuration.minDelay,
+                maxDelay: this.configuration.maxDelay,
+                jitter: this.configuration.jitter,
+                timeout: this.configuration.timeout,
+                handleTimeout: this.configuration.handleTimeout,
+                beforeAttempt: (context) => {
+                    if (!this.shouldConnect || cancelAttempt) {
+                        context.abort();
+                    }
+                },
+            }).catch((error) => {
+                // If we aborted the connection attempt then don’t throw an error
+                // ref: https://github.com/lifeomic/attempt/blob/master/src/index.ts#L136
+                if (error && error.code !== "ATTEMPT_ABORTED") {
+                    throw error;
+                }
+            });
+            return {
+                retryPromise,
+                cancelFunc: () => {
+                    cancelAttempt = true;
+                },
+            };
+        };
+        const { retryPromise, cancelFunc } = abortableRetry();
+        this.cancelWebsocketRetry = cancelFunc;
+        return retryPromise;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    attachWebSocketListeners(ws, reject) {
+        const { identifier } = ws;
+        const onMessageHandler = (payload) => this.emit("message", payload);
+        const onCloseHandler = (payload) => this.emit("close", { event: payload });
+        const onOpenHandler = (payload) => this.emit("open", payload);
+        const onErrorHandler = (err) => {
+            reject(err);
+        };
+        this.webSocketHandlers[identifier] = {
+            message: onMessageHandler,
+            close: onCloseHandler,
+            open: onOpenHandler,
+            error: onErrorHandler,
+        };
+        const handlers = this.webSocketHandlers[ws.identifier];
+        Object.keys(handlers).forEach((name) => {
+            ws.addEventListener(name, handlers[name]);
+        });
+    }
+    cleanupWebSocket() {
+        if (!this.webSocket) {
+            return;
+        }
+        const { identifier } = this.webSocket;
+        const handlers = this.webSocketHandlers[identifier];
+        Object.keys(handlers).forEach((name) => {
+            var _a;
+            (_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.removeEventListener(name, handlers[name]);
+            delete this.webSocketHandlers[identifier];
+        });
+        this.webSocket.close();
+        this.webSocket = null;
+    }
+    createWebSocketConnection() {
+        return new Promise((resolve, reject) => {
+            if (this.webSocket) {
+                this.messageQueue = [];
+                this.cleanupWebSocket();
+            }
+            this.lastMessageReceived = 0;
+            this.identifier += 1;
+            // Init the WebSocket connection
+            const ws = new this.configuration.WebSocketPolyfill(this.url);
+            ws.binaryType = "arraybuffer";
+            ws.identifier = this.identifier;
+            this.attachWebSocketListeners(ws, reject);
+            this.webSocket = ws;
+            // Reset the status
+            this.status = WebSocketStatus.Connecting;
+            this.emit("status", { status: WebSocketStatus.Connecting });
+            // Store resolve/reject for later use
+            this.connectionAttempt = {
+                resolve,
+                reject,
+            };
+        });
+    }
+    onMessage(event) {
+        var _a;
+        this.resolveConnectionAttempt();
+        this.lastMessageReceived = getUnixTime();
+        const message = new IncomingMessage(event.data);
+        const documentName = message.peekVarString();
+        (_a = this.configuration.providerMap.get(documentName)) === null || _a === void 0 ? void 0 : _a.onMessage(event);
+    }
+    resolveConnectionAttempt() {
+        if (this.connectionAttempt) {
+            this.connectionAttempt.resolve();
+            this.connectionAttempt = null;
+            this.status = WebSocketStatus.Connected;
+            this.emit("status", { status: WebSocketStatus.Connected });
+            this.emit("connect");
+            this.messageQueue.forEach((message) => this.send(message));
+            this.messageQueue = [];
+        }
+    }
+    stopConnectionAttempt() {
+        this.connectionAttempt = null;
+    }
+    rejectConnectionAttempt() {
+        var _a;
+        (_a = this.connectionAttempt) === null || _a === void 0 ? void 0 : _a.reject();
+        this.connectionAttempt = null;
+    }
+    checkConnection() {
+        var _a;
+        // Don’t check the connection when it’s not even established
+        if (this.status !== WebSocketStatus.Connected) {
+            return;
+        }
+        // Don’t close the connection while waiting for the first message
+        if (!this.lastMessageReceived) {
+            return;
+        }
+        // Don’t close the connection when a message was received recently
+        if (this.configuration.messageReconnectTimeout >=
+            getUnixTime() - this.lastMessageReceived) {
+            return;
+        }
+        // No message received in a long time, not even your own
+        // Awareness updates, which are updated every 15 seconds
+        // if awareness is enabled.
+        this.closeTries += 1;
+        // https://bugs.webkit.org/show_bug.cgi?id=247943
+        if (this.closeTries > 2) {
+            this.onClose({
+                event: {
+                    code: 4408,
+                    reason: "forced",
+                },
+            });
+            this.closeTries = 0;
+        }
+        else {
+            (_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.close();
+            this.messageQueue = [];
+        }
+    }
+    get serverUrl() {
+        if (this.configuration.preserveTrailingSlash) {
+            return this.configuration.url;
+        }
+        // By default, ensure that the URL never ends with /
+        let url = this.configuration.url;
+        while (url[url.length - 1] === "/") {
+            url = url.slice(0, url.length - 1);
+        }
+        return url;
+    }
+    get url() {
+        return this.serverUrl;
+    }
+    disconnect() {
+        this.shouldConnect = false;
+        if (this.webSocket === null) {
+            return;
+        }
+        try {
+            this.webSocket.close();
+            this.messageQueue = [];
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    send(message) {
+        var _a;
+        if (((_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.readyState) === WsReadyStates.Open) {
+            this.webSocket.send(message);
+        }
+        else {
+            this.messageQueue.push(message);
+        }
+    }
+    onClose({ event }) {
+        this.closeTries = 0;
+        this.cleanupWebSocket();
+        if (this.connectionAttempt) {
+            // That connection attempt failed.
+            this.rejectConnectionAttempt();
+        }
+        // Let’s update the connection status.
+        this.status = WebSocketStatus.Disconnected;
+        this.emit("status", { status: WebSocketStatus.Disconnected });
+        this.emit("disconnect", { event });
+        // trigger connect if no retry is running and we want to have a connection
+        if (!this.cancelWebsocketRetry && this.shouldConnect) {
+            setTimeout(() => {
+                this.connect();
+            }, this.configuration.delay);
+        }
+    }
+    destroy() {
+        this.emit("destroy");
+        clearInterval(this.intervals.connectionChecker);
+        // If there is still a connection attempt outstanding then we should stop
+        // it before calling disconnect, otherwise it will be rejected in the onClose
+        // handler and trigger a retry
+        this.stopConnectionAttempt();
+        this.disconnect();
+        this.removeAllListeners();
+        this.cleanupWebSocket();
+    }
+}
+
+/**
+ * @module sync-protocol
+ */
+
+
+/**
+ * @typedef {Map<number, number>} StateMap
+ */
+
+/**
+ * Core Yjs defines two message types:
+ * • YjsSyncStep1: Includes the State Set of the sending client. When received, the client should reply with YjsSyncStep2.
+ * • YjsSyncStep2: Includes all missing structs and the complete delete set. When received, the client is assured that it
+ *   received all information from the remote client.
+ *
+ * In a peer-to-peer network, you may want to introduce a SyncDone message type. Both parties should initiate the connection
+ * with SyncStep1. When a client received SyncStep2, it should reply with SyncDone. When the local client received both
+ * SyncStep2 and SyncDone, it is assured that it is synced to the remote client.
+ *
+ * In a client-server model, you want to handle this differently: The client should initiate the connection with SyncStep1.
+ * When the server receives SyncStep1, it should reply with SyncStep2 immediately followed by SyncStep1. The client replies
+ * with SyncStep2 when it receives SyncStep1. Optionally the server may send a SyncDone after it received SyncStep2, so the
+ * client knows that the sync is finished.  There are two reasons for this more elaborated sync model: 1. This protocol can
+ * easily be implemented on top of http and websockets. 2. The server should only reply to requests, and not initiate them.
+ * Therefore it is necessary that the client initiates the sync.
+ *
+ * Construction of a message:
+ * [messageType : varUint, message definition..]
+ *
+ * Note: A message does not include information about the room name. This must to be handled by the upper layer protocol!
+ *
+ * stringify[messageType] stringifies a message definition (messageType is already read from the bufffer)
+ */
+
+const messageYjsSyncStep1 = 0;
+const messageYjsSyncStep2 = 1;
+const messageYjsUpdate = 2;
+
+/**
+ * Create a sync step 1 message based on the state of the current shared document.
+ *
+ * @param {encoding.Encoder} encoder
+ * @param {Y.Doc} doc
+ */
+const writeSyncStep1 = (encoder, doc) => {
+  writeVarUint(encoder, messageYjsSyncStep1);
+  const sv = Y__namespace.encodeStateVector(doc);
+  writeVarUint8Array(encoder, sv);
+};
+
+/**
+ * @param {encoding.Encoder} encoder
+ * @param {Y.Doc} doc
+ * @param {Uint8Array} [encodedStateVector]
+ */
+const writeSyncStep2 = (encoder, doc, encodedStateVector) => {
+  writeVarUint(encoder, messageYjsSyncStep2);
+  writeVarUint8Array(encoder, Y__namespace.encodeStateAsUpdate(doc, encodedStateVector));
+};
+
+/**
+ * Read SyncStep1 message and reply with SyncStep2.
+ *
+ * @param {decoding.Decoder} decoder The reply to the received message
+ * @param {encoding.Encoder} encoder The received message
+ * @param {Y.Doc} doc
+ */
+const readSyncStep1 = (decoder, encoder, doc) =>
+  writeSyncStep2(encoder, doc, readVarUint8Array(decoder));
+
+/**
+ * Read and apply Structs and then DeleteStore to a y instance.
+ *
+ * @param {decoding.Decoder} decoder
+ * @param {Y.Doc} doc
+ * @param {any} transactionOrigin
+ */
+const readSyncStep2 = (decoder, doc, transactionOrigin) => {
+  try {
+    Y__namespace.applyUpdate(doc, readVarUint8Array(decoder), transactionOrigin);
+  } catch (error) {
+    // This catches errors that are thrown by event handlers
+    console.error('Caught error while handling a Yjs update', error);
+  }
+};
+
+/**
+ * @param {encoding.Encoder} encoder
+ * @param {Uint8Array} update
+ */
+const writeUpdate = (encoder, update) => {
+  writeVarUint(encoder, messageYjsUpdate);
+  writeVarUint8Array(encoder, update);
+};
+
+/**
+ * Read and apply Structs and then DeleteStore to a y instance.
+ *
+ * @param {decoding.Decoder} decoder
+ * @param {Y.Doc} doc
+ * @param {any} transactionOrigin
+ */
+const readUpdate = readSyncStep2;
+
+/**
+ * @param {decoding.Decoder} decoder A message received from another client
+ * @param {encoding.Encoder} encoder The reply message. Does not need to be sent if empty.
+ * @param {Y.Doc} doc
+ * @param {any} transactionOrigin
+ */
+const readSyncMessage = (decoder, encoder, doc, transactionOrigin) => {
+  const messageType = readVarUint(decoder);
+  switch (messageType) {
+    case messageYjsSyncStep1:
+      readSyncStep1(decoder, encoder, doc);
+      break
+    case messageYjsSyncStep2:
+      readSyncStep2(decoder, doc, transactionOrigin);
+      break
+    case messageYjsUpdate:
+      readUpdate(decoder, doc, transactionOrigin);
+      break
+    default:
+      throw new Error('Unknown message type')
+  }
+  return messageType
+};
+
+class MessageReceiver {
+    constructor(message) {
+        this.message = message;
+    }
+    apply(provider, emitSynced) {
+        const { message } = this;
+        const type = message.readVarUint();
+        const emptyMessageLength = message.length();
+        switch (type) {
+            case MessageType.Sync:
+                this.applySyncMessage(provider, emitSynced);
+                break;
+            case MessageType.Awareness:
+                this.applyAwarenessMessage(provider);
+                break;
+            case MessageType.Auth:
+                this.applyAuthMessage(provider);
+                break;
+            case MessageType.QueryAwareness:
+                this.applyQueryAwarenessMessage(provider);
+                break;
+            case MessageType.Stateless:
+                provider.receiveStateless(readVarString(message.decoder));
+                break;
+            case MessageType.SyncStatus:
+                this.applySyncStatusMessage(provider, readVarInt(message.decoder) === 1);
+                break;
+            case MessageType.CLOSE:
+                // eslint-disable-next-line no-case-declarations
+                const event = {
+                    code: 1000,
+                    reason: readVarString(message.decoder),
+                    // @ts-ignore
+                    target: provider.configuration.websocketProvider.webSocket,
+                    type: "close",
+                };
+                provider.onClose();
+                provider.configuration.onClose({ event });
+                provider.forwardClose({ event });
+                break;
+            default:
+                throw new Error(`Can’t apply message of unknown type: ${type}`);
+        }
+        // Reply
+        if (message.length() > emptyMessageLength + 1) {
+            // length of documentName (considered in emptyMessageLength plus length of yjs sync type, set in applySyncMessage)
+            // @ts-ignore
+            provider.send(OutgoingMessage, { encoder: message.encoder });
+        }
+    }
+    applySyncMessage(provider, emitSynced) {
+        const { message } = this;
+        message.writeVarUint(MessageType.Sync);
+        // Apply update
+        const syncMessageType = readSyncMessage(message.decoder, message.encoder, provider.document, provider);
+        // Synced once we receive Step2
+        if (emitSynced && syncMessageType === messageYjsSyncStep2) {
+            provider.synced = true;
+        }
+    }
+    applySyncStatusMessage(provider, applied) {
+        if (applied) {
+            provider.decrementUnsyncedChanges();
+        }
+    }
+    applyAwarenessMessage(provider) {
+        if (!provider.awareness)
+            return;
+        const { message } = this;
+        applyAwarenessUpdate(provider.awareness, message.readVarUint8Array(), provider);
+    }
+    applyAuthMessage(provider) {
+        const { message } = this;
+        readAuthMessage(message.decoder, provider.sendToken.bind(provider), provider.permissionDeniedHandler.bind(provider), provider.authenticatedHandler.bind(provider));
+    }
+    applyQueryAwarenessMessage(provider) {
+        if (!provider.awareness)
+            return;
+        const { message } = this;
+        message.writeVarUint(MessageType.Awareness);
+        message.writeVarUint8Array(encodeAwarenessUpdate(provider.awareness, Array.from(provider.awareness.getStates().keys())));
+    }
+}
+
+class MessageSender {
+    constructor(Message, args = {}) {
+        this.message = new Message();
+        this.encoder = this.message.get(args);
+    }
+    create() {
+        return toUint8Array(this.encoder);
+    }
+    send(webSocket) {
+        webSocket === null || webSocket === void 0 ? void 0 : webSocket.send(this.create());
+    }
+}
+
+class AuthenticationMessage extends OutgoingMessage {
+    constructor() {
+        super(...arguments);
+        this.type = MessageType.Auth;
+        this.description = "Authentication";
+    }
+    get(args) {
+        if (typeof args.token === "undefined") {
+            throw new Error("The authentication message requires `token` as an argument.");
+        }
+        writeVarString(this.encoder, args.documentName);
+        writeVarUint(this.encoder, this.type);
+        writeAuthentication(this.encoder, args.token);
+        return this.encoder;
+    }
+}
+
+class AwarenessMessage extends OutgoingMessage {
+    constructor() {
+        super(...arguments);
+        this.type = MessageType.Awareness;
+        this.description = "Awareness states update";
+    }
+    get(args) {
+        if (typeof args.awareness === "undefined") {
+            throw new Error("The awareness message requires awareness as an argument");
+        }
+        if (typeof args.clients === "undefined") {
+            throw new Error("The awareness message requires clients as an argument");
+        }
+        writeVarString(this.encoder, args.documentName);
+        writeVarUint(this.encoder, this.type);
+        let awarenessUpdate;
+        if (args.states === undefined) {
+            awarenessUpdate = encodeAwarenessUpdate(args.awareness, args.clients);
+        }
+        else {
+            awarenessUpdate = encodeAwarenessUpdate(args.awareness, args.clients, args.states);
+        }
+        writeVarUint8Array(this.encoder, awarenessUpdate);
+        return this.encoder;
+    }
+}
+
+class StatelessMessage extends OutgoingMessage {
+    constructor() {
+        super(...arguments);
+        this.type = MessageType.Stateless;
+        this.description = "A stateless message";
+    }
+    get(args) {
+        var _a;
+        writeVarString(this.encoder, args.documentName);
+        writeVarUint(this.encoder, this.type);
+        writeVarString(this.encoder, (_a = args.payload) !== null && _a !== void 0 ? _a : "");
+        return this.encoder;
+    }
+}
+
+class SyncStepOneMessage extends OutgoingMessage {
+    constructor() {
+        super(...arguments);
+        this.type = MessageType.Sync;
+        this.description = "First sync step";
+    }
+    get(args) {
+        if (typeof args.document === "undefined") {
+            throw new Error("The sync step one message requires document as an argument");
+        }
+        writeVarString(this.encoder, args.documentName);
+        writeVarUint(this.encoder, this.type);
+        writeSyncStep1(this.encoder, args.document);
+        return this.encoder;
+    }
+}
+
+class UpdateMessage extends OutgoingMessage {
+    constructor() {
+        super(...arguments);
+        this.type = MessageType.Sync;
+        this.description = "A document update";
+    }
+    get(args) {
+        writeVarString(this.encoder, args.documentName);
+        writeVarUint(this.encoder, this.type);
+        writeUpdate(this.encoder, args.update);
+        return this.encoder;
+    }
+}
+
+class AwarenessError extends Error {
+    constructor() {
+        super(...arguments);
+        this.code = 1001;
+    }
+}
+class HocuspocusProvider extends EventEmitter {
+    constructor(configuration) {
+        var _a, _b, _c;
+        super();
+        this.configuration = {
+            name: "",
+            // @ts-ignore
+            document: undefined,
+            // @ts-ignore
+            awareness: undefined,
+            token: null,
+            forceSyncInterval: false,
+            onAuthenticated: () => null,
+            onAuthenticationFailed: () => null,
+            onOpen: () => null,
+            onConnect: () => null,
+            onMessage: () => null,
+            onOutgoingMessage: () => null,
+            onSynced: () => null,
+            onStatus: () => null,
+            onDisconnect: () => null,
+            onClose: () => null,
+            onDestroy: () => null,
+            onAwarenessUpdate: () => null,
+            onAwarenessChange: () => null,
+            onStateless: () => null,
+            onUnsyncedChanges: () => null,
+        };
+        this.isSynced = false;
+        this.unsyncedChanges = 0;
+        this.isAuthenticated = false;
+        this.authorizedScope = undefined;
+        // @internal
+        this.manageSocket = false;
+        this._isAttached = false;
+        this.intervals = {
+            forceSync: null,
+        };
+        this.boundDocumentUpdateHandler = this.documentUpdateHandler.bind(this);
+        this.boundAwarenessUpdateHandler = this.awarenessUpdateHandler.bind(this);
+        this.boundPageHide = this.pageHide.bind(this);
+        this.boundOnOpen = this.onOpen.bind(this);
+        this.boundOnClose = this.onClose.bind(this);
+        this.forwardConnect = () => this.emit("connect");
+        this.forwardStatus = (e) => this.emit("status", e);
+        this.forwardClose = (e) => this.emit("close", e);
+        this.forwardDisconnect = (e) => this.emit("disconnect", e);
+        this.forwardDestroy = () => this.emit("destroy");
+        this.setConfiguration(configuration);
+        this.configuration.document = configuration.document
+            ? configuration.document
+            : new Y__namespace.Doc();
+        this.configuration.awareness =
+            configuration.awareness !== undefined
+                ? configuration.awareness
+                : new Awareness(this.document);
+        this.on("open", this.configuration.onOpen);
+        this.on("message", this.configuration.onMessage);
+        this.on("outgoingMessage", this.configuration.onOutgoingMessage);
+        this.on("synced", this.configuration.onSynced);
+        this.on("destroy", this.configuration.onDestroy);
+        this.on("awarenessUpdate", this.configuration.onAwarenessUpdate);
+        this.on("awarenessChange", this.configuration.onAwarenessChange);
+        this.on("stateless", this.configuration.onStateless);
+        this.on("unsyncedChanges", this.configuration.onUnsyncedChanges);
+        this.on("authenticated", this.configuration.onAuthenticated);
+        this.on("authenticationFailed", this.configuration.onAuthenticationFailed);
+        (_a = this.awareness) === null || _a === void 0 ? void 0 : _a.on("update", () => {
+            this.emit("awarenessUpdate", {
+                states: awarenessStatesToArray(this.awareness.getStates()),
+            });
+        });
+        (_b = this.awareness) === null || _b === void 0 ? void 0 : _b.on("change", () => {
+            this.emit("awarenessChange", {
+                states: awarenessStatesToArray(this.awareness.getStates()),
+            });
+        });
+        this.document.on("update", this.boundDocumentUpdateHandler);
+        (_c = this.awareness) === null || _c === void 0 ? void 0 : _c.on("update", this.boundAwarenessUpdateHandler);
+        this.registerEventListeners();
+        if (this.configuration.forceSyncInterval &&
+            typeof this.configuration.forceSyncInterval === "number") {
+            this.intervals.forceSync = setInterval(this.forceSync.bind(this), this.configuration.forceSyncInterval);
+        }
+        if (this.manageSocket) {
+            this.attach();
+        }
+    }
+    setConfiguration(configuration = {}) {
+        if (!configuration.websocketProvider) {
+            this.manageSocket = true;
+            this.configuration.websocketProvider = new HocuspocusProviderWebsocket(configuration);
+        }
+        this.configuration = { ...this.configuration, ...configuration };
+    }
+    get document() {
+        return this.configuration.document;
+    }
+    get isAttached() {
+        return this._isAttached;
+    }
+    get awareness() {
+        return this.configuration.awareness;
+    }
+    get hasUnsyncedChanges() {
+        return this.unsyncedChanges > 0;
+    }
+    resetUnsyncedChanges() {
+        this.unsyncedChanges = 1;
+        this.emit("unsyncedChanges", { number: this.unsyncedChanges });
+    }
+    incrementUnsyncedChanges() {
+        this.unsyncedChanges += 1;
+        this.emit("unsyncedChanges", { number: this.unsyncedChanges });
+    }
+    decrementUnsyncedChanges() {
+        if (this.unsyncedChanges > 0) {
+            this.unsyncedChanges -= 1;
+        }
+        if (this.unsyncedChanges === 0) {
+            this.synced = true;
+        }
+        this.emit("unsyncedChanges", { number: this.unsyncedChanges });
+    }
+    forceSync() {
+        this.resetUnsyncedChanges();
+        this.send(SyncStepOneMessage, {
+            document: this.document,
+            documentName: this.configuration.name,
+        });
+    }
+    pageHide() {
+        if (this.awareness) {
+            removeAwarenessStates(this.awareness, [this.document.clientID], "page hide");
+        }
+    }
+    registerEventListeners() {
+        if (typeof window === "undefined" || !("addEventListener" in window)) {
+            return;
+        }
+        window.addEventListener("pagehide", this.boundPageHide);
+    }
+    sendStateless(payload) {
+        this.send(StatelessMessage, {
+            documentName: this.configuration.name,
+            payload,
+        });
+    }
+    async sendToken() {
+        let token;
+        try {
+            token = await this.getToken();
+        }
+        catch (error) {
+            this.permissionDeniedHandler(`Failed to get token during sendToken(): ${error}`);
+            return;
+        }
+        this.send(AuthenticationMessage, {
+            token: token !== null && token !== void 0 ? token : "",
+            documentName: this.configuration.name,
+        });
+    }
+    documentUpdateHandler(update, origin) {
+        if (origin === this) {
+            return;
+        }
+        this.incrementUnsyncedChanges();
+        this.send(UpdateMessage, { update, documentName: this.configuration.name });
+    }
+    awarenessUpdateHandler({ added, updated, removed }, origin) {
+        const changedClients = added.concat(updated).concat(removed);
+        this.send(AwarenessMessage, {
+            awareness: this.awareness,
+            clients: changedClients,
+            documentName: this.configuration.name,
+        });
+    }
+    /**
+     * Indicates whether a first handshake with the server has been established
+     *
+     * Note: this does not mean all updates from the client have been persisted to the backend. For this,
+     * use `hasUnsyncedChanges`.
+     */
+    get synced() {
+        return this.isSynced;
+    }
+    set synced(state) {
+        if (this.isSynced === state) {
+            return;
+        }
+        this.isSynced = state;
+        if (state) {
+            this.emit("synced", { state });
+        }
+    }
+    receiveStateless(payload) {
+        this.emit("stateless", { payload });
+    }
+    // not needed, but provides backward compatibility with e.g. lexical/yjs
+    async connect() {
+        if (this.manageSocket) {
+            return this.configuration.websocketProvider.connect();
+        }
+        console.warn("HocuspocusProvider::connect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.");
+    }
+    disconnect() {
+        if (this.manageSocket) {
+            return this.configuration.websocketProvider.disconnect();
+        }
+        console.warn("HocuspocusProvider::disconnect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.");
+    }
+    async onOpen(event) {
+        this.isAuthenticated = false;
+        this.emit("open", { event });
+        await this.sendToken();
+        this.startSync();
+    }
+    async getToken() {
+        if (typeof this.configuration.token === "function") {
+            const token = await this.configuration.token();
+            return token;
+        }
+        return this.configuration.token;
+    }
+    startSync() {
+        this.resetUnsyncedChanges();
+        this.send(SyncStepOneMessage, {
+            document: this.document,
+            documentName: this.configuration.name,
+        });
+        if (this.awareness && this.awareness.getLocalState() !== null) {
+            this.send(AwarenessMessage, {
+                awareness: this.awareness,
+                clients: [this.document.clientID],
+                documentName: this.configuration.name,
+            });
+        }
+    }
+    send(message, args) {
+        if (!this._isAttached)
+            return;
+        const messageSender = new MessageSender(message, args);
+        this.emit("outgoingMessage", { message: messageSender.message });
+        messageSender.send(this.configuration.websocketProvider);
+    }
+    onMessage(event) {
+        const message = new IncomingMessage(event.data);
+        const documentName = message.readVarString();
+        message.writeVarString(documentName);
+        this.emit("message", { event, message: new IncomingMessage(event.data) });
+        new MessageReceiver(message).apply(this, true);
+    }
+    onClose() {
+        this.isAuthenticated = false;
+        this.synced = false;
+        // update awareness (all users except local left)
+        if (this.awareness) {
+            removeAwarenessStates(this.awareness, Array.from(this.awareness.getStates().keys()).filter((client) => client !== this.document.clientID), this);
+        }
+    }
+    destroy() {
+        this.emit("destroy");
+        if (this.intervals.forceSync) {
+            clearInterval(this.intervals.forceSync);
+        }
+        if (this.awareness) {
+            removeAwarenessStates(this.awareness, [this.document.clientID], "provider destroy");
+            this.awareness.off("update", this.boundAwarenessUpdateHandler);
+            this.awareness.destroy();
+        }
+        this.document.off("update", this.boundDocumentUpdateHandler);
+        this.removeAllListeners();
+        this.detach();
+        if (this.manageSocket) {
+            this.configuration.websocketProvider.destroy();
+        }
+        if (typeof window === "undefined" || !("removeEventListener" in window)) {
+            return;
+        }
+        window.removeEventListener("pagehide", this.boundPageHide);
+    }
+    detach() {
+        this.configuration.websocketProvider.off("connect", this.configuration.onConnect);
+        this.configuration.websocketProvider.off("connect", this.forwardConnect);
+        this.configuration.websocketProvider.off("status", this.forwardStatus);
+        this.configuration.websocketProvider.off("status", this.configuration.onStatus);
+        this.configuration.websocketProvider.off("open", this.boundOnOpen);
+        this.configuration.websocketProvider.off("close", this.boundOnClose);
+        this.configuration.websocketProvider.off("close", this.configuration.onClose);
+        this.configuration.websocketProvider.off("close", this.forwardClose);
+        this.configuration.websocketProvider.off("disconnect", this.configuration.onDisconnect);
+        this.configuration.websocketProvider.off("disconnect", this.forwardDisconnect);
+        this.configuration.websocketProvider.off("destroy", this.configuration.onDestroy);
+        this.configuration.websocketProvider.off("destroy", this.forwardDestroy);
+        this.configuration.websocketProvider.detach(this);
+        this._isAttached = false;
+    }
+    attach() {
+        if (this._isAttached)
+            return;
+        this.configuration.websocketProvider.on("connect", this.configuration.onConnect);
+        this.configuration.websocketProvider.on("connect", this.forwardConnect);
+        this.configuration.websocketProvider.on("status", this.configuration.onStatus);
+        this.configuration.websocketProvider.on("status", this.forwardStatus);
+        this.configuration.websocketProvider.on("open", this.boundOnOpen);
+        this.configuration.websocketProvider.on("close", this.boundOnClose);
+        this.configuration.websocketProvider.on("close", this.configuration.onClose);
+        this.configuration.websocketProvider.on("close", this.forwardClose);
+        this.configuration.websocketProvider.on("disconnect", this.configuration.onDisconnect);
+        this.configuration.websocketProvider.on("disconnect", this.forwardDisconnect);
+        this.configuration.websocketProvider.on("destroy", this.configuration.onDestroy);
+        this.configuration.websocketProvider.on("destroy", this.forwardDestroy);
+        this.configuration.websocketProvider.attach(this);
+        this._isAttached = true;
+    }
+    permissionDeniedHandler(reason) {
+        this.emit("authenticationFailed", { reason });
+        this.isAuthenticated = false;
+    }
+    authenticatedHandler(scope) {
+        this.isAuthenticated = true;
+        this.authorizedScope = scope;
+        this.emit("authenticated", { scope });
+    }
+    setAwarenessField(key, value) {
+        if (!this.awareness) {
+            throw new AwarenessError(`Cannot set awareness field "${key}" to ${JSON.stringify(value)}. You have disabled Awareness for this provider by explicitly passing awareness: null in the provider configuration.`);
+        }
+        this.awareness.setLocalStateField(key, value);
+    }
+}
+
+/**
+ * Hocuspocus sync provider for real-time collaboration
+ * Supports multiplexing - multiple documents can share the same WebSocket connection
+ */
+class HocuspocusSyncProvider {
+    static type = 'network';
+    type = 'network';
+    provider;
+    isConnected = false;
+    isSynced = false;
+    usesSharedSocket = false;
+    isDestroyed = false;
+    connectTimeout = null;
+    pendingConnectReject = null;
+    connectionTimeoutMs;
+    _connectionStatus = 'disconnected';
+    visibilityHandler = null;
+    onlineHandler = null;
+    get awareness() {
+        return this.provider.awareness;
+    }
+    get rawProvider() {
+        return this.provider;
+    }
+    get connectionStatus() {
+        return this._connectionStatus;
+    }
+    // Static shared WebSocket instance for multiplexing
+    static sharedWebSocketProvider = null;
+    constructor(docName, doc, options) {
+        const name = options?.name || docName;
+        const url = options?.url || 'ws://localhost:1234';
+        this.connectionTimeoutMs = options?.connectionTimeout ?? 10000;
+        // Use provided websocketProvider or the static shared one
+        const websocketProvider = options?.websocketProvider || HocuspocusSyncProvider.sharedWebSocketProvider;
+        // Build reconnect config from options
+        const reconnectConfig = {};
+        if (options?.delay !== undefined)
+            reconnectConfig.delay = options.delay;
+        if (options?.factor !== undefined)
+            reconnectConfig.factor = options.factor;
+        if (options?.maxAttempts !== undefined)
+            reconnectConfig.maxAttempts = options.maxAttempts;
+        if (options?.minDelay !== undefined)
+            reconnectConfig.minDelay = options.minDelay;
+        if (options?.maxDelay !== undefined)
+            reconnectConfig.maxDelay = options.maxDelay;
+        const onConnect = () => {
+            if (this.isDestroyed) {
+                return;
+            }
+            this.isConnected = true;
+            this._connectionStatus = 'connected';
+            if (!options?.quiet) {
+                console.info(`Hocuspocus connected: ${name}`);
+            }
+            if (options?.onConnect) {
+                options.onConnect();
+            }
+        };
+        const onDisconnect = () => {
+            if (this.isDestroyed) {
+                return;
+            }
+            this.isConnected = false;
+            this.isSynced = false;
+            this._connectionStatus = 'disconnected';
+            if (!options?.quiet) {
+                console.info(`Hocuspocus disconnected: ${name}`);
+            }
+            if (options?.onDisconnect) {
+                options.onDisconnect();
+            }
+        };
+        const onSynced = () => {
+            if (this.isDestroyed) {
+                return;
+            }
+            this.isSynced = true;
+            this._connectionStatus = 'synced';
+            if (!options?.quiet) {
+                console.info(`Hocuspocus synced: ${name}`);
+            }
+            if (options?.onSynced) {
+                options.onSynced();
+            }
+        };
+        const onStatus = (data) => {
+            if (this.isDestroyed) {
+                return;
+            }
+            if (data.status === 'connecting') {
+                this._connectionStatus = 'connecting';
+            }
+            if (options?.onStatus) {
+                options.onStatus(data);
+            }
+        };
+        if (websocketProvider) {
+            // Multiplexing mode - use shared WebSocket connection
+            this.usesSharedSocket = true;
+            const config = {
+                websocketProvider,
+                name,
+                document: doc,
+                token: options?.token || null,
+                onStatus,
+                onConnect,
+                onDisconnect,
+                onSynced,
+                ...reconnectConfig,
+            };
+            // Add optional settings
+            if (options?.forceSyncInterval !== undefined) {
+                config.forceSyncInterval = options.forceSyncInterval;
+            }
+            if (options?.onAuthenticationFailed) {
+                config.onAuthenticationFailed = options.onAuthenticationFailed;
+            }
+            this.provider = new HocuspocusProvider(config);
+            // Must call attach() explicitly when using shared socket
+            this.provider.attach();
+            if (!options?.quiet) {
+                console.info(`Hocuspocus Provider initialized (multiplexed): ${name}`);
+            }
+        }
+        else {
+            // Standalone mode - create own WebSocket connection
+            this.usesSharedSocket = false;
+            const config = {
+                url,
+                name,
+                document: doc,
+                token: options?.token || null,
+                autoConnect: false,
+                onStatus,
+                onConnect,
+                onDisconnect,
+                onSynced,
+                ...reconnectConfig,
+            };
+            // Add optional settings
+            if (options?.forceSyncInterval !== undefined) {
+                config.forceSyncInterval = options.forceSyncInterval;
+            }
+            if (options?.onAuthenticationFailed) {
+                config.onAuthenticationFailed = options.onAuthenticationFailed;
+            }
+            if (options?.WebSocketPolyfill) {
+                config.WebSocketPolyfill = options.WebSocketPolyfill;
+            }
+            this.provider = new HocuspocusProvider(config);
+            if (!options?.quiet) {
+                console.info(`Hocuspocus Provider initialized: ${url}/${name}`);
+            }
+        }
+        this.setupBrowserEventListeners();
+    }
+    setupBrowserEventListeners() {
+        if (typeof document !== 'undefined') {
+            this.visibilityHandler = () => {
+                if (document.visibilityState === 'visible' && !this.isConnected && !this.isDestroyed) {
+                    this.provider.connect();
+                }
+            };
+            document.addEventListener('visibilitychange', this.visibilityHandler);
+        }
+        if (typeof window !== 'undefined') {
+            this.onlineHandler = () => {
+                if (!this.isConnected && !this.isDestroyed) {
+                    this.provider.connect();
+                }
+            };
+            window.addEventListener('online', this.onlineHandler);
+        }
+    }
+    removeBrowserEventListeners() {
+        if (this.visibilityHandler && typeof document !== 'undefined') {
+            document.removeEventListener('visibilitychange', this.visibilityHandler);
+            this.visibilityHandler = null;
+        }
+        if (this.onlineHandler && typeof window !== 'undefined') {
+            window.removeEventListener('online', this.onlineHandler);
+            this.onlineHandler = null;
+        }
+    }
+    /**
+     * Create a shared WebSocket connection for multiplexing
+     * Call this once to create a shared connection that multiple providers can use
+     */
+    static createSharedWebSocket(options) {
+        if (HocuspocusSyncProvider.sharedWebSocketProvider) {
+            console.warn('Shared WebSocket already exists. Returning existing instance.');
+            return HocuspocusSyncProvider.sharedWebSocketProvider;
+        }
+        const config = {
+            url: options.url,
+        };
+        if (options.WebSocketPolyfill) {
+            config.WebSocketPolyfill = options.WebSocketPolyfill;
+        }
+        if (options.onConnect) {
+            config.onConnect = options.onConnect;
+        }
+        if (options.onDisconnect) {
+            config.onDisconnect = options.onDisconnect;
+        }
+        if (options.onStatus) {
+            config.onStatus = options.onStatus;
+        }
+        HocuspocusSyncProvider.sharedWebSocketProvider = new HocuspocusProviderWebsocket(config);
+        console.info(`Shared Hocuspocus WebSocket created: ${options.url}`);
+        return HocuspocusSyncProvider.sharedWebSocketProvider;
+    }
+    /**
+     * Destroy the shared WebSocket connection
+     * Call this when you're done with all multiplexed providers
+     */
+    static destroySharedWebSocket() {
+        if (HocuspocusSyncProvider.sharedWebSocketProvider) {
+            HocuspocusSyncProvider.sharedWebSocketProvider.destroy();
+            HocuspocusSyncProvider.sharedWebSocketProvider = null;
+            console.info('Shared Hocuspocus WebSocket destroyed');
+        }
+    }
+    /**
+     * Get the shared WebSocket provider instance (if it exists)
+     */
+    static getSharedWebSocket() {
+        return HocuspocusSyncProvider.sharedWebSocketProvider;
+    }
+    /**
+     * Static factory method for creating HocuspocusSyncProvider with configuration options
+     * Returns a ProviderFactory that can be used in sync configuration
+     */
+    static with(options) {
+        return {
+            type: 'network',
+            create: (docName, doc, runtimeOptions) => {
+                const mergedOptions = runtimeOptions ? { ...options, ...runtimeOptions } : options;
+                return new HocuspocusSyncProvider(docName, doc, mergedOptions);
+            },
+        };
+    }
+    async connect() {
+        if (this.isSynced || this.isDestroyed) {
+            return;
+        }
+        this._connectionStatus = 'connecting';
+        return new Promise((resolve, reject) => {
+            // Store reject function so we can cancel the connection if destroyed
+            this.pendingConnectReject = reject;
+            this.connectTimeout = setTimeout(() => {
+                this.pendingConnectReject = null;
+                this.connectTimeout = null;
+                reject(new Error('Hocuspocus connection timeout'));
+            }, this.connectionTimeoutMs);
+            const syncHandler = () => {
+                if (this.connectTimeout) {
+                    clearTimeout(this.connectTimeout);
+                    this.connectTimeout = null;
+                }
+                this.pendingConnectReject = null;
+                this.provider.off('synced', syncHandler);
+                if (!this.isDestroyed) {
+                    resolve();
+                }
+            };
+            this.provider.on('synced', syncHandler);
+            // If already synced, resolve immediately
+            if (this.provider.isSynced) {
+                if (this.connectTimeout) {
+                    clearTimeout(this.connectTimeout);
+                    this.connectTimeout = null;
+                }
+                this.pendingConnectReject = null;
+                this.provider.off('synced', syncHandler);
+                resolve();
+                return;
+            }
+            // Connect if not already connected (standalone mode only)
+            if (!this.isConnected && !this.usesSharedSocket) {
+                this.provider.connect();
+            }
+        });
+    }
+    async reconnect() {
+        this.disconnect();
+        return this.connect();
+    }
+    disconnect() {
+        // Cancel any pending connection attempt
+        if (this.connectTimeout) {
+            clearTimeout(this.connectTimeout);
+            this.connectTimeout = null;
+        }
+        if (this.pendingConnectReject) {
+            this.pendingConnectReject = null; // Don't reject, just abandon the promise
+        }
+        if (this.provider) {
+            if (this.usesSharedSocket) {
+                // Detach from shared socket instead of disconnecting
+                this.provider.detach();
+            }
+            else {
+                this.provider.disconnect();
+            }
+        }
+        this.isConnected = false;
+        this.isSynced = false;
+        this._connectionStatus = 'disconnected';
+    }
+    destroy() {
+        // Mark as destroyed first to prevent any callbacks from doing work
+        this.isDestroyed = true;
+        // Cancel any pending connection attempt
+        if (this.connectTimeout) {
+            clearTimeout(this.connectTimeout);
+            this.connectTimeout = null;
+        }
+        if (this.pendingConnectReject) {
+            this.pendingConnectReject = null; // Don't reject, just abandon the promise
+        }
+        this.removeBrowserEventListeners();
+        if (this.provider) {
+            this.provider.destroy();
+        }
+        this.isConnected = false;
+        this.isSynced = false;
+        this._connectionStatus = 'disconnected';
+    }
+}
+
+/**
+ * Remote asset storage provider backed by a plain HTTP endpoint.
+ *
+ * The host application is responsible for exposing a REST-ish backend
+ * that accepts a multipart upload and serves the stored asset at a
+ * stable URL. Authentication is injected via `headers`.
+ */
+class HttpAssetProvider {
+    type = 'remote';
+    name = 'HttpAssetProvider';
+    _options;
+    constructor(options) {
+        this._options = options;
+    }
+    /**
+     * Factory helper enabling use as `HttpAssetProvider.with({ ... })` inside
+     * a `KritzelAssetStorageConfig.providers` array.
+     */
+    static with(options) {
+        return { create: () => new HttpAssetProvider(options) };
+    }
+    async init() {
+        if (!this._options.quiet) {
+            console.info('HttpAssetProvider initialized');
+        }
+    }
+    destroy() {
+        // No-op; no resources to release.
+    }
+    canResolve(_id) {
+        // Remote providers don't know without a round-trip; assume yes.
+        return true;
+    }
+    async put(blob, metadata) {
+        const id = metadata.id ?? this.generateUuid();
+        const fullMetadata = { ...metadata, id };
+        const headers = (await this._options.headers?.()) ?? {};
+        const url = await this._options.uploadUrl(fullMetadata);
+        const uploader = this._options.upload ?? this.defaultUpload;
+        const response = await uploader(url, blob, fullMetadata, headers);
+        return {
+            id: response.id ?? id,
+            kind: metadata.kind ?? 'file',
+            mimeType: metadata.mimeType,
+            size: blob.size,
+            createdAt: Date.now(),
+            width: metadata.width,
+            height: metadata.height,
+            durationMs: metadata.durationMs,
+            originalFilename: metadata.originalFilename,
+        };
+    }
+    async resolve(id) {
+        return this._options.resolveUrl(id);
+    }
+    async fetch(id) {
+        const url = await this._options.resolveUrl(id);
+        const headers = (await this._options.headers?.()) ?? {};
+        const res = await fetch(url, { headers });
+        if (!res.ok) {
+            throw new Error(`[HttpAssetProvider] Failed to fetch asset ${id}: ${res.status} ${res.statusText}`);
+        }
+        return res.blob();
+    }
+    async delete(id) {
+        if (!this._options.deleteUrl)
+            return;
+        const url = await this._options.deleteUrl(id);
+        const headers = (await this._options.headers?.()) ?? {};
+        const res = await fetch(url, { method: 'DELETE', headers });
+        if (!res.ok) {
+            throw new Error(`[HttpAssetProvider] Failed to delete asset ${id}: ${res.status} ${res.statusText}`);
+        }
+        if (!this._options.quiet) {
+            console.info(`HttpAssetProvider: deleted asset ${id}`);
+        }
+    }
+    defaultUpload = async (url, blob, metadata, headers) => {
+        const form = new FormData();
+        form.append('metadata', JSON.stringify(metadata));
+        form.append('file', blob, metadata.originalFilename || `${metadata.id}.${this.extensionFromMime(metadata.mimeType)}`);
+        const res = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: form,
+        });
+        if (!res.ok) {
+            throw new Error(`[HttpAssetProvider] Upload failed: ${res.status} ${res.statusText}`);
+        }
+        // Try to parse a JSON response; tolerate empty/plain-text bodies.
+        const contentType = res.headers.get('content-type') || '';
+        if (contentType.includes('application/json')) {
+            return (await res.json());
+        }
+        return {};
+    };
+    extensionFromMime(mime) {
+        const slash = mime.indexOf('/');
+        return slash >= 0 ? mime.slice(slash + 1) : 'bin';
+    }
+    generateUuid() {
+        if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+            return crypto.randomUUID();
+        }
+        const bytes = crypto.getRandomValues(new Uint8Array(16));
+        bytes[6] = (bytes[6] & 0x0f) | 0x40;
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        const hex = Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
+        return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    }
+}
+
+/**
+ * Remote asset storage provider for pre-signed URL uploads (S3, GCS, ...).
+ *
+ * All auth and URL signing is performed by the host application via the
+ * callbacks in {@link PresignedAssetProviderOptions}. The library simply
+ * PUTs/POSTs bytes to the provided URL.
+ */
+class PresignedAssetProvider {
+    type = 'remote';
+    name = 'PresignedAssetProvider';
+    _options;
+    constructor(options) {
+        this._options = options;
+    }
+    static with(options) {
+        return { create: () => new PresignedAssetProvider(options) };
+    }
+    async init() {
+        if (!this._options.quiet) {
+            console.info('PresignedAssetProvider initialized');
+        }
+    }
+    destroy() {
+        // No-op.
+    }
+    canResolve(_id) {
+        return true;
+    }
+    async put(blob, metadata) {
+        const descriptor = await this._options.getUploadDescriptor(metadata);
+        const method = descriptor.method ?? 'PUT';
+        const headers = { ...(descriptor.headers ?? {}) };
+        if (!headers['Content-Type'] && !headers['content-type']) {
+            headers['Content-Type'] = metadata.mimeType;
+        }
+        let body;
+        if (method === 'POST' && descriptor.fields) {
+            const form = new FormData();
+            for (const [key, value] of Object.entries(descriptor.fields)) {
+                form.append(key, value);
+            }
+            form.append('file', blob);
+            body = form;
+            // Browser sets multipart boundary; avoid forcing content-type.
+            delete headers['Content-Type'];
+            delete headers['content-type'];
+        }
+        else {
+            body = blob;
+        }
+        const res = await fetch(descriptor.url, { method, headers, body });
+        if (!res.ok) {
+            throw new Error(`[PresignedAssetProvider] Upload failed: ${res.status} ${res.statusText}`);
+        }
+        return {
+            id: descriptor.id,
+            kind: metadata.kind ?? 'file',
+            mimeType: metadata.mimeType,
+            size: blob.size,
+            createdAt: Date.now(),
+            width: metadata.width,
+            height: metadata.height,
+            durationMs: metadata.durationMs,
+            originalFilename: metadata.originalFilename,
+        };
+    }
+    async resolve(id) {
+        return this._options.getDownloadUrl(id);
+    }
+    async fetch(id) {
+        const url = await this._options.getDownloadUrl(id);
+        const res = await fetch(url);
+        if (!res.ok) {
+            throw new Error(`[PresignedAssetProvider] Failed to fetch asset ${id}: ${res.status} ${res.statusText}`);
+        }
+        return res.blob();
+    }
+    async delete(id) {
+        if (!this._options.deleteAsset)
+            return;
+        await this._options.deleteAsset(id);
+        if (!this._options.quiet) {
+            console.info(`PresignedAssetProvider: deleted asset ${id}`);
+        }
+    }
+}
+
+/**
+ * Returns the provider type (`'local'` or `'network'`) for a given provider config entry.
+ * Works for both class constructors (via a static `type` property) and
+ * factory objects (via an optional `type` property on the factory).
+ */
+function getProviderConfigType(config) {
+    if (typeof config === 'function') {
+        return config.type;
+    }
+    return config.type;
+}
+/**
+ * Returns `true` when the given sync configuration contains at least one remote
+ * (network) provider, meaning the share option should be available in the UI.
+ */
+function hasRemoteSyncProvider(syncConfig) {
+    if (!syncConfig?.providers?.length) {
+        return false;
+    }
+    return syncConfig.providers.some(p => getProviderConfigType(p) === 'network');
+}
+
+const DEFAULT_BRUSH_CONFIG = {
+    color: engine_constants.DEFAULT_COLOR_PALETTE[0],
+    size: 16,
+    opacity: 1,
+    palette: [...engine_constants.DEFAULT_COLOR_PALETTE],
+    sizes: [...engine_constants.DEFAULT_STROKE_SIZES],
+};
+
+const DEFAULT_TEXT_CONFIG = {
+    color: engine_constants.DEFAULT_COLOR_PALETTE[0],
+    size: 8,
+    opacity: 1,
+    fontFamily: 'Arial',
+    availableFonts: [...engine_constants.DEFAULT_TEXT_TOOL_AVAILABLE_FONTS],
+    palette: [...engine_constants.DEFAULT_COLOR_PALETTE],
+    sizes: [...engine_constants.DEFAULT_FONT_SIZES],
+};
+
+const DEFAULT_LINE_TOOL_CONFIG = {
+    color: engine_constants.DEFAULT_COLOR_PALETTE[0],
+    size: 4,
+    opacity: 1,
+    palette: [...engine_constants.DEFAULT_COLOR_PALETTE],
+    sizes: [...engine_constants.DEFAULT_STROKE_SIZES],
+    arrows: {
+        end: { enabled: true, style: 'triangle' },
+    },
+};
+
+const DEFAULT_SHAPE_CONFIG = {
+    shapeType: engine_constants.ShapeType.Rectangle,
+    fillColor: { light: 'transparent', dark: 'transparent' },
+    strokeColor: engine_constants.DEFAULT_COLOR_PALETTE[0],
+    strokeWidth: 4,
+    opacity: 1,
+    fontColor: engine_constants.DEFAULT_COLOR_PALETTE[0],
+    fontSize: 16,
+    fontFamily: 'Arial',
+    palette: [...engine_constants.DEFAULT_COLOR_PALETTE],
+    sizes: [...engine_constants.DEFAULT_STROKE_SIZES],
+};
+
+/**
+ * Default asset storage configuration. Stores bytes in IndexedDB only,
+ * which provides offline-friendly behavior out of the box. Applications
+ * that sync Yjs over the network should also configure a remote provider
+ * (e.g. HttpAssetProvider) so images are available across devices.
+ */
+const DEFAULT_ASSET_STORAGE_CONFIG = {
+    providers: [],
+};
+
+/**
+ * The current version of the Kritzel library.
+ * This file is auto-generated by the version bump scripts.
+ * Do not modify manually.
+ */
+const KRITZEL_VERSION = '0.4.31';
+
+exports.ABSOLUTE_SCALE_MAX = engine_constants.ABSOLUTE_SCALE_MAX;
+exports.ABSOLUTE_SCALE_MIN = engine_constants.ABSOLUTE_SCALE_MIN;
+exports.APP_STATE_MIGRATIONS = engine_constants.APP_STATE_MIGRATIONS;
+exports.AssetNotFoundError = engine_constants.AssetNotFoundError;
+exports.CURRENT_APP_STATE_SCHEMA_VERSION = engine_constants.CURRENT_APP_STATE_SCHEMA_VERSION;
+exports.CURRENT_WORKSPACE_SCHEMA_VERSION = engine_constants.CURRENT_WORKSPACE_SCHEMA_VERSION;
+exports.DEFAULT_COLOR_PALETTE = engine_constants.DEFAULT_COLOR_PALETTE;
+exports.DEFAULT_SYNC_CONFIG = engine_constants.DEFAULT_SYNC_CONFIG;
+exports.DEFAULT_TEXT_TOOL_AVAILABLE_FONTS = engine_constants.DEFAULT_TEXT_TOOL_AVAILABLE_FONTS;
+exports.DE_LOCALE = engine_constants.DE_LOCALE;
+exports.EN_LOCALE = engine_constants.EN_LOCALE;
+exports.FR_LOCALE = engine_constants.FR_LOCALE;
+exports.IndexedDBAssetProvider = engine_constants.IndexedDBAssetProvider;
+exports.KRITZEL_WEBSITE_URL = engine_constants.KRITZEL_WEBSITE_URL;
+Object.defineProperty(exports, "KritzelAlignment", {
+    enumerable: true,
+    get: function () { return engine_constants.KritzelAlignment; }
+});
+exports.KritzelAnchorManager = engine_constants.KritzelAnchorManager;
+exports.KritzelAssetResolver = engine_constants.KritzelAssetResolver;
+exports.KritzelBaseObject = engine_constants.KritzelBaseObject;
+exports.KritzelBaseTool = engine_constants.KritzelBaseTool;
+exports.KritzelBrushTool = engine_constants.KritzelBrushTool;
+exports.KritzelColorHelper = engine_constants.KritzelColorHelper;
+exports.KritzelCursorHelper = engine_constants.KritzelCursorHelper;
+exports.KritzelDevicesHelper = engine_constants.KritzelDevicesHelper;
+exports.KritzelDynamicObject = engine_constants.KritzelDynamicObject;
+exports.KritzelDynamicObjectRendererRegistry = engine_constants.KritzelDynamicObjectRendererRegistry;
+exports.KritzelEraserTool = engine_constants.KritzelEraserTool;
+exports.KritzelFontRegistry = engine_constants.KritzelFontRegistry;
+exports.KritzelGroup = engine_constants.KritzelGroup;
+exports.KritzelHTMLHelper = engine_constants.KritzelHTMLHelper;
+exports.KritzelIconRegistry = engine_constants.KritzelIconRegistry;
+exports.KritzelImage = engine_constants.KritzelImage;
+exports.KritzelImageTool = engine_constants.KritzelImageTool;
+exports.KritzelKeyboardHelper = engine_constants.KritzelKeyboardHelper;
+exports.KritzelLicenseManager = engine_constants.KritzelLicenseManager;
+exports.KritzelLine = engine_constants.KritzelLine;
+exports.KritzelLineTool = engine_constants.KritzelLineTool;
+exports.KritzelLocalizationManager = engine_constants.KritzelLocalizationManager;
+exports.KritzelPath = engine_constants.KritzelPath;
+exports.KritzelSelectionBox = engine_constants.KritzelSelectionBox;
+exports.KritzelSelectionGroup = engine_constants.KritzelSelectionGroup;
+exports.KritzelSelectionTool = engine_constants.KritzelSelectionTool;
+exports.KritzelShape = engine_constants.KritzelShape;
+exports.KritzelShapeTool = engine_constants.KritzelShapeTool;
+exports.KritzelText = engine_constants.KritzelText;
+exports.KritzelTextTool = engine_constants.KritzelTextTool;
+exports.KritzelThemeManager = engine_constants.KritzelThemeManager;
+exports.KritzelWorkspace = engine_constants.KritzelWorkspace;
+exports.ObjectHelper = engine_constants.ObjectHelper;
+Object.defineProperty(exports, "ShapeType", {
+    enumerable: true,
+    get: function () { return engine_constants.ShapeType; }
+});
+exports.ThemeHelper = engine_constants.ThemeHelper;
+exports.WORKSPACE_EXPORT_VERSION = engine_constants.WORKSPACE_EXPORT_VERSION;
+exports.WORKSPACE_MIGRATIONS = engine_constants.WORKSPACE_MIGRATIONS;
+exports.darkTheme = engine_constants.darkTheme;
+exports.lightTheme = engine_constants.lightTheme;
+exports.resolveColor = engine_constants.resolveColor;
+exports.resolveTextToolAvailableFonts = engine_constants.resolveTextToolAvailableFonts;
+exports.runMigrations = engine_constants.runMigrations;
+exports.BroadcastSyncProvider = BroadcastSyncProvider;
+exports.DEFAULT_ASSET_STORAGE_CONFIG = DEFAULT_ASSET_STORAGE_CONFIG;
+exports.DEFAULT_BRUSH_CONFIG = DEFAULT_BRUSH_CONFIG;
+exports.DEFAULT_LINE_TOOL_CONFIG = DEFAULT_LINE_TOOL_CONFIG;
+exports.DEFAULT_SHAPE_CONFIG = DEFAULT_SHAPE_CONFIG;
+exports.DEFAULT_TEXT_CONFIG = DEFAULT_TEXT_CONFIG;
+exports.HocuspocusSyncProvider = HocuspocusSyncProvider;
+exports.HttpAssetProvider = HttpAssetProvider;
+exports.InMemorySyncProvider = InMemorySyncProvider;
+exports.IndexedDBSyncProvider = IndexedDBSyncProvider;
+exports.KRITZEL_VERSION = KRITZEL_VERSION;
+exports.KritzelToolConfigHelper = KritzelToolConfigHelper;
+exports.PresignedAssetProvider = PresignedAssetProvider;
+exports.WebSocketSyncProvider = WebSocketSyncProvider;
+exports.hasRemoteSyncProvider = hasRemoteSyncProvider;