@hocuspocus/provider 2.15.2 → 3.0.4-rc.0

package/dist/hocuspocus-provider.esm.js

@@ -1,46 +1,46 @@
-import { WsReadyStates, Unauthorized, Forbidden, MessageTooBig, readAuthMessage, writeAuthentication, awarenessStatesToArray } from '@hocuspocus/common';
+import { WsReadyStates, readAuthMessage, writeAuthentication, awarenessStatesToArray } from '@hocuspocus/common';
 import * as Y from 'yjs';
 import { retry } from '@lifeomic/attempt';
 
 /**
- * Utility module to work with key-value stores.
+ * Common Math expressions.
  *
- * @module map
+ * @module math
  */
 
+const floor = Math.floor;
+
 /**
- * Creates a new Map instance.
- *
  * @function
- * @return {Map<any, any>}
- *
+ * @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 create$2 = () => new Map();
+const max = (a, b) => a > b ? a : b;
+
+/* eslint-env browser */
+
+const BIT7 = 64;
+const BIT8 = 128;
+const BITS6 = 63;
+const BITS7 = 127;
 
 /**
- * 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)
- * ```
+ * Utility helpers for working with numbers.
  *
- * @function
- * @template V,K
- * @template {Map<K,V>} MAP
- * @param {MAP} map
- * @param {K} key
- * @param {function():V} createT
- * @return {V}
+ * @module number
  */
-const setIfUndefined = (map, key, createT) => {
-  let set = map.get(key);
-  if (set === undefined) {
-    map.set(key, set = createT());
-  }
-  return set
-};
+
+
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
 
 /**
  * Utility module to work with sets.
@@ -48,7 +48,7 @@ const setIfUndefined = (map, key, createT) => {
  * @module set
  */
 
-const create$1 = () => new Set();
+const create$2 = () => new Set();
 
 /**
  * Utility module to work with Arrays.
@@ -56,6 +56,7 @@ const create$1 = () => new Set();
  * @module array
  */
 
+
 /**
  * Transforms something array-like to an actual Array.
  *
@@ -142,387 +143,228 @@ if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
 }
 
 /**
- * Often used conditions.
+ * Efficient schema-less binary encoding with support for variable length encoding.
  *
- * @module conditions
- */
-
-/**
- * @template T
- * @param {T|null|undefined} v
- * @return {T|null}
+ * 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
  */
-/* c8 ignore next */
-const undefinedToNull = v => v === undefined ? null : v;
 
-/* eslint-env browser */
 
 /**
- * Isomorphic variable storage.
- *
- * Uses LocalStorage in the browser and falls back to in-memory storage.
- *
- * @module storage
+ * A BinaryEncoder handles the encoding to an Uint8Array.
  */
-
-/* c8 ignore start */
-class VarStoragePolyfill {
+class Encoder {
   constructor () {
-    this.map = new Map();
-  }
-
-  /**
-   * @param {string} key
-   * @param {any} newValue
-   */
-  setItem (key, newValue) {
-    this.map.set(key, newValue);
-  }
-
-  /**
-   * @param {string} key
-   */
-  getItem (key) {
-    return this.map.get(key)
+    this.cpos = 0;
+    this.cbuf = new Uint8Array(100);
+    /**
+     * @type {Array<Uint8Array>}
+     */
+    this.bufs = [];
   }
 }
-/* c8 ignore stop */
 
 /**
- * @type {any}
+ * @function
+ * @return {Encoder}
  */
-let _localStorage = new VarStoragePolyfill();
-let usePolyfill = true;
-
-/* c8 ignore start */
-try {
-  // if the same-origin rule is violated, accessing localStorage might thrown an error
-  if (typeof localStorage !== 'undefined' && localStorage) {
-    _localStorage = localStorage;
-    usePolyfill = false;
-  }
-} catch (e) { }
-/* c8 ignore stop */
+const createEncoder = () => new Encoder();
 
 /**
- * This is basically localStorage in browser, or a polyfill in nodejs
+ * The current length of the encoded data.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @return {number}
  */
-/* c8 ignore next */
-const varStorage = _localStorage;
+const length$1 = encoder => {
+  let len = encoder.cpos;
+  for (let i = 0; i < encoder.bufs.length; i++) {
+    len += encoder.bufs[i].length;
+  }
+  return len
+};
 
 /**
- * A polyfill for `addEventListener('storage', event => {..})` that does nothing if the polyfill is being used.
+ * Transform to Uint8Array.
  *
- * @param {function({ key: string, newValue: string, oldValue: string }): void} eventHandler
  * @function
+ * @param {Encoder} encoder
+ * @return {Uint8Array} The created ArrayBuffer.
  */
-/* c8 ignore next */
-const onChange = eventHandler => usePolyfill || addEventListener('storage', /** @type {any} */ (eventHandler));
+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
+};
 
 /**
- * A polyfill for `removeEventListener('storage', event => {..})` that does nothing if the polyfill is being used.
+ * Write one byte to the encoder.
  *
- * @param {function({ key: string, newValue: string, oldValue: string }): void} eventHandler
  * @function
+ * @param {Encoder} encoder
+ * @param {number} num The byte that is to be encoded.
  */
-/* c8 ignore next */
-const offChange = eventHandler => usePolyfill || removeEventListener('storage', /** @type {any} */ (eventHandler));
+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;
+};
 
 /**
- * Utility functions for working with EcmaScript objects.
+ * Write a variable length unsigned integer. Max encodable integer is 2^53.
  *
- * @module object
+ * @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);
+};
 
 /**
- * @param {Object<string,any>} obj
+ * A cache to store strings temporarily
  */
-const keys = Object.keys;
+const _strBuffer = new Uint8Array(30000);
+const _maxStrBSize = _strBuffer.length / 3;
 
 /**
- * @todo implement mapToArray & map
+ * Write a variable length string.
  *
- * @template R
- * @param {Object<string,any>} obj
- * @param {function(any,string):R} f
- * @return {Array<R>}
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
  */
-const map = (obj, f) => {
-  const results = [];
-  for (const key in obj) {
-    results.push(f(obj[key], key));
+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));
   }
-  return results
 };
 
 /**
- * @param {Object<string,any>} obj
- * @return {number}
- */
-const length$1 = obj => keys(obj).length;
-
-/**
- * Calls `Object.prototype.hasOwnProperty`.
+ * Write a variable length string.
  *
- * @param {any} obj
- * @param {string|symbol} key
- * @return {boolean}
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
  */
-const hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+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)));
+  }
+};
 
 /**
- * Common functions and function call helpers.
+ * Write a variable length string.
  *
- * @module function
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
  */
