@hocuspocus/provider 4.0.0-rc.6 → 4.0.0

package/dist/hocuspocus-provider.esm.js

@@ -1,1002 +1,15 @@
 import { WsReadyStates, awarenessStatesToArray, makeRoutingKey, parseRoutingKey, readAuthMessage, writeAuthentication } from "@hocuspocus/common";
+import * as awarenessProtocol from "y-protocols/awareness";
+import { Awareness, encodeAwarenessUpdate, removeAwarenessStates } from "y-protocols/awareness";
 import * as Y from "yjs";
 import { retry } from "@lifeomic/attempt";
+import { createDecoder, peekVarString, readVarInt, readVarString, readVarUint, readVarUint8Array } from "lib0/decoding";
+import * as encoding from "lib0/encoding";
+import { createEncoder, length, toUint8Array, writeVarString, writeVarUint, writeVarUint8Array } from "lib0/encoding";
+import * as time from "lib0/time";
+import * as syncProtocol from "y-protocols/sync";
+import { messageYjsSyncStep2, readSyncMessage, writeUpdate } from "y-protocols/sync";
 
-//#region node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/math.js
-/**
-* Common Math expressions.
-*
-* @module math
-*/
-const floor = Math.floor;
-/**
-* @function
-* @param {number} a
-* @param {number} b
-* @return {number} The smaller element of a and b
-*/
-const min = (a, b) => a < b ? a : b;
-/**
-* @function
-* @param {number} a
-* @param {number} b
-* @return {number} The bigger element of a and b
-*/
-const max = (a, b) => a > b ? a : b;
-const isNaN$1 = Number.isNaN;
-
-//#endregion
-//#region node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/binary.js
-const BIT7 = 64;
-const BIT8 = 128;
-const BIT18 = 1 << 17;
-const BIT19 = 1 << 18;
-const BIT20 = 1 << 19;
-const BIT21 = 1 << 20;
-const BIT22 = 1 << 21;
-const BIT23 = 1 << 22;
-const BIT24 = 1 << 23;
-const BIT25 = 1 << 24;
-const BIT26 = 1 << 25;
-const BIT27 = 1 << 26;
-const BIT28 = 1 << 27;
-const BIT29 = 1 << 28;
-const BIT30 = 1 << 29;
-const BIT31 = 1 << 30;
-const BIT32 = 1 << 31;
-const BITS6 = 63;
-const BITS7 = 127;
-const BITS17 = BIT18 - 1;
-const BITS18 = BIT19 - 1;
-const BITS19 = BIT20 - 1;
-const BITS20 = BIT21 - 1;
-const BITS21 = BIT22 - 1;
-const BITS22 = BIT23 - 1;
-const BITS23 = BIT24 - 1;
-const BITS24 = BIT25 - 1;
-const BITS25 = BIT26 - 1;
-const BITS26 = BIT27 - 1;
-const BITS27 = BIT28 - 1;
-const BITS28 = BIT29 - 1;
-const BITS29 = BIT30 - 1;
-const BITS30 = BIT31 - 1;
-/**
-* @type {number}
-*/
-const BITS31 = 2147483647;
-/**
-* @type {number}
-*/
-const BITS32 = 4294967295;
-
-//#endregion
-//#region node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/number.js
-/**
-* Utility helpers for working with numbers.
-*
-* @module number
-*/
-const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
-const MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
-const LOWEST_INT32 = 1 << 31;
-const HIGHEST_INT32 = BITS31;
-const HIGHEST_UINT32 = BITS32;
-/* c8 ignore next */
-const isInteger = Number.isInteger || ((num) => typeof num === "number" && isFinite(num) && floor(num) === num);
-const isNaN = Number.isNaN;
-const parseInt = Number.parseInt;
-
-//#endregion
-//#region node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/set.js
-/**
-* Utility module to work with sets.
-*
-* @module set
-*/
-const create$2 = () => /* @__PURE__ */ new Set();
-
-//#endregion
-//#region node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/array.js
-/**
-* Transforms something array-like to an actual Array.
-*
-* @function
-* @template T
-* @param {ArrayLike<T>|Iterable<T>} arraylike
-* @return {T}
-*/
-const from = Array.from;
-const isArray$1 = Array.isArray;
-
-//#endregion
-//#region node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/string.js
-/**
-* Utility module to work with strings.
-*
-* @module string
-*/
-const fromCharCode = String.fromCharCode;
-const fromCodePoint = String.fromCodePoint;
-/**
-* The largest utf16 character.
-* Corresponds to Uint8Array([255, 255]) or charcodeof(2x2^8)
-*/
-const MAX_UTF16_CHARACTER = fromCharCode(65535);
-/**
-* @param {string} str
-* @return {Uint8Array<ArrayBuffer>}
-*/
-const _encodeUtf8Polyfill = (str) => {
-	const encodedString = unescape(encodeURIComponent(str));
-	const len = encodedString.length;
-	const buf = new Uint8Array(len);
-	for (let i = 0; i < len; i++) buf[i] = encodedString.codePointAt(i);
-	return buf;
-};
-/* c8 ignore next */
-const utf8TextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
-/**
-* @param {string} str
-* @return {Uint8Array<ArrayBuffer>}
-*/
-const _encodeUtf8Native = (str) => utf8TextEncoder.encode(str);
-/**
-* @param {string} str
-* @return {Uint8Array}
-*/
-/* c8 ignore next */
-const encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
-/* c8 ignore next */
-let utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8", {
-	fatal: true,
-	ignoreBOM: true
-});
-/* c8 ignore start */
-if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1)
- /* c8 ignore next */
-utf8TextDecoder = null;
-
-//#endregion
-//#region node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/encoding.js
-/**
-* Efficient schema-less binary encoding with support for variable length encoding.
-*
-* Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.
-*
-* Encodes numbers in little-endian order (least to most significant byte order)
-* and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
-* which is also used in Protocol Buffers.
-*
-* ```js
-* // encoding step
-* const encoder = encoding.createEncoder()
-* encoding.writeVarUint(encoder, 256)
-* encoding.writeVarString(encoder, 'Hello world!')
-* const buf = encoding.toUint8Array(encoder)
-* ```
-*
-* ```js
-* // decoding step
-* const decoder = decoding.createDecoder(buf)
-* decoding.readVarUint(decoder) // => 256
-* decoding.readVarString(decoder) // => 'Hello world!'
-* decoding.hasContent(decoder) // => false - all data is read
-* ```
-*
-* @module encoding
-*/
-/**
-* A BinaryEncoder handles the encoding to an Uint8Array.
-*/
-var Encoder = class {
-	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<ArrayBuffer>} 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);
-	}
-	write(encoder, BITS7 & num);
-};
-/**
-* A cache to store strings temporarily
-*/
-const _strBuffer = new Uint8Array(3e4);
-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) {
-		/* 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, 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 && 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) {
-		encoder.bufs.push(encoder.cbuf);
-		encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
-		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);
-};
-
-//#endregion
-//#region node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/error.js
-/**
-* Error helpers.
-*
-* @module error
-*/
-/**
-* @param {string} s
-* @return {Error}
-*/
-/* c8 ignore next */
-const create$1 = (s) => new Error(s);
-
-//#endregion
-//#region node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/decoding.js
-/**
-* Efficient schema-less binary decoding with support for variable length encoding.
-*
-* Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.
-*
-* Encodes numbers in little-endian order (least to most significant byte order)
-* and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
-* which is also used in Protocol Buffers.
-*
-* ```js
-* // encoding step
-* const encoder = encoding.createEncoder()
-* encoding.writeVarUint(encoder, 256)
-* encoding.writeVarString(encoder, 'Hello world!')
-* const buf = encoding.toUint8Array(encoder)
-* ```
-*
-* ```js
-* // decoding step
-* const decoder = decoding.createDecoder(buf)
-* decoding.readVarUint(decoder) // => 256
-* decoding.readVarString(decoder) // => 'Hello world!'
-* decoding.hasContent(decoder) // => false - all data is read
-* ```
-*
-* @module decoding
-*/
-const errorUnexpectedEndOfArray = create$1("Unexpected end of array");
-const errorIntegerOutOfRange = create$1("Integer out of Range");
-/**
-* A Decoder handles the decoding of an Uint8Array.
-* @template {ArrayBufferLike} [Buf=ArrayBufferLike]
-*/
-var Decoder = class {
-	/**
-	* @param {Uint8Array<Buf>} uint8Array Binary data to decode
-	*/
-	constructor(uint8Array) {
-		/**
-		* Decoding target.
-		*
-		* @type {Uint8Array<Buf>}
-		*/
-		this.arr = uint8Array;
-		/**
-		* Current decoding position.
-		*
-		* @type {number}
-		*/
-		this.pos = 0;
-	}
-};
-/**
-* @function
-* @template {ArrayBufferLike} Buf
-* @param {Uint8Array<Buf>} uint8Array
-* @return {Decoder<Buf>}
-*/
-const createDecoder = (uint8Array) => new Decoder(uint8Array);
-/**
-* Create an Uint8Array view of the next `len` bytes and advance the position by `len`.
-*
-* Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
-*            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
-*
-* @function
-* @template {ArrayBufferLike} Buf
-* @param {Decoder<Buf>} decoder The decoder instance
-* @param {number} len The length of bytes to read
-* @return {Uint8Array<Buf>}
-*/
-const readUint8Array = (decoder, len) => {
-	const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
-	decoder.pos += len;
-	return view;
-};
-/**
-* Read variable length Uint8Array.
-*
-* Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
-*            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
-*
-* @function
-* @template {ArrayBufferLike} Buf
-* @param {Decoder<Buf>} decoder
-* @return {Uint8Array<Buf>}
-*/
-const readVarUint8Array = (decoder) => readUint8Array(decoder, readVarUint(decoder));
-/**
-* Read one byte as unsigned integer.
-* @function
-* @param {Decoder} decoder The decoder instance
-* @return {number} Unsigned 8-bit integer
-*/
-const readUint8 = (decoder) => decoder.arr[decoder.pos++];
-/**
-* Read unsigned integer (32bit) with variable length.
-* 1/8th of the storage is used as encoding overhead.
-*  * numbers < 2^7 is stored in one bytlength
-*  * numbers < 2^14 is stored in two bylength
-*
-* @function
-* @param {Decoder} decoder
-* @return {number} An unsigned integer.length
-*/
-const readVarUint = (decoder) => {
-	let num = 0;
-	let mult = 1;
-	const len = decoder.arr.length;
-	while (decoder.pos < len) {
-		const r = decoder.arr[decoder.pos++];
-		num = num + (r & BITS7) * mult;
-		mult *= 128;
-		if (r < BIT8) return num;
-		/* c8 ignore start */
-		if (num > MAX_SAFE_INTEGER) throw errorIntegerOutOfRange;
-	}
-	throw errorUnexpectedEndOfArray;
-};
-/**
-* Read signed integer (32bit) with variable length.
-* 1/8th of the storage is used as encoding overhead.
-*  * numbers < 2^7 is stored in one bytlength
-*  * numbers < 2^14 is stored in two bylength
-* @todo This should probably create the inverse ~num if number is negative - but this would be a breaking change.
-*
-* @function
-* @param {Decoder} decoder
-* @return {number} An unsigned integer.length
-*/
-const readVarInt = (decoder) => {
-	let r = decoder.arr[decoder.pos++];
-	let num = r & BITS6;
-	let mult = 64;
-	const sign = (r & BIT7) > 0 ? -1 : 1;
-	if ((r & BIT8) === 0) return sign * num;
-	const len = decoder.arr.length;
-	while (decoder.pos < len) {
-		r = decoder.arr[decoder.pos++];
-		num = num + (r & BITS7) * mult;
-		mult *= 128;
-		if (r < BIT8) return sign * num;
-		/* c8 ignore start */
-		if (num > MAX_SAFE_INTEGER) throw errorIntegerOutOfRange;
-	}
-	throw errorUnexpectedEndOfArray;
-};
-/**
-* We don't test this function anymore as we use native decoding/encoding by default now.
-* Better not modify this anymore..
-*
-* Transforming utf8 to a string is pretty expensive. The code performs 10x better
-* when String.fromCodePoint is fed with all characters as arguments.
-* But most environments have a maximum number of arguments per functions.
-* For effiency reasons we apply a maximum of 10000 characters at once.
-*
-* @function
-* @param {Decoder} decoder
-* @return {String} The read String.
-*/
-/* c8 ignore start */
-const _readVarStringPolyfill = (decoder) => {
-	let remainingLen = readVarUint(decoder);
-	if (remainingLen === 0) return "";
-	else {
-		let encodedString = String.fromCodePoint(readUint8(decoder));
-		if (--remainingLen < 100) while (remainingLen--) encodedString += String.fromCodePoint(readUint8(decoder));
-		else while (remainingLen > 0) {
-			const nextLen = remainingLen < 1e4 ? remainingLen : 1e4;
-			const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen);
-			decoder.pos += nextLen;
-			encodedString += String.fromCodePoint.apply(null, bytes);
-			remainingLen -= nextLen;
-		}
-		return decodeURIComponent(escape(encodedString));
-	}
-};
-/* c8 ignore stop */
-/**
-* @function
-* @param {Decoder} decoder
-* @return {String} The read String
-*/
-const _readVarStringNative = (decoder) => utf8TextDecoder.decode(readVarUint8Array(decoder));
-/**
-* Read string of variable length
-* * varUint is used to store the length of the string
-*
-* @function
-* @param {Decoder} decoder
-* @return {String} The read String
-*
-*/
-/* c8 ignore next */
-const readVarString = utf8TextDecoder ? _readVarStringNative : _readVarStringPolyfill;
-/**
-* Look ahead and read varString without incrementing position
-*
-* @function
-* @param {Decoder} decoder
-* @return {string}
-*/
-const peekVarString = (decoder) => {
-	const pos = decoder.pos;
-	const s = readVarString(decoder);
-	decoder.pos = pos;
-	return s;
-};
-
-//#endregion
-//#region node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/time.js
-/**
-* Return current unix time.
-*
-* @return {number}
-*/
-const getUnixTime = Date.now;
-
-//#endregion
-//#region node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/map.js
-/**
-* Utility module to work with key-value stores.
-*
-* @module map
-*/
-/**
-* @template K
-* @template V
-* @typedef {Map<K,V>} GlobalMap
-*/
-/**
-* Creates a new Map instance.
-*
-* @function
-* @return {Map<any, any>}
-*
-* @function
-*/
-const create = () => /* @__PURE__ */ new Map();
-/**
-* Get map property. Create T if property is undefined and set T on map.
-*
-* ```js
-* const listeners = map.setIfUndefined(events, 'eventName', set.create)
-* listeners.add(listener)
-* ```
-*
-* @function
-* @template {Map<any, any>} MAP
-* @template {MAP extends Map<any,infer V> ? function():V : unknown} CF
-* @param {MAP} map
-* @param {MAP extends Map<infer K,any> ? K : unknown} key
-* @param {CF} createT
-* @return {ReturnType<CF>}
-*/
-const setIfUndefined = (map, key, createT) => {
-	let set = map.get(key);
-	if (set === void 0) map.set(key, set = createT());
-	return set;
-};
-
-//#endregion
-//#region node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/observable.js
-/**
-* Observable class prototype.
-*
-* @module observable
-*/
-/* c8 ignore start */
-/**
-* Handles named events.
-*
-* @deprecated
-* @template N
-*/
-var Observable = class {
-	constructor() {
-		/**
-		* Some desc.
-		* @type {Map<N, any>}
-		*/
-		this._observers = create();
-	}
-	/**
-	* @param {N} name
-	* @param {function} f
-	*/
-	on(name, f) {
-		setIfUndefined(this._observers, name, create$2).add(f);
-	}
-	/**
-	* @param {N} name
-	* @param {function} f
-	*/
-	once(name, f) {
-		/**
-		* @param  {...any} args
-		*/
-		const _f = (...args) => {
-			this.off(name, _f);
-			f(...args);
-		};
-		this.on(name, _f);
-	}
-	/**
-	* @param {N} name
-	* @param {function} f
-	*/
-	off(name, f) {
-		const observers = this._observers.get(name);
-		if (observers !== void 0) {
-			observers.delete(f);
-			if (observers.size === 0) this._observers.delete(name);
-		}
-	}
-	/**
-	* Emit a named event. All registered event listeners that listen to the
-	* specified name will receive the event.
-	*
-	* @todo This should catch exceptions
-	*
-	* @param {N} name The event name.
-	* @param {Array<any>} args The arguments that are applied to the event listener.
-	*/
-	emit(name, args) {
-		return from((this._observers.get(name) || create()).values()).forEach((f) => f(...args));
-	}
-	destroy() {
-		this._observers = create();
-	}
-};
-/* c8 ignore end */
-
-//#endregion
-//#region node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/trait/equality.js
-const EqualityTraitSymbol = Symbol("Equality");
-
-//#endregion
-//#region node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/object.js
-/**
-* @param {Object<string,any>} obj
-*/
-const keys = Object.keys;
-/**
-* @param {Object<string,any>} obj
-* @return {number}
-*/
-const size = (obj) => keys(obj).length;
-/**
-* Calls `Object.prototype.hasOwnProperty`.
-*
-* @param {any} obj
-* @param {string|number|symbol} key
-* @return {boolean}
-*/
-const hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
-
-//#endregion
-//#region node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/function.js
-/**
-* Common functions and function call helpers.
-*
-* @module function
-*/
-/* c8 ignore start */
-/**
-* @param {any} a
-* @param {any} b
-* @return {boolean}
-*/
-const equalityDeep = (a, b) => {
-	if (a === b) return true;
-	if (a == null || b == null || a.constructor !== b.constructor && (a.constructor || Object) !== (b.constructor || Object)) return false;
-	if (a[EqualityTraitSymbol] != null) return a[EqualityTraitSymbol](b);
-	switch (a.constructor) {
-		case ArrayBuffer:
-			a = new Uint8Array(a);
-			b = new Uint8Array(b);
-		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 void 0:
-		case Object:
-			if (size(a) !== size(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;
-};
-/* c8 ignore stop */
-const isArray = isArray$1;
-
-//#endregion
-//#region node_modules/.pnpm/y-protocols@1.0.7_yjs@13.6.29/node_modules/y-protocols/awareness.js
-/**
-* @module awareness-protocol
-*/
-const outdatedTimeout = 3e4;
-/**
-* @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>}
-*/
-var Awareness = class 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 = /* @__PURE__ */ new Map();
-		/**
-		* @type {Map<number, MetaClientState>}
-		*/
-		this.meta = /* @__PURE__ */ new Map();
-		this._checkInterval = setInterval(() => {
-			const now = getUnixTime();
-			if (this.getLocalState() !== null && outdatedTimeout / 2 <= now - this.meta.get(this.clientID).lastUpdated) this.setLocalState(this.getLocalState());
-			/**
-			* @type {Array<number>}
-			*/
-			const remove = [];
-			this.meta.forEach((meta, clientid) => {
-				if (clientid !== this.clientID && outdatedTimeout <= now - meta.lastUpdated && this.states.has(clientid)) remove.push(clientid);
-			});
-			if (remove.length > 0) removeAwarenessStates(this, remove, "timeout");
-		}, floor(outdatedTimeout / 10));
-		doc.on("destroy", () => {
-			this.destroy();
-		});
-		this.setLocalState({});
-	}
-	destroy() {
-		this.emit("destroy", [this]);
-		this.setLocalState(null);
-		super.destroy();
-		clearInterval(this._checkInterval);
-	}
-	/**
-	* @return {Object<string,any>|null}
-	*/
-	getLocalState() {
-		return this.states.get(this.clientID) || null;
-	}
-	/**
-	* @param {Object<string,any>|null} state
-	*/
-	setLocalState(state) {
-		const clientID = this.clientID;
-		const currLocalMeta = this.meta.get(clientID);
-		const clock = currLocalMeta === void 0 ? 0 : currLocalMeta.clock + 1;
-		const prevState = this.states.get(clientID);
-		if (state === null) this.states.delete(clientID);
-		else this.states.set(clientID, state);
-		this.meta.set(clientID, {
-			clock,
-			lastUpdated: getUnixTime()
-		});
-		const added = [];
-		const updated = [];
-		const filteredUpdated = [];
-		const removed = [];
-		if (state === null) removed.push(clientID);
-		else if (prevState == null) {
-			if (state != null) added.push(clientID);
-		} else {
-			updated.push(clientID);
-			if (!equalityDeep(prevState, state)) filteredUpdated.push(clientID);
-		}
-		if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) this.emit("change", [{
-			added,
-			updated: filteredUpdated,
-			removed
-		}, "local"]);
-		this.emit("update", [{
-			added,
-			updated,
-			removed
-		}, "local"]);
-	}
-	/**
-	* @param {string} field
-	* @param {any} value
-	*/
-	setLocalStateField(field, value) {
-		const state = this.getLocalState();
-		if (state !== null) this.setLocalState({
-			...state,
-			[field]: value
-		});
-	}
-	/**
-	* @return {Map<number,Object<string,any>>}
-	*/
-	getStates() {
-		return this.states;
-	}
-};
-/**
-* Mark (remote) clients as inactive and remove them from the list of active peers.
-* This change will be propagated to remote clients.
-*
-* @param {Awareness} awareness
-* @param {Array<number>} clients
-* @param {any} origin
-*/
-const removeAwarenessStates = (awareness, clients, origin) => {
-	const removed = [];
-	for (let i = 0; i < clients.length; i++) {
-		const clientID = clients[i];
-		if (awareness.states.has(clientID)) {
-			awareness.states.delete(clientID);
-			if (clientID === awareness.clientID) {
-				const curMeta = awareness.meta.get(clientID);
-				awareness.meta.set(clientID, {
-					clock: curMeta.clock + 1,
-					lastUpdated: getUnixTime()
-				});
-			}
-			removed.push(clientID);
-		}
-	}
-	if (removed.length > 0) {
-		awareness.emit("change", [{
-			added: [],
-			updated: [],
-			removed
-		}, origin]);
-		awareness.emit("update", [{
-			added: [],
-			updated: [],
-			removed
-		}, origin]);
-	}
-};
-/**
-* @param {Awareness} awareness
-* @param {Array<number>} clients
-* @return {Uint8Array}
-*/
-const encodeAwarenessUpdate = (awareness, clients, states = awareness.states) => {
-	const len = clients.length;
-	const encoder = createEncoder();
-	writeVarUint(encoder, len);
-	for (let i = 0; i < len; i++) {
-		const clientID = clients[i];
-		const state = states.get(clientID) || null;
-		const clock = awareness.meta.get(clientID).clock;
-		writeVarUint(encoder, clientID);
-		writeVarUint(encoder, clock);
-		writeVarString(encoder, JSON.stringify(state));
-	}
-	return toUint8Array(encoder);
-};
-/**
-* @param {Awareness} awareness
-* @param {Uint8Array} update
-* @param {any} origin This will be added to the emitted change event
-*/
-const applyAwarenessUpdate = (awareness, update, origin) => {
-	const decoder = createDecoder(update);
-	const timestamp = getUnixTime();
-	const added = [];
-	const updated = [];
-	const filteredUpdated = [];
-	const removed = [];
-	const len = readVarUint(decoder);
-	for (let i = 0; i < len; i++) {
-		const clientID = readVarUint(decoder);
-		let clock = readVarUint(decoder);
-		const state = JSON.parse(readVarString(decoder));
-		const clientMeta = awareness.meta.get(clientID);
-		const prevState = awareness.states.get(clientID);
-		const currClock = clientMeta === void 0 ? 0 : clientMeta.clock;
-		if (currClock < clock || currClock === clock && state === null && awareness.states.has(clientID)) {
-			if (state === null) if (clientID === awareness.clientID && awareness.getLocalState() != null) clock++;
-			else awareness.states.delete(clientID);
-			else awareness.states.set(clientID, state);
-			awareness.meta.set(clientID, {
-				clock,
-				lastUpdated: timestamp
-			});
-			if (clientMeta === void 0 && state !== null) added.push(clientID);
-			else if (clientMeta !== void 0 && state === null) removed.push(clientID);
-			else if (state !== null) {
-				if (!equalityDeep(state, prevState)) filteredUpdated.push(clientID);
-				updated.push(clientID);
-			}
-		}
-	}
-	if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) awareness.emit("change", [{
-		added,
-		updated: filteredUpdated,
-		removed
-	}, origin]);
-	if (added.length > 0 || updated.length > 0 || removed.length > 0) awareness.emit("update", [{
-		added,
-		updated,
-		removed
-	}, origin]);
-};
-
-//#endregion
 //#region packages/provider/src/EventEmitter.ts
 var EventEmitter = class {
 	constructor() {
@@ -1101,8 +114,8 @@ var CloseMessage = class extends OutgoingMessage {
 		this.description = "Ask the server to close the connection";
 	}
 	get(args) {
-		writeVarString(this.encoder, args.documentName);
-		writeVarUint(this.encoder, this.type);
+		encoding.writeVarString(this.encoder, args.documentName);
+		encoding.writeVarUint(this.encoder, this.type);
 		return this.encoder;
 	}
 };
@@ -1291,7 +304,7 @@ var HocuspocusProviderWebsocket = class HocuspocusProviderWebsocket extends Even
 	}
 	onMessage(event) {
 		this.resolveConnectionAttempt();
-		this.lastMessageReceived = getUnixTime();
+		this.lastMessageReceived = time.getUnixTime();
 		const data = new Uint8Array(event.data);
 		if (data.length === 1 && data[0] === MessageType.Ping) {
 			this.sendPong();
@@ -1304,9 +317,9 @@ var HocuspocusProviderWebsocket = class HocuspocusProviderWebsocket extends Even
 	* Send application-level Pong response to server Ping
 	*/
 	sendPong() {
-		const encoder = createEncoder();
-		writeVarUint(encoder, MessageType.Pong);
-		this.send(toUint8Array(encoder));
+		const encoder = encoding.createEncoder();
+		encoding.writeVarUint(encoder, MessageType.Pong);
+		this.send(encoding.toUint8Array(encoder));
 	}
 	resolveConnectionAttempt() {
 		if (this.connectionAttempt) {
@@ -1329,7 +342,7 @@ var HocuspocusProviderWebsocket = class HocuspocusProviderWebsocket extends Even
 	checkConnection() {
 		if (this.status !== WebSocketStatus.Connected) return;
 		if (!this.lastMessageReceived) return;
-		if (this.configuration.messageReconnectTimeout >= getUnixTime() - this.lastMessageReceived) return;
+		if (this.configuration.messageReconnectTimeout >= time.getUnixTime() - this.lastMessageReceived) return;
 		this.closeTries += 1;
 		if (this.closeTries > 2) {
 			this.onClose({ event: {
@@ -1409,126 +422,6 @@ var HocuspocusProviderWebsocket = class HocuspocusProviderWebsocket extends Even
 	}
 };
 
-//#endregion
-//#region node_modules/.pnpm/y-protocols@1.0.7_yjs@13.6.29/node_modules/y-protocols/sync.js
-/**
-* @module sync-protocol
-*/
-/**
-* @typedef {Map<number, number>} StateMap
-*/
-/**
-* Core Yjs defines two message types:
-* • YjsSyncStep1: Includes the State Set of the sending client. When received, the client should reply with YjsSyncStep2.
-* • YjsSyncStep2: Includes all missing structs and the complete delete set. When received, the client is assured that it
-*   received all information from the remote client.
-*
-* In a peer-to-peer network, you may want to introduce a SyncDone message type. Both parties should initiate the connection
-* with SyncStep1. When a client received SyncStep2, it should reply with SyncDone. When the local client received both
-* SyncStep2 and SyncDone, it is assured that it is synced to the remote client.
-*
-* In a client-server model, you want to handle this differently: The client should initiate the connection with SyncStep1.
-* When the server receives SyncStep1, it should reply with SyncStep2 immediately followed by SyncStep1. The client replies
-* with SyncStep2 when it receives SyncStep1. Optionally the server may send a SyncDone after it received SyncStep2, so the
-* client knows that the sync is finished.  There are two reasons for this more elaborated sync model: 1. This protocol can
-* easily be implemented on top of http and websockets. 2. The server should only reply to requests, and not initiate them.
-* Therefore it is necessary that the client initiates the sync.
-*
-* Construction of a message:
-* [messageType : varUint, message definition..]
-*
-* Note: A message does not include information about the room name. This must to be handled by the upper layer protocol!
-*
-* stringify[messageType] stringifies a message definition (messageType is already read from the bufffer)
-*/
-const messageYjsSyncStep1 = 0;
-const messageYjsSyncStep2 = 1;
-const messageYjsUpdate = 2;
-/**
-* Create a sync step 1 message based on the state of the current shared document.
-*
-* @param {encoding.Encoder} encoder
-* @param {Y.Doc} doc
-*/
-const writeSyncStep1 = (encoder, doc) => {
-	writeVarUint(encoder, messageYjsSyncStep1);
-	const sv = Y.encodeStateVector(doc);
-	writeVarUint8Array(encoder, sv);
-};
-/**
-* @param {encoding.Encoder} encoder
-* @param {Y.Doc} doc
-* @param {Uint8Array} [encodedStateVector]
-*/
-const writeSyncStep2 = (encoder, doc, encodedStateVector) => {
-	writeVarUint(encoder, messageYjsSyncStep2);
-	writeVarUint8Array(encoder, Y.encodeStateAsUpdate(doc, encodedStateVector));
-};
-/**
-* Read SyncStep1 message and reply with SyncStep2.
-*
-* @param {decoding.Decoder} decoder The reply to the received message
-* @param {encoding.Encoder} encoder The received message
-* @param {Y.Doc} doc
-*/
-const readSyncStep1 = (decoder, encoder, doc) => writeSyncStep2(encoder, doc, readVarUint8Array(decoder));
-/**
-* Read and apply Structs and then DeleteStore to a y instance.
-*
-* @param {decoding.Decoder} decoder
-* @param {Y.Doc} doc
-* @param {any} transactionOrigin
-* @param {(error:Error)=>any} [errorHandler]
-*/
-const readSyncStep2 = (decoder, doc, transactionOrigin, errorHandler) => {
-	try {
-		Y.applyUpdate(doc, readVarUint8Array(decoder), transactionOrigin);
-	} catch (error) {
-		if (errorHandler != null) errorHandler(error);
-		console.error("Caught error while handling a Yjs update", error);
-	}
-};
-/**
-* @param {encoding.Encoder} encoder
-* @param {Uint8Array} update
-*/
-const writeUpdate = (encoder, update) => {
-	writeVarUint(encoder, messageYjsUpdate);
-	writeVarUint8Array(encoder, update);
-};
-/**
-* Read and apply Structs and then DeleteStore to a y instance.
-*
-* @param {decoding.Decoder} decoder
-* @param {Y.Doc} doc
-* @param {any} transactionOrigin
-* @param {(error:Error)=>any} [errorHandler]
-*/
-const readUpdate = readSyncStep2;
-/**
-* @param {decoding.Decoder} decoder A message received from another client
-* @param {encoding.Encoder} encoder The reply message. Does not need to be sent if empty.
-* @param {Y.Doc} doc
-* @param {any} transactionOrigin
-* @param {(error:Error)=>any} [errorHandler] Optional error handler that catches errors when reading Yjs messages.
-*/
-const readSyncMessage = (decoder, encoder, doc, transactionOrigin, errorHandler) => {
-	const messageType = readVarUint(decoder);
-	switch (messageType) {
-		case messageYjsSyncStep1:
-			readSyncStep1(decoder, encoder, doc);
-			break;
-		case messageYjsSyncStep2:
-			readSyncStep2(decoder, doc, transactionOrigin, errorHandler);
-			break;
-		case messageYjsUpdate:
-			readUpdate(decoder, doc, transactionOrigin, errorHandler);
-			break;
-		default: throw new Error("Unknown message type");
-	}
-	return messageType;
-};
-
 //#endregion
 //#region packages/provider/src/MessageReceiver.ts
 var MessageReceiver = class {
@@ -1584,7 +477,7 @@ var MessageReceiver = class {
 	applyAwarenessMessage(provider) {
 		if (!provider.awareness) return;
 		const { message } = this;
-		applyAwarenessUpdate(provider.awareness, message.readVarUint8Array(), provider);
+		awarenessProtocol.applyAwarenessUpdate(provider.awareness, message.readVarUint8Array(), provider);
 	}
 	applyAuthMessage(provider) {
 		const { message } = this;
@@ -1594,7 +487,7 @@ var MessageReceiver = class {
 		if (!provider.awareness) return;
 		const { message } = this;
 		message.writeVarUint(MessageType.Awareness);
-		message.writeVarUint8Array(encodeAwarenessUpdate(provider.awareness, Array.from(provider.awareness.getStates().keys())));
+		message.writeVarUint8Array(awarenessProtocol.encodeAwarenessUpdate(provider.awareness, Array.from(provider.awareness.getStates().keys())));
 	}
 };
 
@@ -1615,7 +508,7 @@ var MessageSender = class {
 
 //#endregion
 //#region packages/provider/src/version.ts
-const version = "4.0.0-rc.6";
+const version = "4.0.0";
 
 //#endregion
 //#region packages/provider/src/OutgoingMessages/AuthenticationMessage.ts
@@ -1646,12 +539,12 @@ var AwarenessMessage = class extends OutgoingMessage {
 	get(args) {
 		if (typeof args.awareness === "undefined") throw new Error("The awareness message requires awareness as an argument");
 		if (typeof args.clients === "undefined") throw new Error("The awareness message requires clients as an argument");
-		writeVarString(this.encoder, args.documentName);
-		writeVarUint(this.encoder, this.type);
+		encoding.writeVarString(this.encoder, args.documentName);
+		encoding.writeVarUint(this.encoder, this.type);
 		let awarenessUpdate;
 		if (args.states === void 0) awarenessUpdate = encodeAwarenessUpdate(args.awareness, args.clients);
 		else awarenessUpdate = encodeAwarenessUpdate(args.awareness, args.clients, args.states);
-		writeVarUint8Array(this.encoder, awarenessUpdate);
+		encoding.writeVarUint8Array(this.encoder, awarenessUpdate);
 		return this.encoder;
 	}
 };
@@ -1682,9 +575,9 @@ var SyncStepOneMessage = class extends OutgoingMessage {
 	}
 	get(args) {
 		if (typeof args.document === "undefined") throw new Error("The sync step one message requires document as an argument");
-		writeVarString(this.encoder, args.documentName);
-		writeVarUint(this.encoder, this.type);
-		writeSyncStep1(this.encoder, args.document);
+		encoding.writeVarString(this.encoder, args.documentName);
+		encoding.writeVarUint(this.encoder, this.type);
+		syncProtocol.writeSyncStep1(this.encoder, args.document);
 		return this.encoder;
 	}
 };