@push.rocks/smartlinuxrepo 1.1.1 → 1.2.0

package/dist_ts/debian/indexreader.d.ts

@@ -0,0 +1,107 @@
+import { type ILinuxPackageLimits } from '../shared/limits.js';
+import type { TLinuxCompression } from '../shared/types.js';
+/** One stanza of a `Packages` index. */
+export interface IDebianPackagesStanza {
+    /** The stanza's lines, first line through the last LF, without a separating empty line (a view into `decoded`). */
+    readonly bytes: Uint8Array;
+    /** The stanza's offset in `decoded`. */
+    readonly offset: number;
+    /** The first-line value of the stanza's last `Filename` field: the unit key. */
+    readonly filename: string;
+    /** The first-line values of the last `Package`, `Version` and `Architecture` fields; `''` when absent. */
+    readonly package: string;
+    readonly version: string;
+    readonly architecture: string;
+}
+/** A `Packages` index read into its stanzas. */
+export interface IDebianPackagesIndex {
+    /** The decompressed document (a copy for `'none'`); every `offset` indexes into it. */
+    readonly decoded: Uint8Array;
+    /** Every stanza in document order, duplicates included. */
+    readonly stanzas: readonly IDebianPackagesStanza[];
+}
+/** One field of a `Release` file. */
+export interface IDebianReleaseField {
+    /** The field name as written. */
+    readonly name: string;
+    /**
+     * The first-line value without surrounding spaces and tabs, then `"\n"`
+     * plus each continuation line verbatim.
+     */
+    readonly value: string;
+    /** The field's line(s), each with its LF. */
+    readonly bytes: Uint8Array;
+}
+/** One file of a `Release` checksum list. */
+export interface IDebianReleaseFile {
+    readonly path: string;
+    readonly size: number;
+    /** As written: hex of the algorithm's length. */
+    readonly digest: string;
+}
+/** A `Release` file read into its fields and checksum lists. */
+export interface IDebianRelease {
+    /** Every field in order, the checksum fields included. */
+    readonly fields: readonly IDebianReleaseField[];
+    /** The `MD5Sum`, `SHA1`, `SHA256` and `SHA512` lists; `[]` when the field is absent. */
+    readonly files: {
+        readonly md5Sum: readonly IDebianReleaseFile[];
+        readonly sha1: readonly IDebianReleaseFile[];
+        readonly sha256: readonly IDebianReleaseFile[];
+        readonly sha512: readonly IDebianReleaseFile[];
+    };
+}
+/**
+ * Reads a `Packages` index (`dists/<d>/<c>/binary-<a>/Packages`, `.gz`,
+ * `.xz`; the caller names `compression` from the file name) into its stanzas.
+ *
+ * - Lines end in LF, the last one too; a line longer than `maxHeaderBytes`
+ *   is `limit-exceeded`.
+ * - A stanza is a maximal run of non-empty lines; one or more empty lines
+ *   separate stanzas, and leading or trailing empty lines are accepted.
+ * - A line holding only spaces or tabs is `malformed-index` (Gitea and the
+ *   codec cannot write one; Debian Policy and the strip rule would read it
+ *   differently). A stanza starting with a continuation line is
+ *   `malformed-index`. A line without `:` is accepted (Gitea can write one).
+ * - Field names are the Go `TrimSpace` of the bytes before the first `:`,
+ *   matched ASCII case-insensitively; values are the Go `TrimSpace` of the
+ *   rest of the field's first line, decoded as Go does (U+FFFD for invalid
+ *   UTF-8), from the field's last occurrence.
+ * - A stanza without `Filename` is `missing-field` (`Filename`, `value` the
+ *   stanza offset).
+ *
+ * Bounds: the decoded document by `maxIndexBytes`, stanzas by `maxEntries`,
+ * one stanza by `maxMetadataBytes`. Every stanza is returned in document
+ * order, duplicates included; `bytes` are views into `decoded`.
+ */
+export declare function readDebianPackagesIndex(inputArg: {
+    bytes: Uint8Array;
+    compression: TLinuxCompression;
+    limits?: Partial<ILinuxPackageLimits>;
+}): Promise<IDebianPackagesIndex>;
+/**
+ * Reads a `Release` file (the plain `dists/<d>/Release`) into its fields and
+ * checksum lists. For an `InRelease`, verify it with `createOpenPgpVerifier`
+ * and pass the verified `signedText` here (plus a final LF when it lacks one).
+ *
+ * - Lines end in LF, the last one too; a line longer than `maxHeaderBytes`
+ *   is `limit-exceeded`.
+ * - Exactly one stanza: an empty line, a line holding only spaces or tabs, a
+ *   continuation line before the first field, a field line without `:`, a
+ *   field name that is empty or holds a space or tab, a second checksum field
+ *   of one algorithm, or an empty document is `malformed-index`.
+ * - `MD5Sum`, `SHA1`, `SHA256` and `SHA512` (ASCII case-insensitive) hold an
+ *   empty first-line value and continuation lines of leading whitespace, then
+ *   exactly three tokens separated by one or more spaces or tabs: the digest
+ *   (hex of the algorithm's length), the size (decimal digits within a safe
+ *   integer) and the path. Anything else is `invalid-field` (`field` the field
+ *   name as written, `value` the line's offset).
+ *
+ * Bounds: the document by `maxIndexBytes`, fields and the files per list by
+ * `maxEntries`. Field names and values are decoded as Go does (U+FFFD for
+ * invalid UTF-8); `bytes` are views into a copy of the input.
+ */
+export declare function readDebianRelease(inputArg: {
+    bytes: Uint8Array;
+    limits?: Partial<ILinuxPackageLimits>;
+}): Promise<IDebianRelease>;