+/* c8 ignore next */
+const writeVarString = (utf8TextEncoder && /** @type {any} */ (utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill;
 
 /**
- * @template T
+ * Append fixed-length Uint8Array to the encoder.
  *
- * @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}
+ * @function
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
  */
-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$1(a) !== length$1(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
+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;
   }
-  return true
 };
 
 /**
- * @template V
- * @template {V} OPTS
- *
- * @param {V} value
- * @param {Array<OPTS>} options
- */
-// @ts-ignore
-const isOneOf = (value, options) => options.includes(value);
-
-/**
- * Isomorphic module to work access the environment (query params, env variables).
+ * Append an Uint8Array to Encoder.
  *
- * @module map
- */
-
-/* c8 ignore next 2 */
-// @ts-ignore
-const isNode = typeof process !== 'undefined' && process.release && /node|io\.js/.test(process.release.name) && Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
-
-/* c8 ignore next */
-const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && !isNode;
-/* c8 ignore next 3 */
-typeof navigator !== 'undefined'
-  ? /Mac/.test(navigator.platform)
-  : false;
-
-/**
- * @type {Map<string,string>}
+ * @function
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
  */
-let params;
-
-/* c8 ignore start */
-const computeParams = () => {
-  if (params === undefined) {
-    if (isNode) {
-      params = create$2();
-      const pargs = process.argv;
-      let currParamName = null;
-      for (let i = 0; i < pargs.length; i++) {
-        const parg = pargs[i];
-        if (parg[0] === '-') {
-          if (currParamName !== null) {
-            params.set(currParamName, '');
-          }
-          currParamName = parg;
-        } else {
-          if (currParamName !== null) {
-            params.set(currParamName, parg);
-            currParamName = null;
-          }
-        }
-      }
-      if (currParamName !== null) {
-        params.set(currParamName, '');
-      }
-      // in ReactNative for example this would not be true (unless connected to the Remote Debugger)
-    } else if (typeof location === 'object') {
-      params = create$2(); // eslint-disable-next-line no-undef
-      (location.search || '?').slice(1).split('&').forEach((kv) => {
-        if (kv.length !== 0) {
-          const [key, value] = kv.split('=');
-          params.set(`--${fromCamelCase(key, '-')}`, value);
-          params.set(`-${fromCamelCase(key, '-')}`, value);
-        }
-      });
-    } else {
-      params = create$2();
-    }
-  }
-  return params
+const writeVarUint8Array = (encoder, uint8Array) => {
+  writeVarUint(encoder, uint8Array.byteLength);
+  writeUint8Array(encoder, uint8Array);
 };
-/* c8 ignore stop */
-
-/**
- * @param {string} name
- * @return {boolean}
- */
-/* c8 ignore next */
-const hasParam = (name) => computeParams().has(name);
-
-/**
- * @param {string} name
- * @return {string|null}
- */
-/* c8 ignore next 4 */
-const getVariable = (name) =>
-  isNode
-    ? undefinedToNull(process.env[name.toUpperCase()])
-    : undefinedToNull(varStorage.getItem(name));
-
-/**
- * @param {string} name
- * @return {boolean}
- */
-/* c8 ignore next 2 */
-const hasConf = (name) =>
-  hasParam('--' + name) || getVariable(name) !== null;
-
-/* c8 ignore next */
-hasConf('production');
-
-/* c8 ignore next 2 */
-const forceColor = isNode &&
-  isOneOf(process.env.FORCE_COLOR, ['true', '1', '2']);
-
-/* c8 ignore start */
-!hasParam('no-colors') &&
-  (!isNode || process.stdout.isTTY || forceColor) && (
-  !isNode || hasParam('color') || forceColor ||
-    getVariable('COLORTERM') !== null ||
-    (getVariable('TERM') || '').includes('color')
-);
-/* c8 ignore stop */
 
 /**
- * Common Math expressions.
+ * Error helpers.
  *
- * @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
+ * @module error
  */
-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
+ * @param {string} s
+ * @return {Error}
  */
-
-const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+/* c8 ignore next */
+const create$1 = s => new Error(s);
 
 /**
- * Efficient schema-less binary encoding with support for variable length encoding.
+ * Efficient schema-less binary decoding with support for variable length encoding.
  *
- * Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.
+ * 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/)
@@ -544,232 +386,15 @@ const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
  * decoding.hasContent(decoder) // => false - all data is read
  * ```
  *
- * @module encoding
+ * @module decoding
  */
 
+
+const errorUnexpectedEndOfArray = create$1('Unexpected end of array');
+const errorIntegerOutOfRange = create$1('Integer out of Range');
+
 /**
- * A BinaryEncoder handles the encoding to an Uint8Array.
- */
-class Encoder {
-  constructor () {
-    this.cpos = 0;
-    this.cbuf = new Uint8Array(100);
-    /**
-     * @type {Array<Uint8Array>}
-     */
-    this.bufs = [];
-  }
-}
-
-/**
- * @function
- * @return {Encoder}
- */
-const createEncoder = () => new Encoder();
-
-/**
- * The current length of the encoded data.
- *
- * @function
- * @param {Encoder} encoder
- * @return {number}
- */
-const length = encoder => {
-  let len = encoder.cpos;
-  for (let i = 0; i < encoder.bufs.length; i++) {
-    len += encoder.bufs[i].length;
-  }
-  return len
-};
-
-/**
- * Transform to Uint8Array.
- *
- * @function
- * @param {Encoder} encoder
- * @return {Uint8Array} The created ArrayBuffer.
- */
-const toUint8Array = encoder => {
-  const uint8arr = new Uint8Array(length(encoder));
-  let curPos = 0;
-  for (let i = 0; i < encoder.bufs.length; i++) {
-    const d = encoder.bufs[i];
-    uint8arr.set(d, curPos);
-    curPos += d.length;
-  }
-  uint8arr.set(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos), curPos);
-  return uint8arr
-};
-
-/**
- * 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 = s => new Error(s);
-
-/**
- * Efficient schema-less binary decoding with support for variable length encoding.
- *
- * Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.
- *
- * Encodes numbers in little-endian order (least to most significant byte order)
- * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
- * which is also used in Protocol Buffers.
- *
- * ```js
- * // encoding step
- * const encoder = encoding.createEncoder()
- * encoding.writeVarUint(encoder, 256)
- * encoding.writeVarString(encoder, 'Hello world!')
- * const buf = encoding.toUint8Array(encoder)
- * ```
- *
- * ```js
- * // decoding step
- * const decoder = decoding.createDecoder(buf)
- * decoding.readVarUint(decoder) // => 256
- * decoding.readVarString(decoder) // => 'Hello world!'
- * decoding.hasContent(decoder) // => false - all data is read
- * ```
- *
- * @module decoding
- */
-
-const errorUnexpectedEndOfArray = create('Unexpected end of array');
-const errorIntegerOutOfRange = create('Integer out of Range');
-
-/**
- * A Decoder handles the decoding of an Uint8Array.
+ * A Decoder handles the decoding of an Uint8Array.
  */
 class Decoder {
   /**
@@ -979,255 +604,66 @@ const peekVarString = decoder => {
 };
 
 /**
- * Utility functions to work with buffers (Uint8Array).
+ * Utility module to work with time.
  *
- * @module buffer
+ * @module time
  */
 
-/**
- * @param {number} len
- */
-const createUint8ArrayFromLen = len => new Uint8Array(len);
 
 /**
- * Create Uint8Array with initial content from buffer
+ * Return current unix time.
  *
- * @param {ArrayBuffer} buffer
- * @param {number} byteOffset
- * @param {number} length
+ * @return {number}
  */
-const createUint8ArrayViewFromArrayBuffer = (buffer, byteOffset, length) => new Uint8Array(buffer, byteOffset, length);
+const getUnixTime = Date.now;
 
 /**
- * Create Uint8Array with initial content from buffer
+ * Utility module to work with key-value stores.
  *
- * @param {ArrayBuffer} buffer
+ * @module map
  */
-const createUint8ArrayFromArrayBuffer = buffer => new Uint8Array(buffer);
 
-/* c8 ignore start */
 /**
- * @param {Uint8Array} bytes
- * @return {string}
+ * Creates a new Map instance.
+ *
+ * @function
+ * @return {Map<any, any>}
+ *
+ * @function
  */
-const toBase64Browser = bytes => {
-  let s = '';
-  for (let i = 0; i < bytes.byteLength; i++) {
-    s += fromCharCode(bytes[i]);
-  }
-  // eslint-disable-next-line no-undef
-  return btoa(s)
-};
-/* c8 ignore stop */
+const create = () => new Map();
 
 /**
- * @param {Uint8Array} bytes
- * @return {string}
- */
-const toBase64Node = bytes => Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString('base64');
-
-/* c8 ignore start */
-/**
- * @param {string} s
- * @return {Uint8Array}
- */
-const fromBase64Browser = s => {
-  // eslint-disable-next-line no-undef
-  const a = atob(s);
-  const bytes = createUint8ArrayFromLen(a.length);
-  for (let i = 0; i < a.length; i++) {
-    bytes[i] = a.charCodeAt(i);
-  }
-  return bytes
-};
-/* c8 ignore stop */
-
-/**
- * @param {string} s
- */
-const fromBase64Node = s => {
-  const buf = Buffer.from(s, 'base64');
-  return createUint8ArrayViewFromArrayBuffer(buf.buffer, buf.byteOffset, buf.byteLength)
-};
-
-/* c8 ignore next */
-const toBase64 = isBrowser ? toBase64Browser : toBase64Node;
-
-/* c8 ignore next */
-const fromBase64 = isBrowser ? fromBase64Browser : fromBase64Node;
-
-/* eslint-env browser */
-
-/**
- * @typedef {Object} Channel
- * @property {Set<function(any, any):any>} Channel.subs
- * @property {any} Channel.bc
- */
-
-/**
- * @type {Map<string, Channel>}
- */
-const channels = new Map();
-
-/* c8 ignore start */
-class LocalStoragePolyfill {
-  /**
-   * @param {string} room
-   */
-  constructor (room) {
-    this.room = room;
-    /**
-     * @type {null|function({data:ArrayBuffer}):void}
-     */
-    this.onmessage = null;
-    /**
-     * @param {any} e
-     */
-    this._onChange = e => e.key === room && this.onmessage !== null && this.onmessage({ data: fromBase64(e.newValue || '') });
-    onChange(this._onChange);
-  }
-
-  /**
-   * @param {ArrayBuffer} buf
-   */
-  postMessage (buf) {
-    varStorage.setItem(this.room, toBase64(createUint8ArrayFromArrayBuffer(buf)));
-  }
-
-  close () {
-    offChange(this._onChange);
-  }
-}
-/* c8 ignore stop */
-
-// Use BroadcastChannel or Polyfill
-/* c8 ignore next */
-const BC = typeof BroadcastChannel === 'undefined' ? LocalStoragePolyfill : BroadcastChannel;
-
-/**
- * @param {string} room
- * @return {Channel}
- */
-const getChannel = room =>
-  setIfUndefined(channels, room, () => {
-    const subs = create$1();
-    const bc = new BC(room);
-    /**
-     * @param {{data:ArrayBuffer}} e
-     */
-    /* c8 ignore next */
-    bc.onmessage = e => subs.forEach(sub => sub(e.data, 'broadcastchannel'));
-    return {
-      bc, subs
-    }
-  });
-
-/**
- * Subscribe to global `publish` events.
- *
- * @function
- * @param {string} room
- * @param {function(any, any):any} f
- */
-const subscribe = (room, f) => {
-  getChannel(room).subs.add(f);
-  return f
-};
-
-/**
- * Unsubscribe from `publish` global events.
- *
- * @function
- * @param {string} room
- * @param {function(any, any):any} f
- */
-const unsubscribe = (room, f) => {
-  const channel = getChannel(room);
-  const unsubscribed = channel.subs.delete(f);
-  if (unsubscribed && channel.subs.size === 0) {
-    channel.bc.close();
-    channels.delete(room);
-  }
-  return unsubscribed
-};
-
-/**
- * Publish data to all subscribers (including subscribers on this tab)
- *
- * @function
- * @param {string} room
- * @param {any} data
- * @param {any} [origin]
- */
-const publish = (room, data, origin = null) => {
-  const c = getChannel(room);
-  c.bc.postMessage(data);
-  c.subs.forEach(sub => sub(data, origin));
-};
-
-/**
- * Mutual exclude for JavaScript.
- *
- * @module mutex
- */
-
-/**
- * @callback mutex
- * @param {function():void} cb Only executed when this mutex is not in the current stack
- * @param {function():void} [elseCb] Executed when this mutex is in the current stack
- */
-
-/**
- * Creates a mutual exclude function with the following property:
+ * Get map property. Create T if property is undefined and set T on map.
  *
  * ```js
- * const mutex = createMutex()
- * mutex(() => {
- *   // This function is immediately executed
- *   mutex(() => {
- *     // This function is not executed, as the mutex is already active.
- *   })
- * })
+ * const listeners = map.setIfUndefined(events, 'eventName', set.create)
+ * listeners.add(listener)
  * ```
  *
- * @return {mutex} A mutual exclude function
- * @public
- */
-const createMutex = () => {
-  let token = true;
-  return (f, g) => {
-    if (token) {
-      token = false;
-      try {
-        f();
-      } finally {
-        token = true;
-      }
-    } else if (g !== undefined) {
-      g();
-    }
+ * @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
 };
 
-/**
- * Utility module to work with time.
- *
- * @module time
- */
-
-/**
- * Return current unix time.
- *
- * @return {number}
- */
-const getUnixTime = Date.now;
-
 /**
  * Observable class prototype.
  *
  * @module observable
  */
 
+
 /* c8 ignore start */
 /**
  * Handles named events.
@@ -1241,7 +677,7 @@ class Observable {
      * Some desc.
      * @type {Map<N, any>}
      */
-    this._observers = create$2();
+    this._observers = create();
   }
 
   /**
@@ -1249,7 +685,7 @@ class Observable {
    * @param {function} f
    */
   on (name, f) {
-    setIfUndefined(this._observers, name, create$1).add(f);
+    setIfUndefined(this._observers, name, create$2).add(f);
   }
 
   /**
@@ -1292,106 +728,258 @@ class Observable {
    */
   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$2()).values()).forEach(f => f(...args))
