@hocuspocus/common 3.4.6-rc.0 → 3.4.6-rc.2

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@hocuspocus/common",
 	"description": "shared code for multiple Hocuspocus packages",
-	"version": "3.4.6-rc.0",
+	"version": "3.4.6-rc.2",
 	"homepage": "https://hocuspocus.dev",
 	"keywords": [
 		"hocuspocus"

package/dist/index.js

@@ -1,524 +0,0 @@
-//#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 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 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/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}
-*/
-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}
-*/
-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
-*/
-/**
-* 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 = (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("Unexpected end of array");
-const errorIntegerOutOfRange = create("Integer out of Range");
-/**
-* Create an Uint8Array view of the next `len` bytes and advance the position by `len`.
-*
-* Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
-*            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
-*
-* @function
-* @param {Decoder} decoder The decoder instance
-* @param {number} len The length of bytes to read
-* @return {Uint8Array}
-*/
-const readUint8Array = (decoder, len) => {
-	const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
-	decoder.pos += len;
-	return view;
-};
-/**
-* Read variable length Uint8Array.
-*
-* Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
-*            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
-*
-* @function
-* @param {Decoder} decoder
-* @return {Uint8Array}
-*/
-const readVarUint8Array = (decoder) => readUint8Array(decoder, readVarUint(decoder));
-/**
-* Read one byte as unsigned integer.
-* @function
-* @param {Decoder} decoder The decoder instance
-* @return {number} Unsigned 8-bit integer
-*/
-const readUint8 = (decoder) => decoder.arr[decoder.pos++];
-/**
-* Read unsigned integer (32bit) with variable length.
-* 1/8th of the storage is used as encoding overhead.
-*  * numbers < 2^7 is stored in one bytlength
-*  * numbers < 2^14 is stored in two bylength
-*
-* @function
-* @param {Decoder} decoder
-* @return {number} An unsigned integer.length
-*/
-const readVarUint = (decoder) => {
-	let num = 0;
-	let mult = 1;
-	const len = decoder.arr.length;
-	while (decoder.pos < len) {
-		const r = decoder.arr[decoder.pos++];
-		num = num + (r & BITS7) * mult;
-		mult *= 128;
-		if (r < BIT8) return 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;
-
-//#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 writePermissionDenied = (encoder, reason) => {
-	writeVarUint(encoder, AuthMessageType.PermissionDenied);
-	writeVarString(encoder, reason);
-};
-const writeAuthenticated = (encoder, scope) => {
-	writeVarUint(encoder, AuthMessageType.Authenticated);
-	writeVarString(encoder, scope);
-};
-const writeTokenSyncRequest = (encoder) => {
-	writeVarUint(encoder, AuthMessageType.Token);
-};
-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/CloseEvents.ts
-/**
-* The server is terminating the connection because a data frame was received
-* that is too large.
-* See: https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/code
-*/
-const MessageTooBig = {
-	code: 1009,
-	reason: "Message Too Big"
-};
-/**
-* The server successfully processed the request, asks that the requester reset
-* its document view, and is not returning any content.
-*/
-const ResetConnection = {
-	code: 4205,
-	reason: "Reset Connection"
-};
-/**
-* Similar to Forbidden, but specifically for use when authentication is required and has
-* failed or has not yet been provided.
-*/
-const Unauthorized = {
-	code: 4401,
-	reason: "Unauthorized"
-};
-/**
-* The request contained valid data and was understood by the server, but the server
-* is refusing action.
-*/
-const Forbidden = {
-	code: 4403,
-	reason: "Forbidden"
-};
-/**
-* The server timed out waiting for the request.
-*/
-const ConnectionTimeout = {
-	code: 4408,
-	reason: "Connection Timeout"
-};
-
-//#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
-export { AuthMessageType, ConnectionTimeout, Forbidden, MessageTooBig, ResetConnection, Unauthorized, WsReadyStates, awarenessStatesToArray, readAuthMessage, writeAuthenticated, writeAuthentication, writePermissionDenied, writeTokenSyncRequest };