@push.rocks/smartlinuxrepo 1.1.1 → 1.2.0

package/dist_ts/readers/decompress.d.ts

@@ -1,11 +1,15 @@
 import type { ILinuxPackageLimits } from '../shared/limits.js';
+import type { TLinuxCompression } from '../shared/types.js';
 import { type IByteReader } from './bytes.js';
-/** The stream compressions the readers decode. */
-export type TLinuxCompression = 'none' | 'gzip' | 'xz' | 'zstd';
 export interface IDecompressOptions {
     /** Bound on the decompressed bytes delivered. */
     maxOutputBytes: number;
     outputLimit: keyof ILinuxPackageLimits;
+    /**
+     * Bound on the Zstandard frames of a zstd stream (skippable frames do not
+     * count): one more is `limit-exceeded` on `maxEntries`.
+     */
+    maxZstdFrames: number;
 }
 /**
  * A reader over the decompressed bytes of an inner reader. Pulling is lazy
@@ -13,15 +17,20 @@ export interface IDecompressOptions {
  * `limit-exceeded` and stops the decoder. `close()` releases the decoder and
  * must be called (see `withDecompressingReader`).
  *
- * - gzip (multi-member) and zstd come from `node:zlib`, xz from
- *   `@napi-rs/lzma` `xz.decompressStream` (64 KiB chunks, cancellable).
+ * - gzip (multi-member) comes from `node:zlib` `createGunzip`; zstd from one
+ *   `node:zlib` `createZstdDecompress` fed by the codec's RFC 8878 frame walk,
+ *   at most `maxZstdFrames` Zstandard frames; xz from `@napi-rs/lzma`
+ *   `xz.decompressStream` (64 KiB chunks, cancellable).
  * - An error from the inner reader (the caller's source, or a codec limit on
  *   it) propagates unchanged.
  * - A compressed stream that ends early is `truncated`; corrupt data is
  *   `malformed-archive` with the decoder error as `cause`.
  * - The decoder reads the inner reader ahead and never hands bytes back, so
  *   the compressed stream must run to the end of the inner reader (a whole
- *   package, or a `LimitedReader` over one archive member).
+ *   package, or a `LimitedReader` over one archive member). Bytes after the
+ *   last gzip member or zstd frame are `malformed-archive` (zstd skippable
+ *   frames are skipped). A reader closed before the end skips the end check;
+ *   the zstd walk still refuses such bytes when it has already read them.
  * - Opening a zstd decoder on a Node.js without nodejs/node#64593 throws a
  *   plain `Error` (see `isZstdDecodingSafe`): a server fault, not a verdict
  *   on the package.

package/dist_ts/readers/decompress.js

@@ -8,14 +8,14 @@ export function openDecompressingReader(inputArg, compressionArg, optionsArg) {
             source = new PassThroughSource(inputArg);
             break;
         case 'gzip':
-            source = new ZlibSource(inputArg, 'gzip');
+            source = new GzipSource(inputArg);
             break;
         case 'zstd':
             if (!isZstdDecodingSafe(process.versions.node)) {
                 throw new Error(`zstd decoding needs Node.js ${ZSTD_NODE_FLOOR} (nodejs/node#64593 reports a zstd frame that ends early); ` +
                     `this process runs Node.js ${process.versions.node}`);
             }
-            source = new ZlibSource(inputArg, 'zstd');
+            source = new ZstdSource(inputArg, optionsArg.maxZstdFrames);
             break;
         case 'xz':
             source = new XzSource(inputArg);
@@ -117,28 +117,35 @@ class PassThroughSource {
     }
     async close() { }
 }
-/** gzip (multi-member, like Go's default) and zstd through `node:zlib`, with stream backpressure. */
-class ZlibSource {
-    kind;
+/**
+ * gzip through `node:zlib` `createGunzip`, with stream backpressure. Gunzip
+ * decodes concatenated members, as Go's default reader does, but it stops at a
+ * NUL byte after a member and ignores the rest of the input, a valid member
+ * included; its `bytesWritten` counts only the bytes it consumed. So when the
+ * decoder ends by itself it must have consumed every byte read from the inner
+ * reader, and the inner reader must be at its end; anything else is
+ * `malformed-archive`. A source closed before that skips the check.
+ */
+class GzipSource {
+    input;
     feeder;
     decoder;
     iterator;
+    /** Bytes read from the inner reader. */
+    inputBytes = 0;
+    inputEnded = false;
     inputFailed = false;
     inputError = undefined;
+    /** The read in flight on the inner reader; there is never more than one. */
+    pendingRead = null;
+    /** Set when the decoder has ended: the feeder starts no further read. */
+    stopped = false;
     finished = false;
-    constructor(inputArg, kindArg) {
-        this.kind = kindArg;
+    constructor(inputArg) {
+        this.input = inputArg;
         const pump = async function* () {
-            for (;;) {
-                let chunk;
-                try {
-                    chunk = await inputArg.read(READ_CHUNK_BYTES);
-                }
-                catch (error) {
-                    this.inputFailed = true;
-                    this.inputError = error;
-                    throw error;
-                }
+            while (!this.stopped) {
+                const chunk = await this.readInput(READ_CHUNK_BYTES);
                 if (chunk === null) {
                     return;
                 }
@@ -146,7 +153,7 @@ class ZlibSource {
             }
         };
         this.feeder = plugins.stream.Readable.from(pump.call(this), { objectMode: false });
-        this.decoder = kindArg === 'gzip' ? plugins.zlib.createGunzip() : plugins.zlib.createZstdDecompress();
+        this.decoder = plugins.zlib.createGunzip();
         // errors surface through the iterator below; the callback only completes the pipeline
         plugins.stream.pipeline(this.feeder, this.decoder, () => { });
         this.iterator = this.decoder[Symbol.asyncIterator]();
@@ -155,27 +162,395 @@ class ZlibSource {
         if (this.finished) {
             return null;
         }
+        let result;
         try {
-            const result = await this.iterator.next();
-            if (result.done) {
-                this.finished = true;
-                return null;
-            }
-            return result.value;
+            result = await this.iterator.next();
         }
         catch (error) {
             this.finished = true;
             if (this.inputFailed) {
                 throw this.inputError;
             }
-            throw mapZlibError(error, this.kind);
+            throw mapZlibError(error, 'gzip');
+        }
+        if (!result.done) {
+            return result.value;
+        }
+        this.finished = true;
+        await this.checkEnd();
+        return null;
+    }
+    async close() {
+        this.finished = true;
+        this.stopped = true;
+        this.feeder.destroy();
+        this.decoder.destroy();
+    }
+    /** Reads the inner reader and counts what it returns. */
+    readInput(maxArg) {
+        const pending = this.input.read(maxArg).then((chunk) => {
+            this.pendingRead = null;
+            if (chunk === null) {
+                this.inputEnded = true;
+            }
+            else {
+                this.inputBytes += chunk.length;
+            }
+            return chunk;
+        }, (error) => {
+            this.pendingRead = null;
+            this.inputFailed = true;
+            this.inputError = error;
+            throw error;
+        });
+        this.pendingRead = pending;
+        return pending;
+    }
+    /**
+     * The decoder ended by itself. It must have consumed every byte read from
+     * the inner reader, and one more read must report the end of input.
+     */
+    async checkEnd() {
+        this.stopped = true;
+        if (this.pendingRead !== null && this.decoder.bytesWritten === this.inputBytes) {
+            // a read the feeder started settles first: its bytes count, and no two reads overlap
+            await this.pendingRead;
+        }
+        if (this.inputFailed) {
+            throw this.inputError;
+        }
+        const consumedAll = this.decoder.bytesWritten === this.inputBytes && (this.inputEnded || (await this.readInput(1)) === null);
+        if (!consumedAll) {
+            throw new LinuxRepoError('malformed-archive', 'bytes follow the last gzip member', { field: 'gzip stream' });
+        }
+    }
+}
+/** RFC 8878 §3.1.1: the Zstandard frame magic number 0xFD2FB528, little-endian. */
+const ZSTD_FRAME_MAGIC = Uint8Array.of(0x28, 0xb5, 0x2f, 0xfd);
+/** RFC 8878 §3.1.2: a skippable frame magic number 0x184D2A5?, little-endian, after its first byte 0x5?. */
+const ZSTD_SKIPPABLE_MAGIC = Uint8Array.of(0x50, 0x2a, 0x4d, 0x18);
+/** Dictionary_ID field bytes by Dictionary_ID_Flag (RFC 8878 §3.1.1.1.1). */
+const ZSTD_DICTIONARY_ID_BYTES = [0, 1, 2, 4];
+/** Frame_Content_Size field bytes by Frame_Content_Size_Flag; flag 0 means 1 byte with Single_Segment_Flag, else 0. */
+const ZSTD_CONTENT_SIZE_BYTES = [0, 2, 4, 8];
+const ZSTD_BLOCK_TYPE_RLE = 1;
+const ZSTD_BLOCK_TYPE_RESERVED = 3;
+/** Place values of the bytes of a little-endian integer. */
+const LITTLE_ENDIAN_PLACE = [1, 0x100, 0x10000, 0x1000000];
+/**
+ * zstd through one `node:zlib` `createZstdDecompress` for the whole stream,
+ * fed by the codec's own RFC 8878 frame walk. node:zlib's zstd decoder before
+ * Node.js 26 drops the rest of a write after a frame (a second frame in the
+ * same write is lost, one in the next write is decoded), and every release
+ * ignores non-frame bytes after a frame. So the walk decides the frame
+ * boundaries, and no write to the decoder holds the end of one frame and any
+ * byte after it: every frame therefore costs at least one write (about 35 µs),
+ * which is why `maxZstdFrames` caps the Zstandard frames of a stream.
+ * - The walk reads the inner reader in chunks of `READ_CHUNK_BYTES` and parses
+ *   each chunk synchronously; it writes the longest runs of Zstandard-frame
+ *   bytes as views into the chunk, each ending at the end of the chunk or at a
+ *   frame end, so a frame costs one write per chunk it spans, never one per
+ *   header or block. Magic-number bytes from an earlier read are written as a
+ *   copy before the run. It keeps no bytes across reads, only the state below.
+ * - Skippable frames are skipped, never written; they do not count against
+ *   the cap. Anything else at a frame start, a set reserved header bit and
+ *   block type 3 are `malformed-archive`, raised as soon as the byte is read.
+ * - Input that ends inside a frame, a magic-number prefix included, or is
+ *   empty, is `truncated`; at least one Zstandard frame is required.
+ * - When the decoder ends by itself it must have consumed every byte written:
+ *   libzstd and the walk read the same header fields, so one check at the end
+ *   fails closed. A walk error is rethrown unchanged; a source closed before
+ *   the end skips the check.
+ */
+class ZstdSource {
+    input;
+    maxFrames;
+    feeder;
+    decoder;
+    iterator;
+    /** Frame bytes the walk has written to the decoder. */
+    written = 0;
+    walkFailed = false;
+    walkError = undefined;
+    /** Set when the source closes: the walk starts no further read. */
+    stopped = false;
+    finished = false;
+    state = 'magic';
+    /** Bytes of the current magic number, skippable frame size or block header read so far. */
+    fieldBytes = 0;
+    /** Whether the magic number being read is a skippable frame's. */
+    skippable = false;
+    /** A skippable frame size or block header as read so far, little-endian. */
+    fieldValue = 0;
+    /** Bytes left in the current header fields, block content, checksum or skippable content. */
+    remaining = 0;
+    descriptor = 0;
+    lastBlock = false;
+    zstandardFrames = 0;
+    sawInput = false;
+    constructor(inputArg, maxFramesArg) {
+        this.input = inputArg;
+        this.maxFrames = maxFramesArg;
+        this.feeder = plugins.stream.Readable.from(this.walk(), { objectMode: false });
+        this.decoder = plugins.zlib.createZstdDecompress();
+        // errors surface through the iterator below; the callback only completes the pipeline
+        plugins.stream.pipeline(this.feeder, this.decoder, () => { });
+        this.iterator = this.decoder[Symbol.asyncIterator]();
+    }
+    async next() {
+        if (this.finished) {
+            return null;
+        }
+        let result;
+        try {
+            result = await this.iterator.next();
+        }
+        catch (error) {
+            await this.close();
+            if (this.walkFailed) {
+                throw this.walkError;
+            }
+            throw mapZlibError(error, 'zstd');
+        }
+        if (!result.done) {
+            return result.value;
         }
+        const consumed = this.decoder.bytesWritten;
+        await this.close();
+        if (this.walkFailed) {
+            throw this.walkError;
+        }
+        if (consumed !== this.written) {
+            throw zstdMalformed(`the zstd decoder ended after ${consumed} of the ${this.written} frame bytes`);
+        }
+        return null;
     }
     async close() {
         this.finished = true;
+        this.stopped = true;
         this.feeder.destroy();
         this.decoder.destroy();
     }
+    /** Reads and parses the inner reader chunk by chunk and yields the runs of Zstandard-frame bytes to write. */
+    async *walk() {
+        const runs = [];
+        for (;;) {
+            // only errors the walk raises or reads count as walk errors, not ones a destroyed feeder injects at a yield
+            try {
+                const chunk = await this.input.read(READ_CHUNK_BYTES);
+                if (this.stopped) {
+                    return;
+                }
+                if (chunk === null) {
+                    this.endOfInput();
+                    return;
+                }
+                this.parse(chunk, runs);
+            }
+            catch (error) {
+                this.walkFailed = true;
+                this.walkError = error;
+                throw error;
+            }
+            for (const run of runs) {
+                this.written += run.length;
+                yield run;
+            }
+            runs.length = 0;
+        }
+    }
+    /** Advances the state over `chunkArg` and appends the runs of Zstandard-frame bytes it holds to `runsArg`. */
+    parse(chunkArg, runsArg) {
+        const length = chunkArg.length;
+        if (length > 0) {
+            this.sawInput = true;
+        }
+        const outsideFrame = this.state === 'magic' || this.state === 'skippable-size' || this.state === 'skippable-body';
+        /** Start of the current run in this chunk, or -1 outside a Zstandard frame. */
+        let runStart = outsideFrame ? -1 : 0;
+        /** Magic-number bytes read before this chunk. */
+        let earlier = this.state === 'magic' ? this.fieldBytes : 0;
+        let index = 0;
+        while (index < length) {
+            switch (this.state) {
+                case 'magic': {
+                    const byte = chunkArg[index];
+                    if (this.fieldBytes === 0) {
+                        this.skippable = (byte & 0xf0) === ZSTD_SKIPPABLE_MAGIC[0];
+                        if (!this.skippable && byte !== ZSTD_FRAME_MAGIC[0]) {
+                            throw zstdMalformed('bytes at a zstd frame start are not a zstd frame');
+                        }
+                    }
+                    else if (byte !== (this.skippable ? ZSTD_SKIPPABLE_MAGIC : ZSTD_FRAME_MAGIC)[this.fieldBytes]) {
+                        throw zstdMalformed('bytes at a zstd frame start are not a zstd frame');
+                    }
+                    index += 1;
+                    this.fieldBytes += 1;
+                    if (this.fieldBytes < 4) {
+                        break;
+                    }
+                    this.fieldBytes = 0;
+                    if (this.skippable) {
+                        this.fieldValue = 0;
+                        this.state = 'skippable-size';
+                    }
+                    else {
+                        this.zstandardFrames += 1;
+                        if (this.zstandardFrames > this.maxFrames) {
+                            throw limitExceeded('maxEntries', this.maxFrames, 'zstd frames');
+                        }
+                        if (earlier > 0) {
+                            runsArg.push(ZSTD_FRAME_MAGIC.slice(0, earlier));
+                            runStart = 0;
+                        }
+                        else {
+                            runStart = index - 4;
+                        }
+                        this.state = 'frame-header';
+                    }
+                    earlier = 0;
+                    break;
+                }
+                case 'skippable-size':
+                    this.fieldValue += chunkArg[index] * LITTLE_ENDIAN_PLACE[this.fieldBytes];
+                    index += 1;
+                    this.fieldBytes += 1;
+                    if (this.fieldBytes === 4) {
+                        this.fieldBytes = 0;
+                        this.remaining = this.fieldValue;
+                        this.state = this.remaining === 0 ? 'magic' : 'skippable-body';
+                    }
+                    break;
+                case 'skippable-body': {
+                    const take = Math.min(this.remaining, length - index);
+                    index += take;
+                    this.remaining -= take;
+                    if (this.remaining === 0) {
+                        this.state = 'magic';
+                    }
+                    break;
+                }
+                case 'frame-header': {
+                    const flags = chunkArg[index];
+                    index += 1;
+                    if ((flags & 0x08) !== 0) {
+                        throw zstdMalformed('a zstd frame header sets the reserved bit');
+                    }
+                    const contentSizeFlag = flags >> 6;
+                    const singleSegment = (flags >> 5) & 1;
+                    this.descriptor = flags;
+                    this.remaining =
+                        (singleSegment === 1 ? 0 : 1) +
+                            ZSTD_DICTIONARY_ID_BYTES[flags & 3] +
+                            (contentSizeFlag === 0 ? singleSegment : ZSTD_CONTENT_SIZE_BYTES[contentSizeFlag]);
+                    this.fieldValue = 0;
+                    this.state = this.remaining === 0 ? 'block-header' : 'header-fields';
+                    break;
+                }
+                case 'header-fields': {
+                    const take = Math.min(this.remaining, length - index);
+                    index += take;
+                    this.remaining -= take;
+                    if (this.remaining === 0) {
+                        this.state = 'block-header';
+                    }
+                    break;
+                }
+                case 'block-header': {
+                    this.fieldValue += chunkArg[index] * LITTLE_ENDIAN_PLACE[this.fieldBytes];
+                    index += 1;
+                    this.fieldBytes += 1;
+                    if (this.fieldBytes < 3) {
+                        break;
+                    }
+                    const header = this.fieldValue;
+                    this.fieldBytes = 0;
+                    this.fieldValue = 0;
+                    const blockType = (header >> 1) & 3;
+                    if (blockType === ZSTD_BLOCK_TYPE_RESERVED) {
+                        throw zstdMalformed('a zstd block has the reserved block type');
+                    }
+                    this.lastBlock = (header & 1) === 1;
+                    this.remaining = blockType === ZSTD_BLOCK_TYPE_RLE ? 1 : header >>> 3;
+                    if (this.remaining > 0) {
+                        this.state = 'block-body';
+                    }
+                    else if (this.endBlock()) {
+                        runsArg.push(chunkArg.subarray(runStart, index));
+                        runStart = -1;
+                    }
+                    break;
+                }
+                case 'block-body':
+                case 'checksum': {
+                    const take = Math.min(this.remaining, length - index);
+                    index += take;
+                    this.remaining -= take;
+                    if (this.remaining > 0) {
+                        break;
+                    }
+                    if (this.state === 'checksum' || this.endBlock()) {
+                        this.state = 'magic';
+                        runsArg.push(chunkArg.subarray(runStart, index));
+                        runStart = -1;
+                    }
+                    break;
+                }
+            }
+        }
+        if (runStart >= 0 && runStart < length) {
+            runsArg.push(chunkArg.subarray(runStart, length));
+        }
+    }
+    /** A block's content has been read: returns true when that ends the frame, else moves to the next field. */
+    endBlock() {
+        if (!this.lastBlock) {
+            this.state = 'block-header';
+            return false;
+        }
+        if ((this.descriptor & 0x04) !== 0) {
+            this.remaining = 4;
+            this.state = 'checksum';
+            return false;
+        }
+        this.state = 'magic';
+        return true;
+    }
+    /** The inner reader has ended: only a frame start after at least one Zstandard frame is a clean end. */
+    endOfInput() {
+        switch (this.state) {
+            case 'magic':
+                if (this.fieldBytes > 0) {
+                    throw zstdTruncated('a zstd frame magic number');
+                }
+                if (this.zstandardFrames > 0) {
+                    return;
+                }
+                if (!this.sawInput) {
+                    throw zstdTruncated('the zstd stream');
+                }
+                throw zstdMalformed('the zstd stream holds no Zstandard frame');
+            case 'skippable-size':
+                throw zstdTruncated('a zstd skippable frame header');
+            case 'skippable-body':
+                throw zstdTruncated('a zstd skippable frame');
+            case 'frame-header':
+            case 'header-fields':
+                throw zstdTruncated('a zstd frame header');
+            case 'block-header':
+                throw zstdTruncated('a zstd block header');
+            case 'block-body':
+                throw zstdTruncated('a zstd block');
+            case 'checksum':
+                throw zstdTruncated('a zstd frame checksum');
+        }
+    }
+}
+function zstdTruncated(whereArg) {
+    return new LinuxRepoError('truncated', `input ended inside ${whereArg}`, { field: 'zstd stream' });
+}
+function zstdMalformed(messageArg) {
+    return new LinuxRepoError('malformed-archive', messageArg, { field: 'zstd stream' });
 }
 function mapZlibError(errorArg, kindArg) {
     const code = errorArg?.code;
@@ -266,4 +641,4 @@ class XzSource {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decompress.js","sourceRoot":"","sources":["../../ts/readers/decompress.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAE/E,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAoB,MAAM,YAAY,CAAC;AAwC3E,MAAM,UAAU,uBAAuB,CACrC,QAAqB,EACrB,cAAiC,EACjC,UAA8B;IAE9B,IAAI,MAAoB,CAAC;IACzB,QAAQ,cAAc,EAAE,CAAC;QACvB,KAAK,MAAM;YACT,MAAM,GAAG,IAAI,iBAAiB,CAAC,QAAQ,CAAC,CAAC;YACzC,MAAM;QACR,KAAK,MAAM;YACT,MAAM,GAAG,IAAI,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YAC1C,MAAM;QACR,KAAK,MAAM;YACT,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC/C,MAAM,IAAI,KAAK,CACb,+BAA+B,eAAe,6DAA6D;oBACzG,6BAA6B,OAAO,CAAC,QAAQ,CAAC,IAAI,EAAE,CACvD,CAAC;YACJ,CAAC;YACD,MAAM,GAAG,IAAI,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YAC1C,MAAM;QACR,KAAK,IAAI;YACP,MAAM,GAAG,IAAI,QAAQ,CAAC,QAAQ,CAAC,CAAC;YAChC,MAAM;QACR;YACE,MAAM,IAAI,cAAc,CAAC,yBAAyB,EAAE,wBAAwB,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE;gBACrG,KAAK,EAAE,aAAa;aACrB,CAAC,CAAC;IACP,CAAC;IACD,OAAO,IAAI,mBAAmB,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AACrD,CAAC;AAED,2EAA2E;AAC3E,MAAM,eAAe,GAAG,sBAAsB,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,UAAkB;IACnD,MAAM,KAAK,GAAG,gCAAgC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAChE,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/B,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/B,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;QACjB,OAAO,KAAK,IAAI,EAAE,CAAC;IACrB,CAAC;IACD,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;QACjB,OAAO,KAAK,IAAI,CAAC,CAAC;IACpB,CAAC;IACD,OAAO,KAAK,IAAI,EAAE,CAAC;AACrB,CAAC;AAED,uEAAuE;AACvE,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,QAAqB,EACrB,cAAiC,EACjC,UAA8B,EAC9B,OAAwD;IAExD,MAAM,MAAM,GAAG,uBAAuB,CAAC,QAAQ,EAAE,cAAc,EAAE,UAAU,CAAC,CAAC;IAC7E,IAAI,CAAC;QACH,OAAO,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/B,CAAC;YAAS,CAAC;QACT,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;IACvB,CAAC;AACH,CAAC;AAED,MAAM,mBAAmB;IAMJ,MAAM;IACN,OAAO;IANlB,SAAS,GAAG,CAAC,CAAC;IACL,UAAU,GAAiB,EAAE,CAAC;IACvC,MAAM,GAAG,KAAK,CAAC;IAEvB,YACmB,MAAoB,EACpB,OAA2B;sBAD3B,MAAM;uBACN,OAAO;IACvB,CAAC;IAEJ,IAAW,WAAW;QACpB,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAEM,KAAK,CAAC,IAAI,CAAC,MAAc;QAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC;QACrC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,OAAO,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QACpD,CAAC;QACD,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QACvC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC,MAAM,CAAC;QAC/B,IAAI,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;YACjD,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;YACnB,MAAM,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,mBAAmB,CAAC,CAAC;QAClG,CAAC;QACD,OAAO,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IACnD,CAAC;IAEM,MAAM,CAAC,QAAoB;QAChC,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,KAAK;QAChB,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC;QAC3B,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IAC5B,CAAC;CACF;AAED,MAAM,iBAAiB;IACQ,KAAK;IAAlC,YAA6B,KAAkB;qBAAlB,KAAK;IAAgB,CAAC;IAE5C,IAAI;QACT,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC3C,CAAC;IAEM,KAAK,CAAC,KAAK,KAAmB,CAAC;CACvC;AAED,qGAAqG;AACrG,MAAM,UAAU;IACG,IAAI,CAAkB;IACtB,MAAM,CAA0B;IAChC,OAAO,CAAoD;IAC3D,QAAQ,CAAwB;IACzC,WAAW,GAAG,KAAK,CAAC;IACpB,UAAU,GAAY,SAAS,CAAC;IAChC,QAAQ,GAAG,KAAK,CAAC;IAEzB,YAAY,QAAqB,EAAE,OAAwB;QACzD,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC;QACpB,MAAM,IAAI,GAAG,KAAK,SAAS,CAAC;YAC1B,SAAS,CAAC;gBACR,IAAI,KAAwB,CAAC;gBAC7B,IAAI,CAAC;oBACH,KAAK,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;gBAChD,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;oBACxB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;oBACxB,MAAM,KAAK,CAAC;gBACd,CAAC;gBACD,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;oBACnB,OAAO;gBACT,CAAC;gBACD,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC,CAAC;QACF,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;QACnF,IAAI,CAAC,OAAO,GAAG,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC;QACtG,sFAAsF;QACtF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QAC7D,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC;IACvD,CAAC;IAEM,KAAK,CAAC,IAAI;QACf,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;YAC1C,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;gBAChB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;gBACrB,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO,MAAM,CAAC,KAAK,CAAC;QACtB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;gBACrB,MAAM,IAAI,CAAC,UAAU,CAAC;YACxB,CAAC;YACD,MAAM,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QACvC,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,KAAK;QAChB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACtB,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IACzB,CAAC;CACF;AAED,SAAS,YAAY,CAAC,QAAiB,EAAE,OAAwB;IAC/D,MAAM,IAAI,GAAI,QAAsC,EAAE,IAAI,CAAC;IAC3D,qGAAqG;IACrG,IAAI,IAAI,KAAK,aAAa,EAAE,CAAC;QAC3B,MAAM,KAAK,GAAG,SAAS,CAAC,GAAG,OAAO,SAAS,CAAC,CAAC;QAC7C,OAAO,IAAI,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC1F,CAAC;IACD,OAAO,IAAI,cAAc,CAAC,mBAAmB,EAAE,WAAW,OAAO,OAAO,EAAE,EAAE,KAAK,EAAE,GAAG,OAAO,SAAS,EAAE,EAAE;QACxG,KAAK,EAAE,QAAQ;KAChB,CAAC,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH,MAAM,QAAQ;IACK,MAAM,CAA0C;IACzD,WAAW,GAAG,KAAK,CAAC;IACpB,UAAU,GAAY,SAAS,CAAC;IAChC,UAAU,GAAG,KAAK,CAAC;IACnB,QAAQ,GAAG,KAAK,CAAC;IACjB,OAAO,GAAG,KAAK,CAAC;IAExB,YAAY,QAAqB;QAC/B,MAAM,KAAK,GAAG,IAAI,cAAc,CAC9B;YACE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE;gBACzB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;oBACjB,UAAU,CAAC,KAAK,EAAE,CAAC;oBACnB,OAAO;gBACT,CAAC;gBACD,IAAI,KAAwB,CAAC;gBAC7B,IAAI,CAAC;oBACH,KAAK,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;gBAChD,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;oBACxB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;oBACxB,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;oBACxB,OAAO;gBACT,CAAC;gBACD,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;oBACnB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;oBACvB,UAAU,CAAC,KAAK,EAAE,CAAC;gBACrB,CAAC;qBAAM,CAAC;oBACN,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;gBAC5B,CAAC;YACH,CAAC;YACD,MAAM,EAAE,GAAG,EAAE;gBACX,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACtB,CAAC;SACF,EACD,EAAE,aAAa,EAAE,CAAC,EAAE,CACrB,CAAC;QACF,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,SAAS,EAAE,CAAC;IACpE,CAAC;IAEM,KAAK,CAAC,IAAI;QACf,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;YACxC,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;gBAChB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;gBACrB,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO,MAAM,CAAC,KAAK,CAAC;QACtB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;gBACrB,MAAM,IAAI,CAAC,UAAU,CAAC;YACxB,CAAC;YACD,wEAAwE;YACxE,yEAAyE;YACzE,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;YAC5D,IAAI,IAAI,CAAC,UAAU,IAAI,OAAO,CAAC,QAAQ,CAAC,6BAA6B,CAAC,EAAE,CAAC;gBACvE,MAAM,IAAI,GAAG,SAAS,CAAC,WAAW,CAAC,CAAC;gBACpC,MAAM,IAAI,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;YACnF,CAAC;YACD,MAAM,IAAI,cAAc,CAAC,mBAAmB,EAAE,iBAAiB,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;QAC7G,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,KAAK;QAChB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QAC7B,CAAC;IACH,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decompress.js","sourceRoot":"","sources":["../../ts/readers/decompress.ts"],"names":[],"mappings":"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"}

package/dist_ts/readers/document.d.ts

@@ -0,0 +1,36 @@
+import type { ILinuxPackageLimits } from '../shared/limits.js';
+import type { TLinuxCompression } from '../shared/types.js';
+/** Refuses a reader argument that is not an object (`invalid-input`, `input`). */
+export declare function assertReaderInput(inputArg: unknown): asserts inputArg is Record<string, unknown>;
+/** Refuses a `bytes` argument that is not a `Uint8Array` (`invalid-input`, `bytes`). */
+export declare function assertReaderBytes(valueArg: unknown): asserts valueArg is Uint8Array;
+/** Refuses a compression that is not a `TLinuxCompression` (`invalid-input`, `compression`). */
+export declare function assertLinuxCompression(valueArg: unknown): asserts valueArg is TLinuxCompression;
+/**
+ * Decodes one index document into a new buffer the reader owns, through
+ * `withDecompressingReader` for every compression (`'none'` passes the input
+ * through and copies it), bounded by `maxIndexBytes`. The decoder's own
+ * mapping applies: a stream that ends early is `truncated`, corrupt data
+ * `malformed-archive`, output past the bound `limit-exceeded`
+ * (`maxIndexBytes`). The result never aliases `bytesArg`.
+ */
+export declare function readIndexDocument(bytesArg: Uint8Array, compressionArg: TLinuxCompression, limitsArg: Readonly<ILinuxPackageLimits>): Promise<Uint8Array>;
+/** One line of a line-format document: `[start, end)` without its LF, which sits at `end`. */
+export interface ILine {
+    readonly start: number;
+    readonly end: number;
+}
+/**
+ * The common line lexer of the line formats: lines end in LF and the last
+ * line must have one too (`malformed-index`, `detail.value` the offset of
+ * the unterminated line); a line longer than `maxHeaderBytes` (without its
+ * LF) is `limit-exceeded`. CR is an ordinary byte; nothing is trimmed. An
+ * empty document has no lines.
+ */
+export declare function lines(bytesArg: Uint8Array, maxLineBytesArg: number, whatArg: string): Generator<ILine>;
+/** True when the line holds only spaces or tabs (at least one). */
+export declare function isBlankLine(bytesArg: Uint8Array, lineArg: ILine): boolean;
+/** Counts one more unit of a document against `maxEntries`. */
+export declare function countUnit(countArg: number, limitsArg: Readonly<ILinuxPackageLimits>, whatArg: string): void;
+/** Refuses one unit larger than `maxMetadataBytes`. */
+export declare function checkUnitBytes(lengthArg: number, limitsArg: Readonly<ILinuxPackageLimits>, whatArg: string): void;