@push.rocks/smartlinuxrepo 0.0.0-stage → 0.1.0

package/dist_ts/readers/tar.js

@@ -0,0 +1,731 @@
+import { LinuxRepoError, limitExceeded, truncated } from '../shared/errors.js';
+import { concatBytes, LimitedReader, readExact, readUpTo } from './bytes.js';
+import { decodeGoUtf8, decodeLatin1 } from './text.js';
+const BLOCK = 512;
+/** Type flags whose header size never has data (Go `isHeaderOnlyType`). */
+const HEADER_ONLY_TYPES = new Set(['1', '2', '3', '4', '5', '6']);
+const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+const INT64_MIN = -(1n << 63n);
+const INT64_MAX = (1n << 63n) - 1n;
+/**
+ * Go `maxSpecialFileSize` (format.go:147-149): the most Go reads of one PAX
+ * header, GNU long name or long link, old GNU sparse map or PAX GNU 1.0
+ * sparse map, whatever `maxHeaderBytes` allows.
+ */
+const MAX_SPECIAL_FILE_SIZE = 1 << 20;
+/**
+ * A bounded ustar reader following Go `archive/tar` (Gitea's reader):
+ * USTAR, PAX (`x`, `g`), GNU long names (`L`, `K`), STAR prefixes, Go's
+ * pre-1.8 GNU prefix fallback, base-256 numbers and signed or unsigned
+ * checksums. A header Go refuses for an unparseable numeric field is refused. The archive ends at two zero
+ * blocks, at a clean end of input on a header boundary (apk segments have no
+ * end marker), or when the input ends inside the padding after an entry.
+ * Sparse maps (old GNU, PAX GNU 0.0, 0.1 and 1.0) are read and validated as
+ * Go does; the holes are not expanded, so a sparse entry's data can only be
+ * skipped.
+ */
+export class TarReader {
+    input;
+    options;
+    done = false;
+    current = null;
+    pad = 0;
+    entries = 0;
+    constructor(input, options) {
+        this.input = input;
+        this.options = options;
+    }
+    async next() {
+        if (this.done) {
+            return null;
+        }
+        if (this.current !== null) {
+            await this.current.skipRest();
+            this.current = null;
+        }
+        if (!(await this.consumePadding())) {
+            return this.finish();
+        }
+        let chainBytes = 0;
+        let paxRecords = null;
+        let gnuLongName = null;
+        let gnuLongLink = null;
+        const addChain = (bytesArg) => {
+            chainBytes += bytesArg;
+            if (chainBytes > this.options.maxHeaderBytes) {
+                throw limitExceeded('maxHeaderBytes', this.options.maxHeaderBytes, 'tar header chain');
+            }
+        };
+        for (;;) {
+            const block = await readUpTo(this.input, BLOCK);
+            if (block.length === 0) {
+                return this.finish();
+            }
+            if (block.length < BLOCK) {
+                throw truncated('tar header');
+            }
+            if (isZeroBlock(block)) {
+                const second = await readUpTo(this.input, BLOCK);
+                if (second.length === 0) {
+                    return this.finish();
+                }
+                if (second.length < BLOCK) {
+                    throw truncated('tar end-of-archive marker');
+                }
+                if (isZeroBlock(second)) {
+                    return this.finish();
+                }
+                throw malformed('a zero block is followed by a non-zero block');
+            }
+            addChain(BLOCK);
+            const header = parseHeaderBlock(block);
+            if (header.typeflag === 'x' || header.typeflag === 'g') {
+                const size = specialFileSize(header, 'PAX header');
+                addChain(size);
+                const data = await readExact(this.input, size, 'tar PAX header');
+                this.pad = padding(size);
+                const records = parsePax(data);
+                if (header.typeflag === 'g') {
+                    this.countEntry();
+                    this.current = new LimitedReader(this.input, 0, 'tar entry data');
+                    // Go returns a global header's name, type flag and records only, and
+                    // ignores mergePAX's error for it (reader.go:107-116); after a failing
+                    // record Go's name depends on map order, the codec takes `path`
+                    const name = records.get('path') || header.name;
+                    return { name, linkName: '', mode: 0n, typeflag: 'g', size: 0n, sparse: false, body: this.current };
+                }
+                paxRecords = records;
+                if (!(await this.consumePadding())) {
+                    return this.finish();
+                }
+                continue;
+            }
+            if (header.typeflag === 'L' || header.typeflag === 'K') {
+                const size = specialFileSize(header, 'GNU long name or link');
+                addChain(size);
+                const data = await readExact(this.input, size, 'tar GNU long name');
+                this.pad = padding(size);
+                const value = decodeGoUtf8(cutAtNul(data));
+                if (header.typeflag === 'L') {
+                    gnuLongName = value;
+                }
+                else {
+                    gnuLongLink = value;
+                }
+                if (!(await this.consumePadding())) {
+                    return this.finish();
+                }
+                continue;
+            }
+            // a real entry: Go mergePAX (reader.go:261-305), then the GNU long names
+            let name = header.name;
+            let linkName = header.linkName;
+            let size = header.size;
+            if (paxRecords !== null) {
+                checkPaxNumbers(paxRecords);
+                const path = paxRecords.get('path');
+                if (path) {
+                    name = path;
+                }
+                const linkPath = paxRecords.get('linkpath');
+                if (linkPath) {
+                    linkName = linkPath;
+                }
+                const paxSize = paxRecords.get('size');
+                if (paxSize) {
+                    size = parsePaxInt(paxSize, 'size');
+                }
+            }
+            if (gnuLongName !== null && gnuLongName !== '') {
+                name = gnuLongName;
+            }
+            if (gnuLongLink !== null && gnuLongLink !== '') {
+                linkName = gnuLongLink;
+            }
+            let typeflag = header.typeflag;
+            if (typeflag === '\0') {
+                typeflag = name.endsWith('/') ? '5' : '0';
+            }
+            const dataSize = HEADER_ONLY_TYPES.has(typeflag) ? 0n : size;
+            if (dataSize < 0n) {
+                throw malformed('negative entry size');
+            }
+            if (dataSize > MAX_SAFE) {
+                throw malformed('entry size is out of range');
+            }
+            const length = Number(dataSize);
+            let body = new LimitedReader(this.input, length, 'tar entry data');
+            // Go handleSparseFile (reader.go:195-214): the reported size becomes the real size
+            let reportedSize = dataSize;
+            let sparse = false;
+            if (typeflag === 'S') {
+                reportedSize = await this.readOldGnuSparseMap(block, header.format, addChain);
+                sparse = true;
+            }
+            else if (paxRecords !== null) {
+                const version = gnuSparseVersion(paxRecords);
+                if (version !== null) {
+                    // Go readGNUSparsePAXHeaders (reader.go:220-259)
+                    const sparseName = paxRecords.get('GNU.sparse.name') ?? '';
+                    if (sparseName !== '') {
+                        name = sparseName;
+                    }
+                    const realSizeText = paxRecords.get('GNU.sparse.size') || paxRecords.get('GNU.sparse.realsize') || '';
+                    const realSize = realSizeText === '' ? size : parsePaxInt(realSizeText, 'GNU sparse size');
+                    const check = new SparseMapCheck(realSize);
+                    if (version === '1.0') {
+                        await checkGnuSparseMap1x0(body, check);
+                    }
+                    else {
+                        checkGnuSparseMap0x1(paxRecords, check);
+                    }
+                    if (HEADER_ONLY_TYPES.has(typeflag) || !check.valid) {
+                        throw malformed('invalid sparse map');
+                    }
+                    reportedSize = realSize;
+                    sparse = true;
+                }
+            }
+            this.countEntry();
+            if (sparse) {
+                body = new SparseEntryBody(this.input, body.unreadBytes, name);
+            }
+            this.current = body;
+            this.pad = padding(length);
+            return { name, linkName, mode: header.mode, typeflag, size: reportedSize, sparse, body };
+        }
+    }
+    /**
+     * Go `readOldGNUSparseMap` (reader.go:478-525) and the map check of
+     * `handleSparseFile`; returns the real size. The map fills the header's
+     * sparse array and extension blocks; Go gives up once its arrays reach
+     * 1 MiB (`errSparseTooLong`), whatever `maxHeaderBytes` allows.
+     */
+    async readOldGnuSparseMap(blockArg, formatArg, addChainArg) {
+        if (formatArg !== 'gnu') {
+            throw malformed('old GNU sparse entry outside the GNU format');
+        }
+        const realSize = parseNumeric(blockArg.subarray(483, 495), 'GNU sparse real size');
+        const check = new SparseMapCheck(realSize);
+        let array = blockArg.subarray(386, 483); // format.go:276
+        let totalSize = array.length;
+        while (totalSize < MAX_SPECIAL_FILE_SIZE) {
+            if (!checkOldGnuSparseArray(array, check)) {
+                if (!check.valid) {
+                    throw malformed('invalid sparse map');
+                }
+                return realSize;
+            }
+            addChainArg(BLOCK);
+            array = await readExact(this.input, BLOCK, 'tar sparse header'); // a whole block (format.go:173)
+            totalSize += array.length;
+        }
+        throw malformed('the old GNU sparse map is longer than 1 MiB');
+    }
+    countEntry() {
+        this.entries += 1;
+        if (this.entries > this.options.maxEntries) {
+            throw limitExceeded('maxEntries', this.options.maxEntries, 'tar entry count');
+        }
+    }
+    /** Reads the pending padding; false when the input ended inside it (a clean end, as in Go). */
+    async consumePadding() {
+        if (this.pad === 0) {
+            return true;
+        }
+        const expected = this.pad;
+        this.pad = 0;
+        const bytes = await readUpTo(this.input, expected);
+        return bytes.length === expected;
+    }
+    finish() {
+        this.done = true;
+        this.current = null;
+        return null;
+    }
+}
+/**
+ * The stored fragments of a sparse entry. The codec does not expand holes,
+ * so reading is refused; `skipRest`, and so `TarReader.next`, skips them.
+ */
+class SparseEntryBody extends LimitedReader {
+    entryName;
+    constructor(innerArg, lengthArg, entryName) {
+        super(innerArg, lengthArg, 'tar entry data');
+        this.entryName = entryName;
+    }
+    async read() {
+        throw sparseDataRefused(this.entryName);
+    }
+}
+/**
+ * Reads a whole entry's data into memory, refusing entries larger than
+ * `maxBytesArg` before reading them, and sparse entries at all.
+ */
+export async function readTarEntryData(entryArg, maxBytesArg, limitArg) {
+    if (entryArg.sparse) {
+        throw sparseDataRefused(entryArg.name);
+    }
+    if (entryArg.size > BigInt(maxBytesArg)) {
+        throw limitExceeded(limitArg, maxBytesArg, `tar entry ${entryArg.name}`);
+    }
+    return readExact(entryArg.body, Number(entryArg.size), 'tar entry data');
+}
+/** Go `block.getFormat`'s magic detection (format.go:187-200); the checksum is checked first. */
+function headerFormat(blockArg) {
+    const magic = decodeLatin1(blockArg.subarray(257, 263));
+    const version = decodeLatin1(blockArg.subarray(263, 265));
+    const trailer = decodeLatin1(blockArg.subarray(508, 512));
+    if (magic === 'ustar\0' && trailer === 'tar\0') {
+        return 'star';
+    }
+    if (magic === 'ustar\0') {
+        return 'ustar'; // USTAR or PAX
+    }
+    if (magic === 'ustar ' && version === ' \0') {
+        return 'gnu';
+    }
+    return 'v7';
+}
+/**
+ * Go `Reader.readHeader` (reader.go:356-468): every numeric field Go parses
+ * with its fatal parser fails the archive here too, although only size and
+ * mode are kept.
+ */
+function parseHeaderBlock(blockArg) {
+    verifyChecksum(blockArg);
+    const format = headerFormat(blockArg);
+    // reader.go:385-389, all formats
+    const size = parseNumeric(blockArg.subarray(124, 136), 'size');
+    const mode = parseNumeric(blockArg.subarray(100, 108), 'mode');
+    parseNumeric(blockArg.subarray(108, 116), 'uid');
+    parseNumeric(blockArg.subarray(116, 124), 'gid');
+    parseNumeric(blockArg.subarray(136, 148), 'mtime');
+    let prefix = new Uint8Array(0);
+    if (format !== 'v7') {
+        // reader.go:392-397: above V7 only, so a V7 header may hold anything there
+        parseNumeric(blockArg.subarray(329, 337), 'devmajor');
+        parseNumeric(blockArg.subarray(337, 345), 'devminor');
+        if (format === 'ustar') {
+            prefix = cutAtNul(blockArg.subarray(345, 500)); // reader.go:401-404
+        }
+        else if (format === 'star') {
+            // reader.go:417-421
+            prefix = cutAtNul(blockArg.subarray(345, 476));
+            parseNumeric(blockArg.subarray(476, 488), 'STAR atime');
+            parseNumeric(blockArg.subarray(488, 500), 'STAR ctime');
+        }
+        else {
+            prefix = gnuLegacyPrefix(blockArg);
+        }
+    }
+    let name = decodeGoUtf8(cutAtNul(blockArg.subarray(0, 100)));
+    if (prefix.length > 0) {
+        name = `${decodeGoUtf8(prefix)}/${name}`; // reader.go:463-465
+    }
+    return {
+        name,
+        linkName: decodeGoUtf8(cutAtNul(blockArg.subarray(157, 257))),
+        mode,
+        typeflag: String.fromCharCode(blockArg[156]),
+        size,
+        format,
+    };
+}
+/**
+ * The old GNU format has no prefix field, but Go before 1.8 wrote one over
+ * atime and ctime. Go parses each of the two only when its first byte is not
+ * NUL, with a parser whose failure is not fatal; when either fails it takes
+ * bytes [345, 500) up to the first NUL as the prefix if they are ASCII
+ * (reader.go:422-461, `isASCII` strconv.go:21-28).
+ */
+function gnuLegacyPrefix(blockArg) {
+    const parses = (fieldArg) => fieldArg[0] === 0 || goNumeric(fieldArg) !== null;
+    if (parses(blockArg.subarray(345, 357)) && parses(blockArg.subarray(357, 369))) {
+        return new Uint8Array(0);
+    }
+    const prefix = cutAtNul(blockArg.subarray(345, 500));
+    return prefix.every((byteArg) => byteArg < 0x80) ? prefix : new Uint8Array(0);
+}
+/**
+ * Reads one old GNU sparse array (Go `sparseArray`, format.go:304-313):
+ * 24-byte entries, each a 12-byte offset and length, then the isExtended
+ * byte. As in Go `readOldGNUSparseMap` (reader.go:496-511), the entries up to
+ * the first whose offset starts with NUL must parse and go into the map
+ * check. Returns isExtended.
+ */
+function checkOldGnuSparseArray(arrayArg, checkArg) {
+    const entries = Math.floor(arrayArg.length / 24);
+    for (let i = 0; i < entries; i++) {
+        const entry = arrayArg.subarray(i * 24, i * 24 + 24);
+        if (entry[0] === 0) {
+            break;
+        }
+        const offset = parseNumeric(entry.subarray(0, 12), 'GNU sparse offset');
+        const length = parseNumeric(entry.subarray(12, 24), 'GNU sparse length');
+        checkArg.add(offset, length);
+    }
+    return arrayArg[entries * 24] !== 0;
+}
+/**
+ * Go `validateSparseEntries` (common.go:255-278), fed one map entry at a
+ * time: no negative offset or length, no int64 overflow, no fragment past the
+ * real size, fragments in order without overlap; a negative real size fails
+ * even an empty map. Go checks the map once it has parsed all of it
+ * (reader.go:206-209), so callers read `valid` after the last entry. Go's
+ * `maxSparseFileEntries` (reader.go:643-648) is not ported: the 1 MiB caps
+ * keep every map below it.
+ */
+class SparseMapCheck {
+    size;
+    previousEnd = 0n;
+    ok;
+    constructor(size) {
+        this.size = size;
+        this.ok = size >= 0n;
+    }
+    get valid() {
+        return this.ok;
+    }
+    add(offsetArg, lengthArg) {
+        if (!this.ok) {
+            return;
+        }
+        const end = offsetArg + lengthArg;
+        if (offsetArg < 0n || lengthArg < 0n || end > INT64_MAX || end > this.size || this.previousEnd > offsetArg) {
+            this.ok = false;
+            return;
+        }
+        this.previousEnd = end;
+    }
+}
+/**
+ * Go `readGNUSparsePAXHeaders`' version detection (reader.go:221-235): 0.0
+ * and 0.1 keep their map in PAX records, 1.0 at the start of the data; null
+ * when the records describe no PAX GNU sparse file.
+ */
+function gnuSparseVersion(recordsArg) {
+    const major = recordsArg.get('GNU.sparse.major') ?? '';
+    const minor = recordsArg.get('GNU.sparse.minor') ?? '';
+    if (major === '0' && (minor === '0' || minor === '1')) {
+        return '0.x';
+    }
+    if (major === '1' && minor === '0') {
+        return '1.0';
+    }
+    if (major !== '' || minor !== '') {
+        return null; // an unknown version
+    }
+    return (recordsArg.get('GNU.sparse.map') ?? '') !== '' ? '0.x' : null;
+}
+/**
+ * Go `readGNUSparseMap0x1` (reader.go:607-641): `GNU.sparse.numblocks`
+ * entries in `GNU.sparse.map` as comma-separated offset and length pairs
+ * (0.0 records arrive here already joined by `parsePax`).
+ */
+function checkGnuSparseMap0x1(recordsArg, checkArg) {
+    const count = sparseEntryCount(recordsArg.get('GNU.sparse.numblocks') ?? '');
+    const map = recordsArg.get('GNU.sparse.map') ?? '';
+    const fields = map === '' ? [] : map.split(',');
+    if (BigInt(fields.length) !== 2n * count) {
+        throw malformed('the sparse map does not hold GNU.sparse.numblocks entries');
+    }
+    for (let i = 0; i < fields.length; i += 2) {
+        const offset = goParseInt(fields[i]);
+        const length = goParseInt(fields[i + 1]);
+        if (offset === null || length === null) {
+            throw malformed('a sparse map entry is not a decimal integer');
+        }
+        checkArg.add(offset, length);
+    }
+}
+/**
+ * Go `readGNUSparseMap1x0` (reader.go:537-603): the map heads the entry's
+ * data as newline-terminated decimals, the entry count and then offset and
+ * length pairs. Go reads whole blocks until it holds the newlines it needs,
+ * at most 1 MiB of them (`errSparseTooLong`); the data after the last of
+ * those blocks is the stored fragments.
+ */
+async function checkGnuSparseMap1x0(dataArg, checkArg) {
+    let buffer = new Uint8Array(0);
+    let cursor = 0;
+    let newlines = 0;
+    let totalSize = 0;
+    const feedTokens = async (countArg) => {
+        const chunks = [buffer.subarray(cursor)];
+        while (BigInt(newlines) < countArg) {
+            totalSize += BLOCK;
+            if (totalSize > MAX_SPECIAL_FILE_SIZE) {
+                throw malformed('the PAX GNU sparse map is longer than 1 MiB');
+            }
+            const block = await readUpTo(dataArg, BLOCK);
+            if (block.length < BLOCK) {
+                throw malformed('the PAX GNU sparse map runs past the entry data');
+            }
+            chunks.push(block);
+            for (const byte of block) {
+                if (byte === 0x0a) {
+                    newlines++;
+                }
+            }
+        }
+        buffer = concatBytes(chunks);
+        cursor = 0;
+    };
+    const nextToken = () => {
+        newlines--;
+        const end = buffer.indexOf(0x0a, cursor);
+        const token = decodeLatin1(buffer.subarray(cursor, end));
+        cursor = end + 1;
+        return token;
+    };
+    await feedTokens(1n);
+    const count = sparseEntryCount(nextToken());
+    await feedTokens(2n * count);
+    for (let i = 0n; i < count; i++) {
+        const offset = goParseInt(nextToken());
+        const length = goParseInt(nextToken());
+        if (offset === null || length === null) {
+            throw malformed('a sparse map entry is not a decimal integer');
+        }
+        checkArg.add(offset, length);
+    }
+}
+/** A sparse map's entry count as Go checks it (reader.go:579-582, :611-614). */
+function sparseEntryCount(textArg) {
+    const count = goParseInt(textArg);
+    if (count === null || count < 0n || 2n * count > INT64_MAX) {
+        throw malformed('invalid sparse map entry count');
+    }
+    return count;
+}
+function verifyChecksum(blockArg) {
+    const stored = goOctal(blockArg.subarray(148, 156));
+    if (stored === null) {
+        throw malformed('checksum field is not octal');
+    }
+    let unsigned = 0;
+    let signed = 0;
+    for (let i = 0; i < BLOCK; i++) {
+        const byte = i >= 148 && i < 156 ? 0x20 : blockArg[i];
+        unsigned += byte;
+        signed += byte >= 0x80 ? byte - 0x100 : byte;
+    }
+    if (stored !== BigInt(unsigned) && stored !== BigInt(signed)) {
+        throw malformed('header checksum mismatch');
+    }
+}
+/** Go `parser.parseNumeric` (strconv.go:96-135), failing the archive where Go sets its error. */
+function parseNumeric(fieldArg, whatArg) {
+    const value = goNumeric(fieldArg);
+    if (value === null) {
+        throw malformed(`${whatArg} field is not a valid tar number`);
+    }
+    return value;
+}
+/**
+ * Go `parser.parseNumeric` (strconv.go:96-135): base-256 when the high bit is
+ * set, else octal; null where Go sets the parser's error.
+ */
+function goNumeric(fieldArg) {
+    if (fieldArg.length > 0 && (fieldArg[0] & 0x80) !== 0) {
+        const inverse = (fieldArg[0] & 0x40) !== 0 ? 0xff : 0x00;
+        let value = 0n;
+        for (let i = 0; i < fieldArg.length; i++) {
+            let byte = fieldArg[i] ^ inverse;
+            if (i === 0) {
+                byte &= 0x7f;
+            }
+            if (value >> 56n > 0n) {
+                return null;
+            }
+            value = (value << 8n) | BigInt(byte);
+        }
+        if (value >> 63n > 0n) {
+            return null;
+        }
+        return inverse === 0xff ? -value - 1n : value;
+    }
+    return goOctal(fieldArg);
+}
+/**
+ * Go `parser.parseOctal` (strconv.go:158-174): trims spaces and NULs, cuts at
+ * a NUL, parses base 8 into 64 bits; null where Go sets the parser's error.
+ */
+function goOctal(fieldArg) {
+    let start = 0;
+    let end = fieldArg.length;
+    while (start < end && (fieldArg[start] === 0x20 || fieldArg[start] === 0x00)) {
+        start++;
+    }
+    while (end > start && (fieldArg[end - 1] === 0x20 || fieldArg[end - 1] === 0x00)) {
+        end--;
+    }
+    const text = decodeLatin1(cutAtNul(fieldArg.subarray(start, end)));
+    if (text.length === 0) {
+        return 0n;
+    }
+    if (!/^[0-7]+$/.test(text)) {
+        return null;
+    }
+    const value = BigInt(`0o${text}`);
+    return value >> 64n > 0n ? null : value;
+}
+/**
+ * Go `strconv.ParseInt(s, 10, 64)`: an optional sign, decimal digits, int64
+ * range; null where Go fails.
+ */
+function goParseInt(textArg) {
+    if (!/^[+-]?[0-9]+$/.test(textArg)) {
+        return null;
+    }
+    const digits = textArg.replace(/^[+-]/, '').replace(/^0+/, '');
+    if (digits.length > 19) {
+        return null;
+    }
+    const value = BigInt(textArg);
+    return value < INT64_MIN || value > INT64_MAX ? null : value;
+}
+/** A PAX integer record Go parses with `strconv.ParseInt`, failing the header where Go does. */
+function parsePaxInt(textArg, keyArg) {
+    const value = goParseInt(textArg);
+    if (value === null) {
+        throw malformedPax(`${keyArg} is not a decimal integer`);
+    }
+    return value;
+}
+/**
+ * Go `mergePAX` (reader.go:261-305) for the records the codec does not keep:
+ * a uid, gid, atime, mtime or ctime Go cannot parse fails the header; an
+ * empty value keeps the USTAR field, as in Go.
+ */
+function checkPaxNumbers(recordsArg) {
+    for (const key of ['uid', 'gid']) {
+        const value = recordsArg.get(key) ?? '';
+        if (value !== '') {
+            parsePaxInt(value, key);
+        }
+    }
+    for (const key of ['atime', 'mtime', 'ctime']) {
+        const value = recordsArg.get(key) ?? '';
+        if (value !== '' && !isGoPaxTime(value)) {
+            throw malformedPax(`${key} is not a PAX time`);
+        }
+    }
+}
+/**
+ * Go `parsePAXTime` (strconv.go:197-231): seconds as `strconv.ParseInt`,
+ * then optionally a dot and any number of digits.
+ */
+function isGoPaxTime(textArg) {
+    const dot = textArg.indexOf('.');
+    const seconds = dot < 0 ? textArg : textArg.slice(0, dot);
+    const fraction = dot < 0 ? '' : textArg.slice(dot + 1);
+    return goParseInt(seconds) !== null && /^[0-9]*$/.test(fraction);
+}
+/**
+ * Go `parsePAX` / `parsePAXRecord` (reader.go:307-346, strconv.go:251-287):
+ * `"<length> <key>=<value>\n"` records; a later `x` header replaces the
+ * earlier records. NUL is refused in `path`, `linkpath`, `uname` and `gname`
+ * values and in every key. GNU sparse 0.0 offset and size records must
+ * alternate, offset first, without commas; Go joins them into
+ * `GNU.sparse.map`, replacing a `GNU.sparse.map` record.
+ */
+function parsePax(dataArg) {
+    const records = new Map();
+    const sparseMap = [];
+    let offset = 0;
+    while (offset < dataArg.length) {
+        const rest = dataArg.subarray(offset);
+        const space = rest.indexOf(0x20);
+        if (space < 0) {
+            throw malformedPax('a record has no length');
+        }
+        const lengthText = decodeLatin1(rest.subarray(0, space));
+        if (!/^[+-]?[0-9]+$/.test(lengthText)) {
+            throw malformedPax('a record length is not a decimal integer');
+        }
+        const length = BigInt(lengthText);
+        if (length < 5n || length > BigInt(rest.length)) {
+            throw malformedPax('a record length is out of range');
+        }
+        const recordLength = Number(length);
+        if (recordLength <= space + 1) {
+            throw malformedPax('a record is shorter than its length field');
+        }
+        if (rest[recordLength - 1] !== 0x0a) {
+            throw malformedPax('a record does not end with a newline');
+        }
+        const record = rest.subarray(space + 1, recordLength - 1);
+        const equals = record.indexOf(0x3d);
+        if (equals < 0) {
+            throw malformedPax('a record has no "="');
+        }
+        const keyBytes = record.subarray(0, equals);
+        const valueBytes = record.subarray(equals + 1);
+        if (keyBytes.length === 0 || keyBytes.includes(0)) {
+            throw malformedPax('a record key is empty or contains NUL');
+        }
+        const key = decodeGoUtf8(keyBytes);
+        if (['path', 'linkpath', 'uname', 'gname'].includes(key) && valueBytes.includes(0)) {
+            throw malformedPax(`the ${key} value contains NUL`);
+        }
+        const value = decodeGoUtf8(valueBytes);
+        if (key === 'GNU.sparse.offset' || key === 'GNU.sparse.numbytes') {
+            const expected = sparseMap.length % 2 === 0 ? 'GNU.sparse.offset' : 'GNU.sparse.numbytes';
+            if (key !== expected || value.includes(',')) {
+                throw malformedPax('GNU sparse 0.0 records are out of order or hold a comma');
+            }
+            sparseMap.push(value);
+        }
+        else {
+            records.set(key, value);
+        }
+        offset += recordLength;
+    }
+    if (sparseMap.length > 0) {
+        records.set('GNU.sparse.map', sparseMap.join(','));
+    }
+    return records;
+}
+/**
+ * The data size of a PAX header or GNU long name or link. Go reads at most
+ * 1 MiB of it (`readSpecialFile`, reader.go:868-876, `ErrFieldTooLong`); the
+ * codec refuses a larger one from its declared size, before reading.
+ */
+function specialFileSize(headerArg, whatArg) {
+    if (headerArg.size < 0n) {
+        throw malformed('negative entry size');
+    }
+    if (headerArg.size > BigInt(MAX_SPECIAL_FILE_SIZE)) {
+        throw malformed(`${whatArg} is longer than 1 MiB`);
+    }
+    return Number(headerArg.size);
+}
+function padding(sizeArg) {
+    return (BLOCK - (sizeArg % BLOCK)) % BLOCK;
+}
+function isZeroBlock(blockArg) {
+    for (let i = 0; i < blockArg.length; i++) {
+        if (blockArg[i] !== 0) {
+            return false;
+        }
+    }
+    return true;
+}
+function cutAtNul(bytesArg) {
+    const nul = bytesArg.indexOf(0);
+    return nul < 0 ? bytesArg : bytesArg.subarray(0, nul);
+}
+function malformed(messageArg) {
+    return new LinuxRepoError('malformed-archive', `tar: ${messageArg}`, { field: 'tar header' });
+}
+/** Reading a sparse entry's data: Go expands its holes, the codec does not (a known difference from Gitea). */
+function sparseDataRefused(nameArg) {
+    const message = `tar: the data of sparse entry ${nameArg} is not read (holes are not expanded)`;
+    return new LinuxRepoError('unsupported-package-format', message, { field: 'tar entry data' });
+}
+function malformedPax(messageArg) {
+    return new LinuxRepoError('malformed-archive', `tar PAX header: ${messageArg}`, { field: 'tar PAX header' });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tar.js","sourceRoot":"","sources":["../../ts/readers/tar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAE/E,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,SAAS,EAAE,QAAQ,EAAoB,MAAM,YAAY,CAAC;AAC/F,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEvD,MAAM,KAAK,GAAG,GAAG,CAAC;AAClB,2EAA2E;AAC3E,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;AAClE,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;AACjD,MAAM,SAAS,GAAG,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,CAAC;AAC/B,MAAM,SAAS,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,GAAG,EAAE,CAAC;AACnC;;;;GAIG;AACH,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,CAAC;AA8DtC;;;;;;;;;;GAUG;AACH,MAAM,OAAO,SAAS;IAOD,KAAK;IACL,OAAO;IAPlB,IAAI,GAAG,KAAK,CAAC;IACb,OAAO,GAAyB,IAAI,CAAC;IACrC,GAAG,GAAG,CAAC,CAAC;IACR,OAAO,GAAG,CAAC,CAAC;IAEpB,YACmB,KAAkB,EAClB,OAA0B;qBAD1B,KAAK;uBACL,OAAO;IACvB,CAAC;IAEG,KAAK,CAAC,IAAI;QACf,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YAC1B,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;YAC9B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACtB,CAAC;QACD,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC,EAAE,CAAC;YACnC,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;QACvB,CAAC;QAED,IAAI,UAAU,GAAG,CAAC,CAAC;QACnB,IAAI,UAAU,GAA+B,IAAI,CAAC;QAClD,IAAI,WAAW,GAAkB,IAAI,CAAC;QACtC,IAAI,WAAW,GAAkB,IAAI,CAAC;QACtC,MAAM,QAAQ,GAAG,CAAC,QAAgB,EAAE,EAAE;YACpC,UAAU,IAAI,QAAQ,CAAC;YACvB,IAAI,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;gBAC7C,MAAM,aAAa,CAAC,gBAAgB,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAAC;YACzF,CAAC;QACH,CAAC,CAAC;QAEF,SAAS,CAAC;YACR,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YAChD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACvB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;YACvB,CAAC;YACD,IAAI,KAAK,CAAC,MAAM,GAAG,KAAK,EAAE,CAAC;gBACzB,MAAM,SAAS,CAAC,YAAY,CAAC,CAAC;YAChC,CAAC;YACD,IAAI,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;gBACvB,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;gBACjD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBACxB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;gBACvB,CAAC;gBACD,IAAI,MAAM,CAAC,MAAM,GAAG,KAAK,EAAE,CAAC;oBAC1B,MAAM,SAAS,CAAC,2BAA2B,CAAC,CAAC;gBAC/C,CAAC;gBACD,IAAI,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC;oBACxB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;gBACvB,CAAC;gBACD,MAAM,SAAS,CAAC,8CAA8C,CAAC,CAAC;YAClE,CAAC;YACD,QAAQ,CAAC,KAAK,CAAC,CAAC;YAChB,MAAM,MAAM,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;YAEvC,IAAI,MAAM,CAAC,QAAQ,KAAK,GAAG,IAAI,MAAM,CAAC,QAAQ,KAAK,GAAG,EAAE,CAAC;gBACvD,MAAM,IAAI,GAAG,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;gBACnD,QAAQ,CAAC,IAAI,CAAC,CAAC;gBACf,MAAM,IAAI,GAAG,MAAM,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,gBAAgB,CAAC,CAAC;gBACjE,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;gBACzB,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;gBAC/B,IAAI,MAAM,CAAC,QAAQ,KAAK,GAAG,EAAE,CAAC;oBAC5B,IAAI,CAAC,UAAU,EAAE,CAAC;oBAClB,IAAI,CAAC,OAAO,GAAG,IAAI,aAAa,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,gBAAgB,CAAC,CAAC;oBAClE,qEAAqE;oBACrE,uEAAuE;oBACvE,gEAAgE;oBAChE,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC;oBAChD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC;gBACtG,CAAC;gBACD,UAAU,GAAG,OAAO,CAAC;gBACrB,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC,EAAE,CAAC;oBACnC,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;gBACvB,CAAC;gBACD,SAAS;YACX,CAAC;YAED,IAAI,MAAM,CAAC,QAAQ,KAAK,GAAG,IAAI,MAAM,CAAC,QAAQ,KAAK,GAAG,EAAE,CAAC;gBACvD,MAAM,IAAI,GAAG,eAAe,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;gBAC9D,QAAQ,CAAC,IAAI,CAAC,CAAC;gBACf,MAAM,IAAI,GAAG,MAAM,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,mBAAmB,CAAC,CAAC;gBACpE,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;gBACzB,MAAM,KAAK,GAAG,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;gBAC3C,IAAI,MAAM,CAAC,QAAQ,KAAK,GAAG,EAAE,CAAC;oBAC5B,WAAW,GAAG,KAAK,CAAC;gBACtB,CAAC;qBAAM,CAAC;oBACN,WAAW,GAAG,KAAK,CAAC;gBACtB,CAAC;gBACD,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC,EAAE,CAAC;oBACnC,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;gBACvB,CAAC;gBACD,SAAS;YACX,CAAC;YAED,yEAAyE;YACzE,IAAI,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;YACvB,IAAI,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;YAC/B,IAAI,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;YACvB,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;gBACxB,eAAe,CAAC,UAAU,CAAC,CAAC;gBAC5B,MAAM,IAAI,GAAG,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBACpC,IAAI,IAAI,EAAE,CAAC;oBACT,IAAI,GAAG,IAAI,CAAC;gBACd,CAAC;gBACD,MAAM,QAAQ,GAAG,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;gBAC5C,IAAI,QAAQ,EAAE,CAAC;oBACb,QAAQ,GAAG,QAAQ,CAAC;gBACtB,CAAC;gBACD,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBACvC,IAAI,OAAO,EAAE,CAAC;oBACZ,IAAI,GAAG,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;gBACtC,CAAC;YACH,CAAC;YACD,IAAI,WAAW,KAAK,IAAI,IAAI,WAAW,KAAK,EAAE,EAAE,CAAC;gBAC/C,IAAI,GAAG,WAAW,CAAC;YACrB,CAAC;YACD,IAAI,WAAW,KAAK,IAAI,IAAI,WAAW,KAAK,EAAE,EAAE,CAAC;gBAC/C,QAAQ,GAAG,WAAW,CAAC;YACzB,CAAC;YACD,IAAI,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;YAC/B,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;gBACtB,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;YAC5C,CAAC;YACD,MAAM,QAAQ,GAAG,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;YAC7D,IAAI,QAAQ,GAAG,EAAE,EAAE,CAAC;gBAClB,MAAM,SAAS,CAAC,qBAAqB,CAAC,CAAC;YACzC,CAAC;YACD,IAAI,QAAQ,GAAG,QAAQ,EAAE,CAAC;gBACxB,MAAM,SAAS,CAAC,4BAA4B,CAAC,CAAC;YAChD,CAAC;YACD,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;YAChC,IAAI,IAAI,GAAG,IAAI,aAAa,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,gBAAgB,CAAC,CAAC;YACnE,mFAAmF;YACnF,IAAI,YAAY,GAAG,QAAQ,CAAC;YAC5B,IAAI,MAAM,GAAG,KAAK,CAAC;YACnB,IAAI,QAAQ,KAAK,GAAG,EAAE,CAAC;gBACrB,YAAY,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;gBAC9E,MAAM,GAAG,IAAI,CAAC;YAChB,CAAC;iBAAM,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;gBAC/B,MAAM,OAAO,GAAG,gBAAgB,CAAC,UAAU,CAAC,CAAC;gBAC7C,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;oBACrB,iDAAiD;oBACjD,MAAM,UAAU,GAAG,UAAU,CAAC,GAAG,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC;oBAC3D,IAAI,UAAU,KAAK,EAAE,EAAE,CAAC;wBACtB,IAAI,GAAG,UAAU,CAAC;oBACpB,CAAC;oBACD,MAAM,YAAY,GAAG,UAAU,CAAC,GAAG,CAAC,iBAAiB,CAAC,IAAI,UAAU,CAAC,GAAG,CAAC,qBAAqB,CAAC,IAAI,EAAE,CAAC;oBACtG,MAAM,QAAQ,GAAG,YAAY,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,YAAY,EAAE,iBAAiB,CAAC,CAAC;oBAC3F,MAAM,KAAK,GAAG,IAAI,cAAc,CAAC,QAAQ,CAAC,CAAC;oBAC3C,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;wBACtB,MAAM,oBAAoB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;oBAC1C,CAAC;yBAAM,CAAC;wBACN,oBAAoB,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;oBAC1C,CAAC;oBACD,IAAI,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;wBACpD,MAAM,SAAS,CAAC,oBAAoB,CAAC,CAAC;oBACxC,CAAC;oBACD,YAAY,GAAG,QAAQ,CAAC;oBACxB,MAAM,GAAG,IAAI,CAAC;gBAChB,CAAC;YACH,CAAC;YACD,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,IAAI,MAAM,EAAE,CAAC;gBACX,IAAI,GAAG,IAAI,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;YACjE,CAAC;YACD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;YAC3B,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;QAC3F,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,mBAAmB,CAC/B,QAAoB,EACpB,SAAqB,EACrB,WAAuC;QAEvC,IAAI,SAAS,KAAK,KAAK,EAAE,CAAC;YACxB,MAAM,SAAS,CAAC,6CAA6C,CAAC,CAAC;QACjE,CAAC;QACD,MAAM,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,sBAAsB,CAAC,CAAC;QACnF,MAAM,KAAK,GAAG,IAAI,cAAc,CAAC,QAAQ,CAAC,CAAC;QAC3C,IAAI,KAAK,GAAG,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,gBAAgB;QACzD,IAAI,SAAS,GAAG,KAAK,CAAC,MAAM,CAAC;QAC7B,OAAO,SAAS,GAAG,qBAAqB,EAAE,CAAC;YACzC,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC;gBAC1C,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;oBACjB,MAAM,SAAS,CAAC,oBAAoB,CAAC,CAAC;gBACxC,CAAC;gBACD,OAAO,QAAQ,CAAC;YAClB,CAAC;YACD,WAAW,CAAC,KAAK,CAAC,CAAC;YACnB,KAAK,GAAG,MAAM,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,gCAAgC;YACjG,SAAS,IAAI,KAAK,CAAC,MAAM,CAAC;QAC5B,CAAC;QACD,MAAM,SAAS,CAAC,6CAA6C,CAAC,CAAC;IACjE,CAAC;IAEO,UAAU;QAChB,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC;QAClB,IAAI,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;YAC3C,MAAM,aAAa,CAAC,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,iBAAiB,CAAC,CAAC;QAChF,CAAC;IACH,CAAC;IAED,+FAA+F;IACvF,KAAK,CAAC,cAAc;QAC1B,IAAI,IAAI,CAAC,GAAG,KAAK,CAAC,EAAE,CAAC;YACnB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC;QAC1B,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC;QACb,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACnD,OAAO,KAAK,CAAC,MAAM,KAAK,QAAQ,CAAC;IACnC,CAAC;IAEO,MAAM;QACZ,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,eAAgB,SAAQ,aAAa;IAItB,SAAS;IAH5B,YACE,QAAqB,EACrB,SAAiB,EACA,SAAiB;QAElC,KAAK,CAAC,QAAQ,EAAE,SAAS,EAAE,gBAAgB,CAAC,CAAC;yBAF5B,SAAS;IAG5B,CAAC;IAEe,KAAK,CAAC,IAAI;QACxB,MAAM,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC1C,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,QAAmB,EACnB,WAAmB,EACnB,QAAmC;IAEnC,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;QACpB,MAAM,iBAAiB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IACD,IAAI,QAAQ,CAAC,IAAI,GAAG,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;QACxC,MAAM,aAAa,CAAC,QAAQ,EAAE,WAAW,EAAE,aAAa,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IAC3E,CAAC;IACD,OAAO,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,gBAAgB,CAAC,CAAC;AAC3E,CAAC;AAED,iGAAiG;AACjG,SAAS,YAAY,CAAC,QAAoB;IACxC,MAAM,KAAK,GAAG,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IACxD,MAAM,OAAO,GAAG,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IAC1D,MAAM,OAAO,GAAG,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IAC1D,IAAI,KAAK,KAAK,SAAS,IAAI,OAAO,KAAK,OAAO,EAAE,CAAC;QAC/C,OAAO,MAAM,CAAC;IAChB,CAAC;IACD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,OAAO,CAAC,CAAC,eAAe;IACjC,CAAC;IACD,IAAI,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;QAC5C,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,SAAS,gBAAgB,CAAC,QAAoB;IAC5C,cAAc,CAAC,QAAQ,CAAC,CAAC;IACzB,MAAM,MAAM,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;IACtC,iCAAiC;IACjC,MAAM,IAAI,GAAG,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;IAC/D,MAAM,IAAI,GAAG,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;IAC/D,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;IACjD,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;IACjD,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC;IACnD,IAAI,MAAM,GAAe,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;IAC3C,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,2EAA2E;QAC3E,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,UAAU,CAAC,CAAC;QACtD,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,UAAU,CAAC,CAAC;QACtD,IAAI,MAAM,KAAK,OAAO,EAAE,CAAC;YACvB,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,oBAAoB;QACtE,CAAC;aAAM,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;YAC7B,oBAAoB;YACpB,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;YAC/C,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,YAAY,CAAC,CAAC;YACxD,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,YAAY,CAAC,CAAC;QAC1D,CAAC;aAAM,CAAC;YACN,MAAM,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAC;QACrC,CAAC;IACH,CAAC;IACD,IAAI,IAAI,GAAG,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;IAC7D,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtB,IAAI,GAAG,GAAG,YAAY,CAAC,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,oBAAoB;IAChE,CAAC;IACD,OAAO;QACL,IAAI;QACJ,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;QAC7D,IAAI;QACJ,QAAQ,EAAE,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QAC5C,IAAI;QACJ,MAAM;KACP,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,eAAe,CAAC,QAAoB;IAC3C,MAAM,MAAM,GAAG,CAAC,QAAoB,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC;IAC3F,IAAI,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC;QAC/E,OAAO,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;IAC3B,CAAC;IACD,MAAM,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IACrD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;GAMG;AACH,SAAS,sBAAsB,CAAC,QAAoB,EAAE,QAAwB;IAC5E,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;IACjD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC;QACjC,MAAM,KAAK,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;QACrD,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;YACnB,MAAM;QACR,CAAC;QACD,MAAM,MAAM,GAAG,YAAY,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,mBAAmB,CAAC,CAAC;QACxE,MAAM,MAAM,GAAG,YAAY,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,mBAAmB,CAAC,CAAC;QACzE,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,QAAQ,CAAC,OAAO,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,cAAc;IAIW,IAAI;IAHzB,WAAW,GAAG,EAAE,CAAC;IACjB,EAAE,CAAU;IAEpB,YAA6B,IAAY;oBAAZ,IAAI;QAC/B,IAAI,CAAC,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC;IACvB,CAAC;IAED,IAAW,KAAK;QACd,OAAO,IAAI,CAAC,EAAE,CAAC;IACjB,CAAC;IAEM,GAAG,CAAC,SAAiB,EAAE,SAAiB;QAC7C,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;YACb,OAAO;QACT,CAAC;QACD,MAAM,GAAG,GAAG,SAAS,GAAG,SAAS,CAAC;QAClC,IAAI,SAAS,GAAG,EAAE,IAAI,SAAS,GAAG,EAAE,IAAI,GAAG,GAAG,SAAS,IAAI,GAAG,GAAG,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,WAAW,GAAG,SAAS,EAAE,CAAC;YAC3G,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC;YAChB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,WAAW,GAAG,GAAG,CAAC;IACzB,CAAC;CACF;AAED;;;;GAIG;AACH,SAAS,gBAAgB,CAAC,UAA+B;IACvD,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC;IACvD,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC;IACvD,IAAI,KAAK,KAAK,GAAG,IAAI,CAAC,KAAK,KAAK,GAAG,IAAI,KAAK,KAAK,GAAG,CAAC,EAAE,CAAC;QACtD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,KAAK,KAAK,GAAG,IAAI,KAAK,KAAK,GAAG,EAAE,CAAC;QACnC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,KAAK,KAAK,EAAE,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;QACjC,OAAO,IAAI,CAAC,CAAC,qBAAqB;IACpC,CAAC;IACD,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AACxE,CAAC;AAED;;;;GAIG;AACH,SAAS,oBAAoB,CAAC,UAA+B,EAAE,QAAwB;IACrF,MAAM,KAAK,GAAG,gBAAgB,CAAC,UAAU,CAAC,GAAG,CAAC,sBAAsB,CAAC,IAAI,EAAE,CAAC,CAAC;IAC7E,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;IACnD,MAAM,MAAM,GAAG,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAChD,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,KAAK,EAAE,CAAC;QACzC,MAAM,SAAS,CAAC,2DAA2D,CAAC,CAAC;IAC/E,CAAC;IACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1C,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACrC,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACzC,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;YACvC,MAAM,SAAS,CAAC,6CAA6C,CAAC,CAAC;QACjE,CAAC;QACD,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,oBAAoB,CAAC,OAAsB,EAAE,QAAwB;IAClF,IAAI,MAAM,GAAe,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;IAC3C,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,MAAM,UAAU,GAAG,KAAK,EAAE,QAAgB,EAAE,EAAE;QAC5C,MAAM,MAAM,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;QACzC,OAAO,MAAM,CAAC,QAAQ,CAAC,GAAG,QAAQ,EAAE,CAAC;YACnC,SAAS,IAAI,KAAK,CAAC;YACnB,IAAI,SAAS,GAAG,qBAAqB,EAAE,CAAC;gBACtC,MAAM,SAAS,CAAC,6CAA6C,CAAC,CAAC;YACjE,CAAC;YACD,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;YAC7C,IAAI,KAAK,CAAC,MAAM,GAAG,KAAK,EAAE,CAAC;gBACzB,MAAM,SAAS,CAAC,iDAAiD,CAAC,CAAC;YACrE,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACnB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;oBAClB,QAAQ,EAAE,CAAC;gBACb,CAAC;YACH,CAAC;QACH,CAAC;QACD,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;QAC7B,MAAM,GAAG,CAAC,CAAC;IACb,CAAC,CAAC;IACF,MAAM,SAAS,GAAG,GAAW,EAAE;QAC7B,QAAQ,EAAE,CAAC;QACX,MAAM,GAAG,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACzC,MAAM,KAAK,GAAG,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;QACzD,MAAM,GAAG,GAAG,GAAG,CAAC,CAAC;QACjB,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IACF,MAAM,UAAU,CAAC,EAAE,CAAC,CAAC;IACrB,MAAM,KAAK,GAAG,gBAAgB,CAAC,SAAS,EAAE,CAAC,CAAC;IAC5C,MAAM,UAAU,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC;IAC7B,KAAK,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;QAChC,MAAM,MAAM,GAAG,UAAU,CAAC,SAAS,EAAE,CAAC,CAAC;QACvC,MAAM,MAAM,GAAG,UAAU,CAAC,SAAS,EAAE,CAAC,CAAC;QACvC,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;YACvC,MAAM,SAAS,CAAC,6CAA6C,CAAC,CAAC;QACjE,CAAC;QACD,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,CAAC;AACH,CAAC;AAED,gFAAgF;AAChF,SAAS,gBAAgB,CAAC,OAAe;IACvC,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;IAClC,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,GAAG,SAAS,EAAE,CAAC;QAC3D,MAAM,SAAS,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,cAAc,CAAC,QAAoB;IAC1C,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IACpD,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,MAAM,SAAS,CAAC,6BAA6B,CAAC,CAAC;IACjD,CAAC;IACD,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;QAC/B,MAAM,IAAI,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QACtD,QAAQ,IAAI,IAAI,CAAC;QACjB,MAAM,IAAI,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;IAC/C,CAAC;IACD,IAAI,MAAM,KAAK,MAAM,CAAC,QAAQ,CAAC,IAAI,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7D,MAAM,SAAS,CAAC,0BAA0B,CAAC,CAAC;IAC9C,CAAC;AACH,CAAC;AAED,iGAAiG;AACjG,SAAS,YAAY,CAAC,QAAoB,EAAE,OAAe;IACzD,MAAM,KAAK,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;IAClC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,MAAM,SAAS,CAAC,GAAG,OAAO,kCAAkC,CAAC,CAAC;IAChE,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,SAAS,SAAS,CAAC,QAAoB;IACrC,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACtD,MAAM,OAAO,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;QACzD,IAAI,KAAK,GAAG,EAAE,CAAC;QACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACzC,IAAI,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;YACjC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;gBACZ,IAAI,IAAI,IAAI,CAAC;YACf,CAAC;YACD,IAAI,KAAK,IAAI,GAAG,GAAG,EAAE,EAAE,CAAC;gBACtB,OAAO,IAAI,CAAC;YACd,CAAC;YACD,KAAK,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;QACvC,CAAC;QACD,IAAI,KAAK,IAAI,GAAG,GAAG,EAAE,EAAE,CAAC;YACtB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;IAChD,CAAC;IACD,OAAO,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC3B,CAAC;AAED;;;GAGG;AACH,SAAS,OAAO,CAAC,QAAoB;IACnC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,GAAG,GAAG,QAAQ,CAAC,MAAM,CAAC;IAC1B,OAAO,KAAK,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,IAAI,IAAI,QAAQ,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,EAAE,CAAC;QAC7E,KAAK,EAAE,CAAC;IACV,CAAC;IACD,OAAO,GAAG,GAAG,KAAK,IAAI,CAAC,QAAQ,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,IAAI,IAAI,QAAQ,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,IAAI,CAAC,EAAE,CAAC;QACjF,GAAG,EAAE,CAAC;IACR,CAAC;IACD,MAAM,IAAI,GAAG,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;IACnE,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;IAClC,OAAO,KAAK,IAAI,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;AAC1C,CAAC;AAED;;;GAGG;AACH,SAAS,UAAU,CAAC,OAAe;IACjC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QACnC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC/D,IAAI,MAAM,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IAC9B,OAAO,KAAK,GAAG,SAAS,IAAI,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;AAC/D,CAAC;AAED,gGAAgG;AAChG,SAAS,WAAW,CAAC,OAAe,EAAE,MAAc;IAClD,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;IAClC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,MAAM,YAAY,CAAC,GAAG,MAAM,2BAA2B,CAAC,CAAC;IAC3D,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;GAIG;AACH,SAAS,eAAe,CAAC,UAA+B;IACtD,KAAK,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC;QACjC,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QACxC,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;YACjB,WAAW,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAC1B,CAAC;IACH,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;QAC9C,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QACxC,IAAI,KAAK,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;YACxC,MAAM,YAAY,CAAC,GAAG,GAAG,oBAAoB,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,SAAS,WAAW,CAAC,OAAe;IAClC,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,OAAO,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IAC1D,MAAM,QAAQ,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;IACvD,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,IAAI,IAAI,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AACnE,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,QAAQ,CAAC,OAAmB;IACnC,MAAM,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC1C,MAAM,SAAS,GAAa,EAAE,CAAC;IAC/B,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,OAAO,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;QAC/B,MAAM,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACtC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACd,MAAM,YAAY,CAAC,wBAAwB,CAAC,CAAC;QAC/C,CAAC;QACD,MAAM,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACtC,MAAM,YAAY,CAAC,0CAA0C,CAAC,CAAC;QACjE,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAClC,IAAI,MAAM,GAAG,EAAE,IAAI,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YAChD,MAAM,YAAY,CAAC,iCAAiC,CAAC,CAAC;QACxD,CAAC;QACD,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QACpC,IAAI,YAAY,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YAC9B,MAAM,YAAY,CAAC,2CAA2C,CAAC,CAAC;QAClE,CAAC;QACD,IAAI,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;YACpC,MAAM,YAAY,CAAC,sCAAsC,CAAC,CAAC;QAC7D,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,CAAC,EAAE,YAAY,GAAG,CAAC,CAAC,CAAC;QAC1D,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;YACf,MAAM,YAAY,CAAC,qBAAqB,CAAC,CAAC;QAC5C,CAAC;QACD,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;QAC5C,MAAM,UAAU,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC/C,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;YAClD,MAAM,YAAY,CAAC,uCAAuC,CAAC,CAAC;QAC9D,CAAC;QACD,MAAM,GAAG,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;QACnC,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;YACnF,MAAM,YAAY,CAAC,OAAO,GAAG,qBAAqB,CAAC,CAAC;QACtD,CAAC;QACD,MAAM,KAAK,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC;QACvC,IAAI,GAAG,KAAK,mBAAmB,IAAI,GAAG,KAAK,qBAAqB,EAAE,CAAC;YACjE,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,qBAAqB,CAAC;YAC1F,IAAI,GAAG,KAAK,QAAQ,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC5C,MAAM,YAAY,CAAC,yDAAyD,CAAC,CAAC;YAChF,CAAC;YACD,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxB,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC1B,CAAC;QACD,MAAM,IAAI,YAAY,CAAC;IACzB,CAAC;IACD,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACzB,OAAO,CAAC,GAAG,CAAC,gBAAgB,EAAE,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;GAIG;AACH,SAAS,eAAe,CAAC,SAAuB,EAAE,OAAe;IAC/D,IAAI,SAAS,CAAC,IAAI,GAAG,EAAE,EAAE,CAAC;QACxB,MAAM,SAAS,CAAC,qBAAqB,CAAC,CAAC;IACzC,CAAC;IACD,IAAI,SAAS,CAAC,IAAI,GAAG,MAAM,CAAC,qBAAqB,CAAC,EAAE,CAAC;QACnD,MAAM,SAAS,CAAC,GAAG,OAAO,uBAAuB,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC;AAED,SAAS,OAAO,CAAC,OAAe;IAC9B,OAAO,CAAC,KAAK,GAAG,CAAC,OAAO,GAAG,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC;AAC7C,CAAC;AAED,SAAS,WAAW,CAAC,QAAoB;IACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,QAAQ,CAAC,QAAoB;IACpC,MAAM,GAAG,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAChC,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AACxD,CAAC;AAED,SAAS,SAAS,CAAC,UAAkB;IACnC,OAAO,IAAI,cAAc,CAAC,mBAAmB,EAAE,QAAQ,UAAU,EAAE,EAAE,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,CAAC;AAChG,CAAC;AAED,+GAA+G;AAC/G,SAAS,iBAAiB,CAAC,OAAe;IACxC,MAAM,OAAO,GAAG,iCAAiC,OAAO,uCAAuC,CAAC;IAChG,OAAO,IAAI,cAAc,CAAC,4BAA4B,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAChG,CAAC;AAED,SAAS,YAAY,CAAC,UAAkB;IACtC,OAAO,IAAI,cAAc,CAAC,mBAAmB,EAAE,mBAAmB,UAAU,EAAE,EAAE,EAAE,KAAK,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAC/G,CAAC"}