package/dist_ts/debian/indexreader.js

@@ -0,0 +1,274 @@
+import { LinuxRepoError } from '../shared/errors.js';
+import { resolveLinuxPackageLimits } from '../shared/limits.js';
+import { assertLinuxCompression, assertReaderBytes, assertReaderInput, checkUnitBytes, countUnit, isBlankLine, lines, readIndexDocument, } from '../readers/document.js';
+import { decodeGoUtf8, decodeLatin1 } from '../readers/text.js';
+import { fromByteString, goTrimSpace } from './gostring.js';
+const SPACE = 0x20;
+const TAB = 0x09;
+const COLON = 0x3a;
+/** The four checksum fields of a Release, lower-cased, with their list key and hex length. */
+const RELEASE_CHECKSUM_FIELDS = new Map([
+    ['md5sum', { key: 'md5Sum', hexLength: 32 }],
+    ['sha1', { key: 'sha1', hexLength: 40 }],
+    ['sha256', { key: 'sha256', hexLength: 64 }],
+    ['sha512', { key: 'sha512', hexLength: 128 }],
+]);
+/**
+ * Reads a `Packages` index (`dists/<d>/<c>/binary-<a>/Packages`, `.gz`,
+ * `.xz`; the caller names `compression` from the file name) into its stanzas.
+ *
+ * - Lines end in LF, the last one too; a line longer than `maxHeaderBytes`
+ *   is `limit-exceeded`.
+ * - A stanza is a maximal run of non-empty lines; one or more empty lines
+ *   separate stanzas, and leading or trailing empty lines are accepted.
+ * - A line holding only spaces or tabs is `malformed-index` (Gitea and the
+ *   codec cannot write one; Debian Policy and the strip rule would read it
+ *   differently). A stanza starting with a continuation line is
+ *   `malformed-index`. A line without `:` is accepted (Gitea can write one).
+ * - Field names are the Go `TrimSpace` of the bytes before the first `:`,
+ *   matched ASCII case-insensitively; values are the Go `TrimSpace` of the
+ *   rest of the field's first line, decoded as Go does (U+FFFD for invalid
+ *   UTF-8), from the field's last occurrence.
+ * - A stanza without `Filename` is `missing-field` (`Filename`, `value` the
+ *   stanza offset).
+ *
+ * Bounds: the decoded document by `maxIndexBytes`, stanzas by `maxEntries`,
+ * one stanza by `maxMetadataBytes`. Every stanza is returned in document
+ * order, duplicates included; `bytes` are views into `decoded`.
+ */
+export async function readDebianPackagesIndex(inputArg) {
+    assertReaderInput(inputArg);
+    assertReaderBytes(inputArg.bytes);
+    assertLinuxCompression(inputArg.compression);
+    const limits = resolveLinuxPackageLimits(inputArg.limits);
+    const decoded = await readIndexDocument(inputArg.bytes, inputArg.compression, limits);
+    const stanzas = [];
+    let stanza = null;
+    const finish = (endArg) => {
+        if (stanza === null) {
+            return;
+        }
+        const current = stanza;
+        stanza = null;
+        if (current.filename === null) {
+            throw new LinuxRepoError('missing-field', 'a Packages stanza has no Filename field', {
+                field: 'Filename',
+                value: current.start,
+            });
+        }
+        stanzas.push({
+            bytes: decoded.subarray(current.start, endArg),
+            offset: current.start,
+            filename: current.filename,
+            package: current.package,
+            version: current.version,
+            architecture: current.architecture,
+        });
+    };
+    for (const line of lines(decoded, limits.maxHeaderBytes, 'Packages')) {
+        if (line.end === line.start) {
+            finish(line.start);
+            continue;
+        }
+        if (isBlankLine(decoded, line)) {
+            throw new LinuxRepoError('malformed-index', 'a Packages line holds only spaces or tabs', {
+                field: 'Packages',
+                value: line.start,
+            });
+        }
+        const first = decoded[line.start];
+        if (stanza === null) {
+            if (first === SPACE || first === TAB) {
+                throw new LinuxRepoError('malformed-index', 'a Packages stanza starts with a continuation line', {
+                    field: 'Packages',
+                    value: line.start,
+                });
+            }
+            countUnit(stanzas.length + 1, limits, 'Packages stanza');
+            stanza = { start: line.start, filename: null, package: '', version: '', architecture: '' };
+        }
+        checkUnitBytes(line.end + 1 - stanza.start, limits, 'Packages stanza');
+        if (first === SPACE || first === TAB) {
+            continue;
+        }
+        readPackagesField(decoded, line, stanza);
+    }
+    finish(decoded.length);
+    return { decoded, stanzas };
+}
+/** Takes the key fields' first-line values; a later occurrence replaces an earlier one. */
+function readPackagesField(bytesArg, lineArg, stanzaArg) {
+    const line = bytesArg.subarray(lineArg.start, lineArg.end);
+    const colon = line.indexOf(COLON);
+    if (colon < 0) {
+        return;
+    }
+    const name = asciiLower(goTrimSpace(decodeLatin1(line.subarray(0, colon))));
+    if (name !== 'filename' && name !== 'package' && name !== 'version' && name !== 'architecture') {
+        return;
+    }
+    const value = fromByteString(goTrimSpace(decodeLatin1(line.subarray(colon + 1))));
+    if (name === 'filename') {
+        stanzaArg.filename = value;
+    }
+    else if (name === 'package') {
+        stanzaArg.package = value;
+    }
+    else if (name === 'version') {
+        stanzaArg.version = value;
+    }
+    else {
+        stanzaArg.architecture = value;
+    }
+}
+/**
+ * Reads a `Release` file (the plain `dists/<d>/Release`) into its fields and
+ * checksum lists. For an `InRelease`, verify it with `createOpenPgpVerifier`
+ * and pass the verified `signedText` here (plus a final LF when it lacks one).
+ *
+ * - Lines end in LF, the last one too; a line longer than `maxHeaderBytes`
+ *   is `limit-exceeded`.
+ * - Exactly one stanza: an empty line, a line holding only spaces or tabs, a
+ *   continuation line before the first field, a field line without `:`, a
+ *   field name that is empty or holds a space or tab, a second checksum field
+ *   of one algorithm, or an empty document is `malformed-index`.
+ * - `MD5Sum`, `SHA1`, `SHA256` and `SHA512` (ASCII case-insensitive) hold an
+ *   empty first-line value and continuation lines of leading whitespace, then
+ *   exactly three tokens separated by one or more spaces or tabs: the digest
+ *   (hex of the algorithm's length), the size (decimal digits within a safe
+ *   integer) and the path. Anything else is `invalid-field` (`field` the field
+ *   name as written, `value` the line's offset).
+ *
+ * Bounds: the document by `maxIndexBytes`, fields and the files per list by
+ * `maxEntries`. Field names and values are decoded as Go does (U+FFFD for
+ * invalid UTF-8); `bytes` are views into a copy of the input.
+ */
+export async function readDebianRelease(inputArg) {
+    assertReaderInput(inputArg);
+    assertReaderBytes(inputArg.bytes);
+    const limits = resolveLinuxPackageLimits(inputArg.limits);
+    const decoded = await readIndexDocument(inputArg.bytes, 'none', limits);
+    const malformed = (messageArg, offsetArg) => new LinuxRepoError('malformed-index', messageArg, { field: 'Release', value: offsetArg });
+    const fields = [];
+    const files = {
+        md5Sum: [],
+        sha1: [],
+        sha256: [],
+        sha512: [],
+    };
+    const seenChecksumFields = new Set();
+    let field = null;
+    const finishField = (endArg) => {
+        if (field !== null) {
+            const value = [field.firstValue, ...field.continuations].join('\n');
+            fields.push({ name: field.name, value, bytes: decoded.subarray(field.start, endArg) });
+            field = null;
+        }
+    };
+    for (const line of lines(decoded, limits.maxHeaderBytes, 'Release')) {
+        if (line.end === line.start) {
+            throw malformed('a Release file holds an empty line', line.start);
+        }
+        if (isBlankLine(decoded, line)) {
+            throw malformed('a Release line holds only spaces or tabs', line.start);
+        }
+        const first = decoded[line.start];
+        if (first === SPACE || first === TAB) {
+            if (field === null) {
+                throw malformed('a Release file starts with a continuation line', line.start);
+            }
+            const current = field;
+            if (current.checksum !== null) {
+                const list = files[current.checksum.key];
+                countUnit(list.length + 1, limits, `Release ${current.name} file`);
+                list.push(readChecksumLine(decoded, line, current.name, current.checksum.hexLength));
+            }
+            current.continuations.push(decodeGoUtf8(decoded.subarray(line.start, line.end)));
+            continue;
+        }
+        finishField(line.start);
+        const colon = decoded.subarray(line.start, line.end).indexOf(COLON);
+        if (colon < 0) {
+            throw malformed('a Release field line has no ":"', line.start);
+        }
+        const nameBytes = decoded.subarray(line.start, line.start + colon);
+        if (nameBytes.length === 0 || nameBytes.includes(SPACE) || nameBytes.includes(TAB)) {
+            throw malformed('a Release field name is empty or holds a space or tab', line.start);
+        }
+        const name = decodeGoUtf8(nameBytes);
+        const lower = asciiLower(decodeLatin1(nameBytes));
+        const checksum = RELEASE_CHECKSUM_FIELDS.get(lower) ?? null;
+        const firstValue = decodeGoUtf8(trimSpaceTab(decoded.subarray(line.start + colon + 1, line.end)));
+        if (checksum !== null) {
+            if (seenChecksumFields.has(lower)) {
+                throw malformed(`a Release file holds a second ${name} field`, line.start);
+            }
+            seenChecksumFields.add(lower);
+            if (firstValue !== '') {
+                throw new LinuxRepoError('invalid-field', `the ${name} field has a value on its first line`, {
+                    field: name,
+                    value: line.start,
+                });
+            }
+        }
+        countUnit(fields.length + 1, limits, 'Release field');
+        field = { name, start: line.start, firstValue, continuations: [], checksum };
+    }
+    finishField(decoded.length);
+    if (fields.length === 0) {
+        throw malformed('a Release file holds no field', 0);
+    }
+    return { fields, files };
+}
+/** One checksum line: leading whitespace, then digest, size and path separated by spaces or tabs. */
+function readChecksumLine(bytesArg, lineArg, fieldArg, hexLengthArg) {
+    const tokens = [];
+    let i = lineArg.start;
+    while (i < lineArg.end) {
+        while (i < lineArg.end && (bytesArg[i] === SPACE || bytesArg[i] === TAB)) {
+            i += 1;
+        }
+        if (i === lineArg.end) {
+            break;
+        }
+        const start = i;
+        while (i < lineArg.end && bytesArg[i] !== SPACE && bytesArg[i] !== TAB) {
+            i += 1;
+        }
+        tokens.push([start, i]);
+        if (tokens.length > 3) {
+            break;
+        }
+    }
+    const last = bytesArg[lineArg.end - 1];
+    const invalid = (whatArg) => new LinuxRepoError('invalid-field', `a ${fieldArg} line ${whatArg}`, { field: fieldArg, value: lineArg.start });
+    if (tokens.length !== 3 || last === SPACE || last === TAB) {
+        throw invalid('is not "<digest> <size> <path>"');
+    }
+    const digest = decodeLatin1(bytesArg.subarray(tokens[0][0], tokens[0][1]));
+    if (digest.length !== hexLengthArg || !/^[0-9a-fA-F]+$/.test(digest)) {
+        throw invalid(`has a digest that is not ${hexLengthArg} hex digits`);
+    }
+    const sizeText = decodeLatin1(bytesArg.subarray(tokens[1][0], tokens[1][1]));
+    const size = /^[0-9]+$/.test(sizeText) ? Number(sizeText) : Number.NaN;
+    if (!Number.isSafeInteger(size)) {
+        throw invalid('has a size that is not decimal digits within a safe integer');
+    }
+    return { path: decodeGoUtf8(bytesArg.subarray(tokens[2][0], tokens[2][1])), size, digest };
+}
+function trimSpaceTab(bytesArg) {
+    let start = 0;
+    let end = bytesArg.length;
+    while (start < end && (bytesArg[start] === SPACE || bytesArg[start] === TAB)) {
+        start += 1;
+    }
+    while (end > start && (bytesArg[end - 1] === SPACE || bytesArg[end - 1] === TAB)) {
+        end -= 1;
+    }
+    return bytesArg.subarray(start, end);
+}
+/** ASCII-only lowercasing of a byte string. */
+function asciiLower(valueArg) {
+    return valueArg.replace(/[A-Z]+/g, (matchArg) => matchArg.toLowerCase());
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"indexreader.js","sourceRoot":"","sources":["../../ts/debian/indexreader.ts"],"names":[],"mappings":"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"}

