zeed 1.3.0 → 1.4.0

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

@@ -1,2 +1,299 @@
-import"./binary.mjs";import{createUint8ArrayViewFromArrayBuffer as e}from"./create.mjs";import{getUtf8TextDecoder as t}from"./string.mjs";const n=`Unexpected end of array`,r=`Integer out of Range`;var i=class{arr;pos;constructor(e){this.arr=e,this.pos=0}};function a(e){return new i(e)}function o(e){return e.pos!==e.arr.length}function s(e,t=e.pos){let n=a(e.arr);return n.pos=t,n}function c(t,n){let r=e(t.arr.buffer,t.pos+t.arr.byteOffset,n);return t.pos+=n,r}function l(e){let t=0,i=1,a=e.arr.length;for(;e.pos<a;){let n=e.arr[e.pos++];if(t+=(n&127)*i,i*=128,n<128)return t;if(t>2**53-1)throw Error(r)}throw Error(n)}function u(e){return c(e,l(e))}function d(e){return c(e,e.arr.length-e.pos)}function f(e){return e.pos++}function p(e){return e.arr[e.pos++]}function m(e){let t=e.arr[e.pos]+(e.arr[e.pos+1]<<8);return e.pos+=2,t}function h(e){let t=e.arr[e.pos]+(e.arr[e.pos+1]<<8)+(e.arr[e.pos+2]<<16)+(e.arr[e.pos+3]<<24)>>>0;return e.pos+=4,t}function g(e){let t=e.arr[e.pos+3]+(e.arr[e.pos+2]<<8)+(e.arr[e.pos+1]<<16)+(e.arr[e.pos]<<24)>>>0;return e.pos+=4,t}function _(e){return e.arr[e.pos]}function v(e){return e.arr[e.pos]+(e.arr[e.pos+1]<<8)}function y(e){return e.arr[e.pos]+(e.arr[e.pos+1]<<8)+(e.arr[e.pos+2]<<16)+(e.arr[e.pos+3]<<24)>>>0}function b(e){let t=e.arr[e.pos++],i=t&63,a=64,o=(t&64)>0?-1:1;if(!(t&128))return o*i;let s=e.arr.length;for(;e.pos<s;){if(t=e.arr[e.pos++],i+=(t&127)*a,a*=128,t<128)return o*i;if(i>2**53-1)throw Error(r)}throw Error(n)}function x(e){let t=e.pos,n=l(e);return e.pos=t,n}function S(e){let t=e.pos,n=b(e);return e.pos=t,n}function C(e){let t=l(e);if(t===0)return``;{let n=String.fromCodePoint(p(e));if(--t<100)for(;t--;)n+=String.fromCodePoint(p(e));else for(;t>0;){let r=t<1e4?t:1e4,i=e.arr.subarray(e.pos,e.pos+r);e.pos+=r,n+=String.fromCodePoint(...i),t-=r}return decodeURIComponent(escape(n))}}function w(e){let n=t();return n?n.decode(u(e)):C(e)}function T(e){let t=e.pos,n=w(e);return e.pos=t,n}function E(e,t){let n=new DataView(e.arr.buffer,e.arr.byteOffset+e.pos,t);return e.pos+=t,n}function D(e){return E(e,4).getFloat32(0,!1)}function O(e){return E(e,8).getFloat64(0,!1)}function k(e){return E(e,8).getBigInt64(0,!1)}function A(e){return E(e,8).getBigUint64(0,!1)}const j=[e=>void 0,e=>null,b,D,O,k,e=>!1,e=>!0,w,e=>{let t=l(e),n={};for(let r=0;r<t;r++){let t=w(e);n[t]=M(e)}return n},e=>{let t=l(e),n=[];for(let r=0;r<t;r++)n.push(M(e));return n},u];function M(e){return j[127-p(e)](e)}export{i as BinDecoder,s as clone,a as createDecoder,o as hasContent,v as peekUint16,y as peekUint32,_ as peekUint8,S as peekVarInt,T as peekVarString,x as peekVarUint,M as readAny,k as readBigInt64,A as readBigUint64,D as readFloat32,O as readFloat64,E as readFromDataView,d as readTailAsUint8Array,m as readUint16,h as readUint32,g as readUint32BigEndian,p as readUint8,c as readUint8Array,b as readVarInt,w as readVarString,l as readVarUint,u as readVarUint8Array,f as skip8};
+import { BIT7, BIT8, BITS6, BITS7 } from "./binary.mjs";
+import { createUint8ArrayViewFromArrayBuffer } from "./create.mjs";
+import { getUtf8TextDecoder } from "./string.mjs";
+
+//#region src/common/bin/lib0/decoding.ts
+/**
+* Original at https://github.com/dmonad/lib0
+*
+* 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 = 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
+* ```
+*/
+const errorUnexpectedEndOfArray = "Unexpected end of array";
+const errorIntegerOutOfRange = "Integer out of Range";
+/**
+* A BinDecoder handles the decoding of an Uint8Array.
+*/
+var BinDecoder = class {
+	/** Decoding target. */
+	arr;
+	/** Current decoding position. */
+	pos;
+	constructor(uint8Array) {
+		this.arr = uint8Array;
+		this.pos = 0;
+	}
+};
+function createDecoder(uint8Array) {
+	return new BinDecoder(uint8Array);
+}
+function hasContent(decoder) {
+	return decoder.pos !== decoder.arr.length;
+}
+/**
+* Clone a decoder instance.
+* Optionally set a new position parameter.
+*/
+function clone(decoder, newPos = decoder.pos) {
+	const _decoder = createDecoder(decoder.arr);
+	_decoder.pos = newPos;
+	return _decoder;
+}
+/**
+* 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 readUint8Array(decoder, len) {
+	const view = createUint8ArrayViewFromArrayBuffer(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+	decoder.pos += len;
+	return view;
+}
+/**
+* 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 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 & 127) * mult;
+		mult *= 128;
+		if (r < 128) return num;
+		if (num > Number.MAX_SAFE_INTEGER) throw new Error(errorIntegerOutOfRange);
+	}
+	throw new Error(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 readVarUint8Array(decoder) {
+	return readUint8Array(decoder, readVarUint(decoder));
+}
+/**
+* Read the rest of the content as an ArrayBuffer
+*/
+function readTailAsUint8Array(decoder) {
+	return readUint8Array(decoder, decoder.arr.length - decoder.pos);
+}
+/**
+* Skip one byte, jump to the next position.
+*/
+function skip8(decoder) {
+	return decoder.pos++;
+}
+/**
+* Read one byte as unsigned integer.
+*/
+function readUint8(decoder) {
+	return decoder.arr[decoder.pos++];
+}
+/**
+* Read 2 bytes as unsigned integer.
+*/
+function readUint16(decoder) {
+	const uint = decoder.arr[decoder.pos] + (decoder.arr[decoder.pos + 1] << 8);
+	decoder.pos += 2;
+	return uint;
+}
+/**
+* Read 4 bytes as unsigned integer.
+*/
+function readUint32(decoder) {
+	const uint = decoder.arr[decoder.pos] + (decoder.arr[decoder.pos + 1] << 8) + (decoder.arr[decoder.pos + 2] << 16) + (decoder.arr[decoder.pos + 3] << 24) >>> 0;
+	decoder.pos += 4;
+	return uint;
+}
+/**
+* Read 4 bytes as unsigned integer in big endian order.
+* (most significant byte first)
+*/
+function readUint32BigEndian(decoder) {
+	const uint = decoder.arr[decoder.pos + 3] + (decoder.arr[decoder.pos + 2] << 8) + (decoder.arr[decoder.pos + 1] << 16) + (decoder.arr[decoder.pos] << 24) >>> 0;
+	decoder.pos += 4;
+	return uint;
+}
+/**
+* Look ahead without incrementing the position
+* to the next byte and read it as unsigned integer.
+*/
+function peekUint8(decoder) {
+	return decoder.arr[decoder.pos];
+}
+/**
+* Look ahead without incrementing the position
+* to the next byte and read it as unsigned integer.
+*/
+function peekUint16(decoder) {
+	return decoder.arr[decoder.pos] + (decoder.arr[decoder.pos + 1] << 8);
+}
+/**
+* Look ahead without incrementing the position
+* to the next byte and read it as unsigned integer.
+*/
+function peekUint32(decoder) {
+	return decoder.arr[decoder.pos] + (decoder.arr[decoder.pos + 1] << 8) + (decoder.arr[decoder.pos + 2] << 16) + (decoder.arr[decoder.pos + 3] << 24) >>> 0;
+}
+/**
+* Read signed integer (32bit) with variable length.
+* 1/8th of the storage is used as encoding overhead.
+* numbers < 2^7 is stored in one bytlength
+* numbers < 2^14 is stored in two bylength
+* @todo This should probably create the inverse ~num if number is negative - but this would be a breaking change.
+*/
+function readVarInt(decoder) {
+	let r = decoder.arr[decoder.pos++];
+	let num = r & 63;
+	let mult = 64;
+	const sign = (r & 64) > 0 ? -1 : 1;
+	if ((r & 128) === 0) return sign * num;
+	const len = decoder.arr.length;
+	while (decoder.pos < len) {
+		r = decoder.arr[decoder.pos++];
+		num = num + (r & 127) * mult;
+		mult *= 128;
+		if (r < 128) return sign * num;
+		if (num > Number.MAX_SAFE_INTEGER) throw new Error(errorIntegerOutOfRange);
+	}
+	throw new Error(errorUnexpectedEndOfArray);
+}
+/**
+* Look ahead and read varUint without incrementing position
+*/
+function peekVarUint(decoder) {
+	const pos = decoder.pos;
+	const s = readVarUint(decoder);
+	decoder.pos = pos;
+	return s;
+}
+/**
+* Look ahead and read varUint without incrementing position
+*/
+function peekVarInt(decoder) {
+	const pos = decoder.pos;
+	const s = readVarInt(decoder);
+	decoder.pos = pos;
+	return s;
+}
+/**
+* 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 _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(...bytes);
+			remainingLen -= nextLen;
+		}
+		return decodeURIComponent(escape(encodedString));
+	}
+}
+/**
+* Read string of variable length
+* varUint is used to store the length of the string
+*/
+function readVarString(decoder) {
+	const utf8TextDecoder = getUtf8TextDecoder();
+	return utf8TextDecoder ? utf8TextDecoder.decode(readVarUint8Array(decoder)) : _readVarStringPolyfill(decoder);
+}
+/**
+* Look ahead and read varString without incrementing position
+*/
+function peekVarString(decoder) {
+	const pos = decoder.pos;
+	const s = readVarString(decoder);
+	decoder.pos = pos;
+	return s;
+}
+function readFromDataView(decoder, len) {
+	const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len);
+	decoder.pos += len;
+	return dv;
+}
+function readFloat32(decoder) {
+	return readFromDataView(decoder, 4).getFloat32(0, false);
+}
+function readFloat64(decoder) {
+	return readFromDataView(decoder, 8).getFloat64(0, false);
+}
+function readBigInt64(decoder) {
+	return readFromDataView(decoder, 8).getBigInt64(0, false);
+}
+function readBigUint64(decoder) {
+	return readFromDataView(decoder, 8).getBigUint64(0, false);
+}
+const readAnyLookupTable = [
+	(_) => void 0,
+	(_) => null,
+	readVarInt,
+	readFloat32,
+	readFloat64,
+	readBigInt64,
+	(_) => false,
+	(_) => true,
+	readVarString,
+	(decoder) => {
+		const len = readVarUint(decoder);
+		const obj = {};
+		for (let i = 0; i < len; i++) {
+			const key = readVarString(decoder);
+			obj[key] = readAny(decoder);
+		}
+		return obj;
+	},
+	(decoder) => {
+		const len = readVarUint(decoder);
+		const arr = [];
+		for (let i = 0; i < len; i++) arr.push(readAny(decoder));
+		return arr;
+	},
+	readVarUint8Array
+];
+function readAny(decoder) {
+	return readAnyLookupTable[127 - readUint8(decoder)](decoder);
+}
+
+//#endregion
+export { BinDecoder, clone, createDecoder, hasContent, peekUint16, peekUint32, peekUint8, peekVarInt, peekVarString, peekVarUint, readAny, readBigInt64, readBigUint64, readFloat32, readFloat64, readFromDataView, readTailAsUint8Array, readUint16, readUint32, readUint32BigEndian, readUint8, readUint8Array, readVarInt, readVarString, readVarUint, readVarUint8Array, skip8 };
 //# sourceMappingURL=decoding.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"decoding.mjs","names":[],"sources":["../../../../src/common/bin/lib0/decoding.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Efficient schema-less binary decoding with support for variable length encoding.\n *\n * Use [lib0/decoding] with [lib0/encoding]. 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 } from './binary'\nimport { createUint8ArrayViewFromArrayBuffer } from './create'\nimport { getUtf8TextDecoder } from './string'\n\nconst errorUnexpectedEndOfArray = 'Unexpected end of array'\nconst errorIntegerOutOfRange = 'Integer out of Range'\n\n/**\n * A BinDecoder handles the decoding of an Uint8Array.\n */\nexport class BinDecoder {\n  /** Decoding target. */\n  arr: Uint8Array\n  /** Current decoding position. */\n  pos: number\n\n  constructor(uint8Array: Uint8Array) {\n    this.arr = uint8Array\n    this.pos = 0\n  }\n}\n\nexport function createDecoder(uint8Array: Uint8Array): BinDecoder {\n  return new BinDecoder(uint8Array)\n}\n\nexport function hasContent(decoder: BinDecoder): boolean {\n  return decoder.pos !== decoder.arr.length\n}\n\n/**\n * Clone a decoder instance.\n * Optionally set a new position parameter.\n */\nexport function clone(decoder: BinDecoder, newPos: number = decoder.pos): BinDecoder {\n  const _decoder = createDecoder(decoder.arr)\n  _decoder.pos = newPos\n  return _decoder\n}\n\n/**\n * Create an Uint8Array view of the next `len` bytes and advance the position by `len`.\n *\n * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.\n *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.\n */\nexport function readUint8Array(decoder: BinDecoder, len: number): Uint8Array {\n  const view = createUint8ArrayViewFromArrayBuffer(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len)\n  decoder.pos += len\n  return view\n}\n\n/**\n * Read unsigned integer (32bit) with variable length.\n * 1/8th of the storage is used as encoding overhead.\n * numbers < 2^7 is stored in one bytlength\n * numbers < 2^14 is stored in two bylength\n */\nexport function readVarUint(decoder: BinDecoder): number {\n  let num = 0\n  let mult = 1\n  const len = decoder.arr.length\n  while (decoder.pos < len) {\n    const r = decoder.arr[decoder.pos++]\n    // num = num | ((r & binary.BITS7) << len)\n    num = num + (r & BITS7) * mult // shift $r << (7*#iterations) and add it to num\n    mult *= 128 // next iteration, shift 7 \"more\" to the left\n    if (r < BIT8)\n      return num\n    if (num > Number.MAX_SAFE_INTEGER)\n      throw new Error(errorIntegerOutOfRange)\n  }\n  throw new Error(errorUnexpectedEndOfArray)\n}\n\n/**\n * Read variable length Uint8Array.\n *\n * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.\n *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.\n */\nexport function readVarUint8Array(decoder: BinDecoder): Uint8Array {\n  return readUint8Array(decoder, readVarUint(decoder))\n}\n\n/**\n * Read the rest of the content as an ArrayBuffer\n */\nexport function readTailAsUint8Array(decoder: BinDecoder): Uint8Array {\n  return readUint8Array(decoder, decoder.arr.length - decoder.pos)\n}\n\n/**\n * Skip one byte, jump to the next position.\n */\nexport function skip8(decoder: BinDecoder): number {\n  return decoder.pos++\n}\n\n/**\n * Read one byte as unsigned integer.\n */\nexport function readUint8(decoder: BinDecoder): number {\n  return decoder.arr[decoder.pos++]\n}\n\n/**\n * Read 2 bytes as unsigned integer.\n */\nexport function readUint16(decoder: BinDecoder): number {\n  const uint = decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n  decoder.pos += 2\n  return uint\n}\n\n/**\n * Read 4 bytes as unsigned integer.\n */\nexport function readUint32(decoder: BinDecoder): number {\n  const uint = (decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n    + (decoder.arr[decoder.pos + 2] << 16)\n    + (decoder.arr[decoder.pos + 3] << 24)) >>> 0\n  decoder.pos += 4\n  return uint\n}\n\n/**\n * Read 4 bytes as unsigned integer in big endian order.\n * (most significant byte first)\n */\nexport function readUint32BigEndian(decoder: BinDecoder): number {\n  const uint = (decoder.arr[decoder.pos + 3]\n    + (decoder.arr[decoder.pos + 2] << 8)\n    + (decoder.arr[decoder.pos + 1] << 16)\n    + (decoder.arr[decoder.pos] << 24)) >>> 0\n  decoder.pos += 4\n  return uint\n}\n\n/**\n * Look ahead without incrementing the position\n * to the next byte and read it as unsigned integer.\n */\nexport function peekUint8(decoder: BinDecoder): number {\n  return decoder.arr[decoder.pos]\n}\n\n/**\n * Look ahead without incrementing the position\n * to the next byte and read it as unsigned integer.\n */\nexport function peekUint16(decoder: BinDecoder): number {\n  return decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n}\n\n/**\n * Look ahead without incrementing the position\n * to the next byte and read it as unsigned integer.\n */\nexport function peekUint32(decoder: BinDecoder): number {\n  return (\n    decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n    + (decoder.arr[decoder.pos + 2] << 16)\n    + (decoder.arr[decoder.pos + 3] << 24)\n  ) >>> 0\n}\n\n/**\n * Read signed integer (32bit) with variable length.\n * 1/8th of the storage is used as encoding overhead.\n * numbers < 2^7 is stored in one bytlength\n * numbers < 2^14 is stored in two bylength\n * @todo This should probably create the inverse ~num if number is negative - but this would be a breaking change.\n */\nexport function readVarInt(decoder: BinDecoder): number {\n  let r = decoder.arr[decoder.pos++]\n  let num = r & BITS6\n  let mult = 64\n  const sign = (r & BIT7) > 0 ? -1 : 1 // use Math.sign(?) for performance?\n  if ((r & BIT8) === 0) {\n    // don't continue reading\n    return sign * num\n  }\n  const len = decoder.arr.length\n  while (decoder.pos < len) {\n    r = decoder.arr[decoder.pos++]\n    // num = num | ((r & binary.BITS7) << len)\n    num = num + (r & BITS7) * mult\n    mult *= 128\n    if (r < BIT8)\n      return sign * num\n\n    if (num > Number.MAX_SAFE_INTEGER)\n      throw new Error(errorIntegerOutOfRange)\n  }\n  throw new Error(errorUnexpectedEndOfArray)\n}\n\n/**\n * Look ahead and read varUint without incrementing position\n */\nexport function peekVarUint(decoder: BinDecoder): number {\n  const pos = decoder.pos\n  const s = readVarUint(decoder)\n  decoder.pos = pos\n  return s\n}\n\n/**\n * Look ahead and read varUint without incrementing position\n */\nexport function peekVarInt(decoder: BinDecoder): number {\n  const pos = decoder.pos\n  const s = readVarInt(decoder)\n  decoder.pos = pos\n  return s\n}\n\n/**\n * We don't test this function anymore as we use native decoding/encoding by default now.\n * Better not modify this anymore..\n *\n * Transforming utf8 to a string is pretty expensive. The code performs 10x better\n * when String.fromCodePoint is fed with all characters as arguments.\n * But most environments have a maximum number of arguments per functions.\n * For effiency reasons we apply a maximum of 10000 characters at once.\n */\nfunction _readVarStringPolyfill(decoder: BinDecoder): string {\n  let remainingLen = readVarUint(decoder)\n  if (remainingLen === 0) {\n    return ''\n  }\n  else {\n    let encodedString = String.fromCodePoint(readUint8(decoder)) // remember to decrease remainingLen\n    if (--remainingLen < 100) { // do not create a Uint8Array for small strings\n      while (remainingLen--)\n        encodedString += String.fromCodePoint(readUint8(decoder))\n    }\n    else {\n      while (remainingLen > 0) {\n        const nextLen = remainingLen < 10000 ? remainingLen : 10000\n        // this is dangerous, we create a fresh array view from the existing buffer\n        const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen)\n        decoder.pos += 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    }\n    return decodeURIComponent(escape(encodedString))\n  }\n}\n\n/**\n * Read string of variable length\n * varUint is used to store the length of the string\n */\nexport function readVarString(decoder: BinDecoder): string {\n  const utf8TextDecoder = getUtf8TextDecoder()\n  return utf8TextDecoder\n    ? utf8TextDecoder.decode(readVarUint8Array(decoder))\n    : _readVarStringPolyfill(decoder)\n}\n\n/**\n * Look ahead and read varString without incrementing position\n */\nexport function peekVarString(decoder: BinDecoder): string {\n  const pos = decoder.pos\n  const s = readVarString(decoder)\n  decoder.pos = pos\n  return s\n}\n\nexport function readFromDataView(decoder: BinDecoder, len: number): DataView {\n  const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len)\n  decoder.pos += len\n  return dv\n}\n\nexport function readFloat32(decoder: BinDecoder) {\n  return readFromDataView(decoder, 4).getFloat32(0, false)\n}\n\nexport function readFloat64(decoder: BinDecoder) {\n  return readFromDataView(decoder, 8).getFloat64(0, false)\n}\n\nexport function readBigInt64(decoder: BinDecoder) {\n  return (readFromDataView(decoder, 8)).getBigInt64(0, false)\n}\n\nexport function readBigUint64(decoder: BinDecoder) {\n  return (readFromDataView(decoder, 8)).getBigUint64(0, false)\n}\n\nconst readAnyLookupTable: Array<((arg0: BinDecoder) => any)> = [\n  _ => undefined, // CASE 127: undefined\n  _ => null, // CASE 126: null\n  readVarInt, // CASE 125: integer\n  readFloat32, // CASE 124: float32\n  readFloat64, // CASE 123: float64\n  readBigInt64, // CASE 122: bigint\n  _ => false, // CASE 121: boolean (false)\n  _ => true, // CASE 120: boolean (true)\n  readVarString, // CASE 119: string\n  (decoder) => { // CASE 118: object<string,any>\n    const len = readVarUint(decoder)\n    const obj: { [s: string]: any } = {}\n    for (let i = 0; i < len; i++) {\n      const key = readVarString(decoder)\n      obj[key] = readAny(decoder)\n    }\n    return obj\n  },\n  (decoder) => { // CASE 117: array<any>\n    const len = readVarUint(decoder)\n    const arr = []\n    for (let i = 0; i < len; i++)\n\n      arr.push(readAny(decoder))\n\n    return arr\n  },\n  readVarUint8Array, // CASE 116: Uint8Array\n]\n\nexport function readAny(decoder: BinDecoder) {\n  return readAnyLookupTable[127 - readUint8(decoder)](decoder)\n}\n"],"mappings":"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"}