+    return from((this._observers.get(name) || create()).values()).forEach(f => f(...args))
   }
 
   destroy () {
-    this._observers = create$2();
+    this._observers = create();
   }
 }
 /* c8 ignore end */
 
 /**
- * @module awareness-protocol
+ * Utility functions for working with EcmaScript objects.
+ *
+ * @module object
  */
 
-const outdatedTimeout = 30000;
 
 /**
- * @typedef {Object} MetaClientState
- * @property {number} MetaClientState.clock
- * @property {number} MetaClientState.lastUpdated unix timestamp
+ * @param {Object<string,any>} obj
  */
+const keys = Object.keys;
 
 /**
- * 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.
+ * @todo implement mapToArray & map
  *
- * @extends {Observable<string>}
+ * @template R
+ * @param {Object<string,any>} obj
+ * @param {function(any,string):R} f
+ * @return {Array<R>}
  */
-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);
+const map = (obj, f) => {
+  const results = [];
+  for (const key in obj) {
+    results.push(f(obj[key], key));
   }
+  return results
+};
 
-  /**
-   * @return {Object<string,any>|null}
-   */
-  getLocalState () {
-    return this.states.get(this.clientID) || null
-  }
+/**
+ * @deprecated use object.size instead
+ * @param {Object<string,any>} obj
+ * @return {number}
+ */
+const length = obj => keys(obj).length;
 
-  /**
-   * @param {Object<string,any>|null} state
+/**
+ * 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
+};
+
+/**
+ * @template V
+ * @template {V} OPTS
+ *
+ * @param {V} value
+ * @param {Array<OPTS>} options
+ */
+// @ts-ignore
+const isOneOf = (value, options) => options.includes(value);
+
+/**
+ * @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;
@@ -1564,8 +1152,10 @@ const applyAwarenessUpdate = (awareness, update, 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] = [];
@@ -1580,6 +1170,7 @@ class EventEmitter {
         }
         return this;
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
     off(event, fn) {
         const callbacks = this.callbacks[event];
         if (callbacks) {
@@ -1603,6 +1194,7 @@ class EventEmitter {
  * @module url
  */
 