package/dist_ts/debian/reader.js

@@ -78,7 +78,11 @@ async function readControl(inputArg, limitsArg) {
         if (member.size > limitsArg.maxMetadataBytes) {
             throw limitExceeded('maxMetadataBytes', limitsArg.maxMetadataBytes, `control member ${member.name}`);
         }
-        const control = await withDecompressingReader(member.body, compression, { maxOutputBytes: limitsArg.maxDecompressedMetadataBytes, outputLimit: 'maxDecompressedMetadataBytes' }, async (decompressed) => {
+        const control = await withDecompressingReader(member.body, compression, {
+            maxOutputBytes: limitsArg.maxDecompressedMetadataBytes,
+            outputLimit: 'maxDecompressedMetadataBytes',
+            maxZstdFrames: limitsArg.maxEntries,
+        }, async (decompressed) => {
             const tar = new TarReader(decompressed, {
                 maxEntries: limitsArg.maxEntries,
                 maxHeaderBytes: limitsArg.maxHeaderBytes,
@@ -107,4 +111,4 @@ async function readControl(inputArg, limitsArg) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/debian/rules.d.ts

@@ -20,3 +20,21 @@ export declare function isDebianReleaseValue(valueArg: string): boolean;
  * returns a record the builder refuses for its file name.
  */
 export declare function hasPoolFileNameRefusedCharacter(textArg: string): boolean;
+/**
+ * The stanza without its index-owned fields: `Filename`, `Size`, `MD5sum`,
+ * `SHA1`, `SHA256` and `SHA512`, matched ASCII case-insensitively on the Go
+ * `TrimSpace` of the bytes before the line's first `:`, each with its
+ * continuation lines. The one line walk `renderDebianPackagesStanza` applies
+ * to a record's control text, on bytes:
+ * - a line starting with a space or tab follows the dropping state of its field;
+ * - otherwise the field is dropped exactly when its name is one of the six;
+ * - a line without a `:` is kept and ends dropping.
+ *
+ * Lines end at LF and keep it; a final line without LF is a line too. The
+ * result is a new array, the kept lines in order. Applied to a stanza that
+ * `readDebianPackagesIndex` returns, from Gitea or from the codec for the same
+ * control file, it yields the same bytes: the trimmed control text without
+ * the index-owned fields, plus a final LF. A non-`Uint8Array` is
+ * `invalid-input`.
+ */
+export declare function stripDebianIndexOwnedFields(stanzaArg: Uint8Array): Uint8Array;

package/dist_ts/debian/rules.js

@@ -1,4 +1,6 @@
-import { hasControlCharacter } from '../shared/validation.js';
+import { decodeLatin1 } from '../readers/text.js';
+import { assertBytes, hasControlCharacter } from '../shared/validation.js';
+import { goTrimSpace } from './gostring.js';
 /** Gitea's distribution and component rule (`modules/packages/debian/metadata.go:67`, applied at upload). */
 export const DEBIAN_SYMBOL_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9.~+_-]*$/;
 /**
@@ -37,4 +39,81 @@ const POOL_FILE_NAME_REFUSED_PATTERN = /[/#?\s\p{Cc}]/u;
 export function hasPoolFileNameRefusedCharacter(textArg) {
     return POOL_FILE_NAME_REFUSED_PATTERN.test(textArg);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kZWJpYW4vcnVsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFOUQsNkdBQTZHO0FBQzdHLE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLGdDQUFnQyxDQUFDO0FBRXRFOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsY0FBYyxDQUFDLFFBQWdCO0lBQzdDLE9BQU8sT0FBTyxRQUFRLEtBQUssUUFBUSxJQUFJLHFCQUFxQixDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztBQUM5RSxDQUFDO0FBRUQ7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsb0JBQW9CLENBQUMsUUFBZ0I7SUFDbkQsT0FBTyxPQUFPLFFBQVEsS0FBSyxRQUFRLElBQUksUUFBUSxLQUFLLEVBQUUsSUFBSSxDQUFDLG1CQUFtQixDQUFDLFFBQVEsQ0FBQyxJQUFJLFFBQVEsS0FBSyxRQUFRLENBQUMsSUFBSSxFQUFFLENBQUM7QUFDM0gsQ0FBQztBQUVEOzs7Ozs7OztHQVFHO0FBQ0gsTUFBTSw4QkFBOEIsR0FBRyxnQkFBZ0IsQ0FBQztBQUV4RDs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSwrQkFBK0IsQ0FBQyxPQUFlO0lBQzdELE9BQU8sOEJBQThCLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0FBQ3RELENBQUMifQ==
+/**
+ * The fields a `Packages` stanza writes itself (`renderDebianPackagesStanza`;
+ * Gitea `services/packages/debian/repository.go:202-209`): `Filename`,
+ * `Size`, `MD5sum`, `SHA1`, `SHA256`, `SHA512`.
+ */
+const INDEX_OWNED_FIELDS = new Set(['filename', 'size', 'md5sum', 'sha1', 'sha256', 'sha512']);
+const LF = 0x0a;
+/**
+ * Whether the bytes before a line's first `:` name an index-owned field: Go
+ * `strings.TrimSpace` of them, matched ASCII case-insensitively. Every other
+ * byte is compared as is, so no non-ASCII text matches (for these six names
+ * this equals `toLowerCase()` on the decoded name, the renderer's former rule).
+ */
+function isIndexOwnedFieldName(nameArg) {
+    const name = goTrimSpace(decodeLatin1(nameArg));
+    if (name.length < 4 || name.length > 8) {
+        return false;
+    }
+    let lower = '';
+    for (let i = 0; i < name.length; i++) {
+        const code = name.charCodeAt(i);
+        lower += String.fromCharCode(code >= 0x41 && code <= 0x5a ? code + 0x20 : code);
+    }
+    return INDEX_OWNED_FIELDS.has(lower);
+}
+/**
+ * The stanza without its index-owned fields: `Filename`, `Size`, `MD5sum`,
+ * `SHA1`, `SHA256` and `SHA512`, matched ASCII case-insensitively on the Go
+ * `TrimSpace` of the bytes before the line's first `:`, each with its
+ * continuation lines. The one line walk `renderDebianPackagesStanza` applies
+ * to a record's control text, on bytes:
+ * - a line starting with a space or tab follows the dropping state of its field;
+ * - otherwise the field is dropped exactly when its name is one of the six;
+ * - a line without a `:` is kept and ends dropping.
+ *
+ * Lines end at LF and keep it; a final line without LF is a line too. The
+ * result is a new array, the kept lines in order. Applied to a stanza that
+ * `readDebianPackagesIndex` returns, from Gitea or from the codec for the same
+ * control file, it yields the same bytes: the trimmed control text without
+ * the index-owned fields, plus a final LF. A non-`Uint8Array` is
+ * `invalid-input`.
+ */
+export function stripDebianIndexOwnedFields(stanzaArg) {
+    assertBytes(stanzaArg, 'stanza');
+    const kept = [];
+    let total = 0;
+    let dropping = false;
+    let start = 0;
+    while (start < stanzaArg.length) {
+        const lineFeed = stanzaArg.indexOf(LF, start);
+        const end = lineFeed < 0 ? stanzaArg.length : lineFeed + 1;
+        const first = stanzaArg[start];
+        if (first === 0x20 || first === 0x09) {
+            if (!dropping) {
+                kept.push(stanzaArg.subarray(start, end));
+                total += end - start;
+            }
+        }
+        else {
+            const lineEnd = lineFeed < 0 ? stanzaArg.length : lineFeed;
+            const colon = stanzaArg.subarray(start, lineEnd).indexOf(0x3a);
+            dropping = colon >= 0 && isIndexOwnedFieldName(stanzaArg.subarray(start, start + colon));
+            if (!dropping) {
+                kept.push(stanzaArg.subarray(start, end));
+                total += end - start;
+            }
+        }
+        start = end;
+    }
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const line of kept) {
+        result.set(line, offset);
+        offset += line.length;
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kZWJpYW4vcnVsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxXQUFXLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUMzRSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTVDLDZHQUE2RztBQUM3RyxNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBRyxnQ0FBZ0MsQ0FBQztBQUV0RTs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLGNBQWMsQ0FBQyxRQUFnQjtJQUM3QyxPQUFPLE9BQU8sUUFBUSxLQUFLLFFBQVEsSUFBSSxxQkFBcUIsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7QUFDOUUsQ0FBQztBQUVEOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLG9CQUFvQixDQUFDLFFBQWdCO0lBQ25ELE9BQU8sT0FBTyxRQUFRLEtBQUssUUFBUSxJQUFJLFFBQVEsS0FBSyxFQUFFLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxRQUFRLENBQUMsSUFBSSxRQUFRLEtBQUssUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDO0FBQzNILENBQUM7QUFFRDs7Ozs7Ozs7R0FRRztBQUNILE1BQU0sOEJBQThCLEdBQUcsZ0JBQWdCLENBQUM7QUFFeEQ7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsK0JBQStCLENBQUMsT0FBZTtJQUM3RCxPQUFPLDhCQUE4QixDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztBQUN0RCxDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sa0JBQWtCLEdBQXdCLElBQUksR0FBRyxDQUFDLENBQUMsVUFBVSxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxRQUFRLENBQUMsQ0FBQyxDQUFDO0FBRXBILE1BQU0sRUFBRSxHQUFHLElBQUksQ0FBQztBQUVoQjs7Ozs7R0FLRztBQUNILFNBQVMscUJBQXFCLENBQUMsT0FBbUI7SUFDaEQsTUFBTSxJQUFJLEdBQUcsV0FBVyxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO0lBQ2hELElBQUksSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLElBQUksSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUUsQ0FBQztRQUN2QyxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7SUFDRCxJQUFJLEtBQUssR0FBRyxFQUFFLENBQUM7SUFDZixLQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDO1FBQ3JDLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDaEMsS0FBSyxJQUFJLE1BQU0sQ0FBQyxZQUFZLENBQUMsSUFBSSxJQUFJLElBQUksSUFBSSxJQUFJLElBQUksSUFBSSxDQUFDLENBQUMsQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNsRixDQUFDO0lBQ0QsT0FBTyxrQkFBa0IsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUM7QUFDdkMsQ0FBQztBQUVEOzs7Ozs7Ozs7Ozs7Ozs7O0dBZ0JHO0FBQ0gsTUFBTSxVQUFVLDJCQUEyQixDQUFDLFNBQXFCO0lBQy9ELFdBQVcsQ0FBQyxTQUFTLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDakMsTUFBTSxJQUFJLEdBQWlCLEVBQUUsQ0FBQztJQUM5QixJQUFJLEtBQUssR0FBRyxDQUFDLENBQUM7SUFDZCxJQUFJLFFBQVEsR0FBRyxLQUFLLENBQUM7SUFDckIsSUFBSSxLQUFLLEdBQUcsQ0FBQyxDQUFDO0lBQ2QsT0FBTyxLQUFLLEdBQUcsU0FBUyxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ2hDLE1BQU0sUUFBUSxHQUFHLFNBQVMsQ0FBQyxPQUFPLENBQUMsRUFBRSxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBQzlDLE1BQU0sR0FBRyxHQUFHLFFBQVEsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLFFBQVEsR0FBRyxDQUFDLENBQUM7UUFDM0QsTUFBTSxLQUFLLEdBQUcsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQy9CLElBQUksS0FBSyxLQUFLLElBQUksSUFBSSxLQUFLLEtBQUssSUFBSSxFQUFFLENBQUM7WUFDckMsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO2dCQUNkLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxLQUFLLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQztnQkFDMUMsS0FBSyxJQUFJLEdBQUcsR0FBRyxLQUFLLENBQUM7WUFDdkIsQ0FBQztRQUNILENBQUM7YUFBTSxDQUFDO1lBQ04sTUFBTSxPQUFPLEdBQUcsUUFBUSxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDO1lBQzNELE1BQU0sS0FBSyxHQUFHLFNBQVMsQ0FBQyxRQUFRLENBQUMsS0FBSyxFQUFFLE9BQU8sQ0FBQyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUMvRCxRQUFRLEdBQUcsS0FBSyxJQUFJLENBQUMsSUFBSSxxQkFBcUIsQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLEtBQUssRUFBRSxLQUFLLEdBQUcsS0FBSyxDQUFDLENBQUMsQ0FBQztZQUN6RixJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7Z0JBQ2QsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLEtBQUssRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFDO2dCQUMxQyxLQUFLLElBQUksR0FBRyxHQUFHLEtBQUssQ0FBQztZQUN2QixDQUFDO1FBQ0gsQ0FBQztRQUNELEtBQUssR0FBRyxHQUFHLENBQUM7SUFDZCxDQUFDO0lBQ0QsTUFBTSxNQUFNLEdBQUcsSUFBSSxVQUFVLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDckMsSUFBSSxNQUFNLEdBQUcsQ0FBQyxDQUFDO0lBQ2YsS0FBSyxNQUFNLElBQUksSUFBSSxJQUFJLEVBQUUsQ0FBQztRQUN4QixNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksRUFBRSxNQUFNLENBQUMsQ0FBQztRQUN6QixNQUFNLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQztJQUN4QixDQUFDO0lBQ0QsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQyJ9

package/dist_ts/index.d.ts

@@ -1,4 +1,4 @@
-export type { TLinuxPackageFormat, ILinuxPackageDigests, IAlpinePackageDigests, ILinuxPackageRecordBase, IAlpinePackageMetadata, IAlpinePackageRecord, IDebianPackageMetadata, IDebianPackageRecord, IRpmDependency, IRpmFile, IRpmChangelog, IRpmPackageMetadata, IRpmPackageRecord, IRpmUpdate, IRpmUpdateReference, IRpmUpdateCollection, IRpmUpdatePackage, IArchPackageMetadata, IArchPackageRecord, TLinuxPackageRecord, TLinuxIndexFileStage, ILinuxIndexFile, } from './shared/types.js';
+export type { TLinuxPackageFormat, ILinuxPackageDigests, IAlpinePackageDigests, ILinuxPackageRecordBase, IAlpinePackageMetadata, IAlpinePackageRecord, IDebianPackageMetadata, IDebianPackageRecord, IRpmDependency, IRpmFile, IRpmChangelog, IRpmPackageMetadata, IRpmPackageRecord, IRpmUpdate, IRpmUpdateReference, IRpmUpdateCollection, IRpmUpdatePackage, IArchPackageMetadata, IArchPackageRecord, TLinuxPackageRecord, TLinuxIndexFileStage, ILinuxIndexFile, TLinuxCompression, } from './shared/types.js';
 export { DEFAULT_LINUX_PACKAGE_LIMITS } from './shared/limits.js';
 export type { ILinuxPackageLimits } from './shared/limits.js';
 export { LinuxRepoError } from './shared/errors.js';
@@ -6,22 +6,32 @@ export type { TLinuxRepoErrorCode, ILinuxRepoErrorDetail } from './shared/errors
 export { isIndexableArchitecture } from './shared/architecture.js';
 export { createAlpineSigner, createOpenPgpSigner } from './signing/signers.js';
 export type { IAlpineSigner, IOpenPgpSigner } from './signing/signers.js';
-export { createOpenPgpVerifier } from './signing/verifiers.js';
-export type { IOpenPgpCleartextVerification, IOpenPgpSignatureVerification, IOpenPgpVerifier, TOpenPgpHashAlgorithm, } from './signing/verifiers.js';
+export { createAlpineVerifier, createOpenPgpVerifier } from './signing/verifiers.js';
+export type { IAlpineSignatureVerification, IAlpineVerifier, IOpenPgpCleartextVerification, IOpenPgpSignatureVerification, IOpenPgpVerifier, TOpenPgpHashAlgorithm, } from './signing/verifiers.js';
 export { generateAlpineKeyPair, generateOpenPgpKeyPair, giteaAlpineKeyName } from './signing/keys.js';
 export type { IAlpineKeyPair, IOpenPgpKeyPair } from './signing/keys.js';
 export { readDebianPackage } from './debian/reader.js';
 export { buildDebianIndex } from './debian/indexbuilder.js';
 export type { IDebianIndexEntry } from './debian/indexbuilder.js';
-export { isDebianReleaseValue, isDebianSymbol } from './debian/rules.js';
+export { isDebianReleaseValue, isDebianSymbol, stripDebianIndexOwnedFields } from './debian/rules.js';
+export { readDebianPackagesIndex, readDebianRelease } from './debian/indexreader.js';
+export type { IDebianPackagesIndex, IDebianPackagesStanza, IDebianRelease, IDebianReleaseField, IDebianReleaseFile, } from './debian/indexreader.js';
 export { readRpmPackage } from './rpm/reader.js';
 export { signRpmPackage } from './rpm/sign.js';
 export { buildRpmIndex } from './rpm/builder.js';
 export { mergeRpmUpdates } from './rpm/updates.js';
 export { renderRpmRepoConfig } from './rpm/repoconfig.js';
+export { isRpmPrimaryPath } from './rpm/repodata.js';
+export { readRpmRepodata, readRpmRepomd, readRpmUpdateInfo } from './rpm/repodatareader.js';
+export type { IRpmRepodata, IRpmRepodataFile, IRpmRepodataPackage, IRpmRepomd, IRpmRepomdChecksum, IRpmRepomdData, IRpmRepomdElement, IRpmUpdateInfo, IRpmUpdateInfoPackage, IRpmUpdateInfoUpdate, IRpmXmlAttribute, IRpmXmlFrame, TRpmRepodataDocument, } from './rpm/repodatareader.js';
 export { readArchPackage } from './arch/reader.js';
 export { buildArchIndex } from './arch/builder.js';
 export type { IArchIndexEntry } from './arch/builder.js';
 export { signArchPackage } from './arch/signer.js';
+export { compareArchVersions } from './arch/vercmp.js';
+export { readArchIndex } from './arch/indexreader.js';
+export type { IArchIndex, IArchIndexMember } from './arch/indexreader.js';
 export { readAlpinePackage } from './alpine/reader.js';
 export { buildAlpineIndex } from './alpine/apkindex.js';
+export { readAlpineIndex } from './alpine/apkindexreader.js';
+export type { IAlpineIndex, IAlpineIndexBlock, IAlpineIndexMember, IAlpineIndexSignatureEntry, } from './alpine/apkindexreader.js';

package/dist_ts/index.js

@@ -2,19 +2,25 @@ export { DEFAULT_LINUX_PACKAGE_LIMITS } from './shared/limits.js';
 export { LinuxRepoError } from './shared/errors.js';
 export { isIndexableArchitecture } from './shared/architecture.js';
 export { createAlpineSigner, createOpenPgpSigner } from './signing/signers.js';
-export { createOpenPgpVerifier } from './signing/verifiers.js';
+export { createAlpineVerifier, createOpenPgpVerifier } from './signing/verifiers.js';
 export { generateAlpineKeyPair, generateOpenPgpKeyPair, giteaAlpineKeyName } from './signing/keys.js';
 export { readDebianPackage } from './debian/reader.js';
 export { buildDebianIndex } from './debian/indexbuilder.js';
-export { isDebianReleaseValue, isDebianSymbol } from './debian/rules.js';
+export { isDebianReleaseValue, isDebianSymbol, stripDebianIndexOwnedFields } from './debian/rules.js';
+export { readDebianPackagesIndex, readDebianRelease } from './debian/indexreader.js';
 export { readRpmPackage } from './rpm/reader.js';
 export { signRpmPackage } from './rpm/sign.js';
 export { buildRpmIndex } from './rpm/builder.js';
 export { mergeRpmUpdates } from './rpm/updates.js';
 export { renderRpmRepoConfig } from './rpm/repoconfig.js';
+export { isRpmPrimaryPath } from './rpm/repodata.js';
+export { readRpmRepodata, readRpmRepomd, readRpmUpdateInfo } from './rpm/repodatareader.js';
 export { readArchPackage } from './arch/reader.js';
 export { buildArchIndex } from './arch/builder.js';
 export { signArchPackage } from './arch/signer.js';
+export { compareArchVersions } from './arch/vercmp.js';
+export { readArchIndex } from './arch/indexreader.js';
 export { readAlpinePackage } from './alpine/reader.js';
 export { buildAlpineIndex } from './alpine/apkindex.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUF3QkEsT0FBTyxFQUFFLDRCQUE0QixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFbEUsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXBELE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ25FLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRS9FLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBTy9ELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxzQkFBc0IsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRXRHLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRTVELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxjQUFjLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN6RSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDakQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMvQyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDakQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQzFELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNuRCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFbkQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDIn0=
+export { readAlpineIndex } from './alpine/apkindexreader.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUF5QkEsT0FBTyxFQUFFLDRCQUE0QixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFbEUsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXBELE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ25FLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRS9FLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBU3JGLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxzQkFBc0IsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRXRHLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRTVELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxjQUFjLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN0RyxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQVFyRixPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDakQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMvQyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDakQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQzFELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3JELE9BQU8sRUFBRSxlQUFlLEVBQUUsYUFBYSxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFnQjVGLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNuRCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFbkQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUV0RCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUN2RCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN4RCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sNEJBQTRCLENBQUMifQ==