+{"version":3,"file":"decoding.mjs","names":[],"sources":["../../../../src/common/bin/lib0/decoding.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Efficient schema-less binary decoding with support for variable length encoding.\n *\n * Use [lib0/decoding] with [lib0/encoding]. 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 } from './binary'\nimport { createUint8ArrayViewFromArrayBuffer } from './create'\nimport { getUtf8TextDecoder } from './string'\n\nconst errorUnexpectedEndOfArray = 'Unexpected end of array'\nconst errorIntegerOutOfRange = 'Integer out of Range'\n\n/**\n * A BinDecoder handles the decoding of an Uint8Array.\n */\nexport class BinDecoder {\n  /** Decoding target. */\n  arr: Uint8Array\n  /** Current decoding position. */\n  pos: number\n\n  constructor(uint8Array: Uint8Array) {\n    this.arr = uint8Array\n    this.pos = 0\n  }\n}\n\nexport function createDecoder(uint8Array: Uint8Array): BinDecoder {\n  return new BinDecoder(uint8Array)\n}\n\nexport function hasContent(decoder: BinDecoder): boolean {\n  return decoder.pos !== decoder.arr.length\n}\n\n/**\n * Clone a decoder instance.\n * Optionally set a new position parameter.\n */\nexport function clone(decoder: BinDecoder, newPos: number = decoder.pos): BinDecoder {\n  const _decoder = createDecoder(decoder.arr)\n  _decoder.pos = newPos\n  return _decoder\n}\n\n/**\n * Create an Uint8Array view of the next `len` bytes and advance the position by `len`.\n *\n * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.\n *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.\n */\nexport function readUint8Array(decoder: BinDecoder, len: number): Uint8Array {\n  const view = createUint8ArrayViewFromArrayBuffer(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len)\n  decoder.pos += len\n  return view\n}\n\n/**\n * Read unsigned integer (32bit) with variable length.\n * 1/8th of the storage is used as encoding overhead.\n * numbers < 2^7 is stored in one bytlength\n * numbers < 2^14 is stored in two bylength\n */\nexport function readVarUint(decoder: BinDecoder): number {\n  let num = 0\n  let mult = 1\n  const len = decoder.arr.length\n  while (decoder.pos < len) {\n    const r = decoder.arr[decoder.pos++]\n    // num = num | ((r & binary.BITS7) << len)\n    num = num + (r & BITS7) * mult // shift $r << (7*#iterations) and add it to num\n    mult *= 128 // next iteration, shift 7 \"more\" to the left\n    if (r < BIT8)\n      return num\n    if (num > Number.MAX_SAFE_INTEGER)\n      throw new Error(errorIntegerOutOfRange)\n  }\n  throw new Error(errorUnexpectedEndOfArray)\n}\n\n/**\n * Read variable length Uint8Array.\n *\n * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.\n *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.\n */\nexport function readVarUint8Array(decoder: BinDecoder): Uint8Array {\n  return readUint8Array(decoder, readVarUint(decoder))\n}\n\n/**\n * Read the rest of the content as an ArrayBuffer\n */\nexport function readTailAsUint8Array(decoder: BinDecoder): Uint8Array {\n  return readUint8Array(decoder, decoder.arr.length - decoder.pos)\n}\n\n/**\n * Skip one byte, jump to the next position.\n */\nexport function skip8(decoder: BinDecoder): number {\n  return decoder.pos++\n}\n\n/**\n * Read one byte as unsigned integer.\n */\nexport function readUint8(decoder: BinDecoder): number {\n  return decoder.arr[decoder.pos++]\n}\n\n/**\n * Read 2 bytes as unsigned integer.\n */\nexport function readUint16(decoder: BinDecoder): number {\n  const uint = decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n  decoder.pos += 2\n  return uint\n}\n\n/**\n * Read 4 bytes as unsigned integer.\n */\nexport function readUint32(decoder: BinDecoder): number {\n  const uint = (decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n    + (decoder.arr[decoder.pos + 2] << 16)\n    + (decoder.arr[decoder.pos + 3] << 24)) >>> 0\n  decoder.pos += 4\n  return uint\n}\n\n/**\n * Read 4 bytes as unsigned integer in big endian order.\n * (most significant byte first)\n */\nexport function readUint32BigEndian(decoder: BinDecoder): number {\n  const uint = (decoder.arr[decoder.pos + 3]\n    + (decoder.arr[decoder.pos + 2] << 8)\n    + (decoder.arr[decoder.pos + 1] << 16)\n    + (decoder.arr[decoder.pos] << 24)) >>> 0\n  decoder.pos += 4\n  return uint\n}\n\n/**\n * Look ahead without incrementing the position\n * to the next byte and read it as unsigned integer.\n */\nexport function peekUint8(decoder: BinDecoder): number {\n  return decoder.arr[decoder.pos]\n}\n\n/**\n * Look ahead without incrementing the position\n * to the next byte and read it as unsigned integer.\n */\nexport function peekUint16(decoder: BinDecoder): number {\n  return decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n}\n\n/**\n * Look ahead without incrementing the position\n * to the next byte and read it as unsigned integer.\n */\nexport function peekUint32(decoder: BinDecoder): number {\n  return (\n    decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n    + (decoder.arr[decoder.pos + 2] << 16)\n    + (decoder.arr[decoder.pos + 3] << 24)\n  ) >>> 0\n}\n\n/**\n * Read signed integer (32bit) with variable length.\n * 1/8th of the storage is used as encoding overhead.\n * numbers < 2^7 is stored in one bytlength\n * numbers < 2^14 is stored in two bylength\n * @todo This should probably create the inverse ~num if number is negative - but this would be a breaking change.\n */\nexport function readVarInt(decoder: BinDecoder): number {\n  let r = decoder.arr[decoder.pos++]\n  let num = r & BITS6\n  let mult = 64\n  const sign = (r & BIT7) > 0 ? -1 : 1 // use Math.sign(?) for performance?\n  if ((r & BIT8) === 0) {\n    // don't continue reading\n    return sign * num\n  }\n  const len = decoder.arr.length\n  while (decoder.pos < len) {\n    r = decoder.arr[decoder.pos++]\n    // num = num | ((r & binary.BITS7) << len)\n    num = num + (r & BITS7) * mult\n    mult *= 128\n    if (r < BIT8)\n      return sign * num\n\n    if (num > Number.MAX_SAFE_INTEGER)\n      throw new Error(errorIntegerOutOfRange)\n  }\n  throw new Error(errorUnexpectedEndOfArray)\n}\n\n/**\n * Look ahead and read varUint without incrementing position\n */\nexport function peekVarUint(decoder: BinDecoder): number {\n  const pos = decoder.pos\n  const s = readVarUint(decoder)\n  decoder.pos = pos\n  return s\n}\n\n/**\n * Look ahead and read varUint without incrementing position\n */\nexport function peekVarInt(decoder: BinDecoder): number {\n  const pos = decoder.pos\n  const s = readVarInt(decoder)\n  decoder.pos = pos\n  return s\n}\n\n/**\n * We don't test this function anymore as we use native decoding/encoding by default now.\n * Better not modify this anymore..\n *\n * Transforming utf8 to a string is pretty expensive. The code performs 10x better\n * when String.fromCodePoint is fed with all characters as arguments.\n * But most environments have a maximum number of arguments per functions.\n * For effiency reasons we apply a maximum of 10000 characters at once.\n */\nfunction _readVarStringPolyfill(decoder: BinDecoder): string {\n  let remainingLen = readVarUint(decoder)\n  if (remainingLen === 0) {\n    return ''\n  }\n  else {\n    let encodedString = String.fromCodePoint(readUint8(decoder)) // remember to decrease remainingLen\n    if (--remainingLen < 100) { // do not create a Uint8Array for small strings\n      while (remainingLen--)\n        encodedString += String.fromCodePoint(readUint8(decoder))\n    }\n    else {\n      while (remainingLen > 0) {\n        const nextLen = remainingLen < 10000 ? remainingLen : 10000\n        // this is dangerous, we create a fresh array view from the existing buffer\n        const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen)\n        decoder.pos += 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    }\n    return decodeURIComponent(escape(encodedString))\n  }\n}\n\n/**\n * Read string of variable length\n * varUint is used to store the length of the string\n */\nexport function readVarString(decoder: BinDecoder): string {\n  const utf8TextDecoder = getUtf8TextDecoder()\n  return utf8TextDecoder\n    ? utf8TextDecoder.decode(readVarUint8Array(decoder))\n    : _readVarStringPolyfill(decoder)\n}\n\n/**\n * Look ahead and read varString without incrementing position\n */\nexport function peekVarString(decoder: BinDecoder): string {\n  const pos = decoder.pos\n  const s = readVarString(decoder)\n  decoder.pos = pos\n  return s\n}\n\nexport function readFromDataView(decoder: BinDecoder, len: number): DataView {\n  const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len)\n  decoder.pos += len\n  return dv\n}\n\nexport function readFloat32(decoder: BinDecoder) {\n  return readFromDataView(decoder, 4).getFloat32(0, false)\n}\n\nexport function readFloat64(decoder: BinDecoder) {\n  return readFromDataView(decoder, 8).getFloat64(0, false)\n}\n\nexport function readBigInt64(decoder: BinDecoder) {\n  return (readFromDataView(decoder, 8)).getBigInt64(0, false)\n}\n\nexport function readBigUint64(decoder: BinDecoder) {\n  return (readFromDataView(decoder, 8)).getBigUint64(0, false)\n}\n\nconst readAnyLookupTable: Array<((arg0: BinDecoder) => any)> = [\n  _ => undefined, // CASE 127: undefined\n  _ => null, // CASE 126: null\n  readVarInt, // CASE 125: integer\n  readFloat32, // CASE 124: float32\n  readFloat64, // CASE 123: float64\n  readBigInt64, // CASE 122: bigint\n  _ => false, // CASE 121: boolean (false)\n  _ => true, // CASE 120: boolean (true)\n  readVarString, // CASE 119: string\n  (decoder) => { // CASE 118: object<string,any>\n    const len = readVarUint(decoder)\n    const obj: { [s: string]: any } = {}\n    for (let i = 0; i < len; i++) {\n      const key = readVarString(decoder)\n      obj[key] = readAny(decoder)\n    }\n    return obj\n  },\n  (decoder) => { // CASE 117: array<any>\n    const len = readVarUint(decoder)\n    const arr = []\n    for (let i = 0; i < len; i++)\n\n      arr.push(readAny(decoder))\n\n    return arr\n  },\n  readVarUint8Array, // CASE 116: Uint8Array\n]\n\nexport function readAny(decoder: BinDecoder) {\n  return readAnyLookupTable[127 - readUint8(decoder)](decoder)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,MAAM,4BAA4B;AAClC,MAAM,yBAAyB;;;;AAK/B,IAAa,aAAb,MAAwB;;CAEtB;;CAEA;CAEA,YAAY,YAAwB;AAClC,OAAK,MAAM;AACX,OAAK,MAAM;;;AAIf,SAAgB,cAAc,YAAoC;AAChE,QAAO,IAAI,WAAW,WAAW;;AAGnC,SAAgB,WAAW,SAA8B;AACvD,QAAO,QAAQ,QAAQ,QAAQ,IAAI;;;;;;AAOrC,SAAgB,MAAM,SAAqB,SAAiB,QAAQ,KAAiB;CACnF,MAAM,WAAW,cAAc,QAAQ,IAAI;AAC3C,UAAS,MAAM;AACf,QAAO;;;;;;;;AAST,SAAgB,eAAe,SAAqB,KAAyB;CAC3E,MAAM,OAAO,oCAAoC,QAAQ,IAAI,QAAQ,QAAQ,MAAM,QAAQ,IAAI,YAAY,IAAI;AAC/G,SAAQ,OAAO;AACf,QAAO;;;;;;;;AAST,SAAgB,YAAY,SAA6B;CACvD,IAAI,MAAM;CACV,IAAI,OAAO;CACX,MAAM,MAAM,QAAQ,IAAI;AACxB,QAAO,QAAQ,MAAM,KAAK;EACxB,MAAM,IAAI,QAAQ,IAAI,QAAQ;AAE9B,QAAM,OAAO,WAAa;AAC1B,UAAQ;AACR,MAAI,QACF,QAAO;AACT,MAAI,MAAM,OAAO,iBACf,OAAM,IAAI,MAAM,uBAAuB;;AAE3C,OAAM,IAAI,MAAM,0BAA0B;;;;;;;;AAS5C,SAAgB,kBAAkB,SAAiC;AACjE,QAAO,eAAe,SAAS,YAAY,QAAQ,CAAC;;;;;AAMtD,SAAgB,qBAAqB,SAAiC;AACpE,QAAO,eAAe,SAAS,QAAQ,IAAI,SAAS,QAAQ,IAAI;;;;;AAMlE,SAAgB,MAAM,SAA6B;AACjD,QAAO,QAAQ;;;;;AAMjB,SAAgB,UAAU,SAA6B;AACrD,QAAO,QAAQ,IAAI,QAAQ;;;;;AAM7B,SAAgB,WAAW,SAA6B;CACtD,MAAM,OAAO,QAAQ,IAAI,QAAQ,QAC5B,QAAQ,IAAI,QAAQ,MAAM,MAAM;AACrC,SAAQ,OAAO;AACf,QAAO;;;;;AAMT,SAAgB,WAAW,SAA6B;CACtD,MAAM,OAAQ,QAAQ,IAAI,QAAQ,QAC7B,QAAQ,IAAI,QAAQ,MAAM,MAAM,MAChC,QAAQ,IAAI,QAAQ,MAAM,MAAM,OAChC,QAAQ,IAAI,QAAQ,MAAM,MAAM,QAAS;AAC9C,SAAQ,OAAO;AACf,QAAO;;;;;;AAOT,SAAgB,oBAAoB,SAA6B;CAC/D,MAAM,OAAQ,QAAQ,IAAI,QAAQ,MAAM,MACnC,QAAQ,IAAI,QAAQ,MAAM,MAAM,MAChC,QAAQ,IAAI,QAAQ,MAAM,MAAM,OAChC,QAAQ,IAAI,QAAQ,QAAQ,QAAS;AAC1C,SAAQ,OAAO;AACf,QAAO;;;;;;AAOT,SAAgB,UAAU,SAA6B;AACrD,QAAO,QAAQ,IAAI,QAAQ;;;;;;AAO7B,SAAgB,WAAW,SAA6B;AACtD,QAAO,QAAQ,IAAI,QAAQ,QACtB,QAAQ,IAAI,QAAQ,MAAM,MAAM;;;;;;AAOvC,SAAgB,WAAW,SAA6B;AACtD,QACE,QAAQ,IAAI,QAAQ,QACjB,QAAQ,IAAI,QAAQ,MAAM,MAAM,MAChC,QAAQ,IAAI,QAAQ,MAAM,MAAM,OAChC,QAAQ,IAAI,QAAQ,MAAM,MAAM,QAC/B;;;;;;;;;AAUR,SAAgB,WAAW,SAA6B;CACtD,IAAI,IAAI,QAAQ,IAAI,QAAQ;CAC5B,IAAI,MAAM;CACV,IAAI,OAAO;CACX,MAAM,QAAQ,UAAY,IAAI,KAAK;AACnC,MAAK,aAAc,EAEjB,QAAO,OAAO;CAEhB,MAAM,MAAM,QAAQ,IAAI;AACxB,QAAO,QAAQ,MAAM,KAAK;AACxB,MAAI,QAAQ,IAAI,QAAQ;AAExB,QAAM,OAAO,WAAa;AAC1B,UAAQ;AACR,MAAI,QACF,QAAO,OAAO;AAEhB,MAAI,MAAM,OAAO,iBACf,OAAM,IAAI,MAAM,uBAAuB;;AAE3C,OAAM,IAAI,MAAM,0BAA0B;;;;;AAM5C,SAAgB,YAAY,SAA6B;CACvD,MAAM,MAAM,QAAQ;CACpB,MAAM,IAAI,YAAY,QAAQ;AAC9B,SAAQ,MAAM;AACd,QAAO;;;;;AAMT,SAAgB,WAAW,SAA6B;CACtD,MAAM,MAAM,QAAQ;CACpB,MAAM,IAAI,WAAW,QAAQ;AAC7B,SAAQ,MAAM;AACd,QAAO;;;;;;;;;;;AAYT,SAAS,uBAAuB,SAA6B;CAC3D,IAAI,eAAe,YAAY,QAAQ;AACvC,KAAI,iBAAiB,EACnB,QAAO;MAEJ;EACH,IAAI,gBAAgB,OAAO,cAAc,UAAU,QAAQ,CAAC;AAC5D,MAAI,EAAE,eAAe,IACnB,QAAO,eACL,kBAAiB,OAAO,cAAc,UAAU,QAAQ,CAAC;MAG3D,QAAO,eAAe,GAAG;GACvB,MAAM,UAAU,eAAe,MAAQ,eAAe;GAEtD,MAAM,QAAQ,QAAQ,IAAI,SAAS,QAAQ,KAAK,QAAQ,MAAM,QAAQ;AACtE,WAAQ,OAAO;AAEf,oBAAiB,OAAO,cAAc,GAAG,MAAa;AACtD,mBAAgB;;AAGpB,SAAO,mBAAmB,OAAO,cAAc,CAAC;;;;;;;AAQpD,SAAgB,cAAc,SAA6B;CACzD,MAAM,kBAAkB,oBAAoB;AAC5C,QAAO,kBACH,gBAAgB,OAAO,kBAAkB,QAAQ,CAAC,GAClD,uBAAuB,QAAQ;;;;;AAMrC,SAAgB,cAAc,SAA6B;CACzD,MAAM,MAAM,QAAQ;CACpB,MAAM,IAAI,cAAc,QAAQ;AAChC,SAAQ,MAAM;AACd,QAAO;;AAGT,SAAgB,iBAAiB,SAAqB,KAAuB;CAC3E,MAAM,KAAK,IAAI,SAAS,QAAQ,IAAI,QAAQ,QAAQ,IAAI,aAAa,QAAQ,KAAK,IAAI;AACtF,SAAQ,OAAO;AACf,QAAO;;AAGT,SAAgB,YAAY,SAAqB;AAC/C,QAAO,iBAAiB,SAAS,EAAE,CAAC,WAAW,GAAG,MAAM;;AAG1D,SAAgB,YAAY,SAAqB;AAC/C,QAAO,iBAAiB,SAAS,EAAE,CAAC,WAAW,GAAG,MAAM;;AAG1D,SAAgB,aAAa,SAAqB;AAChD,QAAQ,iBAAiB,SAAS,EAAE,CAAE,YAAY,GAAG,MAAM;;AAG7D,SAAgB,cAAc,SAAqB;AACjD,QAAQ,iBAAiB,SAAS,EAAE,CAAE,aAAa,GAAG,MAAM;;AAG9D,MAAM,qBAAyD;EAC7D,MAAK;EACL,MAAK;CACL;CACA;CACA;CACA;EACA,MAAK;EACL,MAAK;CACL;EACC,YAAY;EACX,MAAM,MAAM,YAAY,QAAQ;EAChC,MAAM,MAA4B,EAAE;AACpC,OAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK;GAC5B,MAAM,MAAM,cAAc,QAAQ;AAClC,OAAI,OAAO,QAAQ,QAAQ;;AAE7B,SAAO;;EAER,YAAY;EACX,MAAM,MAAM,YAAY,QAAQ;EAChC,MAAM,MAAM,EAAE;AACd,OAAK,IAAI,IAAI,GAAG,IAAI,KAAK,IAEvB,KAAI,KAAK,QAAQ,QAAQ,CAAC;AAE5B,SAAO;;CAET;CACD;AAED,SAAgB,QAAQ,SAAqB;AAC3C,QAAO,mBAAmB,MAAM,UAAU,QAAQ,EAAE,QAAQ"}