@patrickdk77/archive-defuse 0.0.0-stage → 0.1.1

package/dist/sevenzip.js

@@ -0,0 +1,529 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderReader = exports.Nid = void 0;
+exports.parseStartHeader = parseStartHeader;
+exports.coderOf = coderOf;
+exports.firstStream = firstStream;
+exports.readStreamsInfo = readStreamsInfo;
+exports.parseHeader = parseHeader;
+exports.parseEncodedHeader = parseEncodedHeader;
+const errors_1 = require("./errors");
+/** Property IDs of the 7z header. */
+var Nid;
+(function (Nid) {
+    Nid[Nid["End"] = 0] = "End";
+    Nid[Nid["Header"] = 1] = "Header";
+    Nid[Nid["ArchiveProperties"] = 2] = "ArchiveProperties";
+    Nid[Nid["AdditionalStreamsInfo"] = 3] = "AdditionalStreamsInfo";
+    Nid[Nid["MainStreamsInfo"] = 4] = "MainStreamsInfo";
+    Nid[Nid["FilesInfo"] = 5] = "FilesInfo";
+    Nid[Nid["PackInfo"] = 6] = "PackInfo";
+    Nid[Nid["UnpackInfo"] = 7] = "UnpackInfo";
+    Nid[Nid["SubStreamsInfo"] = 8] = "SubStreamsInfo";
+    Nid[Nid["Size"] = 9] = "Size";
+    Nid[Nid["Crc"] = 10] = "Crc";
+    Nid[Nid["Folder"] = 11] = "Folder";
+    Nid[Nid["CodersUnpackSize"] = 12] = "CodersUnpackSize";
+    Nid[Nid["NumUnpackStream"] = 13] = "NumUnpackStream";
+    Nid[Nid["EmptyStream"] = 14] = "EmptyStream";
+    Nid[Nid["EmptyFile"] = 15] = "EmptyFile";
+    Nid[Nid["Anti"] = 16] = "Anti";
+    Nid[Nid["Name"] = 17] = "Name";
+    Nid[Nid["CTime"] = 18] = "CTime";
+    Nid[Nid["ATime"] = 19] = "ATime";
+    Nid[Nid["MTime"] = 20] = "MTime";
+    Nid[Nid["WinAttributes"] = 21] = "WinAttributes";
+    Nid[Nid["Comment"] = 22] = "Comment";
+    Nid[Nid["EncodedHeader"] = 23] = "EncodedHeader";
+    Nid[Nid["StartPos"] = 24] = "StartPos";
+    Nid[Nid["Dummy"] = 25] = "Dummy";
+})(Nid || (exports.Nid = Nid = {}));
+const MAX_SAFE = Number.MAX_SAFE_INTEGER;
+/** Reads the numbers, bit vectors and digests of a 7z header. */
+class HeaderReader {
+    buf;
+    pos = 0;
+    constructor(buf) {
+        this.buf = buf;
+    }
+    get remaining() {
+        return this.buf.length - this.pos;
+    }
+    byte() {
+        if (this.pos >= this.buf.length)
+            throw new errors_1.ParseError('the header ends early');
+        return this.buf[this.pos++];
+    }
+    /** A property ID, read as a 7z number, so an ID can take more than one byte. Any large one is unknown. */
+    id() {
+        return Math.min(this.raw(), MAX_SAFE);
+    }
+    bytes(n) {
+        if (n > this.remaining)
+            throw new errors_1.ParseError('the header ends early');
+        const b = this.buf.subarray(this.pos, this.pos + n);
+        this.pos += n;
+        return b;
+    }
+    /** A 7z number: the first byte's leading one bits count the bytes that follow, which hold the low bits. */
+    raw() {
+        const first = this.byte();
+        let mask = 0x80;
+        let value = 0;
+        for (let i = 0; i < 8; i++) {
+            if ((first & mask) === 0)
+                return value + (first & (mask - 1)) * 2 ** (8 * i);
+            value += this.byte() * 2 ** (8 * i);
+            mask >>>= 1;
+        }
+        return value;
+    }
+    /** A 7z number used as a size, a count or an index. */
+    number() {
+        const value = this.raw();
+        if (value > MAX_SAFE)
+            throw new errors_1.ParseError('a header number is too large');
+        return value;
+    }
+    /** A number used as a count of things that each take at least `unit` bytes of what is left. */
+    count(unit, max = MAX_SAFE) {
+        const n = this.number();
+        if (n > max || n * unit > this.remaining)
+            throw new errors_1.ParseError('a header count is larger than the header');
+        return n;
+    }
+    uint32() {
+        const b = this.bytes(4);
+        return (b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24)) >>> 0;
+    }
+    bits(n) {
+        const out = [];
+        let mask = 0;
+        let cur = 0;
+        for (let i = 0; i < n; i++) {
+            if (mask === 0) {
+                cur = this.byte();
+                mask = 0x80;
+            }
+            out.push((cur & mask) !== 0);
+            mask >>>= 1;
+        }
+        return out;
+    }
+    /** A byte that says all are defined, or a bit vector that says which. */
+    defined(n) {
+        const all = this.byte();
+        return all ? new Array(n).fill(true) : this.bits(n);
+    }
+    digests(n) {
+        const defined = this.defined(n);
+        return defined.map(d => (d ? this.uint32() : undefined));
+    }
+}
+exports.HeaderReader = HeaderReader;
+const hex = (b) => Buffer.from(b).toString('hex');
+/** Reads the 20 bytes after the signature, version and CRC. */
+function parseStartHeader(b) {
+    const view = new DataView(b.buffer, b.byteOffset, b.byteLength);
+    const u64 = (at) => {
+        const v = view.getUint32(at, true) + view.getUint32(at + 4, true) * 2 ** 32;
+        if (v > MAX_SAFE)
+            throw new errors_1.ParseError('the start header holds an offset beyond any file');
+        return v;
+    };
+    return { minorVersion: b[7], nextHeaderOffset: u64(12), nextHeaderSize: u64(20), nextHeaderCrc: view.getUint32(28, true) };
+}
+/** At most 64 coders, and 64 streams, in a folder: more than any chain of 7z methods needs. */
+const MAX_FOLDER_STREAMS = 64;
+function readFolder(r) {
+    const numCoders = r.count(2, MAX_FOLDER_STREAMS);
+    if (numCoders === 0)
+        throw new errors_1.ParseError('a folder has no coders');
+    const coders = [];
+    let totalIn = 0;
+    let totalOut = 0;
+    for (let i = 0; i < numCoders; i++) {
+        const flags = r.byte();
+        if (flags & 0x80)
+            throw new errors_1.UnsupportedError('alternative coder methods', false, { reason: 'alternative coder methods' });
+        const idSize = flags & 0x0f;
+        // A method ID is a big-endian number, so leading zero bytes add nothing, and an ID of no bytes is 0, which is Copy.
+        const method = hex(r.bytes(idSize)).replace(/^(00)+/, '') || '00';
+        let numIn = 1;
+        let numOut = 1;
+        if (flags & 0x10) {
+            numIn = r.count(0, MAX_FOLDER_STREAMS);
+            numOut = r.count(0, MAX_FOLDER_STREAMS);
+        }
+        const props = flags & 0x20 ? r.bytes(r.count(1)).slice() : new Uint8Array(0);
+        coders.push({ method, numIn, numOut, props });
+        totalIn += numIn;
+        totalOut += numOut;
+    }
+    if (totalOut === 0 || totalIn > MAX_FOLDER_STREAMS || totalOut > MAX_FOLDER_STREAMS)
+        throw new errors_1.ParseError('a folder has an invalid number of streams');
+    const bindPairs = [];
+    for (let i = 0; i < totalOut - 1; i++) {
+        const inIndex = r.number();
+        const outIndex = r.number();
+        if (inIndex >= totalIn || outIndex >= totalOut)
+            throw new errors_1.ParseError('a bind pair names a stream the folder does not have');
+        bindPairs.push({ inIndex, outIndex });
+    }
+    const numPacked = totalIn - bindPairs.length;
+    if (numPacked < 1)
+        throw new errors_1.ParseError('a folder reads no packed stream');
+    const packedStreams = [];
+    if (numPacked === 1) {
+        for (let i = 0; i < totalIn; i++) {
+            if (!bindPairs.some(bp => bp.inIndex === i)) {
+                packedStreams.push(i);
+                break;
+            }
+        }
+    }
+    else {
+        for (let i = 0; i < numPacked; i++) {
+            const index = r.number();
+            if (index >= totalIn)
+                throw new errors_1.ParseError('a packed stream index names a stream the folder does not have');
+            packedStreams.push(index);
+        }
+    }
+    if (packedStreams.length !== numPacked)
+        throw new errors_1.ParseError('the folder binds every input');
+    // Every in-stream gets exactly one source, and no out-stream feeds two in-streams.
+    const inUsed = new Set([...bindPairs.map(bp => bp.inIndex), ...packedStreams]);
+    const outUsed = new Set(bindPairs.map(bp => bp.outIndex));
+    if (inUsed.size !== totalIn || outUsed.size !== bindPairs.length)
+        throw new errors_1.ParseError('the folder joins its streams inconsistently');
+    return { coders, bindPairs, packedStreams };
+}
+/** The coder that owns a global in- or out-stream index, and the stream's index within that coder. */
+function coderOf(folder, index, side) {
+    let base = 0;
+    for (let c = 0; c < folder.coders.length; c++) {
+        const n = side === 'in' ? folder.coders[c].numIn : folder.coders[c].numOut;
+        if (index < base + n)
+            return { coder: c, local: index - base };
+        base += n;
+    }
+    throw new errors_1.ParseError('a stream index is out of range');
+}
+/** The first global in- or out-stream index of coder `c`. */
+function firstStream(folder, c, side) {
+    let base = 0;
+    for (let i = 0; i < c; i++)
+        base += side === 'in' ? folder.coders[i].numIn : folder.coders[i].numOut;
+    return base;
+}
+/**
+ * Throws when following the bind pairs from the main output loops back on itself, or leaves a coder unreached. The
+ * walk visits each coder once at most, so a crafted folder cannot make it run long.
+ */
+function checkAcyclic(folder) {
+    const visiting = new Set();
+    const reached = new Set();
+    const visit = (c, depth) => {
+        if (depth > MAX_FOLDER_STREAMS || visiting.has(c) || reached.has(c))
+            throw new errors_1.ParseError('the folder binds its coders in a loop');
+        visiting.add(c);
+        reached.add(c);
+        const first = firstStream(folder, c, 'in');
+        for (let i = 0; i < folder.coders[c].numIn; i++) {
+            const bp = folder.bindPairs.find(p => p.inIndex === first + i);
+            if (bp)
+                visit(coderOf(folder, bp.outIndex, 'out').coder, depth + 1);
+        }
+        visiting.delete(c);
+    };
+    visit(coderOf(folder, folder.mainOut, 'out').coder, 0);
+    if (reached.size !== folder.coders.length)
+        throw new errors_1.ParseError('a coder of the folder feeds nothing the folder outputs');
+}
+/**
+ * Reads a streams info. `maxEntries` caps the substreams, each of which is a file, before anything is allocated for
+ * them; `tooMany` reports a count over it.
+ */
+function readStreamsInfo(r, maxEntries = MAX_SAFE, tooMany) {
+    const info = { packPos: 0, packSizes: [], folders: [], numUnpackStreams: [], subSizes: [], subCrcs: [] };
+    let id = r.id();
+    if (id === Nid.PackInfo) {
+        info.packPos = r.number();
+        const numPack = r.count(1);
+        for (;;) {
+            id = r.id();
+            if (id === Nid.End)
+                break;
+            if (id === Nid.Size)
+                for (let i = 0; i < numPack; i++)
+                    info.packSizes.push(r.number());
+            else if (id === Nid.Crc)
+                r.digests(numPack);
+            else
+                throw new errors_1.ParseError(`unexpected property ${id} in the pack info`);
+        }
+        if (info.packSizes.length !== numPack)
+            throw new errors_1.ParseError('the pack info has no sizes');
+        id = r.id();
+    }
+    if (id === Nid.UnpackInfo) {
+        if (r.id() !== Nid.Folder)
+            throw new errors_1.ParseError('the unpack info does not start with its folders');
+        const numFolders = r.count(3);
+        if (r.byte() !== 0)
+            throw new errors_1.UnsupportedError('folders stored outside the header', false, { reason: 'folders stored outside the header' });
+        const raw = [];
+        for (let i = 0; i < numFolders; i++)
+            raw.push(readFolder(r));
+        if (r.id() !== Nid.CodersUnpackSize)
+            throw new errors_1.ParseError('the unpack info has no sizes');
+        for (const f of raw) {
+            const totalOut = f.coders.reduce((s, c) => s + c.numOut, 0);
+            const unpackSizes = [];
+            for (let i = 0; i < totalOut; i++)
+                unpackSizes.push(r.number());
+            let mainOut = -1;
+            for (let i = 0; i < totalOut; i++)
+                if (!f.bindPairs.some(bp => bp.outIndex === i))
+                    mainOut = i;
+            const folder = { ...f, unpackSizes, mainOut };
+            checkAcyclic(folder);
+            info.folders.push(folder);
+        }
+        for (;;) {
+            id = r.id();
+            if (id === Nid.End)
+                break;
+            if (id === Nid.Crc) {
+                const crcs = r.digests(numFolders);
+                crcs.forEach((c, i) => {
+                    if (c !== undefined)
+                        info.folders[i].crc = c;
+                });
+            }
+            else
+                throw new errors_1.ParseError(`unexpected property ${id} in the unpack info`);
+        }
+        id = r.id();
+    }
+    // Without substream info, each folder holds one file.
+    info.numUnpackStreams = info.folders.map(() => 1);
+    if (id === Nid.SubStreamsInfo) {
+        id = r.id();
+        if (id === Nid.NumUnpackStream) {
+            info.numUnpackStreams = info.folders.map(() => r.number());
+            id = r.id();
+        }
+        const total = info.numUnpackStreams.reduce((s, n) => s + n, 0);
+        if (total > maxEntries)
+            tooMany?.(total);
+        if (total > maxEntries || total > r.remaining * 8 + info.folders.length)
+            throw new errors_1.ParseError('the substream count is larger than the header');
+        const sizes = [];
+        const hasSizes = id === Nid.Size;
+        for (let f = 0; f < info.folders.length; f++) {
+            const n = info.numUnpackStreams[f];
+            if (n === 0)
+                continue;
+            const folder = info.folders[f];
+            const folderSize = folder.unpackSizes[folder.mainOut];
+            let sum = 0;
+            for (let i = 0; i < n - 1; i++) {
+                const s = hasSizes ? r.number() : 0;
+                sizes.push(s);
+                sum += s;
+            }
+            if (sum > folderSize)
+                throw new errors_1.ParseError('substream sizes add up to more than their folder');
+            sizes.push(folderSize - sum);
+        }
+        if (hasSizes)
+            id = r.id();
+        info.subSizes = sizes;
+        // A folder with one substream and a CRC of its own already gives that substream's CRC. The digests list the rest.
+        const crcs = [];
+        const open = [];
+        for (let f = 0; f < info.folders.length; f++) {
+            const n = info.numUnpackStreams[f];
+            if (n === 1 && info.folders[f].crc !== undefined)
+                crcs.push(info.folders[f].crc);
+            else
+                for (let i = 0; i < n; i++) {
+                    open.push(crcs.length);
+                    crcs.push(undefined);
+                }
+        }
+        while (id !== Nid.End) {
+            if (id !== Nid.Crc)
+                throw new errors_1.ParseError(`unexpected property ${id} in the substream info`);
+            const read = r.digests(open.length);
+            open.forEach((at, k) => {
+                crcs[at] = read[k];
+            });
+            id = r.id();
+        }
+        info.subCrcs = crcs;
+        id = r.id();
+    }
+    else {
+        info.subSizes = info.folders.map(f => f.unpackSizes[f.mainOut]);
+        info.subCrcs = info.folders.map(f => f.crc);
+    }
+    if (id !== Nid.End)
+        throw new errors_1.ParseError(`unexpected property ${id} in the streams info`);
+    return info;
+}
+/** Names of the properties this package drops, for the finding that reports them. */
+const PROPERTY_NAMES = {
+    [Nid.Comment]: 'comment',
+    [Nid.StartPos]: 'start positions',
+    [Nid.ArchiveProperties]: 'archive properties',
+};
+function readFiles(r, header, maxEntries, tooMany) {
+    const numFiles = r.number();
+    if (numFiles > maxEntries)
+        tooMany(numFiles);
+    if (numFiles > r.remaining * 8 + 1)
+        throw new errors_1.ParseError('the file count is larger than the header');
+    const files = [];
+    for (let i = 0; i < numFiles; i++)
+        files.push({ hasStream: true, emptyFile: false, anti: false });
+    let emptyStreams = [];
+    const seenTypes = new Set();
+    for (;;) {
+        const type = r.id();
+        if (type === Nid.End)
+            break;
+        // A property given twice would leave the entries described two ways, so the header is refused.
+        if (type !== Nid.Dummy && seenTypes.has(type))
+            throw new errors_1.ParseError(`file property ${type} appears twice`);
+        seenTypes.add(type);
+        const size = r.number();
+        if (size > r.remaining)
+            throw new errors_1.ParseError('a file property is larger than the header');
+        const sub = new HeaderReader(r.bytes(size));
+        switch (type) {
+            case Nid.EmptyStream: {
+                const bits = sub.bits(numFiles);
+                emptyStreams = [];
+                bits.forEach((b, i) => {
+                    files[i].hasStream = !b;
+                    if (b)
+                        emptyStreams.push(i);
+                });
+                break;
+            }
+            case Nid.EmptyFile:
+                sub.bits(emptyStreams.length).forEach((b, k) => {
+                    files[emptyStreams[k]].emptyFile = b;
+                });
+                break;
+            case Nid.Anti:
+                sub.bits(emptyStreams.length).forEach((b, k) => {
+                    files[emptyStreams[k]].anti = b;
+                });
+                break;
+            case Nid.Name: {
+                if (sub.byte() !== 0)
+                    throw new errors_1.UnsupportedError('names stored outside the header', false, { reason: 'names stored outside the header' });
+                const body = sub.bytes(sub.remaining);
+                let at = 0;
+                for (const f of files) {
+                    let end = at;
+                    while (end + 1 < body.length && (body[end] | body[end + 1]) !== 0)
+                        end += 2;
+                    if (end + 1 >= body.length)
+                        throw new errors_1.ParseError('a file name is not terminated');
+                    const units = new Uint16Array(body.buffer.slice(body.byteOffset + at, body.byteOffset + end));
+                    // As stored, lone surrogates included, so the name rules see what an extractor would.
+                    let name = '';
+                    for (let k = 0; k < units.length; k += 4096)
+                        name += String.fromCharCode(...units.subarray(k, k + 4096));
+                    f.name = name;
+                    at = end + 2;
+                }
+                // The names fill their property exactly, so a NUL inside one cannot shift the rest.
+                if (at !== body.length)
+                    throw new errors_1.ParseError('the names do not fill their property');
+                break;
+            }
+            case Nid.CTime:
+            case Nid.ATime:
+            case Nid.MTime: {
+                const defined = sub.defined(numFiles);
+                if (sub.byte() !== 0)
+                    throw new errors_1.UnsupportedError('times stored outside the header', false, { reason: 'times stored outside the header' });
+                defined.forEach((d, i) => {
+                    if (!d)
+                        return;
+                    const t = sub.bytes(8).slice();
+                    if (type === Nid.CTime)
+                        files[i].ctime = t;
+                    else if (type === Nid.ATime)
+                        files[i].atime = t;
+                    else
+                        files[i].mtime = t;
+                });
+                break;
+            }
+            case Nid.WinAttributes: {
+                const defined = sub.defined(numFiles);
+                if (sub.byte() !== 0)
+                    throw new errors_1.UnsupportedError('attributes stored outside the header', false, { reason: 'attributes stored outside the header' });
+                defined.forEach((d, i) => {
+                    if (d)
+                        files[i].attrib = sub.uint32();
+                });
+                break;
+            }
+            case Nid.Dummy:
+                // Padding 7-Zip writes to align what follows.
+                break;
+            default:
+                header.unknown.push(PROPERTY_NAMES[type] ?? `property ${type}`);
+        }
+    }
+    header.files = files;
+}
+/**
+ * Reads a plain header, starting after its kHeader byte. `maxEntries` stops a file count over the limit before
+ * anything is allocated for it.
+ */
+function parseHeader(buf, maxEntries, tooMany) {
+    const r = new HeaderReader(buf);
+    if (r.id() !== Nid.Header)
+        throw new errors_1.ParseError('the header does not start with kHeader');
+    const header = { files: [], unknown: [] };
+    let id = r.id();
+    if (id === Nid.ArchiveProperties) {
+        for (;;) {
+            const type = r.id();
+            if (type === Nid.End)
+                break;
+            r.bytes(r.number());
+        }
+        header.unknown.push(PROPERTY_NAMES[Nid.ArchiveProperties]);
+        id = r.id();
+    }
+    if (id === Nid.AdditionalStreamsInfo)
+        throw new errors_1.UnsupportedError('additional streams', false, { reason: 'additional streams' });
+    if (id === Nid.MainStreamsInfo) {
+        header.streams = readStreamsInfo(r, maxEntries, tooMany);
+        id = r.id();
+    }
+    if (id === Nid.FilesInfo) {
+        readFiles(r, header, maxEntries, tooMany);
+        id = r.id();
+    }
+    if (id !== Nid.End)
+        throw new errors_1.ParseError(`unexpected property ${id} in the header`);
+    return header;
+}
+/** Reads an encoded header's streams info, starting after its kEncodedHeader byte. */
+function parseEncodedHeader(buf) {
+    const r = new HeaderReader(buf);
+    if (r.id() !== Nid.EncodedHeader)
+        throw new errors_1.ParseError('the header is not encoded');
+    return readStreamsInfo(r);
+}

