zeed 1.2.4 → 1.3.1

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

@@ -0,0 +1,378 @@
+import { BIT7, BIT8, BITS31, BITS6, BITS7, BITS8 } from "./binary.mjs";
+import { createUint8ArrayViewFromArrayBuffer } from "./create.mjs";
+import { encodeUtf8, getUtf8TextEncoder } from "./string.mjs";
+
+//#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(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(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 = getUtf8TextEncoder().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 _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 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
+export { BinEncoder, createBinEncoder, encodeToUint8Array, isNegativeZero, length, set, setUint16, setUint32, setUint8, verifyLen, write, writeAny, writeBigInt64, writeBigUint64, writeBinaryEncoder, writeFloat32, writeFloat64, writeOnDataView, writeUint16, writeUint32, writeUint32BigEndian, writeUint8, writeUint8Array, writeVarInt, writeVarString, writeVarUint, writeVarUint8Array };
+//# sourceMappingURL=encoding.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.mjs","names":[],"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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"}

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

@@ -1,2 +1,82 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkJJKWFF7Bcjs = require('../../../chunk-JJKWFF7B.cjs');require('../../../chunk-P7XCQ7WV.cjs');exports._encodeUtf8Polyfill = _chunkJJKWFF7Bcjs.d; exports.decodeUtf8 = _chunkJJKWFF7Bcjs.h; exports.encodeUtf8 = _chunkJJKWFF7Bcjs.f; exports.fromCamelCase = _chunkJJKWFF7Bcjs.b; exports.getUtf8TextDecoder = _chunkJJKWFF7Bcjs.g; exports.getUtf8TextEncoder = _chunkJJKWFF7Bcjs.e; exports.splice = _chunkJJKWFF7Bcjs.i; exports.trimLeft = _chunkJJKWFF7Bcjs.a; exports.utf8ByteLength = _chunkJJKWFF7Bcjs.c;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/common/bin/lib0/string.ts
+/**
+* Original at https://github.com/dmonad/lib0
+*
+* Utility module to work with strings.
+*/
+function toLowerCase(s) {
+	return s.toLowerCase();
+}
+const trimLeftRegex = /^\s*/g;
+function trimLeft(s) {
+	return s.replace(trimLeftRegex, "");
+}
+const fromCamelCaseRegex = /([A-Z])/g;
+function fromCamelCase(s, separator) {
+	return trimLeft(s.replace(fromCamelCaseRegex, (match) => `${separator}${toLowerCase(match)}`));
+}
+/**
+* Compute the utf8ByteLength
+*/
+function utf8ByteLength(str) {
+	return unescape(encodeURIComponent(str)).length;
+}
+function _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;
+}
+let utf8TextEncoder;
+function getUtf8TextEncoder() {
+	if (utf8TextEncoder === void 0) utf8TextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
+	return utf8TextEncoder;
+}
+function encodeUtf8(str) {
+	return getUtf8TextEncoder() ? utf8TextEncoder.encode(str) : _encodeUtf8Polyfill(str);
+}
+function _decodeUtf8Polyfill(buf) {
+	let remainingLen = buf.length;
+	let encodedString = "";
+	let bufPos = 0;
+	while (remainingLen > 0) {
+		const nextLen = remainingLen < 1e4 ? remainingLen : 1e4;
+		const bytes = buf.subarray(bufPos, bufPos + nextLen);
+		bufPos += nextLen;
+		encodedString += String.fromCodePoint(...bytes);
+		remainingLen -= nextLen;
+	}
+	return decodeURIComponent(escape(encodedString));
+}
+let utf8TextDecoder;
+function getUtf8TextDecoder() {
+	if (utf8TextDecoder === void 0) {
+		utf8TextDecoder = (typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8", {
+			fatal: true,
+			ignoreBOM: true
+		})) ?? null;
+		if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) utf8TextDecoder = null;
+	}
+	return utf8TextDecoder;
+}
+function decodeUtf8(buf) {
+	return getUtf8TextDecoder() ? utf8TextDecoder.decode(buf) : _decodeUtf8Polyfill(buf);
+}
+function splice(str, index, remove, insert = "") {
+	return str.slice(0, index) + insert + str.slice(index + remove);
+}
+
+//#endregion
+exports._encodeUtf8Polyfill = _encodeUtf8Polyfill;
+exports.decodeUtf8 = decodeUtf8;
+exports.encodeUtf8 = encodeUtf8;
+exports.fromCamelCase = fromCamelCase;
+exports.getUtf8TextDecoder = getUtf8TextDecoder;
+exports.getUtf8TextEncoder = getUtf8TextEncoder;
+exports.splice = splice;
+exports.trimLeft = trimLeft;
+exports.utf8ByteLength = utf8ByteLength;
 //# sourceMappingURL=string.cjs.map

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/common/bin/lib0/string.cjs"],"names":[],"mappings":"AAAA,wIAA0D,uCAAoC,mZAAkL","file":"/Users/dirk/work/github-zeed/dist/common/bin/lib0/string.cjs"}
+{"version":3,"file":"string.cjs","names":[],"sources":["../../../../src/common/bin/lib0/string.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Utility module to work with strings.\n */\n\n// export const fromCharCode = String.fromCharCode\n// export const fromCodePoint = String.fromCodePoint\n\nfunction toLowerCase(s: string): string {\n  return s.toLowerCase()\n}\n\nconst trimLeftRegex = /^\\s*/g\n\nexport function trimLeft(s: string): string {\n  return s.replace(trimLeftRegex, '')\n}\n\nconst fromCamelCaseRegex = /([A-Z])/g\n\nexport function fromCamelCase(s: string, separator: string): string {\n  return trimLeft(s.replace(fromCamelCaseRegex, match => `${separator}${toLowerCase(match)}`))\n}\n\n/**\n * Compute the utf8ByteLength\n */\nexport function utf8ByteLength(str: string): number {\n  return unescape(encodeURIComponent(str)).length\n}\n\nexport function _encodeUtf8Polyfill(str: string): Uint8Array {\n  const encodedString = unescape(encodeURIComponent(str))\n  const len = encodedString.length\n  const buf = new Uint8Array(len)\n  for (let i = 0; i < len; i++)\n    buf[i] = (encodedString.codePointAt(i) as number)\n\n  return buf\n}\n\nlet utf8TextEncoder: TextEncoder | undefined | null\n\nexport function getUtf8TextEncoder(): TextEncoder | null {\n  if (utf8TextEncoder === undefined)\n    utf8TextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null)\n  return utf8TextEncoder\n}\n\nexport function encodeUtf8(str: string): Uint8Array {\n  return getUtf8TextEncoder()\n    ? utf8TextEncoder!.encode(str)\n    : _encodeUtf8Polyfill(str)\n}\n\nfunction _decodeUtf8Polyfill(buf: Uint8Array): string {\n  let remainingLen = buf.length\n  let encodedString = ''\n  let bufPos = 0\n  while (remainingLen > 0) {\n    const nextLen = remainingLen < 10000 ? remainingLen : 10000\n    const bytes = buf.subarray(bufPos, bufPos + nextLen)\n    bufPos += nextLen\n    // Starting with ES5.1 we can supply a generic array-like object as arguments\n    encodedString += String.fromCodePoint(...bytes as any)\n    remainingLen -= nextLen\n  }\n  return decodeURIComponent(escape(encodedString))\n}\n\nlet utf8TextDecoder: any\n\nexport function getUtf8TextDecoder(): TextDecoder | undefined {\n  if (utf8TextDecoder === undefined) {\n    utf8TextDecoder = (typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8', { fatal: true, ignoreBOM: true })) ?? null\n    if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {\n      // Safari doesn't handle BOM correctly.\n      // This fixes a bug in Safari 13.0.5 where it produces a BOM the first time it is called.\n      // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the first call and\n      // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the second call\n      // Another issue is that from then on no BOM chars are recognized anymore\n      utf8TextDecoder = null\n    }\n  }\n  return utf8TextDecoder\n}\n\nexport function decodeUtf8(buf: Uint8Array): string {\n  return getUtf8TextDecoder()\n    ? utf8TextDecoder.decode(buf)\n    : _decodeUtf8Polyfill(buf)\n}\n\nexport function splice(str: string, index: number, remove: number, insert = '') {\n  return str.slice(0, index) + insert + str.slice(index + remove)\n}\n"],"mappings":";;;;;;;;AASA,SAAS,YAAY,GAAmB;AACtC,QAAO,EAAE,aAAa;;AAGxB,MAAM,gBAAgB;AAEtB,SAAgB,SAAS,GAAmB;AAC1C,QAAO,EAAE,QAAQ,eAAe,GAAG;;AAGrC,MAAM,qBAAqB;AAE3B,SAAgB,cAAc,GAAW,WAA2B;AAClE,QAAO,SAAS,EAAE,QAAQ,qBAAoB,UAAS,GAAG,YAAY,YAAY,MAAM,GAAG,CAAC;;;;;AAM9F,SAAgB,eAAe,KAAqB;AAClD,QAAO,SAAS,mBAAmB,IAAI,CAAC,CAAC;;AAG3C,SAAgB,oBAAoB,KAAyB;CAC3D,MAAM,gBAAgB,SAAS,mBAAmB,IAAI,CAAC;CACvD,MAAM,MAAM,cAAc;CAC1B,MAAM,MAAM,IAAI,WAAW,IAAI;AAC/B,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,IACvB,KAAI,KAAM,cAAc,YAAY,EAAE;AAExC,QAAO;;AAGT,IAAI;AAEJ,SAAgB,qBAAyC;AACvD,KAAI,oBAAoB,OACtB,mBAAmB,OAAO,gBAAgB,cAAc,IAAI,aAAa,GAAG;AAC9E,QAAO;;AAGT,SAAgB,WAAW,KAAyB;AAClD,QAAO,oBAAoB,GACvB,gBAAiB,OAAO,IAAI,GAC5B,oBAAoB,IAAI;;AAG9B,SAAS,oBAAoB,KAAyB;CACpD,IAAI,eAAe,IAAI;CACvB,IAAI,gBAAgB;CACpB,IAAI,SAAS;AACb,QAAO,eAAe,GAAG;EACvB,MAAM,UAAU,eAAe,MAAQ,eAAe;EACtD,MAAM,QAAQ,IAAI,SAAS,QAAQ,SAAS,QAAQ;AACpD,YAAU;AAEV,mBAAiB,OAAO,cAAc,GAAG,MAAa;AACtD,kBAAgB;;AAElB,QAAO,mBAAmB,OAAO,cAAc,CAAC;;AAGlD,IAAI;AAEJ,SAAgB,qBAA8C;AAC5D,KAAI,oBAAoB,QAAW;AACjC,qBAAmB,OAAO,gBAAgB,cAAc,OAAO,IAAI,YAAY,SAAS;GAAE,OAAO;GAAM,WAAW;GAAM,CAAC,KAAK;AAC9H,MAAI,mBAAmB,gBAAgB,OAAO,IAAI,YAAY,CAAC,CAAC,WAAW,EAMzE,mBAAkB;;AAGtB,QAAO;;AAGT,SAAgB,WAAW,KAAyB;AAClD,QAAO,oBAAoB,GACvB,gBAAgB,OAAO,IAAI,GAC3B,oBAAoB,IAAI;;AAG9B,SAAgB,OAAO,KAAa,OAAe,QAAgB,SAAS,IAAI;AAC9E,QAAO,IAAI,MAAM,GAAG,MAAM,GAAG,SAAS,IAAI,MAAM,QAAQ,OAAO"}

