@abraca/dabra 0.1.0

package/dist/hocuspocus-provider.esm.js

@@ -0,0 +1,3199 @@
+import * as Y from "yjs";
+import { retry } from "@lifeomic/attempt";
+import * as ed from "@noble/ed25519";
+
+//#region 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/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/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/lib0/set.js
+/**
+* Utility module to work with sets.
+*
+* @module set
+*/
+const create$2 = () => /* @__PURE__ */ new Set();
+
+//#endregion
+//#region 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/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/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/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/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 packages/common/src/auth.ts
+let AuthMessageType = /* @__PURE__ */ function(AuthMessageType) {
+	AuthMessageType[AuthMessageType["Token"] = 0] = "Token";
+	AuthMessageType[AuthMessageType["PermissionDenied"] = 1] = "PermissionDenied";
+	AuthMessageType[AuthMessageType["Authenticated"] = 2] = "Authenticated";
+	return AuthMessageType;
+}({});
+const writeAuthentication = (encoder, auth) => {
+	writeVarUint(encoder, AuthMessageType.Token);
+	writeVarString(encoder, auth);
+};
+const readAuthMessage = (decoder, sendToken, permissionDeniedHandler, authenticatedHandler) => {
+	switch (readVarUint(decoder)) {
+		case AuthMessageType.Token:
+			sendToken();
+			break;
+		case AuthMessageType.PermissionDenied:
+			permissionDeniedHandler(readVarString(decoder));
+			break;
+		case AuthMessageType.Authenticated:
+			authenticatedHandler(readVarString(decoder));
+			break;
+		default:
+	}
+};
+
+//#endregion
+//#region packages/common/src/awarenessStatesToArray.ts
+const awarenessStatesToArray = (states) => {
+	return Array.from(states.entries()).map(([key, value]) => {
+		return {
+			clientId: key,
+			...value
+		};
+	});
+};
+
+//#endregion
+//#region packages/common/src/types.ts
+/**
+* State of the WebSocket connection.
+* https://developer.mozilla.org/de/docs/Web/API/WebSocket/readyState
+*/
+let WsReadyStates = /* @__PURE__ */ function(WsReadyStates) {
+	WsReadyStates[WsReadyStates["Connecting"] = 0] = "Connecting";
+	WsReadyStates[WsReadyStates["Open"] = 1] = "Open";
+	WsReadyStates[WsReadyStates["Closing"] = 2] = "Closing";
+	WsReadyStates[WsReadyStates["Closed"] = 3] = "Closed";
+	return WsReadyStates;
+}({});
+
+//#endregion
+//#region node_modules/lib0/time.js
+/**
+* Return current unix time.
+*
+* @return {number}
+*/
+const getUnixTime = Date.now;
+
+//#endregion
+//#region 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/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/lib0/trait/equality.js
+const EqualityTraitSymbol = Symbol("Equality");
+
+//#endregion
+//#region 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/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/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() {
+		this.callbacks = {};
+	}
+	on(event, fn) {
+		if (!this.callbacks[event]) this.callbacks[event] = [];
+		this.callbacks[event].push(fn);
+		return this;
+	}
+	emit(event, ...args) {
+		const callbacks = this.callbacks[event];
+		if (callbacks) callbacks.forEach((callback) => callback.apply(this, args));
+		return this;
+	}
+	off(event, fn) {
+		const callbacks = this.callbacks[event];
+		if (callbacks) if (fn) this.callbacks[event] = callbacks.filter((callback) => callback !== fn);
+		else delete this.callbacks[event];
+		return this;
+	}
+	removeAllListeners() {
+		this.callbacks = {};
+	}
+};
+
+//#endregion
+//#region packages/provider/src/IncomingMessage.ts
+var IncomingMessage = class {
+	constructor(data) {
+		this.data = data;
+		this.encoder = createEncoder();
+		this.decoder = createDecoder(new Uint8Array(this.data));
+	}
+	peekVarString() {
+		return peekVarString(this.decoder);
+	}
+	readVarUint() {
+		return readVarUint(this.decoder);
+	}
+	readVarString() {
+		return readVarString(this.decoder);
+	}
+	readVarUint8Array() {
+		return readVarUint8Array(this.decoder);
+	}
+	writeVarUint(type) {
+		return writeVarUint(this.encoder, type);
+	}
+	writeVarString(string) {
+		return writeVarString(this.encoder, string);
+	}
+	writeVarUint8Array(data) {
+		return writeVarUint8Array(this.encoder, data);
+	}
+	length() {
+		return length(this.encoder);
+	}
+};
+
+//#endregion
+//#region packages/provider/src/types.ts
+let MessageType = /* @__PURE__ */ function(MessageType) {
+	MessageType[MessageType["Sync"] = 0] = "Sync";
+	MessageType[MessageType["Awareness"] = 1] = "Awareness";
+	MessageType[MessageType["Auth"] = 2] = "Auth";
+	MessageType[MessageType["QueryAwareness"] = 3] = "QueryAwareness";
+	MessageType[MessageType["Subdoc"] = 4] = "Subdoc";
+	MessageType[MessageType["Stateless"] = 5] = "Stateless";
+	MessageType[MessageType["CLOSE"] = 7] = "CLOSE";
+	MessageType[MessageType["SyncStatus"] = 8] = "SyncStatus";
+	return MessageType;
+}({});
+let WebSocketStatus = /* @__PURE__ */ function(WebSocketStatus) {
+	WebSocketStatus["Connecting"] = "connecting";
+	WebSocketStatus["Connected"] = "connected";
+	WebSocketStatus["Disconnected"] = "disconnected";
+	return WebSocketStatus;
+}({});
+
+//#endregion
+//#region packages/provider/src/OutgoingMessage.ts
+var OutgoingMessage = class {
+	constructor() {
+		this.encoder = createEncoder();
+	}
+	get(args) {
+		return args.encoder;
+	}
+	toUint8Array() {
+		return toUint8Array(this.encoder);
+	}
+};
+
+//#endregion
+//#region packages/provider/src/OutgoingMessages/CloseMessage.ts
+var CloseMessage = class extends OutgoingMessage {
+	constructor(..._args) {
+		super(..._args);
+		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;
+	}
+};
+
+//#endregion
+//#region packages/provider/src/HocuspocusProviderWebsocket.ts
+var HocuspocusProviderWebsocket = class extends EventEmitter {
+	constructor(configuration) {
+		super();
+		this.messageQueue = [];
+		this.configuration = {
+			url: "",
+			autoConnect: true,
+			preserveTrailingSlash: false,
+			document: void 0,
+			WebSocketPolyfill: void 0,
+			messageReconnectTimeout: 3e4,
+			delay: 1e3,
+			initialDelay: 0,
+			factor: 2,
+			maxAttempts: 0,
+			minDelay: 1e3,
+			maxDelay: 3e4,
+			jitter: true,
+			timeout: 0,
+			onOpen: () => null,
+			onConnect: () => null,
+			onMessage: () => null,
+			onOutgoingMessage: () => null,
+			onStatus: () => null,
+			onDisconnect: () => null,
+			onClose: () => null,
+			onDestroy: () => null,
+			onAwarenessUpdate: () => null,
+			onAwarenessChange: () => null,
+			handleTimeout: null,
+			providerMap: /* @__PURE__ */ new Map()
+		};
+		this.webSocket = null;
+		this.webSocketHandlers = {};
+		this.shouldConnect = true;
+		this.status = WebSocketStatus.Disconnected;
+		this.lastMessageReceived = 0;
+		this.identifier = 0;
+		this.intervals = { connectionChecker: null };
+		this.connectionAttempt = null;
+		this.receivedOnOpenPayload = void 0;
+		this.closeTries = 0;
+		this.setConfiguration(configuration);
+		this.configuration.WebSocketPolyfill = configuration.WebSocketPolyfill ? configuration.WebSocketPolyfill : WebSocket;
+		this.on("open", this.configuration.onOpen);
+		this.on("open", this.onOpen.bind(this));
+		this.on("connect", this.configuration.onConnect);
+		this.on("message", this.configuration.onMessage);
+		this.on("outgoingMessage", this.configuration.onOutgoingMessage);
+		this.on("status", this.configuration.onStatus);
+		this.on("disconnect", this.configuration.onDisconnect);
+		this.on("close", this.configuration.onClose);
+		this.on("destroy", this.configuration.onDestroy);
+		this.on("awarenessUpdate", this.configuration.onAwarenessUpdate);
+		this.on("awarenessChange", this.configuration.onAwarenessChange);
+		this.on("close", this.onClose.bind(this));
+		this.on("message", this.onMessage.bind(this));
+		this.intervals.connectionChecker = setInterval(this.checkConnection.bind(this), this.configuration.messageReconnectTimeout / 10);
+		if (this.shouldConnect) this.connect();
+	}
+	async onOpen(event) {
+		this.status = WebSocketStatus.Connected;
+		this.emit("status", { status: WebSocketStatus.Connected });
+		this.cancelWebsocketRetry = void 0;
+		this.receivedOnOpenPayload = event;
+	}
+	attach(provider) {
+		this.configuration.providerMap.set(provider.configuration.name, provider);
+		if (this.status === WebSocketStatus.Disconnected && this.shouldConnect) this.connect();
+		if (this.receivedOnOpenPayload && this.status === WebSocketStatus.Connected) provider.onOpen(this.receivedOnOpenPayload);
+	}
+	detach(provider) {
+		if (this.configuration.providerMap.has(provider.configuration.name)) {
+			provider.send(CloseMessage, { documentName: provider.configuration.name });
+			this.configuration.providerMap.delete(provider.configuration.name);
+		}
+	}
+	setConfiguration(configuration = {}) {
+		this.configuration = {
+			...this.configuration,
+			...configuration
+		};
+		if (!this.configuration.autoConnect) this.shouldConnect = false;
+	}
+	async connect() {
+		if (this.status === WebSocketStatus.Connected) return;
+		if (this.cancelWebsocketRetry) {
+			this.cancelWebsocketRetry();
+			this.cancelWebsocketRetry = void 0;
+		}
+		this.receivedOnOpenPayload = void 0;
+		this.shouldConnect = true;
+		const abortableRetry = () => {
+			let cancelAttempt = false;
+			return {
+				retryPromise: retry(this.createWebSocketConnection.bind(this), {
+					delay: this.configuration.delay,
+					initialDelay: this.configuration.initialDelay,
+					factor: this.configuration.factor,
+					maxAttempts: this.configuration.maxAttempts,
+					minDelay: this.configuration.minDelay,
+					maxDelay: this.configuration.maxDelay,
+					jitter: this.configuration.jitter,
+					timeout: this.configuration.timeout,
+					handleTimeout: this.configuration.handleTimeout,
+					beforeAttempt: (context) => {
+						if (!this.shouldConnect || cancelAttempt) context.abort();
+					}
+				}).catch((error) => {
+					if (error && error.code !== "ATTEMPT_ABORTED") throw error;
+				}),
+				cancelFunc: () => {
+					cancelAttempt = true;
+				}
+			};
+		};
+		const { retryPromise, cancelFunc } = abortableRetry();
+		this.cancelWebsocketRetry = cancelFunc;
+		return retryPromise;
+	}
+	attachWebSocketListeners(ws, reject) {
+		const { identifier } = ws;
+		const onMessageHandler = (payload) => this.emit("message", payload);
+		const onCloseHandler = (payload) => this.emit("close", { event: payload });
+		const onOpenHandler = (payload) => this.emit("open", payload);
+		const onErrorHandler = (err) => {
+			reject(err);
+		};
+		this.webSocketHandlers[identifier] = {
+			message: onMessageHandler,
+			close: onCloseHandler,
+			open: onOpenHandler,
+			error: onErrorHandler
+		};
+		const handlers = this.webSocketHandlers[ws.identifier];
+		Object.keys(handlers).forEach((name) => {
+			ws.addEventListener(name, handlers[name]);
+		});
+	}
+	cleanupWebSocket() {
+		if (!this.webSocket) return;
+		const { identifier } = this.webSocket;
+		const handlers = this.webSocketHandlers[identifier];
+		Object.keys(handlers).forEach((name) => {
+			this.webSocket?.removeEventListener(name, handlers[name]);
+			delete this.webSocketHandlers[identifier];
+		});
+		try {
+			if (this.webSocket.readyState !== 0 && this.webSocket.readyState !== 3) this.webSocket.close();
+		} catch (e) {}
+		this.webSocket = null;
+	}
+	createWebSocketConnection() {
+		return new Promise((resolve, reject) => {
+			if (this.webSocket) {
+				this.messageQueue = [];
+				this.cleanupWebSocket();
+			}
+			this.lastMessageReceived = 0;
+			this.identifier += 1;
+			const ws = new this.configuration.WebSocketPolyfill(this.url);
+			ws.binaryType = "arraybuffer";
+			ws.identifier = this.identifier;
+			this.attachWebSocketListeners(ws, reject);
+			this.webSocket = ws;
+			this.status = WebSocketStatus.Connecting;
+			this.emit("status", { status: WebSocketStatus.Connecting });
+			this.connectionAttempt = {
+				resolve,
+				reject
+			};
+		});
+	}
+	onMessage(event) {
+		this.resolveConnectionAttempt();
+		this.lastMessageReceived = getUnixTime();
+		const documentName = new IncomingMessage(event.data).peekVarString();
+		this.configuration.providerMap.get(documentName)?.onMessage(event);
+	}
+	resolveConnectionAttempt() {
+		if (this.connectionAttempt) {
+			this.connectionAttempt.resolve();
+			this.connectionAttempt = null;
+			this.status = WebSocketStatus.Connected;
+			this.emit("status", { status: WebSocketStatus.Connected });
+			this.emit("connect");
+			this.messageQueue.forEach((message) => this.send(message));
+			this.messageQueue = [];
+		}
+	}
+	stopConnectionAttempt() {
+		this.connectionAttempt = null;
+	}
+	rejectConnectionAttempt() {
+		this.connectionAttempt?.reject();
+		this.connectionAttempt = null;
+	}
+	checkConnection() {
+		if (this.status !== WebSocketStatus.Connected) return;
+		if (!this.lastMessageReceived) return;
+		if (this.configuration.messageReconnectTimeout >= getUnixTime() - this.lastMessageReceived) return;
+		this.closeTries += 1;
+		if (this.closeTries > 2) {
+			this.onClose({ event: {
+				code: 4408,
+				reason: "forced"
+			} });
+			this.closeTries = 0;
+		} else {
+			this.webSocket?.close();
+			this.messageQueue = [];
+		}
+	}
+	get serverUrl() {
+		if (this.configuration.preserveTrailingSlash) return this.configuration.url;
+		let url = this.configuration.url;
+		while (url[url.length - 1] === "/") url = url.slice(0, url.length - 1);
+		return url;
+	}
+	get url() {
+		return this.serverUrl;
+	}
+	disconnect() {
+		this.shouldConnect = false;
+		if (this.webSocket === null) return;
+		try {
+			this.webSocket.close();
+			this.messageQueue = [];
+		} catch (e) {
+			console.error(e);
+		}
+	}
+	send(message) {
+		if (this.webSocket?.readyState === WsReadyStates.Open) this.webSocket.send(message);
+		else this.messageQueue.push(message);
+	}
+	onClose({ event }) {
+		this.closeTries = 0;
+		this.cleanupWebSocket();
+		if (this.connectionAttempt) this.rejectConnectionAttempt();
+		this.status = WebSocketStatus.Disconnected;
+		this.emit("status", { status: WebSocketStatus.Disconnected });
+		this.emit("disconnect", { event });
+		if (!this.cancelWebsocketRetry && this.shouldConnect) setTimeout(() => {
+			this.connect();
+		}, this.configuration.delay);
+	}
+	destroy() {
+		this.emit("destroy");
+		clearInterval(this.intervals.connectionChecker);
+		this.stopConnectionAttempt();
+		this.disconnect();
+		this.removeAllListeners();
+		this.cleanupWebSocket();
+	}
+};
+
+//#endregion
+//#region 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 {
+	constructor(message) {
+		this.message = message;
+	}
+	apply(provider, emitSynced) {
+		const { message } = this;
+		const type = message.readVarUint();
+		const emptyMessageLength = message.length();
+		switch (type) {
+			case MessageType.Sync:
+				this.applySyncMessage(provider, emitSynced);
+				break;
+			case MessageType.Awareness:
+				this.applyAwarenessMessage(provider);
+				break;
+			case MessageType.Auth:
+				this.applyAuthMessage(provider);
+				break;
+			case MessageType.QueryAwareness:
+				this.applyQueryAwarenessMessage(provider);
+				break;
+			case MessageType.Stateless:
+				provider.receiveStateless(readVarString(message.decoder));
+				break;
+			case MessageType.SyncStatus:
+				this.applySyncStatusMessage(provider, readVarInt(message.decoder) === 1);
+				break;
+			case MessageType.CLOSE:
+				const event = {
+					code: 1e3,
+					reason: readVarString(message.decoder),
+					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}`);
+		}
+		if (message.length() > emptyMessageLength + 1) provider.send(OutgoingMessage, { encoder: message.encoder });
+	}
+	applySyncMessage(provider, emitSynced) {
+		const { message } = this;
+		message.writeVarUint(MessageType.Sync);
+		const syncMessageType = readSyncMessage(message.decoder, message.encoder, provider.document, provider);
+		if (emitSynced && syncMessageType === messageYjsSyncStep2) provider.synced = true;
+	}
+	applySyncStatusMessage(provider, applied) {
+		if (applied) provider.decrementUnsyncedChanges();
+	}
+	applyAwarenessMessage(provider) {
+		if (!provider.awareness) return;
+		const { message } = this;
+		applyAwarenessUpdate(provider.awareness, message.readVarUint8Array(), provider);
+	}
+	applyAuthMessage(provider) {
+		const { message } = this;
+		readAuthMessage(message.decoder, provider.sendToken.bind(provider), provider.permissionDeniedHandler.bind(provider), provider.authenticatedHandler.bind(provider));
+	}
+	applyQueryAwarenessMessage(provider) {
+		if (!provider.awareness) return;
+		const { message } = this;
+		message.writeVarUint(MessageType.Awareness);
+		message.writeVarUint8Array(encodeAwarenessUpdate(provider.awareness, Array.from(provider.awareness.getStates().keys())));
+	}
+};
+
+//#endregion
+//#region packages/provider/src/MessageSender.ts
+var MessageSender = class {
+	constructor(Message, args = {}) {
+		this.message = new Message();
+		this.encoder = this.message.get(args);
+	}
+	create() {
+		return toUint8Array(this.encoder);
+	}
+	send(webSocket) {
+		webSocket?.send(this.create());
+	}
+};
+
+//#endregion
+//#region packages/provider/src/OutgoingMessages/AuthenticationMessage.ts
+var AuthenticationMessage = class extends OutgoingMessage {
+	constructor(..._args) {
+		super(..._args);
+		this.type = MessageType.Auth;
+		this.description = "Authentication";
+	}
+	get(args) {
+		if (typeof args.token === "undefined") throw new Error("The authentication message requires `token` as an argument.");
+		writeVarString(this.encoder, args.documentName);
+		writeVarUint(this.encoder, this.type);
+		writeAuthentication(this.encoder, args.token);
+		return this.encoder;
+	}
+};
+
+//#endregion
+//#region packages/provider/src/OutgoingMessages/AwarenessMessage.ts
+var AwarenessMessage = class extends OutgoingMessage {
+	constructor(..._args) {
+		super(..._args);
+		this.type = MessageType.Awareness;
+		this.description = "Awareness states update";
+	}
+	get(args) {
+		if (typeof args.awareness === "undefined") throw new Error("The awareness message requires awareness as an argument");
+		if (typeof args.clients === "undefined") throw new Error("The awareness message requires clients as an argument");
+		writeVarString(this.encoder, args.documentName);
+		writeVarUint(this.encoder, this.type);
+		let awarenessUpdate;
+		if (args.states === void 0) awarenessUpdate = encodeAwarenessUpdate(args.awareness, args.clients);
+		else awarenessUpdate = encodeAwarenessUpdate(args.awareness, args.clients, args.states);
+		writeVarUint8Array(this.encoder, awarenessUpdate);
+		return this.encoder;
+	}
+};
+
+//#endregion
+//#region packages/provider/src/OutgoingMessages/StatelessMessage.ts
+var StatelessMessage = class extends OutgoingMessage {
+	constructor(..._args) {
+		super(..._args);
+		this.type = MessageType.Stateless;
+		this.description = "A stateless message";
+	}
+	get(args) {
+		writeVarString(this.encoder, args.documentName);
+		writeVarUint(this.encoder, this.type);
+		writeVarString(this.encoder, args.payload ?? "");
+		return this.encoder;
+	}
+};
+
+//#endregion
+//#region packages/provider/src/OutgoingMessages/SyncStepOneMessage.ts
+var SyncStepOneMessage = class extends OutgoingMessage {
+	constructor(..._args) {
+		super(..._args);
+		this.type = MessageType.Sync;
+		this.description = "First sync step";
+	}
+	get(args) {
+		if (typeof args.document === "undefined") throw new Error("The sync step one message requires document as an argument");
+		writeVarString(this.encoder, args.documentName);
+		writeVarUint(this.encoder, this.type);
+		writeSyncStep1(this.encoder, args.document);
+		return this.encoder;
+	}
+};
+
+//#endregion
+//#region packages/provider/src/OutgoingMessages/UpdateMessage.ts
+var UpdateMessage = class extends OutgoingMessage {
+	constructor(..._args) {
+		super(..._args);
+		this.type = MessageType.Sync;
+		this.description = "A document update";
+	}
+	get(args) {
+		writeVarString(this.encoder, args.documentName);
+		writeVarUint(this.encoder, this.type);
+		writeUpdate(this.encoder, args.update);
+		return this.encoder;
+	}
+};
+
+//#endregion
+//#region packages/provider/src/HocuspocusProvider.ts
+var AwarenessError = class extends Error {
+	constructor(..._args) {
+		super(..._args);
+		this.code = 1001;
+	}
+};
+var HocuspocusProvider = class extends EventEmitter {
+	constructor(configuration) {
+		super();
+		this.configuration = {
+			name: "",
+			document: void 0,
+			awareness: void 0,
+			token: null,
+			forceSyncInterval: false,
+			onAuthenticated: () => null,
+			onAuthenticationFailed: () => null,
+			onOpen: () => null,
+			onConnect: () => null,
+			onMessage: () => null,
+			onOutgoingMessage: () => null,
+			onSynced: () => null,
+			onStatus: () => null,
+			onDisconnect: () => null,
+			onClose: () => null,
+			onDestroy: () => null,
+			onAwarenessUpdate: () => null,
+			onAwarenessChange: () => null,
+			onStateless: () => null,
+			onUnsyncedChanges: () => null
+		};
+		this.isSynced = false;
+		this.unsyncedChanges = 0;
+		this.isAuthenticated = false;
+		this.authorizedScope = void 0;
+		this.manageSocket = false;
+		this._isAttached = false;
+		this.intervals = { forceSync: null };
+		this.boundDocumentUpdateHandler = this.documentUpdateHandler.bind(this);
+		this.boundAwarenessUpdateHandler = this.awarenessUpdateHandler.bind(this);
+		this.boundPageHide = this.pageHide.bind(this);
+		this.boundOnOpen = this.onOpen.bind(this);
+		this.boundOnClose = this.onClose.bind(this);
+		this.forwardConnect = () => this.emit("connect");
+		this.forwardStatus = (e) => this.emit("status", e);
+		this.forwardClose = (e) => this.emit("close", e);
+		this.forwardDisconnect = (e) => this.emit("disconnect", e);
+		this.forwardDestroy = () => this.emit("destroy");
+		this.setConfiguration(configuration);
+		this.configuration.document = configuration.document ? configuration.document : new Y.Doc();
+		this.configuration.awareness = configuration.awareness !== void 0 ? configuration.awareness : new Awareness(this.document);
+		this.on("open", this.configuration.onOpen);
+		this.on("message", this.configuration.onMessage);
+		this.on("outgoingMessage", this.configuration.onOutgoingMessage);
+		this.on("synced", this.configuration.onSynced);
+		this.on("destroy", this.configuration.onDestroy);
+		this.on("awarenessUpdate", this.configuration.onAwarenessUpdate);
+		this.on("awarenessChange", this.configuration.onAwarenessChange);
+		this.on("stateless", this.configuration.onStateless);
+		this.on("unsyncedChanges", this.configuration.onUnsyncedChanges);
+		this.on("authenticated", this.configuration.onAuthenticated);
+		this.on("authenticationFailed", this.configuration.onAuthenticationFailed);
+		this.awareness?.on("update", () => {
+			this.emit("awarenessUpdate", { states: awarenessStatesToArray(this.awareness.getStates()) });
+		});
+		this.awareness?.on("change", () => {
+			this.emit("awarenessChange", { states: awarenessStatesToArray(this.awareness.getStates()) });
+		});
+		this.document.on("update", this.boundDocumentUpdateHandler);
+		this.awareness?.on("update", this.boundAwarenessUpdateHandler);
+		this.registerEventListeners();
+		if (this.configuration.forceSyncInterval && typeof this.configuration.forceSyncInterval === "number") this.intervals.forceSync = setInterval(this.forceSync.bind(this), this.configuration.forceSyncInterval);
+		if (this.manageSocket) this.attach();
+	}
+	setConfiguration(configuration = {}) {
+		if (!configuration.websocketProvider) {
+			this.manageSocket = true;
+			this.configuration.websocketProvider = new HocuspocusProviderWebsocket(configuration);
+		}
+		this.configuration = {
+			...this.configuration,
+			...configuration
+		};
+	}
+	get document() {
+		return this.configuration.document;
+	}
+	get isAttached() {
+		return this._isAttached;
+	}
+	get awareness() {
+		return this.configuration.awareness;
+	}
+	get hasUnsyncedChanges() {
+		return this.unsyncedChanges > 0;
+	}
+	resetUnsyncedChanges() {
+		this.unsyncedChanges = 1;
+		this.emit("unsyncedChanges", { number: this.unsyncedChanges });
+	}
+	incrementUnsyncedChanges() {
+		this.unsyncedChanges += 1;
+		this.emit("unsyncedChanges", { number: this.unsyncedChanges });
+	}
+	decrementUnsyncedChanges() {
+		if (this.unsyncedChanges > 0) this.unsyncedChanges -= 1;
+		if (this.unsyncedChanges === 0) this.synced = true;
+		this.emit("unsyncedChanges", { number: this.unsyncedChanges });
+	}
+	forceSync() {
+		this.resetUnsyncedChanges();
+		this.send(SyncStepOneMessage, {
+			document: this.document,
+			documentName: this.configuration.name
+		});
+	}
+	pageHide() {
+		if (this.awareness) removeAwarenessStates(this.awareness, [this.document.clientID], "page hide");
+	}
+	registerEventListeners() {
+		if (typeof window === "undefined" || !("addEventListener" in window)) return;
+		window.addEventListener("pagehide", this.boundPageHide);
+	}
+	sendStateless(payload) {
+		this.send(StatelessMessage, {
+			documentName: this.configuration.name,
+			payload
+		});
+	}
+	async sendToken() {
+		let token;
+		try {
+			token = await this.getToken();
+		} catch (error) {
+			this.permissionDeniedHandler(`Failed to get token during sendToken(): ${error}`);
+			return;
+		}
+		this.send(AuthenticationMessage, {
+			token: token ?? "",
+			documentName: this.configuration.name
+		});
+	}
+	documentUpdateHandler(update, origin) {
+		if (origin === this) return;
+		this.incrementUnsyncedChanges();
+		this.send(UpdateMessage, {
+			update,
+			documentName: this.configuration.name
+		});
+	}
+	awarenessUpdateHandler({ added, updated, removed }, origin) {
+		const changedClients = added.concat(updated).concat(removed);
+		this.send(AwarenessMessage, {
+			awareness: this.awareness,
+			clients: changedClients,
+			documentName: this.configuration.name
+		});
+	}
+	/**
+	* Indicates whether a first handshake with the server has been established
+	*
+	* Note: this does not mean all updates from the client have been persisted to the backend. For this,
+	* use `hasUnsyncedChanges`.
+	*/
+	get synced() {
+		return this.isSynced;
+	}
+	set synced(state) {
+		if (this.isSynced === state) return;
+		this.isSynced = state;
+		if (state) this.emit("synced", { state });
+	}
+	receiveStateless(payload) {
+		this.emit("stateless", { payload });
+	}
+	async connect() {
+		if (this.manageSocket) return this.configuration.websocketProvider.connect();
+		console.warn("HocuspocusProvider::connect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.");
+	}
+	disconnect() {
+		if (this.manageSocket) return this.configuration.websocketProvider.disconnect();
+		console.warn("HocuspocusProvider::disconnect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.");
+	}
+	async onOpen(event) {
+		this.isAuthenticated = false;
+		this.emit("open", { event });
+		await this.sendToken();
+		this.startSync();
+	}
+	async getToken() {
+		if (typeof this.configuration.token === "function") return await this.configuration.token();
+		return this.configuration.token;
+	}
+	startSync() {
+		this.resetUnsyncedChanges();
+		this.send(SyncStepOneMessage, {
+			document: this.document,
+			documentName: this.configuration.name
+		});
+		if (this.awareness && this.awareness.getLocalState() !== null) this.send(AwarenessMessage, {
+			awareness: this.awareness,
+			clients: [this.document.clientID],
+			documentName: this.configuration.name
+		});
+	}
+	send(message, args) {
+		if (!this._isAttached) return;
+		const messageSender = new MessageSender(message, args);
+		this.emit("outgoingMessage", { message: messageSender.message });
+		messageSender.send(this.configuration.websocketProvider);
+	}
+	onMessage(event) {
+		const message = new IncomingMessage(event.data);
+		const documentName = message.readVarString();
+		message.writeVarString(documentName);
+		this.emit("message", {
+			event,
+			message: new IncomingMessage(event.data)
+		});
+		new MessageReceiver(message).apply(this, true);
+	}
+	onClose() {
+		this.isAuthenticated = false;
+		this.synced = false;
+		if (this.awareness) removeAwarenessStates(this.awareness, Array.from(this.awareness.getStates().keys()).filter((client) => client !== this.document.clientID), this);
+	}
+	destroy() {
+		this.emit("destroy");
+		if (this.intervals.forceSync) clearInterval(this.intervals.forceSync);
+		if (this.awareness) {
+			removeAwarenessStates(this.awareness, [this.document.clientID], "provider destroy");
+			this.awareness.off("update", this.boundAwarenessUpdateHandler);
+			this.awareness.destroy();
+		}
+		this.document.off("update", this.boundDocumentUpdateHandler);
+		this.removeAllListeners();
+		this.detach();
+		if (this.manageSocket) this.configuration.websocketProvider.destroy();
+		if (typeof window === "undefined" || !("removeEventListener" in window)) return;
+		window.removeEventListener("pagehide", this.boundPageHide);
+	}
+	detach() {
+		this.configuration.websocketProvider.off("connect", this.configuration.onConnect);
+		this.configuration.websocketProvider.off("connect", this.forwardConnect);
+		this.configuration.websocketProvider.off("status", this.forwardStatus);
+		this.configuration.websocketProvider.off("status", this.configuration.onStatus);
+		this.configuration.websocketProvider.off("open", this.boundOnOpen);
+		this.configuration.websocketProvider.off("close", this.boundOnClose);
+		this.configuration.websocketProvider.off("close", this.configuration.onClose);
+		this.configuration.websocketProvider.off("close", this.forwardClose);
+		this.configuration.websocketProvider.off("disconnect", this.configuration.onDisconnect);
+		this.configuration.websocketProvider.off("disconnect", this.forwardDisconnect);
+		this.configuration.websocketProvider.off("destroy", this.configuration.onDestroy);
+		this.configuration.websocketProvider.off("destroy", this.forwardDestroy);
+		this.configuration.websocketProvider.detach(this);
+		this._isAttached = false;
+	}
+	attach() {
+		if (this._isAttached) return;
+		this.configuration.websocketProvider.on("connect", this.configuration.onConnect);
+		this.configuration.websocketProvider.on("connect", this.forwardConnect);
+		this.configuration.websocketProvider.on("status", this.configuration.onStatus);
+		this.configuration.websocketProvider.on("status", this.forwardStatus);
+		this.configuration.websocketProvider.on("open", this.boundOnOpen);
+		this.configuration.websocketProvider.on("close", this.boundOnClose);
+		this.configuration.websocketProvider.on("close", this.configuration.onClose);
+		this.configuration.websocketProvider.on("close", this.forwardClose);
+		this.configuration.websocketProvider.on("disconnect", this.configuration.onDisconnect);
+		this.configuration.websocketProvider.on("disconnect", this.forwardDisconnect);
+		this.configuration.websocketProvider.on("destroy", this.configuration.onDestroy);
+		this.configuration.websocketProvider.on("destroy", this.forwardDestroy);
+		this.configuration.websocketProvider.attach(this);
+		this._isAttached = true;
+	}
+	permissionDeniedHandler(reason) {
+		this.emit("authenticationFailed", { reason });
+		this.isAuthenticated = false;
+	}
+	authenticatedHandler(scope) {
+		this.isAuthenticated = true;
+		this.authorizedScope = scope;
+		this.emit("authenticated", { scope });
+	}
+	setAwarenessField(key, value) {
+		if (!this.awareness) throw new AwarenessError(`Cannot set awareness field "${key}" to ${JSON.stringify(value)}. You have disabled Awareness for this provider by explicitly passing awareness: null in the provider configuration.`);
+		this.awareness.setLocalStateField(key, value);
+	}
+};
+
+//#endregion
+//#region packages/provider/src/OfflineStore.ts
+const DB_VERSION = 1;
+function idbAvailable() {
+	return typeof globalThis !== "undefined" && "indexedDB" in globalThis;
+}
+function openDb$1(docId) {
+	return new Promise((resolve, reject) => {
+		const req = globalThis.indexedDB.open(`abracadabra:${docId}`, DB_VERSION);
+		req.onupgradeneeded = (event) => {
+			const db = event.target.result;
+			if (!db.objectStoreNames.contains("updates")) db.createObjectStore("updates", { autoIncrement: true });
+			if (!db.objectStoreNames.contains("meta")) db.createObjectStore("meta");
+			if (!db.objectStoreNames.contains("subdoc_queue")) db.createObjectStore("subdoc_queue", { keyPath: "childId" });
+		};
+		req.onsuccess = () => resolve(req.result);
+		req.onerror = () => reject(req.error);
+	});
+}
+function txPromise(store, request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error);
+	});
+}
+var OfflineStore = class {
+	constructor(docId) {
+		this.db = null;
+		this.docId = docId;
+	}
+	async getDb() {
+		if (!idbAvailable()) return null;
+		if (!this.db) this.db = await openDb$1(this.docId).catch(() => null);
+		return this.db;
+	}
+	async persistUpdate(update) {
+		const db = await this.getDb();
+		if (!db) return;
+		const store = db.transaction("updates", "readwrite").objectStore("updates");
+		await txPromise(store, store.add(update));
+	}
+	async getPendingUpdates() {
+		const db = await this.getDb();
+		if (!db) return [];
+		return new Promise((resolve, reject) => {
+			const req = db.transaction("updates", "readonly").objectStore("updates").getAll();
+			req.onsuccess = () => resolve(req.result);
+			req.onerror = () => reject(req.error);
+		});
+	}
+	async clearPendingUpdates() {
+		const db = await this.getDb();
+		if (!db) return;
+		const tx = db.transaction("updates", "readwrite");
+		await txPromise(tx.objectStore("updates"), tx.objectStore("updates").clear());
+	}
+	async getStateVector() {
+		const db = await this.getDb();
+		if (!db) return null;
+		const tx = db.transaction("meta", "readonly");
+		return await txPromise(tx.objectStore("meta"), tx.objectStore("meta").get("sv")) ?? null;
+	}
+	async saveStateVector(sv) {
+		const db = await this.getDb();
+		if (!db) return;
+		const tx = db.transaction("meta", "readwrite");
+		await txPromise(tx.objectStore("meta"), tx.objectStore("meta").put(sv, "sv"));
+	}
+	async getPermissionSnapshot() {
+		const db = await this.getDb();
+		if (!db) return null;
+		const tx = db.transaction("meta", "readonly");
+		return await txPromise(tx.objectStore("meta"), tx.objectStore("meta").get("role")) ?? null;
+	}
+	async savePermissionSnapshot(role) {
+		const db = await this.getDb();
+		if (!db) return;
+		const tx = db.transaction("meta", "readwrite");
+		await txPromise(tx.objectStore("meta"), tx.objectStore("meta").put(role, "role"));
+	}
+	async queueSubdoc(entry) {
+		const db = await this.getDb();
+		if (!db) return;
+		const tx = db.transaction("subdoc_queue", "readwrite");
+		await txPromise(tx.objectStore("subdoc_queue"), tx.objectStore("subdoc_queue").put(entry));
+	}
+	async getPendingSubdocs() {
+		const db = await this.getDb();
+		if (!db) return [];
+		return new Promise((resolve, reject) => {
+			const req = db.transaction("subdoc_queue", "readonly").objectStore("subdoc_queue").getAll();
+			req.onsuccess = () => resolve(req.result);
+			req.onerror = () => reject(req.error);
+		});
+	}
+	async removeSubdocFromQueue(childId) {
+		const db = await this.getDb();
+		if (!db) return;
+		const tx = db.transaction("subdoc_queue", "readwrite");
+		await txPromise(tx.objectStore("subdoc_queue"), tx.objectStore("subdoc_queue").delete(childId));
+	}
+	destroy() {
+		this.db?.close();
+		this.db = null;
+	}
+};
+
+//#endregion
+//#region packages/provider/src/OutgoingMessages/SubdocMessage.ts
+/**
+* Registers a new subdocument with the Abracadabra server.
+*
+* Wire format (consumed by handle_subdoc in sync.rs):
+*   [ParentDocName: VarString] [MSG_SUBDOC(4): VarUint] [childDocumentName: VarString]
+*
+* The server responds with a MSG_STATELESS JSON frame:
+*   { type: "subdoc_registered", child_id, parent_id }
+* which AbracadabraProvider intercepts in receiveStateless().
+*/
+var SubdocMessage = class extends OutgoingMessage {
+	constructor(..._args) {
+		super(..._args);
+		this.type = MessageType.Subdoc;
+		this.description = "SubdocRegistration";
+	}
+	get(args) {
+		if (!args.documentName) throw new Error("SubdocMessage requires `documentName` (parent id).");
+		if (!args.childDocumentName) throw new Error("SubdocMessage requires `childDocumentName`.");
+		writeVarString(this.encoder, args.documentName);
+		writeVarUint(this.encoder, this.type);
+		writeVarString(this.encoder, args.childDocumentName);
+		return this.encoder;
+	}
+};
+
+//#endregion
+//#region packages/provider/src/AbracadabraProvider.ts
+/**
+* AbracadabraProvider extends HocuspocusProvider with:
+*
+*  1. Subdocument lifecycle – intercepts Y.Doc subdoc events and syncs them
+*     with the server via MSG_SUBDOC (4) frames.  Child documents get their
+*     own AbracadabraProvider instances sharing the same WebSocket connection.
+*
+*  2. Offline-first – persists CRDT updates to IndexedDB so they survive
+*     page reloads and network outages.  On reconnect, pending updates are
+*     flushed before resuming normal sync.
+*
+*  3. Permission snapshotting – stores the resolved role locally so the UI
+*     can gate write operations without a network round-trip.  Role is
+*     refreshed from the server on every reconnect.
+*/
+var AbracadabraProvider = class AbracadabraProvider extends HocuspocusProvider {
+	constructor(configuration) {
+		super(configuration);
+		this.effectiveRole = null;
+		this.childProviders = /* @__PURE__ */ new Map();
+		this.boundHandleYSubdocsChange = this.handleYSubdocsChange.bind(this);
+		this.abracadabraConfig = configuration;
+		this.subdocLoading = configuration.subdocLoading ?? "lazy";
+		this.offlineStore = configuration.disableOfflineStore ? null : new OfflineStore(configuration.name);
+		this.on("subdocRegistered", configuration.onSubdocRegistered ?? (() => null));
+		this.on("subdocLoaded", configuration.onSubdocLoaded ?? (() => null));
+		this.document.on("subdocs", this.boundHandleYSubdocsChange);
+		this.on("synced", () => this.flushPendingUpdates());
+		this.restorePermissionSnapshot();
+	}
+	authenticatedHandler(scope) {
+		super.authenticatedHandler(scope);
+		this.effectiveRole = scope === "read-write" ? "editor" : "viewer";
+		this.offlineStore?.savePermissionSnapshot(this.effectiveRole);
+	}
+	/**
+	* Override sendToken to send an identity declaration instead of a JWT
+	* when cryptoIdentity is configured.
+	*/
+	async sendToken() {
+		const { cryptoIdentity } = this.abracadabraConfig;
+		if (cryptoIdentity) {
+			const id = typeof cryptoIdentity === "function" ? await cryptoIdentity() : cryptoIdentity;
+			const json = JSON.stringify({
+				type: "identity",
+				username: id.username,
+				publicKey: id.publicKey
+			});
+			this.send(AuthenticationMessage, {
+				token: json,
+				documentName: this.configuration.name
+			});
+		} else await super.sendToken();
+	}
+	/** Handle an auth_challenge message from the server. */
+	async handleAuthChallenge(challenge, expiresAt) {
+		const { signChallenge, cryptoIdentity } = this.abracadabraConfig;
+		if (!signChallenge || !cryptoIdentity) {
+			this.permissionDeniedHandler("No signChallenge callback configured");
+			return;
+		}
+		if (Date.now() > expiresAt * 1e3) {
+			this.permissionDeniedHandler("Challenge expired");
+			return;
+		}
+		const id = typeof cryptoIdentity === "function" ? await cryptoIdentity() : cryptoIdentity;
+		const signature = await signChallenge(challenge);
+		const proof = JSON.stringify({
+			type: "proof",
+			username: id.username,
+			publicKey: id.publicKey,
+			signature,
+			challenge
+		});
+		this.send(AuthenticationMessage, {
+			token: proof,
+			documentName: this.configuration.name
+		});
+	}
+	async restorePermissionSnapshot() {
+		if (!this.offlineStore) return;
+		const role = await this.offlineStore.getPermissionSnapshot();
+		if (role && !this.effectiveRole) this.effectiveRole = role;
+	}
+	get canWrite() {
+		return this.effectiveRole === "owner" || this.effectiveRole === "editor";
+	}
+	/**
+	* Called when a MSG_STATELESS frame arrives from the server.
+	* Abracadabra uses stateless frames to deliver subdoc confirmations
+	* ({ type: "subdoc_registered", child_id, parent_id }).
+	*/
+	receiveStateless(payload) {
+		let parsed;
+		try {
+			parsed = JSON.parse(payload);
+		} catch {
+			super.receiveStateless(payload);
+			return;
+		}
+		const msg = parsed;
+		if (msg.type === "auth_challenge" && msg.challenge && msg.expiresAt) {
+			this.handleAuthChallenge(msg.challenge, msg.expiresAt).catch(() => null);
+			return;
+		}
+		if (msg.type === "subdoc_registered" && msg.child_id && msg.parent_id) {
+			const event = {
+				childId: msg.child_id,
+				parentId: msg.parent_id
+			};
+			this.emit("subdocRegistered", event);
+			this.offlineStore?.removeSubdocFromQueue(msg.child_id);
+			if (this.subdocLoading === "eager") this.loadChild(msg.child_id);
+			return;
+		}
+		super.receiveStateless(payload);
+	}
+	/**
+	* Y.Doc emits 'subdocs' whenever subdocuments are added, removed, or loaded.
+	* We intercept additions to register them with the Abracadabra server.
+	*/
+	handleYSubdocsChange({ added, removed }) {
+		for (const subdoc of added) this.registerSubdoc(subdoc);
+		for (const subdoc of removed) this.unloadChild(subdoc.guid);
+	}
+	/**
+	* Send a subdoc registration frame to the server.
+	* If offline the event is queued in IndexedDB and replayed on reconnect.
+	*/
+	registerSubdoc(subdoc) {
+		const childId = subdoc.guid;
+		if (this.isConnected) this.send(SubdocMessage, {
+			documentName: this.configuration.name,
+			childDocumentName: childId
+		});
+		else this.offlineStore?.queueSubdoc({
+			childId,
+			parentId: this.configuration.name,
+			createdAt: Date.now()
+		});
+	}
+	/**
+	* Create (or return cached) a child AbracadabraProvider for a given
+	* child document id.  The child shares the parent's WebSocket connection.
+	*/
+	async loadChild(childId) {
+		if (this.childProviders.has(childId)) return this.childProviders.get(childId);
+		const childDoc = new Y.Doc({ guid: childId });
+		const parentWsp = this.configuration.websocketProvider;
+		const childProvider = new AbracadabraProvider({
+			name: childId,
+			document: childDoc,
+			url: parentWsp.configuration.url,
+			WebSocketPolyfill: parentWsp.configuration.WebSocketPolyfill,
+			token: this.configuration.token,
+			subdocLoading: this.subdocLoading,
+			disableOfflineStore: this.abracadabraConfig.disableOfflineStore
+		});
+		this.childProviders.set(childId, childProvider);
+		this.emit("subdocLoaded", {
+			childId,
+			provider: childProvider
+		});
+		return childProvider;
+	}
+	unloadChild(childId) {
+		const provider = this.childProviders.get(childId);
+		if (provider) {
+			provider.destroy();
+			this.childProviders.delete(childId);
+		}
+	}
+	/** Return all currently-loaded child providers. */
+	get children() {
+		return this.childProviders;
+	}
+	/**
+	* Override to persist every local update to IndexedDB before sending it
+	* over the wire, ensuring no work is lost during connection outages.
+	*/
+	documentUpdateHandler(update, origin) {
+		if (origin === this) return;
+		this.offlineStore?.persistUpdate(update).catch(() => null);
+		super.documentUpdateHandler(update, origin);
+	}
+	/**
+	* After reconnect + sync, flush any updates that were generated while
+	* offline, then flush any queued subdoc registrations.
+	*/
+	async flushPendingUpdates() {
+		if (!this.offlineStore) return;
+		const updates = await this.offlineStore.getPendingUpdates();
+		if (updates.length > 0) {
+			for (const update of updates) this.send(UpdateMessage, {
+				update,
+				documentName: this.configuration.name
+			});
+			await this.offlineStore.clearPendingUpdates();
+		}
+		const pendingSubdocs = await this.offlineStore.getPendingSubdocs();
+		for (const { childId } of pendingSubdocs) this.send(SubdocMessage, {
+			documentName: this.configuration.name,
+			childDocumentName: childId
+		});
+	}
+	get isConnected() {
+		return this.configuration.websocketProvider.status === "connected";
+	}
+	destroy() {
+		this.document.off("subdocs", this.boundHandleYSubdocsChange);
+		for (const provider of this.childProviders.values()) provider.destroy();
+		this.childProviders.clear();
+		this.offlineStore?.destroy();
+		this.offlineStore = null;
+		super.destroy();
+	}
+};
+
+//#endregion
+//#region node_modules/@noble/hashes/esm/utils.js
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+function isBytes(a) {
+	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+/** Asserts something is positive integer. */
+function anumber(n) {
+	if (!Number.isSafeInteger(n) || n < 0) throw new Error("positive integer expected, got " + n);
+}
+/** Asserts something is Uint8Array. */
+function abytes(b, ...lengths) {
+	if (!isBytes(b)) throw new Error("Uint8Array expected");
+	if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+/** Asserts something is hash */
+function ahash(h) {
+	if (typeof h !== "function" || typeof h.create !== "function") throw new Error("Hash should be wrapped by utils.createHasher");
+	anumber(h.outputLen);
+	anumber(h.blockLen);
+}
+/** Asserts a hash instance has not been destroyed / finished */
+function aexists(instance, checkFinished = true) {
+	if (instance.destroyed) throw new Error("Hash instance has been destroyed");
+	if (checkFinished && instance.finished) throw new Error("Hash#digest() has already been called");
+}
+/** Asserts output is properly-sized byte array */
+function aoutput(out, instance) {
+	abytes(out);
+	const min = instance.outputLen;
+	if (out.length < min) throw new Error("digestInto() expects output buffer of length at least " + min);
+}
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+function clean(...arrays) {
+	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
+}
+/** Create DataView of an array for easy byte-level manipulation. */
+function createView(arr) {
+	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** The rotate right (circular right shift) operation for uint32 */
+function rotr(word, shift) {
+	return word << 32 - shift | word >>> shift;
+}
+/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+const isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+const hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
+/**
+* Converts string to bytes using UTF8 encoding.
+* @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+*/
+function utf8ToBytes(str) {
+	if (typeof str !== "string") throw new Error("string expected");
+	return new Uint8Array(new TextEncoder().encode(str));
+}
+/**
+* Normalizes (non-hex) string or Uint8Array to Uint8Array.
+* Warning: when Uint8Array is passed, it would NOT get copied.
+* Keep in mind for future mutable operations.
+*/
+function toBytes(data) {
+	if (typeof data === "string") data = utf8ToBytes(data);
+	abytes(data);
+	return data;
+}
+/** For runtime check if class implements interface */
+var Hash = class {};
+/** Wraps hash function, creating an interface on top of it */
+function createHasher(hashCons) {
+	const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+	const tmp = hashCons();
+	hashC.outputLen = tmp.outputLen;
+	hashC.blockLen = tmp.blockLen;
+	hashC.create = () => hashCons();
+	return hashC;
+}
+
+//#endregion
+//#region node_modules/@noble/hashes/esm/hmac.js
+/**
+* HMAC: RFC2104 message authentication code.
+* @module
+*/
+var HMAC = class extends Hash {
+	constructor(hash, _key) {
+		super();
+		this.finished = false;
+		this.destroyed = false;
+		ahash(hash);
+		const key = toBytes(_key);
+		this.iHash = hash.create();
+		if (typeof this.iHash.update !== "function") throw new Error("Expected instance of class which extends utils.Hash");
+		this.blockLen = this.iHash.blockLen;
+		this.outputLen = this.iHash.outputLen;
+		const blockLen = this.blockLen;
+		const pad = new Uint8Array(blockLen);
+		pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+		for (let i = 0; i < pad.length; i++) pad[i] ^= 54;
+		this.iHash.update(pad);
+		this.oHash = hash.create();
+		for (let i = 0; i < pad.length; i++) pad[i] ^= 106;
+		this.oHash.update(pad);
+		clean(pad);
+	}
+	update(buf) {
+		aexists(this);
+		this.iHash.update(buf);
+		return this;
+	}
+	digestInto(out) {
+		aexists(this);
+		abytes(out, this.outputLen);
+		this.finished = true;
+		this.iHash.digestInto(out);
+		this.oHash.update(out);
+		this.oHash.digestInto(out);
+		this.destroy();
+	}
+	digest() {
+		const out = new Uint8Array(this.oHash.outputLen);
+		this.digestInto(out);
+		return out;
+	}
+	_cloneInto(to) {
+		to || (to = Object.create(Object.getPrototypeOf(this), {}));
+		const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+		to = to;
+		to.finished = finished;
+		to.destroyed = destroyed;
+		to.blockLen = blockLen;
+		to.outputLen = outputLen;
+		to.oHash = oHash._cloneInto(to.oHash);
+		to.iHash = iHash._cloneInto(to.iHash);
+		return to;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+	destroy() {
+		this.destroyed = true;
+		this.oHash.destroy();
+		this.iHash.destroy();
+	}
+};
+/**
+* HMAC: RFC2104 message authentication code.
+* @param hash - function that would be used e.g. sha256
+* @param key - message key
+* @param message - message data
+* @example
+* import { hmac } from '@noble/hashes/hmac';
+* import { sha256 } from '@noble/hashes/sha2';
+* const mac1 = hmac(sha256, 'key', 'message');
+*/
+const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
+hmac.create = (hash, key) => new HMAC(hash, key);
+
+//#endregion
+//#region node_modules/@noble/hashes/esm/hkdf.js
+/**
+* HKDF (RFC 5869): extract + expand in one step.
+* See https://soatok.blog/2021/11/17/understanding-hkdf/.
+* @module
+*/
+/**
+* HKDF-extract from spec. Less important part. `HKDF-Extract(IKM, salt) -> PRK`
+* Arguments position differs from spec (IKM is first one, since it is not optional)
+* @param hash - hash function that would be used (e.g. sha256)
+* @param ikm - input keying material, the initial key
+* @param salt - optional salt value (a non-secret random value)
+*/
+function extract(hash, ikm, salt) {
+	ahash(hash);
+	if (salt === void 0) salt = new Uint8Array(hash.outputLen);
+	return hmac(hash, toBytes(salt), toBytes(ikm));
+}
+const HKDF_COUNTER = /* @__PURE__ */ Uint8Array.from([0]);
+const EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();
+/**
+* HKDF-expand from the spec. The most important part. `HKDF-Expand(PRK, info, L) -> OKM`
+* @param hash - hash function that would be used (e.g. sha256)
+* @param prk - a pseudorandom key of at least HashLen octets (usually, the output from the extract step)
+* @param info - optional context and application specific information (can be a zero-length string)
+* @param length - length of output keying material in bytes
+*/
+function expand(hash, prk, info, length = 32) {
+	ahash(hash);
+	anumber(length);
+	const olen = hash.outputLen;
+	if (length > 255 * olen) throw new Error("Length should be <= 255*HashLen");
+	const blocks = Math.ceil(length / olen);
+	if (info === void 0) info = EMPTY_BUFFER;
+	const okm = new Uint8Array(blocks * olen);
+	const HMAC = hmac.create(hash, prk);
+	const HMACTmp = HMAC._cloneInto();
+	const T = new Uint8Array(HMAC.outputLen);
+	for (let counter = 0; counter < blocks; counter++) {
+		HKDF_COUNTER[0] = counter + 1;
+		HMACTmp.update(counter === 0 ? EMPTY_BUFFER : T).update(info).update(HKDF_COUNTER).digestInto(T);
+		okm.set(T, olen * counter);
+		HMAC._cloneInto(HMACTmp);
+	}
+	HMAC.destroy();
+	HMACTmp.destroy();
+	clean(T, HKDF_COUNTER);
+	return okm.slice(0, length);
+}
+/**
+* HKDF (RFC 5869): derive keys from an initial input.
+* Combines hkdf_extract + hkdf_expand in one step
+* @param hash - hash function that would be used (e.g. sha256)
+* @param ikm - input keying material, the initial key
+* @param salt - optional salt value (a non-secret random value)
+* @param info - optional context and application specific information (can be a zero-length string)
+* @param length - length of output keying material in bytes
+* @example
+* import { hkdf } from '@noble/hashes/hkdf';
+* import { sha256 } from '@noble/hashes/sha2';
+* import { randomBytes } from '@noble/hashes/utils';
+* const inputKey = randomBytes(32);
+* const salt = randomBytes(32);
+* const info = 'application-key';
+* const hk1 = hkdf(sha256, inputKey, salt, info, 32);
+*/
+const hkdf = (hash, ikm, salt, info, length) => expand(hash, extract(hash, ikm, salt), info, length);
+
+//#endregion
+//#region node_modules/@noble/hashes/esm/_md.js
+/**
+* Internal Merkle-Damgard hash utils.
+* @module
+*/
+/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */
+function setBigUint64(view, byteOffset, value, isLE) {
+	if (typeof view.setBigUint64 === "function") return view.setBigUint64(byteOffset, value, isLE);
+	const _32n = BigInt(32);
+	const _u32_max = BigInt(4294967295);
+	const wh = Number(value >> _32n & _u32_max);
+	const wl = Number(value & _u32_max);
+	const h = isLE ? 4 : 0;
+	const l = isLE ? 0 : 4;
+	view.setUint32(byteOffset + h, wh, isLE);
+	view.setUint32(byteOffset + l, wl, isLE);
+}
+/** Choice: a ? b : c */
+function Chi(a, b, c) {
+	return a & b ^ ~a & c;
+}
+/** Majority function, true if any two inputs is true. */
+function Maj(a, b, c) {
+	return a & b ^ a & c ^ b & c;
+}
+/**
+* Merkle-Damgard hash construction base class.
+* Could be used to create MD5, RIPEMD, SHA1, SHA2.
+*/
+var HashMD = class extends Hash {
+	constructor(blockLen, outputLen, padOffset, isLE) {
+		super();
+		this.finished = false;
+		this.length = 0;
+		this.pos = 0;
+		this.destroyed = false;
+		this.blockLen = blockLen;
+		this.outputLen = outputLen;
+		this.padOffset = padOffset;
+		this.isLE = isLE;
+		this.buffer = new Uint8Array(blockLen);
+		this.view = createView(this.buffer);
+	}
+	update(data) {
+		aexists(this);
+		data = toBytes(data);
+		abytes(data);
+		const { view, buffer, blockLen } = this;
+		const len = data.length;
+		for (let pos = 0; pos < len;) {
+			const take = Math.min(blockLen - this.pos, len - pos);
+			if (take === blockLen) {
+				const dataView = createView(data);
+				for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
+				continue;
+			}
+			buffer.set(data.subarray(pos, pos + take), this.pos);
+			this.pos += take;
+			pos += take;
+			if (this.pos === blockLen) {
+				this.process(view, 0);
+				this.pos = 0;
+			}
+		}
+		this.length += data.length;
+		this.roundClean();
+		return this;
+	}
+	digestInto(out) {
+		aexists(this);
+		aoutput(out, this);
+		this.finished = true;
+		const { buffer, view, blockLen, isLE } = this;
+		let { pos } = this;
+		buffer[pos++] = 128;
+		clean(this.buffer.subarray(pos));
+		if (this.padOffset > blockLen - pos) {
+			this.process(view, 0);
+			pos = 0;
+		}
+		for (let i = pos; i < blockLen; i++) buffer[i] = 0;
+		setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+		this.process(view, 0);
+		const oview = createView(out);
+		const len = this.outputLen;
+		if (len % 4) throw new Error("_sha2: outputLen should be aligned to 32bit");
+		const outLen = len / 4;
+		const state = this.get();
+		if (outLen > state.length) throw new Error("_sha2: outputLen bigger than state");
+		for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
+	}
+	digest() {
+		const { buffer, outputLen } = this;
+		this.digestInto(buffer);
+		const res = buffer.slice(0, outputLen);
+		this.destroy();
+		return res;
+	}
+	_cloneInto(to) {
+		to || (to = new this.constructor());
+		to.set(...this.get());
+		const { blockLen, buffer, length, finished, destroyed, pos } = this;
+		to.destroyed = destroyed;
+		to.finished = finished;
+		to.length = length;
+		to.pos = pos;
+		if (length % blockLen) to.buffer.set(buffer);
+		return to;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+};
+/**
+* Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
+* Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
+*/
+/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
+const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	3144134277,
+	1013904242,
+	2773480762,
+	1359893119,
+	2600822924,
+	528734635,
+	1541459225
+]);
+
+//#endregion
+//#region node_modules/@noble/hashes/esm/_u64.js
+/**
+* Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
+* @todo re-check https://issues.chromium.org/issues/42212588
+* @module
+*/
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+	if (le) return {
+		h: Number(n & U32_MASK64),
+		l: Number(n >> _32n & U32_MASK64)
+	};
+	return {
+		h: Number(n >> _32n & U32_MASK64) | 0,
+		l: Number(n & U32_MASK64) | 0
+	};
+}
+function split(lst, le = false) {
+	const len = lst.length;
+	let Ah = new Uint32Array(len);
+	let Al = new Uint32Array(len);
+	for (let i = 0; i < len; i++) {
+		const { h, l } = fromBig(lst[i], le);
+		[Ah[i], Al[i]] = [h, l];
+	}
+	return [Ah, Al];
+}
+
+//#endregion
+//#region node_modules/@noble/hashes/esm/sha2.js
+/**
+* SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
+* SHA256 is the fastest hash implementable in JS, even faster than Blake3.
+* Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
+* [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+* @module
+*/
+/**
+* Round constants:
+* First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)
+*/
+const SHA256_K = /* @__PURE__ */ Uint32Array.from([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+/** Reusable temporary buffer. "W" comes straight from spec. */
+const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA256 = class extends HashMD {
+	constructor(outputLen = 32) {
+		super(64, outputLen, 8, false);
+		this.A = SHA256_IV[0] | 0;
+		this.B = SHA256_IV[1] | 0;
+		this.C = SHA256_IV[2] | 0;
+		this.D = SHA256_IV[3] | 0;
+		this.E = SHA256_IV[4] | 0;
+		this.F = SHA256_IV[5] | 0;
+		this.G = SHA256_IV[6] | 0;
+		this.H = SHA256_IV[7] | 0;
+	}
+	get() {
+		const { A, B, C, D, E, F, G, H } = this;
+		return [
+			A,
+			B,
+			C,
+			D,
+			E,
+			F,
+			G,
+			H
+		];
+	}
+	set(A, B, C, D, E, F, G, H) {
+		this.A = A | 0;
+		this.B = B | 0;
+		this.C = C | 0;
+		this.D = D | 0;
+		this.E = E | 0;
+		this.F = F | 0;
+		this.G = G | 0;
+		this.H = H | 0;
+	}
+	process(view, offset) {
+		for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);
+		for (let i = 16; i < 64; i++) {
+			const W15 = SHA256_W[i - 15];
+			const W2 = SHA256_W[i - 2];
+			const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+			SHA256_W[i] = (rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10) + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+		}
+		let { A, B, C, D, E, F, G, H } = this;
+		for (let i = 0; i < 64; i++) {
+			const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+			const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+			const T2 = (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Maj(A, B, C) | 0;
+			H = G;
+			G = F;
+			F = E;
+			E = D + T1 | 0;
+			D = C;
+			C = B;
+			B = A;
+			A = T1 + T2 | 0;
+		}
+		A = A + this.A | 0;
+		B = B + this.B | 0;
+		C = C + this.C | 0;
+		D = D + this.D | 0;
+		E = E + this.E | 0;
+		F = F + this.F | 0;
+		G = G + this.G | 0;
+		H = H + this.H | 0;
+		this.set(A, B, C, D, E, F, G, H);
+	}
+	roundClean() {
+		clean(SHA256_W);
+	}
+	destroy() {
+		this.set(0, 0, 0, 0, 0, 0, 0, 0);
+		clean(this.buffer);
+	}
+};
+const K512 = split([
+	"0x428a2f98d728ae22",
+	"0x7137449123ef65cd",
+	"0xb5c0fbcfec4d3b2f",
+	"0xe9b5dba58189dbbc",
+	"0x3956c25bf348b538",
+	"0x59f111f1b605d019",
+	"0x923f82a4af194f9b",
+	"0xab1c5ed5da6d8118",
+	"0xd807aa98a3030242",
+	"0x12835b0145706fbe",
+	"0x243185be4ee4b28c",
+	"0x550c7dc3d5ffb4e2",
+	"0x72be5d74f27b896f",
+	"0x80deb1fe3b1696b1",
+	"0x9bdc06a725c71235",
+	"0xc19bf174cf692694",
+	"0xe49b69c19ef14ad2",
+	"0xefbe4786384f25e3",
+	"0x0fc19dc68b8cd5b5",
+	"0x240ca1cc77ac9c65",
+	"0x2de92c6f592b0275",
+	"0x4a7484aa6ea6e483",
+	"0x5cb0a9dcbd41fbd4",
+	"0x76f988da831153b5",
+	"0x983e5152ee66dfab",
+	"0xa831c66d2db43210",
+	"0xb00327c898fb213f",
+	"0xbf597fc7beef0ee4",
+	"0xc6e00bf33da88fc2",
+	"0xd5a79147930aa725",
+	"0x06ca6351e003826f",
+	"0x142929670a0e6e70",
+	"0x27b70a8546d22ffc",
+	"0x2e1b21385c26c926",
+	"0x4d2c6dfc5ac42aed",
+	"0x53380d139d95b3df",
+	"0x650a73548baf63de",
+	"0x766a0abb3c77b2a8",
+	"0x81c2c92e47edaee6",
+	"0x92722c851482353b",
+	"0xa2bfe8a14cf10364",
+	"0xa81a664bbc423001",
+	"0xc24b8b70d0f89791",
+	"0xc76c51a30654be30",
+	"0xd192e819d6ef5218",
+	"0xd69906245565a910",
+	"0xf40e35855771202a",
+	"0x106aa07032bbd1b8",
+	"0x19a4c116b8d2d0c8",
+	"0x1e376c085141ab53",
+	"0x2748774cdf8eeb99",
+	"0x34b0bcb5e19b48a8",
+	"0x391c0cb3c5c95a63",
+	"0x4ed8aa4ae3418acb",
+	"0x5b9cca4f7763e373",
+	"0x682e6ff3d6b2b8a3",
+	"0x748f82ee5defb2fc",
+	"0x78a5636f43172f60",
+	"0x84c87814a1f0ab72",
+	"0x8cc702081a6439ec",
+	"0x90befffa23631e28",
+	"0xa4506cebde82bde9",
+	"0xbef9a3f7b2c67915",
+	"0xc67178f2e372532b",
+	"0xca273eceea26619c",
+	"0xd186b8c721c0c207",
+	"0xeada7dd6cde0eb1e",
+	"0xf57d4f7fee6ed178",
+	"0x06f067aa72176fba",
+	"0x0a637dc5a2c898a6",
+	"0x113f9804bef90dae",
+	"0x1b710b35131c471b",
+	"0x28db77f523047d84",
+	"0x32caab7b40c72493",
+	"0x3c9ebe0a15c9bebc",
+	"0x431d67c49c100d4c",
+	"0x4cc5d4becb3e42b6",
+	"0x597f299cfc657e2a",
+	"0x5fcb6fab3ad6faec",
+	"0x6c44198c4a475817"
+].map((n) => BigInt(n)));
+const SHA512_Kh = K512[0];
+const SHA512_Kl = K512[1];
+/**
+* SHA2-256 hash function from RFC 4634.
+*
+* It is the fastest JS hash, even faster than Blake3.
+* To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+* BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+*/
+const sha256$1 = /* @__PURE__ */ createHasher(() => new SHA256());
+
+//#endregion
+//#region node_modules/@noble/hashes/esm/sha256.js
+/**
+* SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.
+*
+* To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+* BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+*
+* Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+* @module
+* @deprecated
+*/
+/** @deprecated Use import from `noble/hashes/sha2` module */
+const sha256 = sha256$1;
+
+//#endregion
+//#region packages/provider/src/CryptoIdentityKeystore.ts
+/**
+* CryptoIdentityKeystore
+*
+* Per-device Ed25519 keypair, private key protected by WebAuthn PRF + AES-256-GCM.
+* Stored in IndexedDB under "abracadabra:identity" / "identity" / key "current".
+*
+* No private key is ever shared between devices. Each device generates its own
+* keypair, encrypts the private key with the PRF output from its own WebAuthn
+* credential, and stores the ciphertext in IndexedDB.
+*
+* Dependencies: @noble/ed25519, @noble/hashes (for HKDF)
+*/
+function toBase64url(bytes) {
+	return btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function fromBase64url(b64) {
+	const padded = b64.replace(/-/g, "+").replace(/_/g, "/");
+	const padLen = (4 - padded.length % 4) % 4;
+	const padded2 = padded + "=".repeat(padLen);
+	return Uint8Array.from(atob(padded2), (c) => c.charCodeAt(0));
+}
+const DB_NAME = "abracadabra:identity";
+const STORE_NAME = "identity";
+const RECORD_KEY = "current";
+const HKDF_INFO = new TextEncoder().encode("abracadabra-identity-v1");
+function openDb() {
+	return new Promise((resolve, reject) => {
+		const req = indexedDB.open(DB_NAME, 1);
+		req.onupgradeneeded = () => {
+			req.result.createObjectStore(STORE_NAME);
+		};
+		req.onsuccess = () => resolve(req.result);
+		req.onerror = () => reject(req.error);
+	});
+}
+async function dbGet(db) {
+	return new Promise((resolve, reject) => {
+		const req = db.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME).get(RECORD_KEY);
+		req.onsuccess = () => resolve(req.result);
+		req.onerror = () => reject(req.error);
+	});
+}
+async function dbPut(db, value) {
+	return new Promise((resolve, reject) => {
+		const req = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).put(value, RECORD_KEY);
+		req.onsuccess = () => resolve();
+		req.onerror = () => reject(req.error);
+	});
+}
+async function dbDelete(db) {
+	return new Promise((resolve, reject) => {
+		const req = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).delete(RECORD_KEY);
+		req.onsuccess = () => resolve();
+		req.onerror = () => reject(req.error);
+	});
+}
+async function deriveAesKey(prfOutput, salt) {
+	const keyBytes = hkdf(sha256, new Uint8Array(prfOutput), salt, HKDF_INFO, 32);
+	return crypto.subtle.importKey("raw", keyBytes, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+}
+var CryptoIdentityKeystore = class {
+	/**
+	* One-time setup for a device: generates an Ed25519 keypair, creates a
+	* WebAuthn credential with PRF extension, encrypts the private key, and
+	* stores everything in IndexedDB.
+	*
+	* Returns the base64url-encoded public key. The caller must register this
+	* key with the server via POST /auth/register (first device) or
+	* POST /auth/keys (additional device).
+	*
+	* @param username  - The user's account name.
+	* @param rpId      - WebAuthn relying party ID (e.g. "example.com").
+	* @param rpName    - Human-readable relying party name.
+	*/
+	async register(username, rpId, rpName) {
+		const privateKey = ed.utils.randomPrivateKey();
+		const publicKey = await ed.getPublicKeyAsync(privateKey);
+		const salt = crypto.getRandomValues(new Uint8Array(32));
+		const credential = await navigator.credentials.create({ publicKey: {
+			challenge: crypto.getRandomValues(new Uint8Array(32)),
+			rp: {
+				id: rpId,
+				name: rpName
+			},
+			user: {
+				id: new TextEncoder().encode(username),
+				name: username,
+				displayName: username
+			},
+			pubKeyCredParams: [{
+				alg: -7,
+				type: "public-key"
+			}, {
+				alg: -257,
+				type: "public-key"
+			}],
+			authenticatorSelection: { userVerification: "required" },
+			extensions: { prf: { eval: { first: salt.buffer } } }
+		} });
+		if (!credential) throw new Error("WebAuthn credential creation failed");
+		const prfOutput = credential.getClientExtensionResults()?.prf?.results?.first;
+		if (!prfOutput) throw new Error("WebAuthn PRF extension not available on this authenticator. A PRF-capable authenticator (e.g. platform authenticator with PRF support) is required.");
+		const aesKey = await deriveAesKey(prfOutput, salt);
+		const iv = crypto.getRandomValues(new Uint8Array(12));
+		const encryptedPrivateKey = await crypto.subtle.encrypt({
+			name: "AES-GCM",
+			iv
+		}, aesKey, privateKey);
+		const db = await openDb();
+		await dbPut(db, {
+			username,
+			publicKey: toBase64url(publicKey),
+			encryptedPrivateKey,
+			iv,
+			salt,
+			credentialId: credential.rawId
+		});
+		db.close();
+		return toBase64url(publicKey);
+	}
+	/**
+	* Sign a base64url-encoded challenge using the stored Ed25519 private key.
+	*
+	* This triggers a WebAuthn assertion (biometric / PIN prompt) to unlock the
+	* private key via PRF → HKDF → AES-GCM decryption. The private key is
+	* wiped from memory after signing.
+	*
+	* @param challengeB64 - base64url-encoded challenge bytes from the server.
+	* @returns base64url-encoded Ed25519 signature (64 bytes).
+	*/
+	async sign(challengeB64) {
+		const db = await openDb();
+		const stored = await dbGet(db);
+		db.close();
+		if (!stored) throw new Error("No identity stored. Call register() first.");
+		const assertion = await navigator.credentials.get({ publicKey: {
+			challenge: crypto.getRandomValues(new Uint8Array(32)),
+			allowCredentials: [{
+				id: stored.credentialId,
+				type: "public-key"
+			}],
+			userVerification: "required",
+			extensions: { prf: { eval: { first: stored.salt.buffer } } }
+		} });
+		if (!assertion) throw new Error("WebAuthn assertion failed");
+		const prfOutput = assertion.getClientExtensionResults()?.prf?.results?.first;
+		if (!prfOutput) throw new Error("PRF output not available from authenticator");
+		const aesKey = await deriveAesKey(prfOutput, stored.salt);
+		const privateKeyBytes = await crypto.subtle.decrypt({
+			name: "AES-GCM",
+			iv: stored.iv
+		}, aesKey, stored.encryptedPrivateKey);
+		const privateKey = new Uint8Array(privateKeyBytes);
+		const challengeBytes = fromBase64url(challengeB64);
+		const signature = await ed.signAsync(challengeBytes, privateKey);
+		privateKey.fill(0);
+		return toBase64url(signature);
+	}
+	/** Returns the stored base64url public key, or null if no identity exists. */
+	async getPublicKey() {
+		const db = await openDb();
+		const stored = await dbGet(db);
+		db.close();
+		return stored?.publicKey ?? null;
+	}
+	/** Returns the stored username, or null if no identity exists. */
+	async getUsername() {
+		const db = await openDb();
+		const stored = await dbGet(db);
+		db.close();
+		return stored?.username ?? null;
+	}
+	/** Returns true if an identity is stored in IndexedDB. */
+	async hasIdentity() {
+		const db = await openDb();
+		const stored = await dbGet(db);
+		db.close();
+		return stored !== void 0;
+	}
+	/** Remove the stored identity from IndexedDB. */
+	async clear() {
+		const db = await openDb();
+		await dbDelete(db);
+		db.close();
+	}
+};
+
+//#endregion
+export { AbracadabraProvider, AwarenessError, CryptoIdentityKeystore, HocuspocusProvider, HocuspocusProviderWebsocket, MessageType, OfflineStore, SubdocMessage, WebSocketStatus };
+//# sourceMappingURL=hocuspocus-provider.esm.js.map