@patrickdk77/archive-defuse 0.0.0-stage → 0.1.0

package/dist/seven.js

@@ -0,0 +1,492 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SevenReader = void 0;
+exports.unixMode = unixMode;
+exports.openSevenZip = openSevenZip;
+const aes7z_1 = require("./aes7z");
+const coders_1 = require("./coders");
+const crc32_1 = require("./crc32");
+const errors_1 = require("./errors");
+const sevenzip_1 = require("./sevenzip");
+const stream_meter_1 = require("./stream-meter");
+const types_1 = require("./types");
+const S_IFMT = 0xf000;
+const UNIX_EXTENSION = 0x8000;
+const FILE_ATTRIBUTE_DIRECTORY = 0x10;
+const FILE_ATTRIBUTE_REPARSE_POINT = 0x400;
+/** The Unix mode stored in the high 16 bits of the attributes, when the low bits say one is there. */
+function unixMode(attrib) {
+    return attrib !== undefined && attrib & UNIX_EXTENSION ? attrib >>> 16 : undefined;
+}
+function kindOf(f) {
+    const mode = unixMode(f.attrib);
+    if (mode !== undefined) {
+        switch (mode & S_IFMT) {
+            case 0xa000:
+                return 'symlink';
+            case 0x2000:
+            case 0x6000:
+                return 'device';
+            case 0x1000:
+                return 'fifo';
+            case 0xc000:
+                return 'socket';
+            case 0x4000:
+                return 'dir';
+            default:
+                break;
+        }
+    }
+    if (f.attrib !== undefined && f.attrib & FILE_ATTRIBUTE_REPARSE_POINT)
+        return 'symlink';
+    if (!f.hasStream && !f.emptyFile && !f.anti)
+        return 'dir';
+    if (f.attrib !== undefined && f.attrib & FILE_ATTRIBUTE_DIRECTORY && !f.hasStream)
+        return 'dir';
+    return 'file';
+}
+const keyCache = new WeakMap();
+function folderEnv(env, meter, password) {
+    let cache = keyCache.get(env);
+    if (!cache) {
+        cache = new Map();
+        keyCache.set(env, cache);
+    }
+    const keys = cache;
+    return {
+        source: env.source,
+        deadline: env.deadline,
+        onPacked: n => meter.packed(n),
+        key(props) {
+            if (password === undefined)
+                throw new errors_1.DataError('no password to try');
+            const id = `${password}\0${Buffer.from(props.salt).toString('hex')}\0${props.numCyclesPower}`;
+            let k = keys.get(id);
+            if (!k) {
+                k = (0, aes7z_1.deriveKey)(password, props, env.deadline);
+                keys.set(id, k);
+            }
+            return k;
+        },
+    };
+}
+/** Collects a stream into memory, up to `max` bytes. */
+async function collect(chunks, max) {
+    const parts = [];
+    let n = 0;
+    for await (const c of chunks) {
+        n += c.length;
+        if (n > max)
+            throw new errors_1.DataError('the stream decodes to more than its declared size');
+        parts.push(c);
+    }
+    return Buffer.concat(parts);
+}
+const isEncrypted = (f) => f.coders.some(coders_1.isAes);
+/** Turns a folder check's limit into the stop it causes. */
+function folderLimits(env, folder, location) {
+    const over = (0, coders_1.checkFolder)(folder, { decompressedBytes: env.limits.totalDecompressedBytes, dictionaryBytes: env.limits.dictionaryBytes });
+    if (!over)
+        return;
+    if (over.limit === 'dictionary')
+        throw new errors_1.StopError(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.DictionarySize, 'Dictionary size limit exceeded', { limit: env.limits.dictionaryBytes, dictionary: over.value }, location);
+    throw new errors_1.StopError(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.TotalDecompressedSize, 'Total decompressed size limit exceeded', { limit: env.limits.totalDecompressedBytes, declared: over.value }, location);
+}
+/** Decodes an encoded header, trying each password on an encrypted one. */
+async function decodeHeaderStreams(env, info, base) {
+    if (info.folders.length !== 1)
+        throw new errors_1.ParseError('an encoded header has other than one folder');
+    const folder = info.folders[0];
+    folderLimits(env, folder, 'header');
+    const size = folder.unpackSizes[folder.mainOut];
+    if (size > env.limits.decompressedBytes)
+        throw new errors_1.StopError(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.DecompressedSize, 'Decompressed size limit exceeded', { limit: env.limits.decompressedBytes, declared: size }, 'header');
+    const offsets = [];
+    let at = base + info.packPos;
+    for (const s of info.packSizes) {
+        offsets.push(at);
+        at += s;
+    }
+    if (at > env.size)
+        throw new errors_1.DataError('the encoded header lies past the end of the file', true);
+    const spans = offsets.map((o, i) => ({ start: o, end: o + info.packSizes[i], what: 'encoded header' }));
+    const encrypted = isEncrypted(folder);
+    const tries = encrypted ? env.passwords : [undefined];
+    let lastError;
+    for (const password of tries) {
+        const meter = new stream_meter_1.Meter(env.limits, env.totals, env.deadline, true, 'header');
+        try {
+            const chunks = (0, coders_1.decodeFolder)(folder, offsets, info.packSizes, folderEnv(env, meter, password));
+            const bytes = await collect(meterChunks(chunks, meter), size);
+            if (folder.crc !== undefined && (0, crc32_1.crc32)(bytes) !== folder.crc)
+                throw new errors_1.CheckError('the encoded header CRC32 does not match', 'encoded header CRC32');
+            if (bytes[0] !== sevenzip_1.Nid.Header)
+                throw new errors_1.ParseError('the decoded header does not start with kHeader');
+            return { bytes, encrypted, spans };
+        }
+        catch (e) {
+            if (!encrypted || e instanceof errors_1.StopError || e instanceof errors_1.UnsupportedError || (0, errors_1.stopsTree)(e))
+                throw e;
+            lastError = e;
+        }
+    }
+    if (encrypted)
+        throw new errors_1.StopError(types_1.ArchiveCategory.Encrypted, types_1.ArchiveDetail.PasswordRequired, 'No password opens the header', undefined, 'header');
+    throw lastError;
+}
+async function* meterChunks(chunks, meter) {
+    for await (const c of chunks) {
+        meter.add(c.length);
+        yield c;
+    }
+}
+/**
+ * Reads a 7z archive's signature and headers, decoding an encoded header, and checks that its structures fit the file
+ * and each other. `offset` is where the signature was found.
+ */
+async function openSevenZip(env, offset) {
+    const notes = [];
+    const sig = await env.reader.read(offset, 32);
+    if (sig.length < 32)
+        throw new errors_1.DataError('the file ends in its signature header', true);
+    if (sig[6] !== 0)
+        throw new errors_1.UnsupportedError(`7z format version ${sig[6]}.${sig[7]}`, false, { reason: `format version ${sig[6]}.${sig[7]}` });
+    const storedStart = new DataView(sig.buffer, sig.byteOffset, 32).getUint32(8, true);
+    const base = offset + 32;
+    if (!sig.subarray(8, 32).every(b => b === 0)) {
+        if ((0, crc32_1.crc32)(sig.subarray(12, 32)) !== storedStart)
+            throw new errors_1.CheckError('the start header CRC32 does not match', 'start header CRC32');
+        return openWith(env, offset, (0, sevenzip_1.parseStartHeader)(sig), notes);
+    }
+    // An empty start header: each place a header may start near the end is tried, the nearest to the end first.
+    // A place that is not the header can claim any count or size, so a limit fails that place, not the file. When no
+    // place works, the failure of the one nearest the end is reported.
+    let failure;
+    for (const start of await headerCandidates(env, base)) {
+        try {
+            const found = await openWith(env, offset, start, [{ category: types_1.ArchiveCategory.Structure, detail: types_1.ArchiveDetail.EmptyStartHeader }]);
+            // An empty header parses anywhere, so a found one must hold data and files, as Commons Compress requires.
+            if (found.streams && found.streams.packSizes.length > 0 && found.entries.length > 0)
+                return found;
+            failure ??= new errors_1.ParseError('the header found at the end of the file holds no data');
+        }
+        catch (e) {
+            if (!(e instanceof errors_1.DataError || e instanceof errors_1.UnsupportedError || e instanceof errors_1.StopError))
+                throw e;
+            failure ??= e;
+        }
+    }
+    throw failure ?? new errors_1.CheckError('the start header is empty and no header is found at the end of the file', 'start header CRC32');
+}
+/** Reads the headers an intact or recovered start header points to. */
+async function openWith(env, offset, start, notes) {
+    const base = offset + 32;
+    const spans = [{ start: offset, end: base, what: 'signature header' }];
+    const archive = { offset, entries: [], notes, headerEncrypted: false, packOffsets: [], folderPack: [] };
+    if (start.nextHeaderSize === 0) {
+        finishSpans(env, archive, spans, base);
+        return archive;
+    }
+    const headerStart = base + start.nextHeaderOffset;
+    const headerEnd = headerStart + start.nextHeaderSize;
+    if (headerEnd > env.size)
+        throw new errors_1.DataError('the header lies past the end of the file', true);
+    if (start.nextHeaderSize > env.limits.decompressedBytes) {
+        throw new errors_1.StopError(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.DecompressedSize, 'Decompressed size limit exceeded', { limit: env.limits.decompressedBytes, declared: start.nextHeaderSize }, 'header');
+    }
+    spans.push({ start: headerStart, end: headerEnd, what: 'header' });
+    let headerBytes = await env.reader.read(headerStart, start.nextHeaderSize);
+    if ((0, crc32_1.crc32)(headerBytes) !== start.nextHeaderCrc)
+        throw new errors_1.CheckError('the next header CRC32 does not match', 'next header CRC32');
+    if (headerBytes[0] === sevenzip_1.Nid.EncodedHeader) {
+        const decoded = await decodeHeaderStreams(env, (0, sevenzip_1.parseEncodedHeader)(headerBytes), base);
+        headerBytes = decoded.bytes;
+        archive.headerEncrypted = decoded.encrypted;
+        spans.push(...decoded.spans);
+    }
+    const header = (0, sevenzip_1.parseHeader)(headerBytes, env.limits.entries, n => {
+        throw new errors_1.StopError(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.EntryCount, 'Entry count limit exceeded', { limit: env.limits.entries, entries: n });
+    });
+    for (const u of header.unknown)
+        notes.push({ category: types_1.ArchiveCategory.Structure, detail: types_1.ArchiveDetail.UnknownProperty, data: { property: u } });
+    const streams = header.streams;
+    archive.streams = streams;
+    // Packed streams, and which folder starts where.
+    if (streams) {
+        let at = base + streams.packPos;
+        for (const s of streams.packSizes) {
+            archive.packOffsets.push(at);
+            spans.push({ start: at, end: at + s, what: 'packed stream' });
+            at += s;
+        }
+        if (at > env.size)
+            throw new errors_1.DataError('packed streams lie past the end of the file', true);
+        let next = 0;
+        for (const f of streams.folders) {
+            archive.folderPack.push(next);
+            next += f.packedStreams.length;
+        }
+        if (next > streams.packSizes.length)
+            throw new errors_1.ParseError('the folders read more packed streams than the archive has');
+    }
+    // Entries and the substreams that hold their data.
+    const subCount = streams ? streams.subSizes.length : 0;
+    const withData = header.files.filter(f => f.hasStream).length;
+    if (withData !== subCount)
+        throw new errors_1.ParseError('the number of files with data does not match the streams that hold it');
+    let sub = 0;
+    let folder = 0;
+    let inFolder = 0;
+    let folderAt = 0;
+    for (const [index, info] of header.files.entries()) {
+        const entry = { index, info, kind: kindOf(info), size: 0, start: 0 };
+        if (info.hasStream && streams) {
+            while (inFolder >= streams.numUnpackStreams[folder]) {
+                folder++;
+                inFolder = 0;
+                folderAt = 0;
+            }
+            entry.folder = folder;
+            entry.size = streams.subSizes[sub];
+            entry.crc = streams.subCrcs[sub];
+            entry.start = folderAt;
+            folderAt += entry.size;
+            sub++;
+            inFolder++;
+        }
+        archive.entries.push(entry);
+    }
+    if (streams) {
+        streams.folders.forEach((f, i) => {
+            folderLimits(env, f, `folder ${i + 1}`);
+        });
+        const total = streams.folders.reduce((sum, f) => sum + f.unpackSizes[f.mainOut], 0);
+        if (total > env.limits.totalDecompressedBytes) {
+            throw new errors_1.StopError(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.TotalDecompressedSize, 'Total decompressed size limit exceeded', { limit: env.limits.totalDecompressedBytes, declared: total });
+        }
+    }
+    for (const e of archive.entries) {
+        if (e.size > env.limits.decompressedBytes) {
+            throw new errors_1.StopError(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.DecompressedSize, 'Decompressed size limit exceeded', { limit: env.limits.decompressedBytes, declared: e.size }, e.info.name);
+        }
+    }
+    finishSpans(env, archive, spans, base);
+    return archive;
+}
+/** How far from the end a header is looked for when the start header is empty, as Commons Compress looks. */
+const RECOVERY_WINDOW = 1024 * 1024;
+/** How many places in that window are tried at most. */
+const RECOVERY_TRIES = 256;
+/**
+ * Where the header of an archive whose start header is all zeros may start, as an interrupted write leaves it:
+ * each kEncodedHeader followed by kPackInfo, and each kHeader followed by kMainStreamsInfo, in the last 1 MiB, the
+ * nearest to the end first, each taken to run to the end of the file. 7-Zip's FORMAT_7Z_RECOVERY looks for these
+ * pairs, and Commons Compress looks as far back.
+ */
+async function headerCandidates(env, base) {
+    const n = Math.min(RECOVERY_WINDOW, env.size - base);
+    const tail = await env.reader.read(env.size - n, n);
+    const out = [];
+    for (let i = n - 1; i >= 0 && out.length < RECOVERY_TRIES; i--) {
+        if ((tail[i] === sevenzip_1.Nid.EncodedHeader && tail[i + 1] === sevenzip_1.Nid.PackInfo) || (tail[i] === sevenzip_1.Nid.Header && tail[i + 1] === sevenzip_1.Nid.MainStreamsInfo)) {
+            out.push({ minorVersion: 0, nextHeaderOffset: env.size - n + i - base, nextHeaderSize: n - i, nextHeaderCrc: (0, crc32_1.crc32)(tail.subarray(i)) });
+        }
+    }
+    return out;
+}
+/** Notes overlapping structures, bytes between them and bytes after the last one. */
+function finishSpans(env, archive, spans, base) {
+    const sorted = spans.filter(s => s.end > s.start).sort((a, b) => a.start - b.start || a.end - b.end);
+    let end = archive.offset;
+    let hidden = 0;
+    let overlap = false;
+    for (const s of sorted) {
+        if (s.start < end)
+            overlap = true;
+        else
+            hidden += s.start - end;
+        end = Math.max(end, s.end);
+    }
+    if (overlap)
+        archive.notes.push({ category: types_1.ArchiveCategory.Structure, detail: types_1.ArchiveDetail.Overlap });
+    if (hidden > 0)
+        archive.notes.push({ category: types_1.ArchiveCategory.Structure, detail: types_1.ArchiveDetail.HiddenData, data: { bytes: hidden } });
+    end = Math.max(end, base);
+    if (end < env.size)
+        archive.trailingAt = end;
+}
+/** Reads a folder's output a stretch at a time, so each entry takes its own bytes. */
+class FolderCursor {
+    chunks;
+    it;
+    buf = new Uint8Array(0);
+    pos = 0;
+    /** Bytes of the folder's output taken so far. */
+    taken = 0;
+    /** Why the folder stopped decoding, once it has. */
+    failed;
+    constructor(chunks) {
+        this.chunks = chunks;
+    }
+    async more() {
+        this.it ??= this.chunks[Symbol.asyncIterator]();
+        const r = await this.it.next();
+        if (r.done)
+            return false;
+        this.buf = r.value;
+        this.pos = 0;
+        return true;
+    }
+    /** The next `n` bytes. A failure stays with the cursor, and every later call throws it too. */
+    async *take(n) {
+        if (this.failed !== undefined)
+            throw this.failed;
+        let left = n;
+        try {
+            while (left > 0) {
+                if (this.pos >= this.buf.length && !(await this.more()))
+                    throw new errors_1.DataError('the folder decodes to less than its entries need', true);
+                const k = Math.min(left, this.buf.length - this.pos);
+                const part = this.buf.subarray(this.pos, this.pos + k);
+                this.pos += k;
+                this.taken += k;
+                left -= k;
+                yield part;
+            }
+        }
+        catch (e) {
+            if (!(e instanceof errors_1.StopError) && !(0, errors_1.stopsTree)(e))
+                this.failed = e;
+            throw e;
+        }
+    }
+    async close() {
+        await this.it?.return?.();
+    }
+}
+/**
+ * True when `password` opens an encrypted folder: the folder decodes under it up to the end of its first entry with a
+ * CRC, and that entry matches its CRC. A folder with no CRC to check opens when its first entry, or its first 64 KiB,
+ * decodes. The trial counts toward no total.
+ */
+async function opensFolder(env, archive, f, password) {
+    const streams = archive.streams;
+    if (!streams)
+        return false;
+    const folder = streams.folders[f];
+    const first = archive.entries.find(e => e.folder === f && e.size > 0 && e.crc !== undefined) ?? archive.entries.find(e => e.folder === f && e.size > 0);
+    const skip = first ? archive.entries.filter(e => e.folder === f && e.index < first.index).reduce((n, e) => n + e.size, 0) : 0;
+    const want = first ? skip + first.size : Math.min(folder.unpackSizes[folder.mainOut], 1 << 16);
+    const meter = new stream_meter_1.Meter(env.limits, { decoded: 0, compressed: 0 }, env.deadline, false, `folder ${f + 1}`);
+    const cursor = new FolderCursor(meterChunks((0, coders_1.decodeFolder)(folder, packOffsetsOf(archive, f), packSizesOf(archive, f), folderEnv(env, meter, password)), meter));
+    try {
+        let crc = 0;
+        let at = 0;
+        for await (const c of cursor.take(want)) {
+            if (at + c.length > skip)
+                crc = (0, crc32_1.crc32)(c.subarray(Math.max(0, skip - at)), crc);
+            at += c.length;
+        }
+        return !first || first.crc === undefined || crc === first.crc;
+    }
+    catch (e) {
+        if (e instanceof errors_1.StopError || e instanceof errors_1.UnsupportedError || (0, errors_1.stopsTree)(e))
+            throw e;
+        return false;
+    }
+    finally {
+        await cursor.close();
+    }
+}
+function packOffsetsOf(archive, f) {
+    const n = archive.streams?.folders[f].packedStreams.length ?? 0;
+    return archive.packOffsets.slice(archive.folderPack[f], archive.folderPack[f] + n);
+}
+function packSizesOf(archive, f) {
+    const n = archive.streams?.folders[f].packedStreams.length ?? 0;
+    return archive.streams?.packSizes.slice(archive.folderPack[f], archive.folderPack[f] + n) ?? [];
+}
+/**
+ * The content of each entry, decoded folder by folder. Entries of one folder read in order share one decode; an entry
+ * before the last one read starts the folder again.
+ */
+class SevenReader {
+    env;
+    archive;
+    open;
+    /**
+     * The password that opened each encrypted folder. A folder opens with one password, the first the engine tries that
+     * opens it, so an entry that fails its CRC never sends the reader back to the start of the folder with another.
+     */
+    chosen = new Map();
+    /** Passwords that did not open a folder, by folder and password. */
+    refused = new Set();
+    constructor(env, archive) {
+        this.env = env;
+        this.archive = archive;
+    }
+    /** True when the folder of `entry` is not encrypted, or `password` opens it. */
+    async unlock(entry, password) {
+        const f = entry.folder;
+        const folder = f === undefined ? undefined : this.archive.streams?.folders[f];
+        if (f === undefined || !folder || !isEncrypted(folder))
+            return true;
+        const chosen = this.chosen.get(f);
+        if (chosen !== undefined)
+            return chosen === password;
+        const key = `${f}\0${password}`;
+        if (this.refused.has(key))
+            return false;
+        if (await opensFolder(this.env, this.archive, f, password)) {
+            this.chosen.set(f, password);
+            return true;
+        }
+        this.refused.add(key);
+        return false;
+    }
+    async folder(f, password) {
+        if (this.open?.index === f && this.open.password === password)
+            return this.open;
+        await this.open?.cursor.close();
+        this.open = undefined;
+        const streams = this.archive.streams;
+        if (!streams)
+            throw new errors_1.ParseError('an entry has data but the archive has no streams');
+        const folder = streams.folders[f];
+        const encrypted = isEncrypted(folder);
+        if (encrypted && password === undefined)
+            throw new errors_1.StopError(types_1.ArchiveCategory.Encrypted, types_1.ArchiveDetail.PasswordRequired, 'No password opens the folder', undefined, `folder ${f + 1}`);
+        // Each decode of a folder counts its own ratio. The folders' declared sizes were checked against the totals when
+        // the archive opened, and a decode stops at them.
+        const meter = new stream_meter_1.Meter(this.env.limits, { decoded: 0, compressed: 0 }, this.env.deadline, false, `folder ${f + 1}`);
+        const chunks = (0, coders_1.decodeFolder)(folder, packOffsetsOf(this.archive, f), packSizesOf(this.archive, f), folderEnv(this.env, meter, encrypted ? password : undefined));
+        this.open = { index: f, cursor: new FolderCursor(meterChunks(chunks, meter)), meter, decrypted: encrypted, password };
+        return this.open;
+    }
+    /** The decoded content of an entry with data. It throws when the folder cannot decode it or its CRC does not match. */
+    async *content(entry, password) {
+        if (entry.folder === undefined)
+            return;
+        let open = await this.folder(entry.folder, password);
+        if (open.cursor.taken > entry.start) {
+            await this.close();
+            open = await this.folder(entry.folder, password);
+        }
+        // Bytes of earlier entries nobody read are skipped.
+        if (open.cursor.taken < entry.start)
+            for await (const _ of open.cursor.take(entry.start - open.cursor.taken))
+                ;
+        let crc = 0;
+        for await (const c of open.cursor.take(entry.size)) {
+            crc = (0, crc32_1.crc32)(c, crc);
+            yield c;
+        }
+        if (entry.crc !== undefined && crc !== entry.crc)
+            throw new errors_1.CheckError('the entry CRC32 does not match', 'CRC32');
+    }
+    async close() {
+        await this.open?.cursor.close();
+        this.open = undefined;
+    }
+}
+exports.SevenReader = SevenReader;