package/dist/common/bin/lib0/string.d.cts

@@ -1,3 +1,4 @@
+//#region src/common/bin/lib0/string.d.ts
 /**
  * Original at https://github.com/dmonad/lib0
  *
@@ -15,5 +16,6 @@ declare function encodeUtf8(str: string): Uint8Array;
 declare function getUtf8TextDecoder(): TextDecoder | undefined;
 declare function decodeUtf8(buf: Uint8Array): string;
 declare function splice(str: string, index: number, remove: number, insert?: string): string;
-
+//#endregion
 export { _encodeUtf8Polyfill, decodeUtf8, encodeUtf8, fromCamelCase, getUtf8TextDecoder, getUtf8TextEncoder, splice, trimLeft, utf8ByteLength };
+//# sourceMappingURL=string.d.cts.map

package/dist/common/bin/lib0/string.d.mts

@@ -0,0 +1,21 @@
+//#region src/common/bin/lib0/string.d.ts
+/**
+ * Original at https://github.com/dmonad/lib0
+ *
+ * Utility module to work with strings.
+ */
+declare function trimLeft(s: string): string;
+declare function fromCamelCase(s: string, separator: string): string;
+/**
+ * Compute the utf8ByteLength
+ */
+declare function utf8ByteLength(str: string): number;
+declare function _encodeUtf8Polyfill(str: string): Uint8Array;
+declare function getUtf8TextEncoder(): TextEncoder | null;
+declare function encodeUtf8(str: string): Uint8Array;
+declare function getUtf8TextDecoder(): TextDecoder | undefined;
+declare function decodeUtf8(buf: Uint8Array): string;
+declare function splice(str: string, index: number, remove: number, insert?: string): string;
+//#endregion
+export { _encodeUtf8Polyfill, decodeUtf8, encodeUtf8, fromCamelCase, getUtf8TextDecoder, getUtf8TextEncoder, splice, trimLeft, utf8ByteLength };
+//# sourceMappingURL=string.d.mts.map

