{"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 | 118 | custom | Writes {length} then {length} key-value pairs |\n * | array | 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 | 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,IAAa,aAAb,MAAwB;CACtB;CACA;CACA;CAEA,cAAc;AACZ,OAAK,OAAO;AACZ,OAAK,OAAO,IAAI,WAAW,IAAI;AAC/B,OAAK,OAAO,EAAE;;;AAIlB,SAAgB,mBAA+B;AAC7C,QAAO,IAAI,YAAY;;;;;AAMzB,SAAgB,OAAO,SAA6B;CAClD,IAAI,MAAM,QAAQ;AAClB,MAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAAK,QAAQ,IACvC,QAAO,QAAQ,KAAK,GAAG;AAEzB,QAAO;;;;;AAMT,SAAgB,mBAAmB,SAAiC;CAClE,MAAM,WAAW,IAAI,WAAW,OAAO,QAAQ,CAAC;CAChD,IAAI,SAAS;AACb,MAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAAK,QAAQ,KAAK;EAC5C,MAAM,IAAI,QAAQ,KAAK;AACvB,WAAS,IAAI,GAAG,OAAO;AACvB,YAAU,EAAE;;AAEd,UAAS,IAAIA,mEAAoC,QAAQ,KAAK,QAAQ,GAAG,QAAQ,KAAK,EAAE,OAAO;AAC/F,QAAO;;;;;;AAOT,SAAgB,UAAU,SAAqB,KAAa;CAC1D,MAAM,YAAY,QAAQ,KAAK;AAC/B,KAAI,YAAY,QAAQ,OAAO,KAAK;AAClC,UAAQ,KAAK,KAAKA,mEAAoC,QAAQ,KAAK,QAAQ,GAAG,QAAQ,KAAK,CAAC;AAC5F,UAAQ,OAAO,IAAI,WAAW,KAAK,IAAI,WAAW,IAAI,GAAG,EAAE;AAC3D,UAAQ,OAAO;;;;;;AAOnB,SAAgB,MAAM,SAAqB,KAAa;CACtD,MAAM,YAAY,QAAQ,KAAK;AAC/B,KAAI,QAAQ,SAAS,WAAW;AAC9B,UAAQ,KAAK,KAAK,QAAQ,KAAK;AAC/B,UAAQ,OAAO,IAAI,WAAW,YAAY,EAAE;AAC5C,UAAQ,OAAO;;AAEjB,SAAQ,KAAK,QAAQ,UAAU;;;;;;AAOjC,SAAgB,IAAI,SAAqB,KAAa,KAAa;CACjE,IAAI,SAAS;AAEb,MAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAAK,UAAU,WAAW,MAAM,KAAK;EAC/D,MAAM,IAAI,QAAQ,KAAK;AACvB,MAAI,MAAM,EAAE,OACV,UAAS;MAGT,QAAO,EAAE;;AAEb,KAAI,WAAW,KAEb,UAAS,QAAQ;AAEnB,QAAO,OAAO;;;;;AAMhB,MAAa,aAAa;;;;AAK1B,MAAa,WAAW;;;;AAKxB,SAAgB,YAAY,SAAqB,KAAa;AAC5D,OAAM,SAAS,UAAY;AAC3B,OAAM,SAAU,QAAQ,QAAW;;;;;AAKrC,SAAgB,UAAU,SAAqB,KAAa,KAAa;AACvE,KAAI,SAAS,KAAK,UAAY;AAC9B,KAAI,SAAS,MAAM,GAAI,QAAQ,QAAW;;;;;AAM5C,SAAgB,YAAY,SAAqB,KAAa;AAC5D,MAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,QAAM,SAAS,UAAY;AAC3B,WAAS;;;;;;;AAQb,SAAgB,qBAAqB,SAAqB,KAAa;AACrE,MAAK,IAAI,IAAI,GAAG,KAAK,GAAG,IACtB,OAAM,SAAU,QAAS,IAAI,QAAY;;;;;AAM7C,SAAgB,UAAU,SAAqB,KAAa,KAAa;AACvE,MAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,MAAI,SAAS,MAAM,GAAG,UAAY;AAClC,WAAS;;;;;;AAOb,SAAgB,aAAa,SAAqB,KAAa;AAC7D,QAAO,WAAa;AAClB,QAAM,qBAAyB,IAAK;AACpC,QAAM,KAAK,MAAM,MAAM,IAAI;;AAE7B,OAAM,eAAiB,IAAI;;AAG7B,SAAgB,eAAe,GAAW;AACxC,QAAO,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI;;;;;;;AAQnC,SAAgB,YAAY,SAAqB,KAAa;CAC5D,MAAM,aAAa,eAAe,IAAI;AACtC,KAAI,WACF,OAAM,CAAC;AAGT,OAAM,UAAU,iBAAqB,MAAM,kBAAoB,UAAc,IAAK;AAClF,OAAM,KAAK,MAAM,MAAM,GAAG;AAI1B,QAAO,MAAM,GAAG;AACd,QAAM,UAAU,kBAAqB,WAAc,IAAK;AACxD,QAAM,KAAK,MAAM,MAAM,IAAI;;;;;;AAO/B,SAAgB,gBAAgB,SAAqB,YAAwB;CAC3E,MAAM,YAAY,QAAQ,KAAK;CAC/B,MAAM,OAAO,QAAQ;CACrB,MAAM,cAAc,KAAK,IAAI,YAAY,MAAM,WAAW,OAAO;CACjE,MAAM,eAAe,WAAW,SAAS;AACzC,SAAQ,KAAK,IAAI,WAAW,SAAS,GAAG,YAAY,EAAE,KAAK;AAC3D,SAAQ,QAAQ;AAChB,KAAI,eAAe,GAAG;AAGpB,UAAQ,KAAK,KAAK,QAAQ,KAAK;AAE/B,UAAQ,OAAO,IAAI,WAAW,KAAK,IAAI,YAAY,GAAG,aAAa,CAAC;AAEpE,UAAQ,KAAK,IAAI,WAAW,SAAS,YAAY,CAAC;AAClD,UAAQ,OAAO;;;;;;AAOnB,SAAgB,mBAAmB,SAAqB,YAA8B;AACpF,cAAa,SAAS,WAAW,WAAW;AAC5C,iBAAgB,SAAS,WAAW;;;;;AAMtC,IAAI;AACJ,IAAI;;;;AAKJ,SAAS,sBAAsB,SAAqB,KAAa;AAC/D,KAAI,cAAc,MAAM;AACtB,eAAa,IAAI,WAAW,IAAM;AAClC,iBAAe,WAAW,SAAS;;AAGrC,KAAI,IAAI,SAAS,cAAc;EAE7B,MAAM,UAAUC,mDAAoB,CAAE,WAAW,KAAK,WAAW,CAAC,WAAW;AAC7E,eAAa,SAAS,QAAQ;AAC9B,OAAK,IAAI,IAAI,GAAG,IAAI,SAAS,IAC3B,OAAM,SAAS,WAAW,GAAG;OAG/B,oBAAmB,SAASC,0CAAW,IAAI,CAAC;;;;;AAOhD,SAAS,wBAAwB,SAAqB,KAAa;CACjE,MAAM,gBAAgB,SAAS,mBAAmB,IAAI,CAAC;CACvD,MAAM,MAAM,cAAc;AAC1B,cAAa,SAAS,IAAI;AAC1B,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,IACvB,OAAM,SAAU,cAAc,YAAY,EAAE,CAAY;;;;;AAM5D,SAAgB,eAAe,SAAqB,KAAa;AAC/D,QAAOD,mDAAoB,EAAE,aACzB,sBAAsB,SAAS,IAAI,GACnC,wBAAwB,SAAS,IAAI;;;;;;;;;AAU3C,SAAgB,mBAAmB,SAAqB,QAAoB;AAC1E,QAAO,gBAAgB,SAAS,mBAAmB,OAAO,CAAC;;;;;;;;;;;;;;;AAgB7D,SAAgB,gBAAgB,SAAqB,KAAuB;AAC1E,WAAU,SAAS,IAAI;CACvB,MAAM,QAAQ,IAAI,SAAS,QAAQ,KAAK,QAAQ,QAAQ,MAAM,IAAI;AAClE,SAAQ,QAAQ;AAChB,QAAO;;AAGT,SAAgB,aAAa,SAAqB,KAAa;AAC7D,QAAO,gBAAgB,SAAS,EAAE,CAAC,WAAW,GAAG,KAAK,MAAM;;AAG9D,SAAgB,aAAa,SAAqB,KAAa;AAC7D,QAAO,gBAAgB,SAAS,EAAE,CAAC,WAAW,GAAG,KAAK,MAAM;;AAG9D,SAAgB,cAAc,SAAqB,KAAa;AAC9D,QAAQ,gBAAgB,SAAS,EAAE,CAAE,YAAY,GAAG,KAAK,MAAM;;AAGjE,SAAgB,eAAe,SAAqB,KAAa;AAC/D,QAAQ,gBAAgB,SAAS,EAAE,CAAE,aAAa,GAAG,KAAK,MAAM;;AAGlE,IAAI;;;;AAKJ,SAAS,UAAU,KAAsB;AACvC,kCAAiB,IAAI,yBAAS,IAAI,YAAY,EAAE,CAAC;AACjD,cAAa,WAAW,GAAG,IAAI;AAC/B,QAAO,aAAa,WAAW,EAAE,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCxC,SAAgB,SAAS,SAAqB,MAA8G;AAC1J,SAAQ,OAAO,MAAf;EACE,KAAK;AAEH,SAAM,SAAS,IAAI;AACnB,kBAAe,SAAS,KAAK;AAC7B;EACF,KAAK;AACH,OAAI,OAAO,UAAU,KAAK,IAAI,KAAK,IAAI,KAAK,gBAAY;AAEtD,UAAM,SAAS,IAAI;AACnB,gBAAY,SAAS,KAAK;cAEnB,UAAU,KAAK,EAAE;AAExB,UAAM,SAAS,IAAI;AACnB,iBAAa,SAAS,KAAK;UAExB;AAEH,UAAM,SAAS,IAAI;AACnB,iBAAa,SAAS,KAAK;;AAE7B;EACF,KAAK;AAEH,SAAM,SAAS,IAAI;AACnB,iBAAc,SAAS,KAAK;AAC5B;EACF,KAAK;AACH,OAAI,SAAS,KAEX,OAAM,SAAS,IAAI;YAEZ,MAAM,QAAQ,KAAK,EAAE;AAE5B,UAAM,SAAS,IAAI;AACnB,iBAAa,SAAS,KAAK,OAAO;AAClC,SAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,IAC/B,UAAS,SAAS,KAAK,GAAG;cAErB,gBAAgB,YAAY;AAEnC,UAAM,SAAS,IAAI;AACnB,uBAAmB,SAAS,KAAK;UAE9B;AAEH,UAAM,SAAS,IAAI;IACnB,MAAM,OAAO,OAAO,KAAK,KAAK;AAC9B,SAAK,MAAM;AACX,iBAAa,SAAS,KAAK,OAAO;AAClC,SAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;KACpC,MAAM,MAAM,KAAK;AACjB,oBAAe,SAAS,IAAI;AAC5B,cAAS,SAAS,KAAK,KAAK;;;AAGhC;EACF,KAAK;AAEH,SAAM,SAAS,OAAO,MAAM,IAAI;AAChC;EACF,QAEE,OAAM,SAAS,IAAI"}