@hocuspocus/common 3.4.3 → 3.4.5-rc.0

package/dist/hocuspocus-common.esm.js

@@ -1,509 +1,525 @@
+//#region node_modules/lib0/math.js
 /**
- * Common Math expressions.
- *
- * @module math
- */
-
+* 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
- */
+* @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
- */
+* @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;
 
-/* eslint-env browser */
-
+//#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;
-
-/**
- * Utility helpers for working with numbers.
- *
- * @module number
- */
-
-
+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;
-
-/**
- * @param {string} str
- * @return {Uint8Array}
- */
-const _encodeUtf8Polyfill = str => {
-  const encodedString = unescape(encodeURIComponent(str));
-  const len = encodedString.length;
-  const buf = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    buf[i] = /** @type {number} */ (encodedString.codePointAt(i));
-  }
-  return buf
+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 = /** @type {TextEncoder} */ (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null);
-
+const utf8TextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
 /**
- * @param {string} str
- * @return {Uint8Array}
- */
-const _encodeUtf8Native = str => utf8TextEncoder.encode(str);
-
+* @param {string} str
+* @return {Uint8Array}
+*/
+const _encodeUtf8Native = (str) => utf8TextEncoder.encode(str);
 /**
- * @param {string} str
- * @return {Uint8Array}
- */
+* @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 });
-
+let utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
 /* c8 ignore start */