+
 /**
  * @param {Object<string,string>} params
  * @return {string}
@@ -1655,7 +1247,32 @@ class IncomingMessage {
         return writeVarUint8Array(this.encoder, data);
     }
     length() {
-        return length(this.encoder);
+        return length$1(this.encoder);
+    }
+}
+
+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;
     }
 }
 
@@ -1700,7 +1317,6 @@ class HocuspocusProviderWebsocket extends EventEmitter {
             onDestroy: () => null,
             onAwarenessUpdate: () => null,
             onAwarenessChange: () => null,
-            quiet: false,
             providerMap: new Map(),
         };
         this.webSocket = null;
@@ -1710,7 +1326,6 @@ class HocuspocusProviderWebsocket extends EventEmitter {
         this.lastMessageReceived = 0;
         this.identifier = 0;
         this.intervals = {
-            forceSync: null,
             connectionChecker: null,
         };
         this.connectionAttempt = null;
@@ -1745,27 +1360,26 @@ class HocuspocusProviderWebsocket extends EventEmitter {
         this.connect();
     }
     async onOpen(event) {
+        this.cancelWebsocketRetry = undefined;
         this.receivedOnOpenPayload = event;
     }
     async onStatus(data) {
         this.receivedOnStatusPayload = data;
     }
     attach(provider) {
-        let connectPromise;
         this.configuration.providerMap.set(provider.configuration.name, provider);
         if (this.status === WebSocketStatus.Disconnected && this.shouldConnect) {
-            connectPromise = this.connect();
+            this.connect();
         }
         if (this.receivedOnOpenPayload) {
             provider.onOpen(this.receivedOnOpenPayload);
         }
-        if (this.receivedOnStatusPayload) {
-            provider.onStatus(this.receivedOnStatusPayload);
-        }
-        return connectPromise;
     }
     detach(provider) {
-        this.configuration.providerMap.delete(provider.configuration.name);
+        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 };
@@ -1816,6 +1430,7 @@ class HocuspocusProviderWebsocket extends EventEmitter {
         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);
@@ -1934,7 +1549,7 @@ class HocuspocusProviderWebsocket extends EventEmitter {
             this.messageQueue = [];
         }
     }
-    // Ensure that the URL always ends with /
+    // Ensure that the URL never ends with /
     get serverUrl() {
         while (this.configuration.url[this.configuration.url.length - 1] === '/') {
             return this.configuration.url.slice(0, this.configuration.url.length - 1);
@@ -1954,8 +1569,8 @@ class HocuspocusProviderWebsocket extends EventEmitter {
             this.webSocket.close();
             this.messageQueue = [];
         }
-        catch {
-            //
+        catch (e) {
+            console.error(e);
         }
     }
     send(message) {
@@ -1970,56 +1585,23 @@ class HocuspocusProviderWebsocket extends EventEmitter {
     onClose({ event }) {
         this.closeTries = 0;
         this.cleanupWebSocket();
-        if (this.status === WebSocketStatus.Connected) {
-            this.status = WebSocketStatus.Disconnected;
-            this.emit('status', { status: WebSocketStatus.Disconnected });
-            this.emit('disconnect', { event });
-        }
-        if (event.code === Unauthorized.code) {
-            if (event.reason === Unauthorized.reason) {
-                console.warn('[HocuspocusProvider] An authentication token is required, but you didn’t send one. Try adding a `token` to your HocuspocusProvider configuration. Won’t try again.');
-            }
-            else {
-                console.warn(`[HocuspocusProvider] Connection closed with status Unauthorized: ${event.reason}`);
-            }
-            this.shouldConnect = false;
-        }
-        if (event.code === Forbidden.code) {
-            if (!this.configuration.quiet) {
-                console.warn('[HocuspocusProvider] The provided authentication token isn’t allowed to connect to this server. Will try again.');
-                return; // TODO REMOVE ME
-            }
-        }
-        if (event.code === MessageTooBig.code) {
-            console.warn(`[HocuspocusProvider] Connection closed with status MessageTooBig: ${event.reason}`);
-            this.shouldConnect = false;
-        }
         if (this.connectionAttempt) {
             // That connection attempt failed.
             this.rejectConnectionAttempt();
         }
-        else if (this.shouldConnect) {
-            // The connection was closed by the server. Let’s just try again.
-            this.connect();
-        }
-        // If we’ll reconnect, we’re done for now.
-        if (this.shouldConnect) {
-            return;
-        }
-        // The status is set correctly already.
-        if (this.status === WebSocketStatus.Disconnected) {
-            return;
-        }
         // 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');
-        if (this.intervals.forceSync) {
-            clearInterval(this.intervals.forceSync);
-        }
         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
@@ -2035,6 +1617,7 @@ class HocuspocusProviderWebsocket extends EventEmitter {
  * @module sync-protocol
  */
 
+
 /**
  * @typedef {Map<number, number>} StateMap
  */
@@ -2158,27 +1741,10 @@ const readSyncMessage = (decoder, encoder, doc, transactionOrigin) => {
   return messageType
 };
 
-class OutgoingMessage {
-    constructor() {
-        this.encoder = createEncoder();
-    }
-    get(args) {
-        return args.encoder;
-    }
-    toUint8Array() {
-        return toUint8Array(this.encoder);
-    }
-}
-
 class MessageReceiver {
     constructor(message) {
-        this.broadcasted = false;
         this.message = message;
     }
-    setBroadcasted(value) {
-        this.broadcasted = value;
-        return this;
-    }
     apply(provider, emitSynced) {
         const { message } = this;
         const type = message.readVarUint();
@@ -2202,21 +1768,26 @@ class MessageReceiver {
             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)
-            if (this.broadcasted) {
-                // TODO: Some weird TypeScript error
-                // @ts-ignore
-                provider.broadcast(OutgoingMessage, { encoder: message.encoder });
-            }
-            else {
-                // TODO: Some weird TypeScript error
-                // @ts-ignore
-                provider.send(OutgoingMessage, { encoder: message.encoder });
-            }
+            // @ts-ignore
+            provider.send(OutgoingMessage, { encoder: message.encoder });
         }
     }
     applySyncMessage(provider, emitSynced) {
@@ -2253,6 +1824,366 @@ class MessageReceiver {
     }
 }
 
