zeed 1.3.0 → 1.4.0

package/dist/common/bin/lib0/encoding.cjs

@@ -1,2 +1,405 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`}),require(`./binary.cjs`);const e=require(`./create.cjs`),t=require(`./string.cjs`);var n=class{cpos;cbuf;bufs;constructor(){this.cpos=0,this.cbuf=new Uint8Array(100),this.bufs=[]}};function r(){return new n}function i(e){let t=e.cpos;for(let n=0;n<e.bufs.length;n++)t+=e.bufs[n].length;return t}function a(t){let n=new Uint8Array(i(t)),r=0;for(let e=0;e<t.bufs.length;e++){let i=t.bufs[e];n.set(i,r),r+=i.length}return n.set(e.createUint8ArrayViewFromArrayBuffer(t.cbuf.buffer,0,t.cpos),r),n}function o(t,n){let r=t.cbuf.length;r-t.cpos<n&&(t.bufs.push(e.createUint8ArrayViewFromArrayBuffer(t.cbuf.buffer,0,t.cpos)),t.cbuf=new Uint8Array(Math.max(r,n)*2),t.cpos=0)}function s(e,t){let n=e.cbuf.length;e.cpos===n&&(e.bufs.push(e.cbuf),e.cbuf=new Uint8Array(n*2),e.cpos=0),e.cbuf[e.cpos++]=t}function c(e,t,n){let r=null;for(let n=0;n<e.bufs.length&&r===null;n++){let i=e.bufs[n];t<i.length?r=i:t-=i.length}r===null&&(r=e.cbuf),r[t]=n}const l=s,u=c;function d(e,t){s(e,t&255),s(e,t>>>8&255)}function f(e,t,n){c(e,t,n&255),c(e,t+1,n>>>8&255)}function p(e,t){for(let n=0;n<4;n++)s(e,t&255),t>>>=8}function m(e,t){for(let n=3;n>=0;n--)s(e,t>>>8*n&255)}function h(e,t,n){for(let r=0;r<4;r++)c(e,t+r,n&255),n>>>=8}function g(e,t){for(;t>127;)s(e,128|127&t),t=Math.floor(t/128);s(e,127&t)}function _(e){return e===0?1/e<0:e<0}function v(e,t){let n=_(t);for(n&&(t=-t),s(e,(t>63?128:0)|(n?64:0)|63&t),t=Math.floor(t/64);t>0;)s(e,(t>127?128:0)|127&t),t=Math.floor(t/128)}function y(e,t){let n=e.cbuf.length,r=e.cpos,i=Math.min(n-r,t.length),a=t.length-i;e.cbuf.set(t.subarray(0,i),r),e.cpos+=i,a>0&&(e.bufs.push(e.cbuf),e.cbuf=new Uint8Array(Math.max(n*2,a)),e.cbuf.set(t.subarray(i)),e.cpos=a)}function b(e,t){g(e,t.byteLength),y(e,t)}let x,S;function C(e,n){if(x??(x=new Uint8Array(3e4),S=x.length/3),n.length<S){let r=t.getUtf8TextEncoder().encodeInto(n,x).written||0;g(e,r);for(let t=0;t<r;t++)s(e,x[t])}else b(e,t.encodeUtf8(n))}function w(e,t){let n=unescape(encodeURIComponent(t)),r=n.length;g(e,r);for(let t=0;t<r;t++)s(e,n.codePointAt(t))}function T(e,n){return t.getUtf8TextEncoder()?.encodeInto?C(e,n):w(e,n)}function E(e,t){return y(e,a(t))}function D(e,t){o(e,t);let n=new DataView(e.cbuf.buffer,e.cpos,t);return e.cpos+=t,n}function O(e,t){return D(e,4).setFloat32(0,t,!1)}function k(e,t){return D(e,8).setFloat64(0,t,!1)}function A(e,t){return D(e,8).setBigInt64(0,t,!1)}function j(e,t){return D(e,8).setBigUint64(0,t,!1)}let M;function N(e){return M??=new DataView(new ArrayBuffer(4)),M.setFloat32(0,e),M.getFloat32(0)===e}function P(e,t){switch(typeof t){case`string`:s(e,119),T(e,t);break;case`number`:Number.isInteger(t)&&Math.abs(t)<=2147483647?(s(e,125),v(e,t)):N(t)?(s(e,124),O(e,t)):(s(e,123),k(e,t));break;case`bigint`:s(e,122),A(e,t);break;case`object`:if(t===null)s(e,126);else if(Array.isArray(t)){s(e,117),g(e,t.length);for(let n=0;n<t.length;n++)P(e,t[n])}else if(t instanceof Uint8Array)s(e,116),b(e,t);else{s(e,118);let n=Object.keys(t);n.sort(),g(e,n.length);for(let r=0;r<n.length;r++){let i=n[r];T(e,i),P(e,t[i])}}break;case`boolean`:s(e,t?120:121);break;default:s(e,127)}}exports.BinEncoder=n,exports.createBinEncoder=r,exports.encodeToUint8Array=a,exports.isNegativeZero=_,exports.length=i,exports.set=c,exports.setUint16=f,exports.setUint32=h,exports.setUint8=u,exports.verifyLen=o,exports.write=s,exports.writeAny=P,exports.writeBigInt64=A,exports.writeBigUint64=j,exports.writeBinaryEncoder=E,exports.writeFloat32=O,exports.writeFloat64=k,exports.writeOnDataView=D,exports.writeUint16=d,exports.writeUint32=p,exports.writeUint32BigEndian=m,exports.writeUint8=l,exports.writeUint8Array=y,exports.writeVarInt=v,exports.writeVarString=T,exports.writeVarUint=g,exports.writeVarUint8Array=b;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_common_bin_lib0_binary = require('./binary.cjs');
+const require_common_bin_lib0_create = require('./create.cjs');
+const require_common_bin_lib0_string = require('./string.cjs');
+
+//#region src/common/bin/lib0/encoding.ts
+/**
+* Original at https://github.com/dmonad/lib0
+*
+* 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 = new encoding.createEncoder()
+* encoding.writeVarUint(encoder, 256)
+* encoding.writeVarString(encoder, 'Hello world!')
+* const buf = encoding.toUint8Array(encoder)
+* ```
+*
+* ```js
+* // decoding step
+* const decoder = new decoding.createDecoder(buf)
+* decoding.readVarUint(decoder) // => 256
+* decoding.readVarString(decoder) // => 'Hello world!'
+* decoding.hasContent(decoder) // => false - all data is read
+* ```
+*/
+/**
+* A BinaryEncoder handles the encoding to an Uint8Array.
+*/
+var BinEncoder = class {
+	cpos;
+	cbuf;
+	bufs;
+	constructor() {
+		this.cpos = 0;
+		this.cbuf = new Uint8Array(100);
+		this.bufs = [];
+	}
+};
+function createBinEncoder() {
+	return new BinEncoder();
+}
+/**
+* The current length of the encoded data.
+*/
+function 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 encodeToUint8Array(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(require_common_bin_lib0_create.createUint8ArrayViewFromArrayBuffer(encoder.cbuf.buffer, 0, encoder.cpos), curPos);
+	return uint8arr;
+}
+/**
+* Verify that it is possible to write `len` bytes wtihout checking. If
+* necessary, a new Buffer with the required length is attached.
+*/
+function verifyLen(encoder, len) {
+	const bufferLen = encoder.cbuf.length;
+	if (bufferLen - encoder.cpos < len) {
+		encoder.bufs.push(require_common_bin_lib0_create.createUint8ArrayViewFromArrayBuffer(encoder.cbuf.buffer, 0, encoder.cpos));
+		encoder.cbuf = new Uint8Array(Math.max(bufferLen, len) * 2);
+		encoder.cpos = 0;
+	}
+}
+/**
+* Write one byte to the encoder.
+*/
+function 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 one byte at a specific position.
+* Position must already be written (i.e. encoder.length > pos)
+*/
+function set(encoder, pos, num) {
+	let buffer = null;
+	for (let i = 0; i < encoder.bufs.length && buffer === null; i++) {
+		const b = encoder.bufs[i];
+		if (pos < b.length) buffer = b;
+		else pos -= b.length;
+	}
+	if (buffer === null) buffer = encoder.cbuf;
+	buffer[pos] = num;
+}
+/**
+* Write one byte as an unsigned integer.
+*/
+const writeUint8 = write;
+/**
+* Write one byte as an unsigned Integer at a specific location.
+*/
+const setUint8 = set;
+/**
+* Write two bytes as an unsigned integer.
+*/
+function writeUint16(encoder, num) {
+	write(encoder, num & 255);
+	write(encoder, num >>> 8 & 255);
+}
+/**
+* Write two bytes as an unsigned integer at a specific location.
+*/
+function setUint16(encoder, pos, num) {
+	set(encoder, pos, num & 255);
+	set(encoder, pos + 1, num >>> 8 & 255);
+}
+/**
+* Write two bytes as an unsigned integer
+*/
+function writeUint32(encoder, num) {
+	for (let i = 0; i < 4; i++) {
+		write(encoder, num & 255);
+		num >>>= 8;
+	}
+}
+/**
+* Write two bytes as an unsigned integer in big endian order.
+* (most significant byte first)
+*/
+function writeUint32BigEndian(encoder, num) {
+	for (let i = 3; i >= 0; i--) write(encoder, num >>> 8 * i & 255);
+}
+/**
+* Write two bytes as an unsigned integer at a specific location.
+*/
+function setUint32(encoder, pos, num) {
+	for (let i = 0; i < 4; i++) {
+		set(encoder, pos + i, num & 255);
+		num >>>= 8;
+	}
+}
+/**
+* Write a variable length unsigned integer. Max encodable integer is 2^53.
+*/
+function writeVarUint(encoder, num) {
+	while (num > 127) {
+		write(encoder, 128 | 127 & num);
+		num = Math.floor(num / 128);
+	}
+	write(encoder, 127 & num);
+}
+function isNegativeZero(n) {
+	return n !== 0 ? n < 0 : 1 / n < 0;
+}
+/**
+* Write a variable length integer.
+*
+* We use the 7th bit instead for signaling that this is a negative number.
+*/
+function writeVarInt(encoder, num) {
+	const isNegative = isNegativeZero(num);
+	if (isNegative) num = -num;
+	write(encoder, (num > 63 ? 128 : 0) | (isNegative ? 64 : 0) | 63 & num);
+	num = Math.floor(num / 64);
+	while (num > 0) {
+		write(encoder, (num > 127 ? 128 : 0) | 127 & num);
+		num = Math.floor(num / 128);
+	}
+}
+/**
+* Append fixed-length Uint8Array to the encoder.
+*/
+function writeUint8Array(encoder, uint8Array) {
+	const bufferLen = encoder.cbuf.length;
+	const cpos = encoder.cpos;
+	const leftCopyLen = Math.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(Math.max(bufferLen * 2, rightCopyLen));
+		encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
+		encoder.cpos = rightCopyLen;
+	}
+}
+/**
+* Append an Uint8Array to BinEncoder.
+*/
+function writeVarUint8Array(encoder, uint8Array) {
+	writeVarUint(encoder, uint8Array.byteLength);
+	writeUint8Array(encoder, uint8Array);
+}
+/**
+* A cache to store strings temporarily
+*/
+let _strBuffer;
+let _maxStrBSize;
+/**
+* Write a variable length string.
+*/
+function _writeVarStringNative(encoder, str) {
+	if (_strBuffer == null) {
+		_strBuffer = new Uint8Array(3e4);
+		_maxStrBSize = _strBuffer.length / 3;
+	}
+	if (str.length < _maxStrBSize) {
+		const written = require_common_bin_lib0_string.getUtf8TextEncoder().encodeInto(str, _strBuffer).written || 0;
+		writeVarUint(encoder, written);
+		for (let i = 0; i < written; i++) write(encoder, _strBuffer[i]);
+	} else writeVarUint8Array(encoder, require_common_bin_lib0_string.encodeUtf8(str));
+}
+/**
+* Write a variable length string.
+*/
+function _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 writeVarString(encoder, str) {
+	return require_common_bin_lib0_string.getUtf8TextEncoder()?.encodeInto ? _writeVarStringNative(encoder, str) : _writeVarStringPolyfill(encoder, str);
+}
+/**
+* Write the content of another Encoder.
+*
+* @TODO: can be improved!
+*        - Note: Should consider that when appending a lot of small Encoders, we should rather clone than referencing the old structure.
+*                Encoders start with a rather big initial buffer.
+*/
+function writeBinaryEncoder(encoder, append) {
+	return writeUint8Array(encoder, encodeToUint8Array(append));
+}
+/**
+* Create an DataView of the next `len` bytes. Use it to write data after
+* calling this function.
+*
+* ```js
+* // write float32 using DataView
+* const dv = writeOnDataView(encoder, 4)
+* dv.setFloat32(0, 1.1)
+* // read float32 using DataView
+* const dv = readFromDataView(encoder, 4)
+* dv.getFloat32(0) // => 1.100000023841858 (leaving it to the reader to find out why this is the correct result)
+* ```
+*/
+function writeOnDataView(encoder, len) {
+	verifyLen(encoder, len);
+	const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len);
+	encoder.cpos += len;
+	return dview;
+}
+function writeFloat32(encoder, num) {
+	return writeOnDataView(encoder, 4).setFloat32(0, num, false);
+}
+function writeFloat64(encoder, num) {
+	return writeOnDataView(encoder, 8).setFloat64(0, num, false);
+}
+function writeBigInt64(encoder, num) {
+	return writeOnDataView(encoder, 8).setBigInt64(0, num, false);
+}
+function writeBigUint64(encoder, num) {
+	return writeOnDataView(encoder, 8).setBigUint64(0, num, false);
+}
+let floatTestBed;
+/**
+* Check if a number can be encoded as a 32 bit float.
+*/
+function isFloat32(num) {
+	floatTestBed ??= /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(4));
+	floatTestBed.setFloat32(0, num);
+	return floatTestBed.getFloat32(0) === num;
+}
+/**
+* Encode data with efficient binary format.
+*
+* Differences to JSON:
+* • Transforms data to a binary format (not to a string)
+* • Encodes undefined, NaN, and ArrayBuffer (these can't be represented in JSON)
+* • Numbers are efficiently encoded either as a variable length integer, as a
+*   32 bit float, as a 64 bit float, or as a 64 bit bigint.
+*
+* Encoding table:
+*
+* | Data Type           | Prefix   | Encoding Method    | Comment |
+* | ------------------- | -------- | ------------------ | ------- |
+* | undefined           | 127      |                    | Functions, symbol, and everything that cannot be identified is encoded as undefined |
+* | null                | 126      |                    | |
+* | integer             | 125      | writeVarInt        | Only encodes 32 bit signed integers |
+* | float32             | 124      | writeFloat32       | |
+* | float64             | 123      | writeFloat64       | |
+* | bigint              | 122      | writeBigInt64      | |
+* | boolean (false)     | 121      |                    | True and false are different data types so we save the following byte |
+* | boolean (true)      | 120      |                    | - 0b01111000 so the last bit determines whether true or false |
+* | string              | 119      | writeVarString     | |
+* | object<string,any>  | 118      | custom             | Writes {length} then {length} key-value pairs |
+* | array<any>          | 117      | custom             | Writes {length} then {length} json values |
+* | Uint8Array          | 116      | writeVarUint8Array | We use Uint8Array for any kind of binary data |
+*
+* Reasons for the decreasing prefix:
+* We need the first bit for extendability (later we may want to encode the
+* prefix with writeVarUint). The remaining 7 bits are divided as follows:
+* [0-30]   the beginning of the data range is used for custom purposes
+*          (defined by the function that uses this library)
+* [31-127] the end of the data range is used for data encoding by
+*          lib0/encoding.js
+*/
+function writeAny(encoder, data) {
+	switch (typeof data) {
+		case "string":
+			write(encoder, 119);
+			writeVarString(encoder, data);
+			break;
+		case "number":
+			if (Number.isInteger(data) && Math.abs(data) <= 2147483647) {
+				write(encoder, 125);
+				writeVarInt(encoder, data);
+			} else if (isFloat32(data)) {
+				write(encoder, 124);
+				writeFloat32(encoder, data);
+			} else {
+				write(encoder, 123);
+				writeFloat64(encoder, data);
+			}
+			break;
+		case "bigint":
+			write(encoder, 122);
+			writeBigInt64(encoder, data);
+			break;
+		case "object":
+			if (data === null) write(encoder, 126);
+			else if (Array.isArray(data)) {
+				write(encoder, 117);
+				writeVarUint(encoder, data.length);
+				for (let i = 0; i < data.length; i++) writeAny(encoder, data[i]);
+			} else if (data instanceof Uint8Array) {
+				write(encoder, 116);
+				writeVarUint8Array(encoder, data);
+			} else {
+				write(encoder, 118);
+				const keys = Object.keys(data);
+				keys.sort();
+				writeVarUint(encoder, keys.length);
+				for (let i = 0; i < keys.length; i++) {
+					const key = keys[i];
+					writeVarString(encoder, key);
+					writeAny(encoder, data[key]);
+				}
+			}
+			break;
+		case "boolean":
+			write(encoder, data ? 120 : 121);
+			break;
+		default: write(encoder, 127);
+	}
+}
+
+//#endregion
+exports.BinEncoder = BinEncoder;
+exports.createBinEncoder = createBinEncoder;
+exports.encodeToUint8Array = encodeToUint8Array;
+exports.isNegativeZero = isNegativeZero;
+exports.length = length;
+exports.set = set;
+exports.setUint16 = setUint16;
+exports.setUint32 = setUint32;
+exports.setUint8 = setUint8;
+exports.verifyLen = verifyLen;
+exports.write = write;
+exports.writeAny = writeAny;
+exports.writeBigInt64 = writeBigInt64;
+exports.writeBigUint64 = writeBigUint64;
+exports.writeBinaryEncoder = writeBinaryEncoder;
+exports.writeFloat32 = writeFloat32;
+exports.writeFloat64 = writeFloat64;
+exports.writeOnDataView = writeOnDataView;
+exports.writeUint16 = writeUint16;
+exports.writeUint32 = writeUint32;
+exports.writeUint32BigEndian = writeUint32BigEndian;
+exports.writeUint8 = writeUint8;
+exports.writeUint8Array = writeUint8Array;
+exports.writeVarInt = writeVarInt;
+exports.writeVarString = writeVarString;
+exports.writeVarUint = writeVarUint;
+exports.writeVarUint8Array = writeVarUint8Array;
 //# sourceMappingURL=encoding.cjs.map