package/dist/common/bin/lib0/string.mjs

@@ -0,0 +1,72 @@
+//#region src/common/bin/lib0/string.ts
+/**
+* Original at https://github.com/dmonad/lib0
+*
+* Utility module to work with strings.
+*/
+function toLowerCase(s) {
+	return s.toLowerCase();
+}
+const trimLeftRegex = /^\s*/g;
+function trimLeft(s) {
+	return s.replace(trimLeftRegex, "");
+}
+const fromCamelCaseRegex = /([A-Z])/g;
+function fromCamelCase(s, separator) {
+	return trimLeft(s.replace(fromCamelCaseRegex, (match) => `${separator}${toLowerCase(match)}`));
+}
+/**
+* Compute the utf8ByteLength
+*/
+function utf8ByteLength(str) {
+	return unescape(encodeURIComponent(str)).length;
+}
+function _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;
+}
+let utf8TextEncoder;
+function getUtf8TextEncoder() {
+	if (utf8TextEncoder === void 0) utf8TextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
+	return utf8TextEncoder;
+}
+function encodeUtf8(str) {
+	return getUtf8TextEncoder() ? utf8TextEncoder.encode(str) : _encodeUtf8Polyfill(str);
+}
+function _decodeUtf8Polyfill(buf) {
+	let remainingLen = buf.length;
+	let encodedString = "";
+	let bufPos = 0;
+	while (remainingLen > 0) {
+		const nextLen = remainingLen < 1e4 ? remainingLen : 1e4;
+		const bytes = buf.subarray(bufPos, bufPos + nextLen);
+		bufPos += nextLen;
+		encodedString += String.fromCodePoint(...bytes);
+		remainingLen -= nextLen;
+	}
+	return decodeURIComponent(escape(encodedString));
+}
+let utf8TextDecoder;
+function getUtf8TextDecoder() {
+	if (utf8TextDecoder === void 0) {
+		utf8TextDecoder = (typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8", {
+			fatal: true,
+			ignoreBOM: true
+		})) ?? null;
+		if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) utf8TextDecoder = null;
+	}
+	return utf8TextDecoder;
+}
+function decodeUtf8(buf) {
+	return getUtf8TextDecoder() ? utf8TextDecoder.decode(buf) : _decodeUtf8Polyfill(buf);
+}
+function splice(str, index, remove, insert = "") {
+	return str.slice(0, index) + insert + str.slice(index + remove);
+}
+
+//#endregion
+export { _encodeUtf8Polyfill, decodeUtf8, encodeUtf8, fromCamelCase, getUtf8TextDecoder, getUtf8TextEncoder, splice, trimLeft, utf8ByteLength };
+//# sourceMappingURL=string.mjs.map