+/**
+ * Often used conditions.
+ *
+ * @module conditions
+ */
+
+/**
+ * @template T
+ * @param {T|null|undefined} v
+ * @return {T|null}
+ */
+/* c8 ignore next */
+const undefinedToNull = v => v === undefined ? null : v;
+
+/* eslint-env browser */
+
+/**
+ * Isomorphic variable storage.
+ *
+ * Uses LocalStorage in the browser and falls back to in-memory storage.
+ *
+ * @module storage
+ */
+
+/* c8 ignore start */
+class VarStoragePolyfill {
+  constructor () {
+    this.map = new Map();
+  }
+
+  /**
+   * @param {string} key
+   * @param {any} newValue
+   */
+  setItem (key, newValue) {
+    this.map.set(key, newValue);
+  }
+
+  /**
+   * @param {string} key
+   */
+  getItem (key) {
+    return this.map.get(key)
+  }
+}
+/* c8 ignore stop */
+
+/**
+ * @type {any}
+ */
+let _localStorage = new VarStoragePolyfill();
+let usePolyfill = true;
+
+/* c8 ignore start */
+try {
+  // if the same-origin rule is violated, accessing localStorage might thrown an error
+  if (typeof localStorage !== 'undefined' && localStorage) {
+    _localStorage = localStorage;
+    usePolyfill = false;
+  }
+} catch (e) { }
+/* c8 ignore stop */
+
+/**
+ * This is basically localStorage in browser, or a polyfill in nodejs
+ */
+/* c8 ignore next */
+const varStorage = _localStorage;
+
+/**
+ * A polyfill for `addEventListener('storage', event => {..})` that does nothing if the polyfill is being used.
+ *
+ * @param {function({ key: string, newValue: string, oldValue: string }): void} eventHandler
+ * @function
+ */
+/* c8 ignore next */
+const onChange = eventHandler => usePolyfill || addEventListener('storage', /** @type {any} */ (eventHandler));
+
+/**
+ * A polyfill for `removeEventListener('storage', event => {..})` that does nothing if the polyfill is being used.
+ *
+ * @param {function({ key: string, newValue: string, oldValue: string }): void} eventHandler
+ * @function
+ */
+/* c8 ignore next */
+const offChange = eventHandler => usePolyfill || removeEventListener('storage', /** @type {any} */ (eventHandler));
+
+/**
+ * Isomorphic module to work access the environment (query params, env variables).
+ *
+ * @module environment
+ */
+
+
+/* c8 ignore next 2 */
+// @ts-ignore
+const isNode = typeof process !== 'undefined' && process.release && /node|io\.js/.test(process.release.name) && Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
+
+/* c8 ignore next */
+const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && !isNode;
+
+/**
+ * @type {Map<string,string>}
+ */
+let params;
+
+/* c8 ignore start */
+const computeParams = () => {
+  if (params === undefined) {
+    if (isNode) {
+      params = create();
+      const pargs = process.argv;
+      let currParamName = null;
+      for (let i = 0; i < pargs.length; i++) {
+        const parg = pargs[i];
+        if (parg[0] === '-') {
+          if (currParamName !== null) {
+            params.set(currParamName, '');
+          }
+          currParamName = parg;
+        } else {
+          if (currParamName !== null) {
+            params.set(currParamName, parg);
+            currParamName = null;
+          }
+        }
+      }
+      if (currParamName !== null) {
+        params.set(currParamName, '');
+      }
+      // in ReactNative for example this would not be true (unless connected to the Remote Debugger)
+    } else if (typeof location === 'object') {
+      params = create(); // eslint-disable-next-line no-undef
+      (location.search || '?').slice(1).split('&').forEach((kv) => {
+        if (kv.length !== 0) {
+          const [key, value] = kv.split('=');
+          params.set(`--${fromCamelCase(key, '-')}`, value);
+          params.set(`-${fromCamelCase(key, '-')}`, value);
+        }
+      });
+    } else {
+      params = create();
+    }
+  }
+  return params
+};
+/* c8 ignore stop */
+
+/**
+ * @param {string} name
+ * @return {boolean}
+ */
+/* c8 ignore next */
+const hasParam = (name) => computeParams().has(name);
+
+/**
+ * @param {string} name
+ * @return {string|null}
+ */
+/* c8 ignore next 4 */
+const getVariable = (name) =>
+  isNode
+    ? undefinedToNull(process.env[name.toUpperCase().replaceAll('-', '_')])
+    : undefinedToNull(varStorage.getItem(name));
+
+/**
+ * @param {string} name
+ * @return {boolean}
+ */
+/* c8 ignore next 2 */
+const hasConf = (name) =>
+  hasParam('--' + name) || getVariable(name) !== null;
+
+/* c8 ignore next */
+hasConf('production');
+
+/* c8 ignore next 2 */
+const forceColor = isNode &&
+  isOneOf(process.env.FORCE_COLOR, ['true', '1', '2']);
+
+/* c8 ignore start */
+/**
+ * Color is enabled by default if the terminal supports it.
+ *
+ * Explicitly enable color using `--color` parameter
+ * Disable color using `--no-color` parameter or using `NO_COLOR=1` environment variable.
+ * `FORCE_COLOR=1` enables color and takes precedence over all.
+ */
+forceColor || (
+  !hasParam('--no-colors') && // @todo deprecate --no-colors
+  !hasConf('no-color') &&
+  (!isNode || process.stdout.isTTY) && (
+    !isNode ||
+    hasParam('--color') ||
+    getVariable('COLORTERM') !== null ||
+    (getVariable('TERM') || '').includes('color')
+  )
+);
+/* c8 ignore stop */
+
+/**
+ * Utility functions to work with buffers (Uint8Array).
+ *
+ * @module buffer
+ */
+
+
+/**
+ * @param {number} len
+ */
+const createUint8ArrayFromLen = len => new Uint8Array(len);
+
+/**
+ * Create Uint8Array with initial content from buffer
+ *
+ * @param {ArrayBuffer} buffer
+ * @param {number} byteOffset
+ * @param {number} length
+ */
+const createUint8ArrayViewFromArrayBuffer = (buffer, byteOffset, length) => new Uint8Array(buffer, byteOffset, length);
+
+/**
+ * Create Uint8Array with initial content from buffer
+ *
+ * @param {ArrayBuffer} buffer
+ */
+const createUint8ArrayFromArrayBuffer = buffer => new Uint8Array(buffer);
+
+/* c8 ignore start */
+/**
+ * @param {Uint8Array} bytes
+ * @return {string}
+ */
+const toBase64Browser = bytes => {
+  let s = '';
+  for (let i = 0; i < bytes.byteLength; i++) {
+    s += fromCharCode(bytes[i]);
+  }
+  // eslint-disable-next-line no-undef
+  return btoa(s)
+};
+/* c8 ignore stop */
+
+/**
+ * @param {Uint8Array} bytes
+ * @return {string}
+ */
+const toBase64Node = bytes => Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString('base64');
+
+/* c8 ignore start */
+/**
+ * @param {string} s
+ * @return {Uint8Array}
+ */
+const fromBase64Browser = s => {
+  // eslint-disable-next-line no-undef
+  const a = atob(s);
+  const bytes = createUint8ArrayFromLen(a.length);
+  for (let i = 0; i < a.length; i++) {
+    bytes[i] = a.charCodeAt(i);
+  }
+  return bytes
+};
+/* c8 ignore stop */
+
+/**
+ * @param {string} s
+ */
+const fromBase64Node = s => {
+  const buf = Buffer.from(s, 'base64');
+  return createUint8ArrayViewFromArrayBuffer(buf.buffer, buf.byteOffset, buf.byteLength)
+};
+
+/* c8 ignore next */
+const toBase64 = isBrowser ? toBase64Browser : toBase64Node;
+
+/* c8 ignore next */
+const fromBase64 = isBrowser ? fromBase64Browser : fromBase64Node;
+
+/* eslint-env browser */
+
+
+/**
+ * @typedef {Object} Channel
+ * @property {Set<function(any, any):any>} Channel.subs
+ * @property {any} Channel.bc
+ */
+
+/**
+ * @type {Map<string, Channel>}
+ */
+const channels = new Map();
+
+/* c8 ignore start */
+class LocalStoragePolyfill {
+  /**
+   * @param {string} room
+   */
+  constructor (room) {
+    this.room = room;
+    /**
+     * @type {null|function({data:ArrayBuffer}):void}
+     */
+    this.onmessage = null;
+    /**
+     * @param {any} e
+     */
+    this._onChange = e => e.key === room && this.onmessage !== null && this.onmessage({ data: fromBase64(e.newValue || '') });
+    onChange(this._onChange);
+  }
+
+  /**
+   * @param {ArrayBuffer} buf
+   */
+  postMessage (buf) {
+    varStorage.setItem(this.room, toBase64(createUint8ArrayFromArrayBuffer(buf)));
+  }
+
+  close () {
+    offChange(this._onChange);
+  }
+}
+/* c8 ignore stop */
+
+// Use BroadcastChannel or Polyfill
+/* c8 ignore next */
+const BC = typeof BroadcastChannel === 'undefined' ? LocalStoragePolyfill : BroadcastChannel;
+
+/**
+ * @param {string} room
+ * @return {Channel}
+ */
+const getChannel = room =>
+  setIfUndefined(channels, room, () => {
+    const subs = create$2();
+    const bc = new BC(room);
+    /**
+     * @param {{data:ArrayBuffer}} e
+     */
+    /* c8 ignore next */
+    bc.onmessage = e => subs.forEach(sub => sub(e.data, 'broadcastchannel'));
+    return {
+      bc, subs
+    }
+  });
+
+/**
+ * Publish data to all subscribers (including subscribers on this tab)
+ *
+ * @function
+ * @param {string} room
+ * @param {any} data
+ * @param {any} [origin]
+ */
+const publish = (room, data, origin = null) => {
+  const c = getChannel(room);
+  c.bc.postMessage(data);
+  c.subs.forEach(sub => sub(data, origin));
+};
+
 class MessageSender {
     constructor(Message, args = {}) {
         this.message = new Message();
@@ -2313,32 +2244,6 @@ class AwarenessMessage extends OutgoingMessage {
     }
 }
 
-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 QueryAwarenessMessage extends OutgoingMessage {
-    constructor() {
-        super(...arguments);
-        this.type = MessageType.QueryAwareness;
-        this.description = 'Queries awareness states';
-    }
-    get(args) {
-        writeVarString(this.encoder, args.documentName);
-        writeVarUint(this.encoder, this.type);
-        return this.encoder;
-    }
-}
-
 class StatelessMessage extends OutgoingMessage {
     constructor() {
         super(...arguments);
@@ -2371,23 +2276,6 @@ class SyncStepOneMessage extends OutgoingMessage {
     }
 }
 
-class SyncStepTwoMessage extends OutgoingMessage {
-    constructor() {
-        super(...arguments);
-        this.type = MessageType.Sync;
-        this.description = 'Second sync step';
-    }
-    get(args) {
-        if (typeof args.document === 'undefined') {
-            throw new Error('The sync step two message requires document as an argument');
-        }
-        writeVarString(this.encoder, args.documentName);
-        writeVarUint(this.encoder, this.type);
-        writeSyncStep2(this.encoder, args.document);
-        return this.encoder;
-    }
-}
-
 class UpdateMessage extends OutgoingMessage {
     constructor() {
         super(...arguments);
@@ -2419,8 +2307,6 @@ class HocuspocusProvider extends EventEmitter {
             // @ts-ignore
             awareness: undefined,
             token: null,
-            parameters: {},
-            broadcast: true,
             forceSyncInterval: false,
             onAuthenticated: () => null,
             onAuthenticationFailed: () => null,
@@ -2428,7 +2314,6 @@ class HocuspocusProvider extends EventEmitter {
             onConnect: () => null,
             onMessage: () => null,
             onOutgoingMessage: () => null,
-            onStatus: () => null,
             onSynced: () => null,
             onDisconnect: () => null,
             onClose: () => null,
@@ -2436,30 +2321,24 @@ class HocuspocusProvider extends EventEmitter {
             onAwarenessUpdate: () => null,
             onAwarenessChange: () => null,
             onStateless: () => null,
-            quiet: false,
-            connect: true,
-            preserveConnection: true,
         };
-        this.subscribedToBroadcastChannel = false;
         this.isSynced = false;
         this.unsyncedChanges = 0;
-        this.status = WebSocketStatus.Disconnected;
         this.isAuthenticated = false;
         this.authorizedScope = undefined;
-        this.mux = createMutex();
+        // @internal
+        this.manageSocket = false;
+        this.isAttached = false;
         this.intervals = {
             forceSync: null,
         };
-        this.isConnected = true;
         this.boundDocumentUpdateHandler = this.documentUpdateHandler.bind(this);
         this.boundAwarenessUpdateHandler = this.awarenessUpdateHandler.bind(this);
-        this.boundBroadcastChannelSubscriber = this.broadcastChannelSubscriber.bind(this);
         this.boundPageHide = this.pageHide.bind(this);
         this.boundOnOpen = this.onOpen.bind(this);
         this.boundOnClose = this.onClose.bind(this);
-        this.boundOnStatus = this.onStatus.bind(this);
         this.forwardConnect = (e) => this.emit('connect', e);
-        this.forwardOpen = (e) => this.emit('open', e);
+        // forwardOpen = (e: any) => this.emit('open', e)
         this.forwardClose = (e) => this.emit('close', e);
         this.forwardDisconnect = (e) => this.emit('disconnect', e);
         this.forwardDestroy = (e) => this.emit('destroy', e);
@@ -2476,18 +2355,6 @@ class HocuspocusProvider extends EventEmitter {
         this.on('stateless', this.configuration.onStateless);
         this.on('authenticated', this.configuration.onAuthenticated);
         this.on('authenticationFailed', this.configuration.onAuthenticationFailed);
-        this.configuration.websocketProvider.on('connect', this.configuration.onConnect);
-        this.configuration.websocketProvider.on('connect', this.forwardConnect);
-        this.configuration.websocketProvider.on('open', this.boundOnOpen);
-        this.configuration.websocketProvider.on('open', this.forwardOpen);
-        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('status', this.boundOnStatus);
-        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);
         (_a = this.awareness) === null || _a === void 0 ? void 0 : _a.on('update', () => {
             this.emit('awarenessUpdate', { states: awarenessStatesToArray(this.awareness.getStates()) });
         });
@@ -2501,20 +2368,16 @@ class HocuspocusProvider extends EventEmitter {
             && typeof this.configuration.forceSyncInterval === 'number') {
             this.intervals.forceSync = setInterval(this.forceSync.bind(this), this.configuration.forceSyncInterval);
         }
-        this.configuration.websocketProvider.attach(this);
-    }
-    onStatus({ status }) {
-        this.status = status;
-        this.configuration.onStatus({ status });
-        this.emit('status', { status });
+        if (this.manageSocket) {
+            this.attach();
+        }
     }
     setConfiguration(configuration = {}) {
-        if (!configuration.websocketProvider && configuration.url) {
+        if (!configuration.websocketProvider) {
             const websocketProviderConfig = configuration;
+            this.manageSocket = true;
             this.configuration.websocketProvider = new HocuspocusProviderWebsocket({
                 url: websocketProviderConfig.url,
-                connect: websocketProviderConfig.connect,
-                parameters: websocketProviderConfig.parameters,
             });
         }
         this.configuration = { ...this.configuration, ...configuration };
@@ -2537,7 +2400,9 @@ class HocuspocusProvider extends EventEmitter {
         this.emit('unsyncedChanges', this.unsyncedChanges);
     }
     decrementUnsyncedChanges() {
-        this.unsyncedChanges -= 1;
+        if (this.unsyncedChanges > 0) {
+            this.unsyncedChanges -= 1;
+        }
         if (this.unsyncedChanges === 0) {
             this.synced = true;
         }
@@ -2566,7 +2431,7 @@ class HocuspocusProvider extends EventEmitter {
             return;
         }
         this.incrementUnsyncedChanges();
-        this.send(UpdateMessage, { update, documentName: this.configuration.name }, true);
+        this.send(UpdateMessage, { update, documentName: this.configuration.name });
     }
     awarenessUpdateHandler({ added, updated, removed }, origin) {
         const changedClients = added.concat(updated).concat(removed);
@@ -2574,7 +2439,7 @@ class HocuspocusProvider extends EventEmitter {
             awareness: this.awareness,
             clients: changedClients,
             documentName: this.configuration.name,
-        }, true);
+        });
     }
     /**
      * Indicates whether a first handshake with the server has been established
@@ -2590,34 +2455,22 @@ class HocuspocusProvider extends EventEmitter {
             return;
         }
         this.isSynced = state;
-        this.emit('synced', { state });
-        this.emit('sync', { state });
+        if (state) {
+            this.emit('synced', { state });
+        }
     }
     receiveStateless(payload) {
         this.emit('stateless', { payload });
     }
-    get isAuthenticationRequired() {
-        return !!this.configuration.token && !this.isAuthenticated;
-    }
     // not needed, but provides backward compatibility with e.g. lexical/yjs
     async connect() {
-        if (this.configuration.broadcast) {
-            this.subscribeToBroadcastChannel();
-        }
-        this.configuration.websocketProvider.shouldConnect = true;
-        return this.configuration.websocketProvider.attach(this);
+        console.warn('HocuspocusProvider::connect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.');
     }
     disconnect() {
-        this.disconnectBroadcastChannel();
-        this.configuration.websocketProvider.detach(this);
-        this.isConnected = false;
-        if (!this.configuration.preserveConnection) {
-            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.isConnected = true;
         this.emit('open', { event });
         let token;
         try {
@@ -2627,12 +2480,10 @@ class HocuspocusProvider extends EventEmitter {
             this.permissionDeniedHandler(`Failed to get token: ${error}`);
             return;
         }
-        if (this.isAuthenticationRequired) {
-            this.send(AuthenticationMessage, {
-                token,
-                documentName: this.configuration.name,
-            });
-        }
+        this.send(AuthenticationMessage, {
+            token: token !== null && token !== void 0 ? token : '',
+            documentName: this.configuration.name,
+        });
         this.startSync();
     }
     async getToken() {
@@ -2653,13 +2504,7 @@ class HocuspocusProvider extends EventEmitter {
             });
         }
     }
-    send(message, args, broadcast = false) {
-        if (!this.isConnected) {
-            return;
-        }
-        if (broadcast) {
-            this.mux(() => { this.broadcast(message, args); });
-        }
+    send(message, args) {
         const messageSender = new MessageSender(message, args);
         this.emit('outgoingMessage', { message: messageSender.message });
         messageSender.send(this.configuration.websocketProvider);
@@ -2671,7 +2516,7 @@ class HocuspocusProvider extends EventEmitter {
         this.emit('message', { event, message: new IncomingMessage(event.data) });
         new MessageReceiver(message).apply(this, true);
     }
-    onClose(event) {
+    onClose() {
         this.isAuthenticated = false;
         this.synced = false;
         // update awareness (all users except local left)
@@ -2691,92 +2536,54 @@ class HocuspocusProvider extends EventEmitter {
         }
         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('open', this.boundOnOpen);
-        this.configuration.websocketProvider.off('open', this.forwardOpen);
         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('status', this.boundOnStatus);
         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.send(CloseMessage, { documentName: this.configuration.name });
-        this.disconnect();
-        if (typeof window === 'undefined' || !('removeEventListener' in window)) {
+        this.configuration.websocketProvider.detach(this);
+        this.isAttached = false;
+    }
+    attach() {
+        if (this.isAttached)
             return;
-        }
-        window.removeEventListener('pagehide', this.boundPageHide);
+        this.configuration.websocketProvider.on('connect', this.configuration.onConnect);
+        this.configuration.websocketProvider.on('connect', this.forwardConnect);
+        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;
-        this.disconnect();
-        this.status = WebSocketStatus.Disconnected;
     }
     authenticatedHandler(scope) {
         this.isAuthenticated = true;
         this.authorizedScope = scope;
         this.emit('authenticated');
     }
-    get broadcastChannel() {
-        return `${this.configuration.name}`;
-    }
-    broadcastChannelSubscriber(data) {
-        this.mux(() => {
-            const message = new IncomingMessage(data);
-            const documentName = message.readVarString();
-            message.writeVarString(documentName);
-            new MessageReceiver(message)
-                .setBroadcasted(true)
-                .apply(this, false);
-        });
-    }
-    subscribeToBroadcastChannel() {
-        if (!this.subscribedToBroadcastChannel) {
-            subscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber);
-            this.subscribedToBroadcastChannel = true;
-        }
-        this.mux(() => {
-            this.broadcast(SyncStepOneMessage, { document: this.document, documentName: this.configuration.name });
-            this.broadcast(SyncStepTwoMessage, { document: this.document, documentName: this.configuration.name });
-            this.broadcast(QueryAwarenessMessage, { document: this.document, documentName: this.configuration.name });
-            if (this.awareness) {
-                this.broadcast(AwarenessMessage, {
-                    awareness: this.awareness,
-                    clients: [this.document.clientID],
-                    document: this.document,
-                    documentName: this.configuration.name,
-                });
-            }
-        });
-    }
-    disconnectBroadcastChannel() {
-        // broadcast message with local awareness state set to null (indicating disconnect)
-        if (this.awareness) {
-            this.send(AwarenessMessage, {
-                awareness: this.awareness,
-                clients: [this.document.clientID],
-                states: new Map(),
-                documentName: this.configuration.name,
-            }, true);
-        }
-        if (this.subscribedToBroadcastChannel) {
-            unsubscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber);
-            this.subscribedToBroadcastChannel = false;
-        }
-    }
-    broadcast(Message, args) {
-        if (!this.configuration.broadcast) {
-            return;
-        }
-        if (!this.subscribedToBroadcastChannel) {
-            return;
-        }
-        new MessageSender(Message, args).broadcast(this.broadcastChannel);
-    }
     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.`);
@@ -2785,408 +2592,5 @@ class HocuspocusProvider extends EventEmitter {
     }
 }
 
-/* eslint-env browser */
-const getRandomValues = crypto.getRandomValues.bind(crypto);
-
-/**
- * Isomorphic module for true random numbers / buffers / uuids.
- *
- * Attention: falls back to Math.random if the browser does not support crypto.
- *
- * @module random
- */
-
-const uint32 = () => getRandomValues(new Uint32Array(1))[0];
-
-// @ts-ignore
-const uuidv4Template = [1e7] + -1e3 + -4e3 + -8e3 + -1e11;
-
-/**
- * @return {string}
- */
-const uuidv4 = () => uuidv4Template.replace(/[018]/g, /** @param {number} c */ c =>
-  (c ^ uint32() & 15 >> c / 4).toString(16)
-);
-
-class TiptapCollabProviderWebsocket extends HocuspocusProviderWebsocket {
-    constructor(configuration) {
-        var _a;
-        let url = (_a = configuration.baseUrl) !== null && _a !== void 0 ? _a : `wss://${configuration.appId}.collab.tiptap.cloud`;
-        if (configuration.shardKey) {
-            url += url.includes('?') ? '&' : '?';
-            url += `shard=${configuration.shardKey}`;
-        }
-        super({ ...configuration, url });
-    }
-}
-
-const defaultDeleteCommentOptions = {
-    deleteContent: false,
-    deleteThread: false,
-};
-const defaultGetThreadsOptions = {
-    types: ['unarchived'],
-};
-const defaultDeleteThreadOptions = {
-    deleteComments: false,
-    force: false,
-};
-class TiptapCollabProvider extends HocuspocusProvider {
-    constructor(configuration) {
-        if (!configuration.websocketProvider) {
-            configuration.websocketProvider = new TiptapCollabProviderWebsocket({ appId: configuration.appId, baseUrl: configuration.baseUrl });
-        }
-        if (!configuration.token) {
-            configuration.token = 'notoken'; // need to send a token anyway (which will be ignored)
-        }
-        super(configuration);
-        this.tiptapCollabConfigurationPrefix = '__tiptapcollab__';
-        if (configuration.user) {
-            this.userData = new Y.PermanentUserData(this.document, this.document.getMap('__tiptapcollab__users'));
-            this.userData.setUserMapping(this.document, this.document.clientID, configuration.user);
-        }
-    }
-    /**
-     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
-     */
-    createVersion(name) {
-        return this.sendStateless(JSON.stringify({ action: 'version.create', name }));
-    }
-    /**
-     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
-     */
-    revertToVersion(targetVersion) {
-        return this.sendStateless(JSON.stringify({ action: 'document.revert', version: targetVersion }));
-    }
-    /**
-     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
-     *
-     * The server will reply with a stateless message (THistoryVersionPreviewEvent)
-     */
-    previewVersion(targetVersion) {
-        return this.sendStateless(JSON.stringify({ action: 'version.preview', version: targetVersion }));
-    }
-    /**
-     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
-     */
-    getVersions() {
-        return this.configuration.document.getArray(`${this.tiptapCollabConfigurationPrefix}versions`).toArray();
-    }
-    watchVersions(callback) {
-        return this.configuration.document.getArray('__tiptapcollab__versions').observe(callback);
-    }
-    unwatchVersions(callback) {
-        return this.configuration.document.getArray('__tiptapcollab__versions').unobserve(callback);
-    }
-    isAutoVersioning() {
-        return !!this.configuration.document.getMap(`${this.tiptapCollabConfigurationPrefix}config`).get('autoVersioning');
-    }
-    enableAutoVersioning() {
-        return this.configuration.document.getMap(`${this.tiptapCollabConfigurationPrefix}config`).set('autoVersioning', 1);
-    }
-    disableAutoVersioning() {
-        return this.configuration.document.getMap(`${this.tiptapCollabConfigurationPrefix}config`).set('autoVersioning', 0);
-    }
-    /**
-     * Returns all users in the document as Y.Map objects
-     * @returns An array of Y.Map objects
-     */
-    getYThreads() {
-        return this.configuration.document.getArray(`${this.tiptapCollabConfigurationPrefix}threads`);
-    }
-    /**
-     * Finds all threads in the document and returns them as JSON objects
-     * @options Options to control the output of the threads (e.g. include deleted threads)
-     * @returns An array of threads as JSON objects
-     */
-    getThreads(options) {
-        const { types } = { ...defaultGetThreadsOptions, ...options };
-        const threads = this.getYThreads().toJSON();
-        if ((types === null || types === void 0 ? void 0 : types.includes('archived')) && (types === null || types === void 0 ? void 0 : types.includes('unarchived'))) {
-            return threads;
-        }
-        return threads.filter(currentThead => {
-            if ((types === null || types === void 0 ? void 0 : types.includes('archived')) && currentThead.deletedAt) {
-                return true;
-            }
-            if ((types === null || types === void 0 ? void 0 : types.includes('unarchived')) && !currentThead.deletedAt) {
-                return true;
-            }
-            return false;
-        });
-    }
-    /**
-     * Find the index of a thread by its id
-     * @param id The thread id
-     * @returns The index of the thread or null if not found
-     */
-    getThreadIndex(id) {
-        let index = null;
-        let i = 0;
-        // eslint-disable-next-line no-restricted-syntax
-        for (const thread of this.getThreads({ types: ['archived', 'unarchived'] })) {
-            if (thread.id === id) {
-                index = i;
-                break;
-            }
-            i += 1;
-        }
-        return index;
-    }
-    /**
-     * Gets a single thread by its id
-     * @param id The thread id
-     * @returns The thread as a JSON object or null if not found
-     */
-    getThread(id) {
-        const index = this.getThreadIndex(id);
-        if (index === null) {
-            return null;
-        }
-        return this.getYThreads().get(index).toJSON();
-    }
-    /**
-     * Gets a single thread by its id as a Y.Map object
-     * @param id The thread id
-     * @returns The thread as a Y.Map object or null if not found
-     */
-    getYThread(id) {
-        const index = this.getThreadIndex(id);
-        if (index === null) {
-            return null;
-        }
-        return this.getYThreads().get(index);
-    }
-    /**
-     * Create a new thread
-     * @param data The thread data
-     * @returns The created thread
-     */
-    createThread(data) {
-        let createdThread = {};
-        this.document.transact(() => {
-            const thread = new Y.Map();
-            thread.set('id', uuidv4());
-            thread.set('createdAt', (new Date()).toISOString());
-            thread.set('comments', new Y.Array());
-            thread.set('deletedComments', new Y.Array());
-            thread.set('deletedAt', null);
-            this.getYThreads().push([thread]);
-            createdThread = this.updateThread(String(thread.get('id')), data);
-        });
-        return createdThread;
-    }
-    /**
-     * Update a specific thread
-     * @param id The thread id
-     * @param data New data for the thread
-     * @returns The updated thread or null if the thread is not found
-     */
-    updateThread(id, data) {
-        let updatedThread = {};
-        this.document.transact(() => {
-            const thread = this.getYThread(id);
-            if (thread === null) {
-                return null;
-            }
-            thread.set('updatedAt', (new Date()).toISOString());
-            if (data.data) {
-                thread.set('data', data.data);
-            }
-            if (data.resolvedAt || data.resolvedAt === null) {
-                thread.set('resolvedAt', data.resolvedAt);
-            }
-            updatedThread = thread.toJSON();
-        });
-        return updatedThread;
-    }
-    /**
-     * Handle the deletion of a thread. By default, the thread and it's comments are not deleted, but marked as deleted
-     * via the `deletedAt` property. Forceful deletion can be enabled by setting the `force` option to `true`.
-     *
-     * If you only want to delete the comments of a thread, you can set the `deleteComments` option to `true`.
-     * @param id The thread id
-     * @param options A set of options that control how the thread is deleted
-     * @returns The deleted thread or null if the thread is not found
-     */
-    deleteThread(id, options) {
-        const { deleteComments, force } = { ...defaultDeleteThreadOptions, ...options };
-        const index = this.getThreadIndex(id);
-        if (index === null) {
-            return null;
-        }
-        if (force) {
-            this.getYThreads().delete(index, 1);
-            return;
-        }
-        const thread = this.getYThreads().get(index);
-        thread.set('deletedAt', (new Date()).toISOString());
-        if (deleteComments) {
-            thread.set('comments', new Y.Array());
-            thread.set('deletedComments', new Y.Array());
-        }
-        return thread.toJSON();
-    }
-    /**
-     * Tries to restore a deleted thread
-     * @param id The thread id
-     * @returns The restored thread or null if the thread is not found
-     */
-    restoreThread(id) {
-        const index = this.getThreadIndex(id);
-        if (index === null) {
-            return null;
-        }
-        const thread = this.getYThreads().get(index);
-        thread.set('deletedAt', null);
-        return thread.toJSON();
-    }
-    /**
-     * Returns comments from a thread, either deleted or not
-     * @param threadId The thread id
-     * @param includeDeleted If you want to include deleted comments, defaults to `false`
-     * @returns The comments or null if the thread is not found
-     */
-    getThreadComments(threadId, includeDeleted) {
-        var _a, _b, _c;
-        const index = this.getThreadIndex(threadId);
-        if (index === null) {
-            return null;
-        }
-        const comments = !includeDeleted ? (_a = this.getThread(threadId)) === null || _a === void 0 ? void 0 : _a.comments : [...(((_b = this.getThread(threadId)) === null || _b === void 0 ? void 0 : _b.comments) || []), ...(((_c = this.getThread(threadId)) === null || _c === void 0 ? void 0 : _c.deletedComments) || [])].sort((a, b) => {
-            return a.createdAt.localeCompare(b.createdAt);
-        });
-        return comments !== null && comments !== void 0 ? comments : [];
-    }
-    /**
-     * Get a single comment from a specific thread
-     * @param threadId The thread id
-     * @param commentId The comment id
-     * @param includeDeleted If you want to include deleted comments in the search
-     * @returns The comment or null if not found
-     */
-    getThreadComment(threadId, commentId, includeDeleted) {
-        var _a;
-        const index = this.getThreadIndex(threadId);
-        if (index === null) {
-            return null;
-        }
-        const comments = this.getThreadComments(threadId, includeDeleted);
-        return (_a = comments === null || comments === void 0 ? void 0 : comments.find(comment => comment.id === commentId)) !== null && _a !== void 0 ? _a : null;
-    }
-    /**
-     * Adds a comment to a thread
-     * @param threadId The thread id
-     * @param data The comment data
-     * @returns The updated thread or null if the thread is not found
-     * @example addComment('123', { content: 'Hello world', data: { author: 'Maria Doe' } })
-     */
-    addComment(threadId, data) {
-        let updatedThread = {};
-        this.document.transact(() => {
-            const thread = this.getYThread(threadId);
-            if (thread === null)
-                return null;
-            const commentMap = new Y.Map();
-            commentMap.set('id', uuidv4());
-            commentMap.set('createdAt', (new Date()).toISOString());
-            thread.get('comments').push([commentMap]);
-            this.updateComment(threadId, String(commentMap.get('id')), data);
-            updatedThread = thread.toJSON();
-        });
-        return updatedThread;
-    }
-    /**
-     * Update a comment in a thread
-     * @param threadId The thread id
-     * @param commentId The comment id
-     * @param data The new comment data
-     * @returns The updated thread or null if the thread or comment is not found
-     * @example updateComment('123', { content: 'The new content', data: { attachments: ['file1.jpg'] }})
-     */
-    updateComment(threadId, commentId, data) {
-        let updatedThread = {};
-        this.document.transact(() => {
-            const thread = this.getYThread(threadId);
-            if (thread === null)
-                return null;
-            let comment = null;
-            // eslint-disable-next-line no-restricted-syntax
-            for (const c of thread.get('comments')) {
-                if (c.get('id') === commentId) {
-                    comment = c;
-                    break;
-                }
-            }
-            if (comment === null)
-                return null;
-            comment.set('updatedAt', (new Date()).toISOString());
-            if (data.data) {
-                comment.set('data', data.data);
-            }
-            if (data.content) {
-                comment.set('content', data.content);
-            }
-            updatedThread = thread.toJSON();
-        });
-        return updatedThread;
-    }
-    /**
-     * Deletes a comment from a thread
-     * @param threadId The thread id
-     * @param commentId The comment id
-     * @param options A set of options that control how the comment is deleted
-     * @returns The updated thread or null if the thread or comment is not found
-     */
-    deleteComment(threadId, commentId, options) {
-        const { deleteContent, deleteThread } = { ...defaultDeleteCommentOptions, ...options };
-        const thread = this.getYThread(threadId);
-        if (thread === null)
-            return null;
-        let commentIndex = 0;
-        // eslint-disable-next-line no-restricted-syntax
-        for (const c of thread.get('comments')) {
-            if (c.get('id') === commentId) {
-                break;
-            }
-            commentIndex += 1;
-        }
-        // if the first comment of a thread is deleted we also
-        // delete the thread itself as the source comment is gone
-        if (commentIndex === 0 && (deleteThread || this.configuration.deleteThreadOnFirstCommentDelete)) {
-            this.deleteThread(threadId);
-            return;
-        }
-        const comment = thread.get('comments').get(commentIndex);
-        const newComment = new Y.Map();
-        newComment.set('id', comment.get('id'));
-        newComment.set('createdAt', comment.get('createdAt'));
-        newComment.set('updatedAt', (new Date()).toISOString());
-        newComment.set('deletedAt', (new Date()).toISOString());
-        newComment.set('data', comment.get('data'));
-        newComment.set('content', deleteContent ? null : comment.get('content'));
-        if (!thread.get('deletedComments')) {
-            thread.set('deletedComments', new Y.Array());
-        }
-        thread.get('deletedComments').push([newComment]);
-        thread.get('comments').delete(commentIndex);
-        return thread.toJSON();
-    }
-    /**
-     * Start watching threads for changes
-     * @param callback The callback function to be called when a thread changes
-     */
-    watchThreads(callback) {
-        this.getYThreads().observeDeep(callback);
-    }
-    /**
-     * Stop watching threads for changes
-     * @param callback The callback function to be removed
-     */
-    unwatchThreads(callback) {
-        this.getYThreads().unobserveDeep(callback);
-    }
-}
-
-export { AwarenessError, HocuspocusProvider, HocuspocusProviderWebsocket, MessageType, TiptapCollabProvider, TiptapCollabProviderWebsocket, WebSocketStatus };
+export { AwarenessError, HocuspocusProvider, HocuspocusProviderWebsocket, MessageType, WebSocketStatus };
 //# sourceMappingURL=hocuspocus-provider.esm.js.map