package/dist/common/bin/lib0/encoding.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"encoding.cjs","names":["createUint8ArrayViewFromArrayBuffer","getUtf8TextEncoder","encodeUtf8"],"sources":["../../../../src/common/bin/lib0/encoding.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Efficient schema-less binary encoding with support for variable length encoding.\n *\n * Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.\n *\n * Encodes numbers in little-endian order (least to most significant byte order)\n * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)\n * which is also used in Protocol Buffers.\n *\n * ```js\n * // encoding step\n * const encoder = new encoding.createEncoder()\n * encoding.writeVarUint(encoder, 256)\n * encoding.writeVarString(encoder, 'Hello world!')\n * const buf = encoding.toUint8Array(encoder)\n * ```\n *\n * ```js\n * // decoding step\n * const decoder = new decoding.createDecoder(buf)\n * decoding.readVarUint(decoder) // => 256\n * decoding.readVarString(decoder) // => 'Hello world!'\n * decoding.hasContent(decoder) // => false - all data is read\n * ```\n */\n\nimport { BIT7, BIT8, BITS6, BITS7, BITS8, BITS31 } from './binary'\nimport { createUint8ArrayViewFromArrayBuffer } from './create'\nimport { encodeUtf8, getUtf8TextEncoder } from './string'\n\n/**\n * A BinaryEncoder handles the encoding to an Uint8Array.\n */\nexport class BinEncoder {\n  cpos: number\n  cbuf: Uint8Array\n  bufs: Uint8Array[]\n\n  constructor() {\n    this.cpos = 0\n    this.cbuf = new Uint8Array(100)\n    this.bufs = []\n  }\n}\n\nexport function createBinEncoder(): BinEncoder {\n  return new BinEncoder()\n}\n\n/**\n * The current length of the encoded data.\n */\nexport function length(encoder: BinEncoder): number {\n  let len = encoder.cpos\n  for (let i = 0; i < encoder.bufs.length; i++)\n    len += encoder.bufs[i].length\n\n  return len\n}\n\n/**\n * Transform to Uint8Array.\n */\nexport function encodeToUint8Array(encoder: BinEncoder): Uint8Array {\n  const uint8arr = new Uint8Array(length(encoder))\n  let curPos = 0\n  for (let i = 0; i < encoder.bufs.length; i++) {\n    const d = encoder.bufs[i]\n    uint8arr.set(d, curPos)\n    curPos += d.length\n  }\n  uint8arr.set(createUint8ArrayViewFromArrayBuffer(encoder.cbuf.buffer, 0, encoder.cpos), curPos)\n  return uint8arr\n}\n\n/**\n * Verify that it is possible to write `len` bytes wtihout checking. If\n * necessary, a new Buffer with the required length is attached.\n */\nexport function verifyLen(encoder: BinEncoder, len: number) {\n  const bufferLen = encoder.cbuf.length\n  if (bufferLen - encoder.cpos < len) {\n    encoder.bufs.push(createUint8ArrayViewFromArrayBuffer(encoder.cbuf.buffer, 0, encoder.cpos))\n    encoder.cbuf = new Uint8Array(Math.max(bufferLen, len) * 2)\n    encoder.cpos = 0\n  }\n}\n\n/**\n * Write one byte to the encoder.\n */\nexport function write(encoder: BinEncoder, num: number) {\n  const bufferLen = encoder.cbuf.length\n  if (encoder.cpos === bufferLen) {\n    encoder.bufs.push(encoder.cbuf)\n    encoder.cbuf = new Uint8Array(bufferLen * 2)\n    encoder.cpos = 0\n  }\n  encoder.cbuf[encoder.cpos++] = num\n}\n\n/**\n * Write one byte at a specific position.\n * Position must already be written (i.e. encoder.length > pos)\n */\nexport function set(encoder: BinEncoder, pos: number, num: number) {\n  let buffer = null\n  // iterate all buffers and adjust position\n  for (let i = 0; i < encoder.bufs.length && buffer === null; i++) {\n    const b = encoder.bufs[i]\n    if (pos < b.length)\n      buffer = b // found buffer\n\n    else\n      pos -= b.length\n  }\n  if (buffer === null) {\n    // use current buffer\n    buffer = encoder.cbuf\n  }\n  buffer[pos] = num\n}\n\n/**\n * Write one byte as an unsigned integer.\n */\nexport const writeUint8 = write\n\n/**\n * Write one byte as an unsigned Integer at a specific location.\n */\nexport const setUint8 = set\n\n/**\n * Write two bytes as an unsigned integer.\n */\nexport function writeUint16(encoder: BinEncoder, num: number) {\n  write(encoder, num & BITS8)\n  write(encoder, (num >>> 8) & BITS8)\n}\n/**\n * Write two bytes as an unsigned integer at a specific location.\n */\nexport function setUint16(encoder: BinEncoder, pos: number, num: number) {\n  set(encoder, pos, num & BITS8)\n  set(encoder, pos + 1, (num >>> 8) & BITS8)\n}\n\n/**\n * Write two bytes as an unsigned integer\n */\nexport function writeUint32(encoder: BinEncoder, num: number) {\n  for (let i = 0; i < 4; i++) {\n    write(encoder, num & BITS8)\n    num >>>= 8\n  }\n}\n\n/**\n * Write two bytes as an unsigned integer in big endian order.\n * (most significant byte first)\n */\nexport function writeUint32BigEndian(encoder: BinEncoder, num: number) {\n  for (let i = 3; i >= 0; i--)\n    write(encoder, (num >>> (8 * i)) & BITS8)\n}\n\n/**\n * Write two bytes as an unsigned integer at a specific location.\n */\nexport function setUint32(encoder: BinEncoder, pos: number, num: number) {\n  for (let i = 0; i < 4; i++) {\n    set(encoder, pos + i, num & BITS8)\n    num >>>= 8\n  }\n}\n\n/**\n * Write a variable length unsigned integer. Max encodable integer is 2^53.\n */\nexport function writeVarUint(encoder: BinEncoder, num: number) {\n  while (num > BITS7) {\n    write(encoder, BIT8 | (BITS7 & num))\n    num = Math.floor(num / 128) // shift >>> 7\n  }\n  write(encoder, BITS7 & num)\n}\n\nexport function isNegativeZero(n: number) {\n  return n !== 0 ? n < 0 : 1 / n < 0\n}\n\n/**\n * Write a variable length integer.\n *\n * We use the 7th bit instead for signaling that this is a negative number.\n */\nexport function writeVarInt(encoder: BinEncoder, num: number) {\n  const isNegative = isNegativeZero(num)\n  if (isNegative)\n    num = -num\n\n  //             |- whether to continue reading         |- whether is negative     |- number\n  write(encoder, (num > BITS6 ? BIT8 : 0) | (isNegative ? BIT7 : 0) | (BITS6 & num))\n  num = Math.floor(num / 64) // shift >>> 6\n\n  // We don't need to consider the case of num === 0 so we can use a different\n  // pattern here than above.\n  while (num > 0) {\n    write(encoder, (num > BITS7 ? BIT8 : 0) | (BITS7 & num))\n    num = Math.floor(num / 128) // shift >>> 7\n  }\n}\n\n/**\n * Append fixed-length Uint8Array to the encoder.\n */\nexport function writeUint8Array(encoder: BinEncoder, uint8Array: Uint8Array) {\n  const bufferLen = encoder.cbuf.length\n  const cpos = encoder.cpos\n  const leftCopyLen = Math.min(bufferLen - cpos, uint8Array.length)\n  const rightCopyLen = uint8Array.length - leftCopyLen\n  encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos)\n  encoder.cpos += leftCopyLen\n  if (rightCopyLen > 0) {\n    // Still something to write, write right half..\n    // Append new buffer\n    encoder.bufs.push(encoder.cbuf)\n    // must have at least size of remaining buffer\n    encoder.cbuf = new Uint8Array(Math.max(bufferLen * 2, rightCopyLen))\n    // copy array\n    encoder.cbuf.set(uint8Array.subarray(leftCopyLen))\n    encoder.cpos = rightCopyLen\n  }\n}\n\n/**\n * Append an Uint8Array to BinEncoder.\n */\nexport function writeVarUint8Array(encoder: BinEncoder, uint8Array: Uint8Array): void {\n  writeVarUint(encoder, uint8Array.byteLength)\n  writeUint8Array(encoder, uint8Array)\n}\n\n/**\n * A cache to store strings temporarily\n */\nlet _strBuffer: Uint8Array\nlet _maxStrBSize: number\n\n/**\n * Write a variable length string.\n */\nfunction _writeVarStringNative(encoder: BinEncoder, str: string) {\n  if (_strBuffer == null) {\n    _strBuffer = new Uint8Array(30000)\n    _maxStrBSize = _strBuffer.length / 3\n  }\n\n  if (str.length < _maxStrBSize) {\n    // We can encode the string into the existing buffer\n    const written = getUtf8TextEncoder()!.encodeInto(str, _strBuffer).written || 0\n    writeVarUint(encoder, written)\n    for (let i = 0; i < written; i++)\n      write(encoder, _strBuffer[i])\n  }\n  else {\n    writeVarUint8Array(encoder, encodeUtf8(str))\n  }\n}\n\n/**\n * Write a variable length string.\n */\nfunction _writeVarStringPolyfill(encoder: BinEncoder, str: string) {\n  const encodedString = unescape(encodeURIComponent(str))\n  const len = encodedString.length\n  writeVarUint(encoder, len)\n  for (let i = 0; i < len; i++)\n    write(encoder, (encodedString.codePointAt(i) as number))\n}\n\n/**\n * Write a variable length string.\n */\nexport function writeVarString(encoder: BinEncoder, str: string) {\n  return getUtf8TextEncoder()?.encodeInto\n    ? _writeVarStringNative(encoder, str)\n    : _writeVarStringPolyfill(encoder, str)\n}\n\n/**\n * Write the content of another Encoder.\n *\n * @TODO: can be improved!\n *        - Note: Should consider that when appending a lot of small Encoders, we should rather clone than referencing the old structure.\n *                Encoders start with a rather big initial buffer.\n */\nexport function writeBinaryEncoder(encoder: BinEncoder, append: BinEncoder) {\n  return writeUint8Array(encoder, encodeToUint8Array(append))\n}\n\n/**\n * Create an DataView of the next `len` bytes. Use it to write data after\n * calling this function.\n *\n * ```js\n * // write float32 using DataView\n * const dv = writeOnDataView(encoder, 4)\n * dv.setFloat32(0, 1.1)\n * // read float32 using DataView\n * const dv = readFromDataView(encoder, 4)\n * dv.getFloat32(0) // => 1.100000023841858 (leaving it to the reader to find out why this is the correct result)\n * ```\n */\nexport function writeOnDataView(encoder: BinEncoder, len: number): DataView {\n  verifyLen(encoder, len)\n  const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len)\n  encoder.cpos += len\n  return dview\n}\n\nexport function writeFloat32(encoder: BinEncoder, num: number) {\n  return writeOnDataView(encoder, 4).setFloat32(0, num, false)\n}\n\nexport function writeFloat64(encoder: BinEncoder, num: number) {\n  return writeOnDataView(encoder, 8).setFloat64(0, num, false)\n}\n\nexport function writeBigInt64(encoder: BinEncoder, num: bigint) {\n  return (writeOnDataView(encoder, 8)).setBigInt64(0, num, false)\n}\n\nexport function writeBigUint64(encoder: BinEncoder, num: bigint) {\n  return (writeOnDataView(encoder, 8)).setBigUint64(0, num, false)\n}\n\nlet floatTestBed: DataView\n\n/**\n * Check if a number can be encoded as a 32 bit float.\n */\nfunction isFloat32(num: number): boolean {\n  floatTestBed ??= new DataView(new ArrayBuffer(4))\n  floatTestBed.setFloat32(0, num)\n  return floatTestBed.getFloat32(0) === num\n}\n\n/**\n * Encode data with efficient binary format.\n *\n * Differences to JSON:\n * • Transforms data to a binary format (not to a string)\n * • Encodes undefined, NaN, and ArrayBuffer (these can't be represented in JSON)\n * • Numbers are efficiently encoded either as a variable length integer, as a\n *   32 bit float, as a 64 bit float, or as a 64 bit bigint.\n *\n * Encoding table:\n *\n * | Data Type           | Prefix   | Encoding Method    | Comment |\n * | ------------------- | -------- | ------------------ | ------- |\n * | undefined           | 127      |                    | Functions, symbol, and everything that cannot be identified is encoded as undefined |\n * | null                | 126      |                    | |\n * | integer             | 125      | writeVarInt        | Only encodes 32 bit signed integers |\n * | float32             | 124      | writeFloat32       | |\n * | float64             | 123      | writeFloat64       | |\n * | bigint              | 122      | writeBigInt64      | |\n * | boolean (false)     | 121      |                    | True and false are different data types so we save the following byte |\n * | boolean (true)      | 120      |                    | - 0b01111000 so the last bit determines whether true or false |\n * | string              | 119      | writeVarString     | |\n * | object<string,any>  | 118      | custom             | Writes {length} then {length} key-value pairs |\n * | array<any>          | 117      | custom             | Writes {length} then {length} json values |\n * | Uint8Array          | 116      | writeVarUint8Array | We use Uint8Array for any kind of binary data |\n *\n * Reasons for the decreasing prefix:\n * We need the first bit for extendability (later we may want to encode the\n * prefix with writeVarUint). The remaining 7 bits are divided as follows:\n * [0-30]   the beginning of the data range is used for custom purposes\n *          (defined by the function that uses this library)\n * [31-127] the end of the data range is used for data encoding by\n *          lib0/encoding.js\n */\nexport function writeAny(encoder: BinEncoder, data: undefined | null | number | bigint | boolean | string | { [s: string]: any } | Array<any> | Uint8Array) {\n  switch (typeof data) {\n    case 'string':\n      // TYPE 119: STRING\n      write(encoder, 119)\n      writeVarString(encoder, data)\n      break\n    case 'number':\n      if (Number.isInteger(data) && Math.abs(data) <= BITS31) {\n        // TYPE 125: INTEGER\n        write(encoder, 125)\n        writeVarInt(encoder, data)\n      }\n      else if (isFloat32(data)) {\n        // TYPE 124: FLOAT32\n        write(encoder, 124)\n        writeFloat32(encoder, data)\n      }\n      else {\n        // TYPE 123: FLOAT64\n        write(encoder, 123)\n        writeFloat64(encoder, data)\n      }\n      break\n    case 'bigint':\n      // TYPE 122: BigInt\n      write(encoder, 122)\n      writeBigInt64(encoder, data)\n      break\n    case 'object':\n      if (data === null) {\n        // TYPE 126: null\n        write(encoder, 126)\n      }\n      else if (Array.isArray(data)) {\n        // TYPE 117: Array\n        write(encoder, 117)\n        writeVarUint(encoder, data.length)\n        for (let i = 0; i < data.length; i++)\n          writeAny(encoder, data[i])\n      }\n      else if (data instanceof Uint8Array) {\n        // TYPE 116: ArrayBuffer\n        write(encoder, 116)\n        writeVarUint8Array(encoder, data)\n      }\n      else {\n        // TYPE 118: Object\n        write(encoder, 118)\n        const keys = Object.keys(data)\n        keys.sort() // guarantee comparability and consistency\n        writeVarUint(encoder, keys.length)\n        for (let i = 0; i < keys.length; i++) {\n          const key = keys[i]\n          writeVarString(encoder, key)\n          writeAny(encoder, data[key])\n        }\n      }\n      break\n    case 'boolean':\n      // TYPE 120/121: boolean (true/false)\n      write(encoder, data ? 120 : 121)\n      break\n    default:\n      // TYPE 127: undefined\n      write(encoder, 127)\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"encoding.cjs","names":["createUint8ArrayViewFromArrayBuffer","getUtf8TextEncoder","encodeUtf8"],"sources":["../../../../src/common/bin/lib0/encoding.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Efficient schema-less binary encoding with support for variable length encoding.\n *\n * Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.\n *\n * Encodes numbers in little-endian order (least to most significant byte order)\n * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)\n * which is also used in Protocol Buffers.\n *\n * ```js\n * // encoding step\n * const encoder = new encoding.createEncoder()\n * encoding.writeVarUint(encoder, 256)\n * encoding.writeVarString(encoder, 'Hello world!')\n * const buf = encoding.toUint8Array(encoder)\n * ```\n *\n * ```js\n * // decoding step\n * const decoder = new decoding.createDecoder(buf)\n * decoding.readVarUint(decoder) // => 256\n * decoding.readVarString(decoder) // => 'Hello world!'\n * decoding.hasContent(decoder) // => false - all data is read\n * ```\n */\n\nimport { BIT7, BIT8, BITS6, BITS7, BITS8, BITS31 } from './binary'\nimport { createUint8ArrayViewFromArrayBuffer } from './create'\nimport { encodeUtf8, getUtf8TextEncoder } from './string'\n\n/**\n * A BinaryEncoder handles the encoding to an Uint8Array.\n */\nexport class BinEncoder {\n  cpos: number\n  cbuf: Uint8Array\n  bufs: Uint8Array[]\n\n  constructor() {\n    this.cpos = 0\n    this.cbuf = new Uint8Array(100)\n    this.bufs = []\n  }\n}\n\nexport function createBinEncoder(): BinEncoder {\n  return new BinEncoder()\n}\n\n/**\n * The current length of the encoded data.\n */\nexport function length(encoder: BinEncoder): number {\n  let len = encoder.cpos\n  for (let i = 0; i < encoder.bufs.length; i++)\n    len += encoder.bufs[i].length\n\n  return len\n}\n\n/**\n * Transform to Uint8Array.\n */\nexport function encodeToUint8Array(encoder: BinEncoder): Uint8Array {\n  const uint8arr = new Uint8Array(length(encoder))\n  let curPos = 0\n  for (let i = 0; i < encoder.bufs.length; i++) {\n    const d = encoder.bufs[i]\n    uint8arr.set(d, curPos)\n    curPos += d.length\n  }\n  uint8arr.set(createUint8ArrayViewFromArrayBuffer(encoder.cbuf.buffer, 0, encoder.cpos), curPos)\n  return uint8arr\n}\n\n/**\n * Verify that it is possible to write `len` bytes wtihout checking. If\n * necessary, a new Buffer with the required length is attached.\n */\nexport function verifyLen(encoder: BinEncoder, len: number) {\n  const bufferLen = encoder.cbuf.length\n  if (bufferLen - encoder.cpos < len) {\n    encoder.bufs.push(createUint8ArrayViewFromArrayBuffer(encoder.cbuf.buffer, 0, encoder.cpos))\n    encoder.cbuf = new Uint8Array(Math.max(bufferLen, len) * 2)\n    encoder.cpos = 0\n  }\n}\n\n/**\n * Write one byte to the encoder.\n */\nexport function write(encoder: BinEncoder, num: number) {\n  const bufferLen = encoder.cbuf.length\n  if (encoder.cpos === bufferLen) {\n    encoder.bufs.push(encoder.cbuf)\n    encoder.cbuf = new Uint8Array(bufferLen * 2)\n    encoder.cpos = 0\n  }\n  encoder.cbuf[encoder.cpos++] = num\n}\n\n/**\n * Write one byte at a specific position.\n * Position must already be written (i.e. encoder.length > pos)\n */\nexport function set(encoder: BinEncoder, pos: number, num: number) {\n  let buffer = null\n  // iterate all buffers and adjust position\n  for (let i = 0; i < encoder.bufs.length && buffer === null; i++) {\n    const b = encoder.bufs[i]\n    if (pos < b.length)\n      buffer = b // found buffer\n\n    else\n      pos -= b.length\n  }\n  if (buffer === null) {\n    // use current buffer\n    buffer = encoder.cbuf\n  }\n  buffer[pos] = num\n}\n\n/**\n * Write one byte as an unsigned integer.\n */\nexport const writeUint8 = write\n\n/**\n * Write one byte as an unsigned Integer at a specific location.\n */\nexport const setUint8 = set\n\n/**\n * Write two bytes as an unsigned integer.\n */\nexport function writeUint16(encoder: BinEncoder, num: number) {\n  write(encoder, num & BITS8)\n  write(encoder, (num >>> 8) & BITS8)\n}\n/**\n * Write two bytes as an unsigned integer at a specific location.\n */\nexport function setUint16(encoder: BinEncoder, pos: number, num: number) {\n  set(encoder, pos, num & BITS8)\n  set(encoder, pos + 1, (num >>> 8) & BITS8)\n}\n\n/**\n * Write two bytes as an unsigned integer\n */\nexport function writeUint32(encoder: BinEncoder, num: number) {\n  for (let i = 0; i < 4; i++) {\n    write(encoder, num & BITS8)\n    num >>>= 8\n  }\n}\n\n/**\n * Write two bytes as an unsigned integer in big endian order.\n * (most significant byte first)\n */\nexport function writeUint32BigEndian(encoder: BinEncoder, num: number) {\n  for (let i = 3; i >= 0; i--)\n    write(encoder, (num >>> (8 * i)) & BITS8)\n}\n\n/**\n * Write two bytes as an unsigned integer at a specific location.\n */\nexport function setUint32(encoder: BinEncoder, pos: number, num: number) {\n  for (let i = 0; i < 4; i++) {\n    set(encoder, pos + i, num & BITS8)\n    num >>>= 8\n  }\n}\n\n/**\n * Write a variable length unsigned integer. Max encodable integer is 2^53.\n */\nexport function writeVarUint(encoder: BinEncoder, num: number) {\n  while (num > BITS7) {\n    write(encoder, BIT8 | (BITS7 & num))\n    num = Math.floor(num / 128) // shift >>> 7\n  }\n  write(encoder, BITS7 & num)\n}\n\nexport function isNegativeZero(n: number) {\n  return n !== 0 ? n < 0 : 1 / n < 0\n}\n\n/**\n * Write a variable length integer.\n *\n * We use the 7th bit instead for signaling that this is a negative number.\n */\nexport function writeVarInt(encoder: BinEncoder, num: number) {\n  const isNegative = isNegativeZero(num)\n  if (isNegative)\n    num = -num\n\n  //             |- whether to continue reading         |- whether is negative     |- number\n  write(encoder, (num > BITS6 ? BIT8 : 0) | (isNegative ? BIT7 : 0) | (BITS6 & num))\n  num = Math.floor(num / 64) // shift >>> 6\n\n  // We don't need to consider the case of num === 0 so we can use a different\n  // pattern here than above.\n  while (num > 0) {\n    write(encoder, (num > BITS7 ? BIT8 : 0) | (BITS7 & num))\n    num = Math.floor(num / 128) // shift >>> 7\n  }\n}\n\n/**\n * Append fixed-length Uint8Array to the encoder.\n */\nexport function writeUint8Array(encoder: BinEncoder, uint8Array: Uint8Array) {\n  const bufferLen = encoder.cbuf.length\n  const cpos = encoder.cpos\n  const leftCopyLen = Math.min(bufferLen - cpos, uint8Array.length)\n  const rightCopyLen = uint8Array.length - leftCopyLen\n  encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos)\n  encoder.cpos += leftCopyLen\n  if (rightCopyLen > 0) {\n    // Still something to write, write right half..\n    // Append new buffer\n    encoder.bufs.push(encoder.cbuf)\n    // must have at least size of remaining buffer\n    encoder.cbuf = new Uint8Array(Math.max(bufferLen * 2, rightCopyLen))\n    // copy array\n    encoder.cbuf.set(uint8Array.subarray(leftCopyLen))\n    encoder.cpos = rightCopyLen\n  }\n}\n\n/**\n * Append an Uint8Array to BinEncoder.\n */\nexport function writeVarUint8Array(encoder: BinEncoder, uint8Array: Uint8Array): void {\n  writeVarUint(encoder, uint8Array.byteLength)\n  writeUint8Array(encoder, uint8Array)\n}\n\n/**\n * A cache to store strings temporarily\n */\nlet _strBuffer: Uint8Array\nlet _maxStrBSize: number\n\n/**\n * Write a variable length string.\n */\nfunction _writeVarStringNative(encoder: BinEncoder, str: string) {\n  if (_strBuffer == null) {\n    _strBuffer = new Uint8Array(30000)\n    _maxStrBSize = _strBuffer.length / 3\n  }\n\n  if (str.length < _maxStrBSize) {\n    // We can encode the string into the existing buffer\n    const written = getUtf8TextEncoder()!.encodeInto(str, _strBuffer).written || 0\n    writeVarUint(encoder, written)\n    for (let i = 0; i < written; i++)\n      write(encoder, _strBuffer[i])\n  }\n  else {\n    writeVarUint8Array(encoder, encodeUtf8(str))\n  }\n}\n\n/**\n * Write a variable length string.\n */\nfunction _writeVarStringPolyfill(encoder: BinEncoder, str: string) {\n  const encodedString = unescape(encodeURIComponent(str))\n  const len = encodedString.length\n  writeVarUint(encoder, len)\n  for (let i = 0; i < len; i++)\n    write(encoder, (encodedString.codePointAt(i) as number))\n}\n\n/**\n * Write a variable length string.\n */\nexport function writeVarString(encoder: BinEncoder, str: string) {\n  return getUtf8TextEncoder()?.encodeInto\n    ? _writeVarStringNative(encoder, str)\n    : _writeVarStringPolyfill(encoder, str)\n}\n\n/**\n * Write the content of another Encoder.\n *\n * @TODO: can be improved!\n *        - Note: Should consider that when appending a lot of small Encoders, we should rather clone than referencing the old structure.\n *                Encoders start with a rather big initial buffer.\n */\nexport function writeBinaryEncoder(encoder: BinEncoder, append: BinEncoder) {\n  return writeUint8Array(encoder, encodeToUint8Array(append))\n}\n\n/**\n * Create an DataView of the next `len` bytes. Use it to write data after\n * calling this function.\n *\n * ```js\n * // write float32 using DataView\n * const dv = writeOnDataView(encoder, 4)\n * dv.setFloat32(0, 1.1)\n * // read float32 using DataView\n * const dv = readFromDataView(encoder, 4)\n * dv.getFloat32(0) // => 1.100000023841858 (leaving it to the reader to find out why this is the correct result)\n * ```\n */\nexport function writeOnDataView(encoder: BinEncoder, len: number): DataView {\n  verifyLen(encoder, len)\n  const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len)\n  encoder.cpos += len\n  return dview\n}\n\nexport function writeFloat32(encoder: BinEncoder, num: number) {\n  return writeOnDataView(encoder, 4).setFloat32(0, num, false)\n}\n\nexport function writeFloat64(encoder: BinEncoder, num: number) {\n  return writeOnDataView(encoder, 8).setFloat64(0, num, false)\n}\n\nexport function writeBigInt64(encoder: BinEncoder, num: bigint) {\n  return (writeOnDataView(encoder, 8)).setBigInt64(0, num, false)\n}\n\nexport function writeBigUint64(encoder: BinEncoder, num: bigint) {\n  return (writeOnDataView(encoder, 8)).setBigUint64(0, num, false)\n}\n\nlet floatTestBed: DataView\n\n/**\n * Check if a number can be encoded as a 32 bit float.\n */\nfunction isFloat32(num: number): boolean {\n  floatTestBed ??= new DataView(new ArrayBuffer(4))\n  floatTestBed.setFloat32(0, num)\n  return floatTestBed.getFloat32(0) === num\n}\n\n/**\n * Encode data with efficient binary format.\n *\n * Differences to JSON:\n * • Transforms data to a binary format (not to a string)\n * • Encodes undefined, NaN, and ArrayBuffer (these can't be represented in JSON)\n * • Numbers are efficiently encoded either as a variable length integer, as a\n *   32 bit float, as a 64 bit float, or as a 64 bit bigint.\n *\n * Encoding table:\n *\n * | Data Type           | Prefix   | Encoding Method    | Comment |\n * | ------------------- | -------- | ------------------ | ------- |\n * | undefined           | 127      |                    | Functions, symbol, and everything that cannot be identified is encoded as undefined |\n * | null                | 126      |                    | |\n * | integer             | 125      | writeVarInt        | Only encodes 32 bit signed integers |\n * | float32             | 124      | writeFloat32       | |\n * | float64             | 123      | writeFloat64       | |\n * | bigint              | 122      | writeBigInt64      | |\n * | boolean (false)     | 121      |                    | True and false are different data types so we save the following byte |\n * | boolean (true)      | 120      |                    | - 0b01111000 so the last bit determines whether true or false |\n * | string              | 119      | writeVarString     | |\n * | object<string,any>  | 118      | custom             | Writes {length} then {length} key-value pairs |\n * | array<any>          | 117      | custom             | Writes {length} then {length} json values |\n * | Uint8Array          | 116      | writeVarUint8Array | We use Uint8Array for any kind of binary data |\n *\n * Reasons for the decreasing prefix:\n * We need the first bit for extendability (later we may want to encode the\n * prefix with writeVarUint). The remaining 7 bits are divided as follows:\n * [0-30]   the beginning of the data range is used for custom purposes\n *          (defined by the function that uses this library)\n * [31-127] the end of the data range is used for data encoding by\n *          lib0/encoding.js\n */\nexport function writeAny(encoder: BinEncoder, data: undefined | null | number | bigint | boolean | string | { [s: string]: any } | Array<any> | Uint8Array) {\n  switch (typeof data) {\n    case 'string':\n      // TYPE 119: STRING\n      write(encoder, 119)\n      writeVarString(encoder, data)\n      break\n    case 'number':\n      if (Number.isInteger(data) && Math.abs(data) <= BITS31) {\n        // TYPE 125: INTEGER\n        write(encoder, 125)\n        writeVarInt(encoder, data)\n      }\n      else if (isFloat32(data)) {\n        // TYPE 124: FLOAT32\n        write(encoder, 124)\n        writeFloat32(encoder, data)\n      }\n      else {\n        // TYPE 123: FLOAT64\n        write(encoder, 123)\n        writeFloat64(encoder, data)\n      }\n      break\n    case 'bigint':\n      // TYPE 122: BigInt\n      write(encoder, 122)\n      writeBigInt64(encoder, data)\n      break\n    case 'object':\n      if (data === null) {\n        // TYPE 126: null\n        write(encoder, 126)\n      }\n      else if (Array.isArray(data)) {\n        // TYPE 117: Array\n        write(encoder, 117)\n        writeVarUint(encoder, data.length)\n        for (let i = 0; i < data.length; i++)\n          writeAny(encoder, data[i])\n      }\n      else if (data instanceof Uint8Array) {\n        // TYPE 116: ArrayBuffer\n        write(encoder, 116)\n        writeVarUint8Array(encoder, data)\n      }\n      else {\n        // TYPE 118: Object\n        write(encoder, 118)\n        const keys = Object.keys(data)\n        keys.sort() // guarantee comparability and consistency\n        writeVarUint(encoder, keys.length)\n        for (let i = 0; i < keys.length; i++) {\n          const key = keys[i]\n          writeVarString(encoder, key)\n          writeAny(encoder, data[key])\n        }\n      }\n      break\n    case 'boolean':\n      // TYPE 120/121: boolean (true/false)\n      write(encoder, data ? 120 : 121)\n      break\n    default:\n      // TYPE 127: undefined\n      write(encoder, 127)\n  }\n}\n"],"mappings":"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"}