-if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
-  // Safari doesn't handle BOM correctly.
-  // This fixes a bug in Safari 13.0.5 where it produces a BOM the first time it is called.
-  // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the first call and
-  // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the second call
-  // Another issue is that from then on no BOM chars are recognized anymore
-  /* c8 ignore next */
-  utf8TextDecoder = null;
-}
-
-/**
- * Efficient schema-less binary encoding with support for variable length encoding.
- *
- * Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.
- *
- * Encodes numbers in little-endian order (least to most significant byte order)
- * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
- * which is also used in Protocol Buffers.
- *
- * ```js
- * // encoding step
- * const encoder = encoding.createEncoder()
- * encoding.writeVarUint(encoder, 256)
- * encoding.writeVarString(encoder, 'Hello world!')
- * const buf = encoding.toUint8Array(encoder)
- * ```
- *
- * ```js
- * // decoding step
- * const decoder = decoding.createDecoder(buf)
- * decoding.readVarUint(decoder) // => 256
- * decoding.readVarString(decoder) // => 'Hello world!'
- * decoding.hasContent(decoder) // => false - all data is read
- * ```
- *
- * @module encoding
- */
-
-
-/**
- * Write one byte to the encoder.
- *
- * @function
- * @param {Encoder} encoder
- * @param {number} num The byte that is to be encoded.
- */
+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;
+	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.
- */
+* Write a variable length unsigned integer. Max encodable integer is 2^53.
+*
+* @function
+* @param {Encoder} encoder
+* @param {number} num The number that is to be encoded.
+*/
 const writeVarUint = (encoder, num) => {
-  while (num > BITS7) {
-    write(encoder, BIT8 | (BITS7 & num));
-    num = floor(num / 128); // shift >>> 7
-  }
-  write(encoder, BITS7 & num);
+	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(30000);
+* 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.
- */
+* Write a variable length string.
+*
+* @function
+* @param {Encoder} encoder
+* @param {String} str The string that is to be encoded.
+*/
 const _writeVarStringNative = (encoder, str) => {
-  if (str.length < _maxStrBSize) {
-    // We can encode the string into the existing buffer
-    /* c8 ignore next */
-    const written = utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
-    writeVarUint(encoder, written);
-    for (let i = 0; i < written; i++) {
-      write(encoder, _strBuffer[i]);
-    }
-  } else {
-    writeVarUint8Array(encoder, encodeUtf8(str));
-  }
+	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.
- */
+* Write a variable length string.
+*
+* @function
+* @param {Encoder} encoder
+* @param {String} str The string that is to be encoded.
+*/
 const _writeVarStringPolyfill = (encoder, str) => {
-  const encodedString = unescape(encodeURIComponent(str));
-  const len = encodedString.length;
-  writeVarUint(encoder, len);
-  for (let i = 0; i < len; i++) {
-    write(encoder, /** @type {number} */ (encodedString.codePointAt(i)));
-  }
+	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.
- */
+* Write a variable length string.
+*
+* @function
+* @param {Encoder} encoder
+* @param {String} str The string that is to be encoded.
+*/
 /* c8 ignore next */
-const writeVarString = (utf8TextEncoder && /** @type {any} */ (utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill;
-
-/**
- * Append fixed-length Uint8Array to the encoder.
- *
- * @function
- * @param {Encoder} encoder
- * @param {Uint8Array} uint8Array
- */
+const 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) {
-    // Still something to write, write right half..
-    // Append new buffer
-    encoder.bufs.push(encoder.cbuf);
-    // must have at least size of remaining buffer
-    encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
-    // copy array
-    encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
-    encoder.cpos = rightCopyLen;
-  }
+	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
- */
+* Append an Uint8Array to Encoder.
+*
+* @function
+* @param {Encoder} encoder
+* @param {Uint8Array} uint8Array
+*/
 const writeVarUint8Array = (encoder, uint8Array) => {
-  writeVarUint(encoder, uint8Array.byteLength);
-  writeUint8Array(encoder, uint8Array);
+	writeVarUint(encoder, uint8Array.byteLength);
+	writeUint8Array(encoder, uint8Array);
 };
 
+//#endregion
+//#region node_modules/lib0/error.js
 /**
- * Error helpers.
- *
- * @module error
- */
-
+* Error helpers.
+*
+* @module error
+*/
 /**
- * @param {string} s
- * @return {Error}
- */
+* @param {string} s
+* @return {Error}
+*/
 /* c8 ignore next */
-const create = s => new Error(s);
-
-/**
- * Efficient schema-less binary decoding with support for variable length encoding.
- *
- * Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.
- *
- * Encodes numbers in little-endian order (least to most significant byte order)
- * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
- * which is also used in Protocol Buffers.
- *
- * ```js
- * // encoding step
- * const encoder = encoding.createEncoder()
- * encoding.writeVarUint(encoder, 256)
- * encoding.writeVarString(encoder, 'Hello world!')
- * const buf = encoding.toUint8Array(encoder)
- * ```
- *
- * ```js
- * // decoding step
- * const decoder = decoding.createDecoder(buf)
- * decoding.readVarUint(decoder) // => 256
- * decoding.readVarString(decoder) // => 'Hello world!'
- * decoding.hasContent(decoder) // => false - all data is read
- * ```
- *
- * @module decoding
- */
-
-
-const errorUnexpectedEndOfArray = create('Unexpected end of array');
-const errorIntegerOutOfRange = create('Integer out of Range');
-
-/**
- * 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 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
+	const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+	decoder.pos += len;
+	return view;
 };
-
-/**
- * Read variable length Uint8Array.
- *
- * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
- *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
- *
- * @function
- * @param {Decoder} decoder
- * @return {Uint8Array}
- */
-const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint(decoder));
-
 /**
- * Read one byte as unsigned integer.
- * @function
- * @param {Decoder} decoder The decoder instance
- * @return {number} Unsigned 8-bit integer
- */
-const readUint8 = decoder => decoder.arr[decoder.pos++];
-
-/**
- * Read unsigned integer (32bit) with variable length.
- * 1/8th of the storage is used as encoding overhead.
- *  * numbers < 2^7 is stored in one bytlength
- *  * numbers < 2^14 is stored in two bylength
- *
- * @function
- * @param {Decoder} decoder
- * @return {number} An unsigned integer.length
- */
-const readVarUint = decoder => {
-  let num = 0;
-  let mult = 1;
-  const len = decoder.arr.length;
-  while (decoder.pos < len) {
-    const r = decoder.arr[decoder.pos++];
-    // num = num | ((r & binary.BITS7) << len)
-    num = num + (r & BITS7) * mult; // shift $r << (7*#iterations) and add it to num
-    mult *= 128; // next iteration, shift 7 "more" to the left
-    if (r < BIT8) {
-      return num
-    }
-    /* c8 ignore start */
-    if (num > MAX_SAFE_INTEGER) {
-      throw errorIntegerOutOfRange
-    }
-    /* c8 ignore stop */
-  }
-  throw errorUnexpectedEndOfArray
+* Read 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.
- */
+* We don't test this function anymore as we use native decoding/encoding by default now.
+* Better not modify this anymore..
+*
+* Transforming utf8 to a string is pretty expensive. The code performs 10x better
+* when String.fromCodePoint is fed with all characters as arguments.
+* But most environments have a maximum number of arguments per functions.
+* For effiency reasons we apply a maximum of 10000 characters at once.
+*
+* @function
+* @param {Decoder} decoder
+* @return {String} The read String.
+*/
 /* c8 ignore start */
-const _readVarStringPolyfill = decoder => {
-  let remainingLen = readVarUint(decoder);
-  if (remainingLen === 0) {
-    return ''
-  } else {
-    let encodedString = String.fromCodePoint(readUint8(decoder)); // remember to decrease remainingLen
-    if (--remainingLen < 100) { // do not create a Uint8Array for small strings
-      while (remainingLen--) {
-        encodedString += String.fromCodePoint(readUint8(decoder));
-      }
-    } else {
-      while (remainingLen > 0) {
-        const nextLen = remainingLen < 10000 ? remainingLen : 10000;
-        // this is dangerous, we create a fresh array view from the existing buffer
-        const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen);
-        decoder.pos += nextLen;
-        // Starting with ES5.1 we can supply a generic array-like object as arguments
-        encodedString += String.fromCodePoint.apply(null, /** @type {any} */ (bytes));
-        remainingLen -= nextLen;
-      }
-    }
-    return decodeURIComponent(escape(encodedString))
-  }
+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 =>
-  /** @type any */ (utf8TextDecoder).decode(readVarUint8Array(decoder));
-
 /**
- * Read string of variable length
- * * varUint is used to store the length of the string
- *
- * @function
- * @param {Decoder} decoder
- * @return {String} The read String
- *
- */
+* @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;
 
-var AuthMessageType;
-(function (AuthMessageType) {
-    AuthMessageType[AuthMessageType["Token"] = 0] = "Token";
-    AuthMessageType[AuthMessageType["PermissionDenied"] = 1] = "PermissionDenied";
-    AuthMessageType[AuthMessageType["Authenticated"] = 2] = "Authenticated";
-})(AuthMessageType || (AuthMessageType = {}));
+//#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);
+	writeVarUint(encoder, AuthMessageType.Token);
+	writeVarString(encoder, auth);
 };
 const writePermissionDenied = (encoder, reason) => {
-    writeVarUint(encoder, AuthMessageType.PermissionDenied);
-    writeVarString(encoder, reason);
+	writeVarUint(encoder, AuthMessageType.PermissionDenied);
+	writeVarString(encoder, reason);
 };
 const writeAuthenticated = (encoder, scope) => {
-    writeVarUint(encoder, AuthMessageType.Authenticated);
-    writeVarString(encoder, scope);
+	writeVarUint(encoder, AuthMessageType.Authenticated);
+	writeVarString(encoder, scope);
 };
 const writeTokenSyncRequest = (encoder) => {
-    writeVarUint(encoder, AuthMessageType.Token);
+	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;
-        }
-    }
+	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
- */
+* 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",
+	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.
- */
+* 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",
+	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.
- */
+* 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",
+	code: 4401,
+	reason: "Unauthorized"
 };
 /**
- * The request contained valid data and was understood by the server, but the server
- * is refusing action.
- */
+* The request contained valid data and was understood by the server, but the server
+* is refusing action.
+*/
 const Forbidden = {
-    code: 4403,
-    reason: "Forbidden",
+	code: 4403,
+	reason: "Forbidden"
 };
 /**
- * The server timed out waiting for the request.
- */
+* The server timed out waiting for the request.
+*/
 const ConnectionTimeout = {
-    code: 4408,
-    reason: "Connection Timeout",
+	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,
-        };
-    });
+	return Array.from(states.entries()).map(([key, value]) => {
+		return {
+			clientId: key,
+			...value
+		};
+	});
 };
 
-/**
- * State of the WebSocket connection.
- * https://developer.mozilla.org/de/docs/Web/API/WebSocket/readyState
- */
-var WsReadyStates;
-(function (WsReadyStates) {
-    WsReadyStates[WsReadyStates["Connecting"] = 0] = "Connecting";
-    WsReadyStates[WsReadyStates["Open"] = 1] = "Open";
-    WsReadyStates[WsReadyStates["Closing"] = 2] = "Closing";
-    WsReadyStates[WsReadyStates["Closed"] = 3] = "Closed";
-})(WsReadyStates || (WsReadyStates = {}));
-
+//#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 };
-//# sourceMappingURL=hocuspocus-common.esm.js.map
+//# sourceMappingURL=hocuspocus-common.esm.js.map