package/dist/common/bin/lib0/string.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.mjs","names":[],"sources":["../../../../src/common/bin/lib0/string.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Utility module to work with strings.\n */\n\n// export const fromCharCode = String.fromCharCode\n// export const fromCodePoint = String.fromCodePoint\n\nfunction toLowerCase(s: string): string {\n  return s.toLowerCase()\n}\n\nconst trimLeftRegex = /^\\s*/g\n\nexport function trimLeft(s: string): string {\n  return s.replace(trimLeftRegex, '')\n}\n\nconst fromCamelCaseRegex = /([A-Z])/g\n\nexport function fromCamelCase(s: string, separator: string): string {\n  return trimLeft(s.replace(fromCamelCaseRegex, match => `${separator}${toLowerCase(match)}`))\n}\n\n/**\n * Compute the utf8ByteLength\n */\nexport function utf8ByteLength(str: string): number {\n  return unescape(encodeURIComponent(str)).length\n}\n\nexport function _encodeUtf8Polyfill(str: string): Uint8Array {\n  const encodedString = unescape(encodeURIComponent(str))\n  const len = encodedString.length\n  const buf = new Uint8Array(len)\n  for (let i = 0; i < len; i++)\n    buf[i] = (encodedString.codePointAt(i) as number)\n\n  return buf\n}\n\nlet utf8TextEncoder: TextEncoder | undefined | null\n\nexport function getUtf8TextEncoder(): TextEncoder | null {\n  if (utf8TextEncoder === undefined)\n    utf8TextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null)\n  return utf8TextEncoder\n}\n\nexport function encodeUtf8(str: string): Uint8Array {\n  return getUtf8TextEncoder()\n    ? utf8TextEncoder!.encode(str)\n    : _encodeUtf8Polyfill(str)\n}\n\nfunction _decodeUtf8Polyfill(buf: Uint8Array): string {\n  let remainingLen = buf.length\n  let encodedString = ''\n  let bufPos = 0\n  while (remainingLen > 0) {\n    const nextLen = remainingLen < 10000 ? remainingLen : 10000\n    const bytes = buf.subarray(bufPos, bufPos + nextLen)\n    bufPos += nextLen\n    // Starting with ES5.1 we can supply a generic array-like object as arguments\n    encodedString += String.fromCodePoint(...bytes as any)\n    remainingLen -= nextLen\n  }\n  return decodeURIComponent(escape(encodedString))\n}\n\nlet utf8TextDecoder: any\n\nexport function getUtf8TextDecoder(): TextDecoder | undefined {\n  if (utf8TextDecoder === undefined) {\n    utf8TextDecoder = (typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8', { fatal: true, ignoreBOM: true })) ?? null\n    if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {\n      // Safari doesn't handle BOM correctly.\n      // This fixes a bug in Safari 13.0.5 where it produces a BOM the first time it is called.\n      // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the first call and\n      // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the second call\n      // Another issue is that from then on no BOM chars are recognized anymore\n      utf8TextDecoder = null\n    }\n  }\n  return utf8TextDecoder\n}\n\nexport function decodeUtf8(buf: Uint8Array): string {\n  return getUtf8TextDecoder()\n    ? utf8TextDecoder.decode(buf)\n    : _decodeUtf8Polyfill(buf)\n}\n\nexport function splice(str: string, index: number, remove: number, insert = '') {\n  return str.slice(0, index) + insert + str.slice(index + remove)\n}\n"],"mappings":";;;;;;AASA,SAAS,YAAY,GAAmB;AACtC,QAAO,EAAE,aAAa;;AAGxB,MAAM,gBAAgB;AAEtB,SAAgB,SAAS,GAAmB;AAC1C,QAAO,EAAE,QAAQ,eAAe,GAAG;;AAGrC,MAAM,qBAAqB;AAE3B,SAAgB,cAAc,GAAW,WAA2B;AAClE,QAAO,SAAS,EAAE,QAAQ,qBAAoB,UAAS,GAAG,YAAY,YAAY,MAAM,GAAG,CAAC;;;;;AAM9F,SAAgB,eAAe,KAAqB;AAClD,QAAO,SAAS,mBAAmB,IAAI,CAAC,CAAC;;AAG3C,SAAgB,oBAAoB,KAAyB;CAC3D,MAAM,gBAAgB,SAAS,mBAAmB,IAAI,CAAC;CACvD,MAAM,MAAM,cAAc;CAC1B,MAAM,MAAM,IAAI,WAAW,IAAI;AAC/B,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,IACvB,KAAI,KAAM,cAAc,YAAY,EAAE;AAExC,QAAO;;AAGT,IAAI;AAEJ,SAAgB,qBAAyC;AACvD,KAAI,oBAAoB,OACtB,mBAAmB,OAAO,gBAAgB,cAAc,IAAI,aAAa,GAAG;AAC9E,QAAO;;AAGT,SAAgB,WAAW,KAAyB;AAClD,QAAO,oBAAoB,GACvB,gBAAiB,OAAO,IAAI,GAC5B,oBAAoB,IAAI;;AAG9B,SAAS,oBAAoB,KAAyB;CACpD,IAAI,eAAe,IAAI;CACvB,IAAI,gBAAgB;CACpB,IAAI,SAAS;AACb,QAAO,eAAe,GAAG;EACvB,MAAM,UAAU,eAAe,MAAQ,eAAe;EACtD,MAAM,QAAQ,IAAI,SAAS,QAAQ,SAAS,QAAQ;AACpD,YAAU;AAEV,mBAAiB,OAAO,cAAc,GAAG,MAAa;AACtD,kBAAgB;;AAElB,QAAO,mBAAmB,OAAO,cAAc,CAAC;;AAGlD,IAAI;AAEJ,SAAgB,qBAA8C;AAC5D,KAAI,oBAAoB,QAAW;AACjC,qBAAmB,OAAO,gBAAgB,cAAc,OAAO,IAAI,YAAY,SAAS;GAAE,OAAO;GAAM,WAAW;GAAM,CAAC,KAAK;AAC9H,MAAI,mBAAmB,gBAAgB,OAAO,IAAI,YAAY,CAAC,CAAC,WAAW,EAMzE,mBAAkB;;AAGtB,QAAO;;AAGT,SAAgB,WAAW,KAAyB;AAClD,QAAO,oBAAoB,GACvB,gBAAgB,OAAO,IAAI,GAC3B,oBAAoB,IAAI;;AAG9B,SAAgB,OAAO,KAAa,OAAe,QAAgB,SAAS,IAAI;AAC9E,QAAO,IAAI,MAAM,GAAG,MAAM,GAAG,SAAS,IAAI,MAAM,QAAQ,OAAO"}