package/dist/single.d.ts

@@ -0,0 +1,103 @@
+import { Reader } from './io';
+import { type Archive, type Entry, type Kept, type Meter, type Note, type WriteContext, type WritePlan } from './model';
+import { type ArchiveFormat, type ByteSink, type ByteSource } from './types';
+import { type ZstdLayout } from './zstd';
+/** The one entry of a compressed file. Its size is known once it has been read. */
+export interface SingleEntry extends Entry {
+    /** The decoded size, set when the engine has read the entry. */
+    decoded?: number;
+}
+/** What the writer copies when the content stays as it was: the one compressed stream, header included. */
+interface RawStream {
+    start: number;
+    length: number;
+}
+declare abstract class Single implements Archive<SingleEntry> {
+    readonly reader: Reader;
+    readonly notes: Note[];
+    abstract readonly format: ArchiveFormat;
+    readonly single = true;
+    readonly lateNotes: Note[];
+    readonly entries: SingleEntry[];
+    comment?: string;
+    /** Set once the entry has been read and the stream turned out to be one stream with nothing after it. */
+    protected raw?: RawStream;
+    constructor(reader: Reader, notes: Note[], name?: string);
+    unlock(): Promise<boolean>;
+    hasMetadata(): boolean;
+    abstract read(e: SingleEntry, meter: Meter): AsyncGenerator<Uint8Array>;
+    /** Compresses the content as one stream of the format. With `store`, a format that can store data uncompressed does. */
+    protected abstract encode(chunks: AsyncIterable<Uint8Array>, plan: WritePlan<SingleEntry>, store: boolean): AsyncIterable<Uint8Array>;
+    /** True when encode() can store data uncompressed. */
+    protected readonly canStore: boolean;
+    /** Notes what follows the last stream, and what it reads as. */
+    protected trailing(at: number): Promise<void>;
+    /**
+     * Writes the stream: the compressed bytes as they were when the content stayed as it was and was one stream, or the
+     * content compressed again. Compressed data that would pass the run's ratio limit is stored instead where the
+     * format can store, so the output reads under the same limit.
+     */
+    protected writeStream(plan: WritePlan<SingleEntry>, sink: ByteSink, context: WriteContext): Promise<void>;
+    /** How much of what encode() wrote to keep. */
+    protected encodedLength(_source: ByteSource, length: number): Promise<number>;
+    protected sizeOf(k: Kept<SingleEntry>): number;
+    write(plan: WritePlan<SingleEntry>, sink: ByteSink, context: WriteContext): Promise<void>;
+    /** Where the data after the last stream starts, once the entry has been read. */
+    protected trailingStart?: number;
+}
+interface GzipHeader {
+    flags: number;
+    mtime: number;
+    os: number;
+    name?: string;
+    comment?: string;
+    /** Offset of the deflate data. */
+    dataStart: number;
+}
+export declare class GzipArchive extends Single {
+    readonly header: GzipHeader;
+    readonly format = "gzip";
+    private constructor();
+    hasMetadata(): boolean;
+    static open(source: ByteSource): Promise<GzipArchive>;
+    read(e: SingleEntry, meter: Meter): AsyncGenerator<Uint8Array>;
+    /** A member header with the name a rule fixed, and the metadata unless it is stripped. */
+    private headerBytes;
+    protected readonly canStore = true;
+    protected encode(chunks: AsyncIterable<Uint8Array>, plan: WritePlan<SingleEntry>, store: boolean): AsyncGenerator<Uint8Array>;
+    /** The header is written again, so the name a rule fixed and the metadata stripped apply also when the data is copied. */
+    protected writeStream(plan: WritePlan<SingleEntry>, sink: ByteSink, context: WriteContext): Promise<void>;
+}
+export declare class Bzip2Archive extends Single {
+    readonly format = "bzip2";
+    private readonly level;
+    private constructor();
+    static open(source: ByteSource): Promise<Bzip2Archive>;
+    read(e: SingleEntry, meter: Meter): AsyncGenerator<Uint8Array>;
+    protected encode(chunks: AsyncIterable<Uint8Array>): AsyncIterable<Uint8Array>;
+}
+export declare class ZstdArchive extends Single {
+    readonly layout: ZstdLayout;
+    readonly format = "zstd";
+    private constructor();
+    static open(source: ByteSource, deadline?: number): Promise<ZstdArchive>;
+    read(e: SingleEntry, meter: Meter): AsyncGenerator<Uint8Array>;
+    protected encode(chunks: AsyncIterable<Uint8Array>): AsyncIterable<Uint8Array>;
+    /** Node's zstd stream can end with a second, empty frame after the one that holds the data, which is left out. */
+    protected encodedLength(source: ByteSource, length: number): Promise<number>;
+}
+export declare class BrotliArchive extends Single {
+    readonly format = "brotli";
+    static open(source: ByteSource): Promise<BrotliArchive>;
+    read(e: SingleEntry, meter: Meter): AsyncGenerator<Uint8Array>;
+    protected encode(chunks: AsyncIterable<Uint8Array>): AsyncIterable<Uint8Array>;
+}
+/**
+ * True when the content decodes as one Brotli stream, which has no signature: the stream must end where the file
+ * does, or decode to more than 32 MiB without an error. A prefix that merely decodes is not enough, since an
+ * uncompressed meta-block can take megabytes of any bytes before the next header shows whether they are Brotli.
+ */
+export declare function looksLikeBrotli(source: ByteSource): Promise<boolean>;
+export declare const isGzip: (b: Uint8Array) => boolean;
+export declare const isBzip2: (b: Uint8Array) => boolean;
+export {};