package/dist/sevenzip.d.ts

@@ -0,0 +1,133 @@
+/** Property IDs of the 7z header. */
+export declare enum Nid {
+    End = 0,
+    Header = 1,
+    ArchiveProperties = 2,
+    AdditionalStreamsInfo = 3,
+    MainStreamsInfo = 4,
+    FilesInfo = 5,
+    PackInfo = 6,
+    UnpackInfo = 7,
+    SubStreamsInfo = 8,
+    Size = 9,
+    Crc = 10,
+    Folder = 11,
+    CodersUnpackSize = 12,
+    NumUnpackStream = 13,
+    EmptyStream = 14,
+    EmptyFile = 15,
+    Anti = 16,
+    Name = 17,
+    CTime = 18,
+    ATime = 19,
+    MTime = 20,
+    WinAttributes = 21,
+    Comment = 22,
+    EncodedHeader = 23,
+    StartPos = 24,
+    Dummy = 25
+}
+/** One coder of a folder. */
+export interface Coder {
+    /** The method ID in hex, such as "030101" for LZMA. */
+    method: string;
+    numIn: number;
+    numOut: number;
+    props: Uint8Array;
+}
+/** A folder: coders joined by bind pairs, fed by packed streams. */
+export interface Folder {
+    coders: Coder[];
+    /** Coder in-stream `inIndex` reads coder out-stream `outIndex`. */
+    bindPairs: Array<{
+        inIndex: number;
+        outIndex: number;
+    }>;
+    /** The in-streams that read packed streams, in the order of the folder's packed streams. */
+    packedStreams: number[];
+    /** Decoded size of every coder out-stream. */
+    unpackSizes: number[];
+    /** CRC of the folder's main output, when stored. */
+    crc?: number;
+    /** The out-stream that is the folder's output: the one no bind pair reads. */
+    mainOut: number;
+}
+export interface StreamsInfo {
+    /** Offset of the first packed stream, from the end of the signature header. */
+    packPos: number;
+    packSizes: number[];
+    folders: Folder[];
+    /** Per folder, how many files its output holds. */
+    numUnpackStreams: number[];
+    /** Per substream, in folder order: its size and CRC. */
+    subSizes: number[];
+    subCrcs: Array<number | undefined>;
+}
+/** One file entry as the header describes it. */
+export interface FileInfo {
+    name?: string;
+    hasStream: boolean;
+    /** For an entry without a stream: an empty file rather than a directory. */
+    emptyFile: boolean;
+    anti: boolean;
+    attrib?: number;
+    ctime?: Uint8Array;
+    atime?: Uint8Array;
+    mtime?: Uint8Array;
+}
+export interface Header {
+    streams?: StreamsInfo;
+    files: FileInfo[];
+    /** Header properties this package does not keep, by name. */
+    unknown: string[];
+}
+/** What a file declares at its start. */
+export interface StartHeader {
+    nextHeaderOffset: number;
+    nextHeaderSize: number;
+    nextHeaderCrc: number;
+    minorVersion: number;
+}
+/** Reads the numbers, bit vectors and digests of a 7z header. */
+export declare class HeaderReader {
+    readonly buf: Uint8Array;
+    pos: number;
+    constructor(buf: Uint8Array);
+    get remaining(): number;
+    byte(): number;
+    /** A property ID, read as a 7z number, so an ID can take more than one byte. Any large one is unknown. */
+    id(): number;
+    bytes(n: number): Uint8Array;
+    /** A 7z number: the first byte's leading one bits count the bytes that follow, which hold the low bits. */
+    private raw;
+    /** A 7z number used as a size, a count or an index. */
+    number(): number;
+    /** A number used as a count of things that each take at least `unit` bytes of what is left. */
+    count(unit: number, max?: number): number;
+    uint32(): number;
+    bits(n: number): boolean[];
+    /** A byte that says all are defined, or a bit vector that says which. */
+    defined(n: number): boolean[];
+    digests(n: number): Array<number | undefined>;
+}
+/** Reads the 20 bytes after the signature, version and CRC. */
+export declare function parseStartHeader(b: Uint8Array): StartHeader;
+/** The coder that owns a global in- or out-stream index, and the stream's index within that coder. */
+export declare function coderOf(folder: Folder, index: number, side: 'in' | 'out'): {
+    coder: number;
+    local: number;
+};
+/** The first global in- or out-stream index of coder `c`. */
+export declare function firstStream(folder: Folder, c: number, side: 'in' | 'out'): number;
+/**
+ * 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.
+ */
+export declare function readStreamsInfo(r: HeaderReader, maxEntries?: number, tooMany?: (n: number) => never): StreamsInfo;
+/**
+ * Reads a plain header, starting after its kHeader byte. `maxEntries` stops a file count over the limit before
+ * anything is allocated for it.
+ */
+export declare function parseHeader(buf: Uint8Array, maxEntries: number, tooMany: (n: number) => never): Header;
+/** Reads an encoded header's streams info, starting after its kEncodedHeader byte. */
+export declare function parseEncodedHeader(buf: Uint8Array): StreamsInfo;