@patrickdk77/archive-defuse 0.0.0-stage → 0.1.1

package/dist/coders.d.ts

@@ -0,0 +1,58 @@
+import { type AesProps } from './aes7z';
+import { type Coder, type Folder } from './sevenzip';
+import type { ByteSource } from './types';
+export type Chunks = AsyncIterable<Uint8Array>;
+/** LZMA2's dictionary size from its properties byte, or undefined for a byte above 40. */
+export declare function lzma2DictSize(p: number): number | undefined;
+/** Turns an error from lzma1's decoders into a data error. Anything else, such as a limit, passes unchanged. */
+export declare function lzmaError(e: unknown): unknown;
+/**
+ * Feeds raw LZMA2 data to lzma1's decoder one chunk at a time. A chunk decodes to at most 2 MiB, so one step never
+ * holds more however small the chunks are made. It also tells where the data ends, which an xz block needs.
+ */
+export declare class Lzma2Feeder {
+    private readonly dec;
+    private readonly out;
+    private pend;
+    /** The end marker has been fed. */
+    ended: boolean;
+    /** Input bytes used, up to and including the end marker. */
+    consumed: number;
+    constructor(dictSize: number);
+    /** The size of the chunk that starts with `pend`, once its header is there. */
+    private chunkSize;
+    /** Feeds `chunk` and returns how many of its bytes were used, fewer than all once the end marker is in. */
+    push(chunk: Uint8Array): number;
+    /** Decoded bytes waiting to be taken. */
+    take(): Uint8Array[];
+    end(): void;
+}
+export declare const methodName: (id: string) => string;
+export declare const isAes: (c: Coder) => boolean;
+/** The limits checked before a folder is decoded. */
+export interface FolderLimits {
+    decompressedBytes: number;
+    dictionaryBytes: number;
+}
+/**
+ * Checks that every coder of `folder` is one this package decodes, with valid properties, and that no coder's output
+ * and no dictionary goes over the limits. Returns the dictionary or size that went over, for the caller's finding.
+ */
+export declare function checkFolder(folder: Folder, limits: FolderLimits): {
+    limit: 'decompressed' | 'dictionary';
+    value: number;
+} | undefined;
+/** What decoding a folder needs from the run. */
+export interface FolderEnv {
+    source: ByteSource;
+    deadline?: number;
+    /** Called with each count of packed bytes read. */
+    onPacked(n: number): void;
+    /** The key for a 7zAES coder, from the password being tried. */
+    key(props: AesProps): Buffer;
+}
+/**
+ * Decodes a folder checked with checkFolder: its main output, exactly as long as declared. `packOffsets` are the
+ * absolute offsets of the folder's packed streams.
+ */
+export declare function decodeFolder(folder: Folder, packOffsets: number[], packSizes: number[], env: FolderEnv): Chunks;

package/dist/coders.js

@@ -0,0 +1,392 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAes = exports.methodName = exports.Lzma2Feeder = void 0;
+exports.lzma2DictSize = lzma2DictSize;
+exports.lzmaError = lzmaError;
+exports.checkFolder = checkFolder;
+exports.decodeFolder = decodeFolder;
+const node_stream_1 = require("node:stream");
+const zlib = __importStar(require("node:zlib"));
+const aes7z_1 = require("./aes7z");
+const bcj2_1 = require("./bcj2");
+const bzip2_1 = require("./bzip2");
+const errors_1 = require("./errors");
+const filters_1 = require("./filters");
+const inflate64_1 = require("./inflate64");
+const lzma2_decoder_1 = require("./lzma1/lzma2-decoder");
+const lzma1_stream_1 = require("./lzma1-stream");
+const sevenzip_1 = require("./sevenzip");
+/** Bytes of LZMA1 input decoded per step. LZMA1 decodes to at most about 7,000 times its input. */
+const LZMA1_SLICE = 1024;
+/** Bytes of packed data read from the source at a time. */
+const READ_SIZE = 1 << 16;
+/** LZMA2's dictionary size from its properties byte, or undefined for a byte above 40. */
+function lzma2DictSize(p) {
+    if (p > 40)
+        return undefined;
+    return p === 40 ? 0xffffffff : (2 | (p & 1)) * 2 ** (Math.floor(p / 2) + 11);
+}
+/** Turns an error from lzma1's decoders into a data error. Anything else, such as a limit, passes unchanged. */
+function lzmaError(e) {
+    if (e instanceof errors_1.DataError)
+        return e;
+    const message = String(e?.message ?? e);
+    if (message === 'Truncated input')
+        return new errors_1.DataError('the data ends before its end', true);
+    if (/^Corrupted input: /.test(message))
+        return new errors_1.DataError(message.replace(/^Corrupted input: /, ''));
+    return e;
+}
+/**
+ * Feeds raw LZMA2 data to lzma1's decoder one chunk at a time. A chunk decodes to at most 2 MiB, so one step never
+ * holds more however small the chunks are made. It also tells where the data ends, which an xz block needs.
+ */
+class Lzma2Feeder {
+    dec;
+    out = [];
+    pend = new Uint8Array(0);
+    /** The end marker has been fed. */
+    ended = false;
+    /** Input bytes used, up to and including the end marker. */
+    consumed = 0;
+    constructor(dictSize) {
+        this.dec = new lzma2_decoder_1.Lzma2Decoder(Math.max(dictSize, 4096), chunk => this.out.push(chunk.slice()));
+    }
+    /** The size of the chunk that starts with `pend`, once its header is there. */
+    chunkSize() {
+        const p = this.pend;
+        if (p.length < 1)
+            return undefined;
+        const control = p[0];
+        if (control === 0x00 || (control > 0x02 && control < 0x80))
+            return 1;
+        if (control < 0x80)
+            return p.length < 3 ? undefined : 3 + ((p[1] << 8) | p[2]) + 1;
+        const header = control >= 0xc0 ? 6 : 5;
+        return p.length < 5 ? undefined : header + ((p[3] << 8) | p[4]) + 1;
+    }
+    /** Feeds `chunk` and returns how many of its bytes were used, fewer than all once the end marker is in. */
+    push(chunk) {
+        let used = 0;
+        while (used < chunk.length && !this.ended) {
+            const size = this.chunkSize();
+            const want = size === undefined ? (this.pend.length < 1 ? 1 : this.pend[0] >= 0x80 ? 5 : 3) : size;
+            const take = Math.min(want - this.pend.length, chunk.length - used);
+            this.pend = (0, lzma1_stream_1.concat)(this.pend, chunk.slice(used, used + take));
+            used += take;
+            const whole = this.chunkSize();
+            if (whole !== undefined && this.pend.length === whole) {
+                const bytes = this.pend;
+                this.pend = new Uint8Array(0);
+                try {
+                    this.dec.write(bytes);
+                }
+                catch (e) {
+                    throw lzmaError(e);
+                }
+                if (bytes[0] === 0x00)
+                    this.ended = true;
+            }
+        }
+        this.consumed += used;
+        return used;
+    }
+    /** Decoded bytes waiting to be taken. */
+    take() {
+        return this.out.splice(0);
+    }
+    end() {
+        if (!this.ended)
+            throw new errors_1.DataError('the LZMA2 data ends before its end marker', true);
+    }
+}
+exports.Lzma2Feeder = Lzma2Feeder;
+/** Bytes of a packed stream handed on at a time, so the count of compressed bytes follows what the coders took. */
+const PACK_SLICE = 4096;
+/** Reads `size` bytes of `source` from `offset`, reporting each piece as it is handed on. */
+async function* packStream(source, offset, size, onRead, deadline) {
+    for (let pos = 0; pos < size;) {
+        (0, errors_1.checkTime)(deadline);
+        const want = Math.min(READ_SIZE, size - pos);
+        const b = await source.read(offset + pos, want);
+        if (b.length === 0)
+            throw new errors_1.DataError('a packed stream ends past the end of the file', true);
+        for (let k = 0; k < b.length; k += PACK_SLICE) {
+            const piece = b.subarray(k, k + PACK_SLICE);
+            onRead(piece.length);
+            yield piece;
+        }
+        pos += b.length;
+    }
+}
+async function* lzma1Decode(input, props, size, deadline) {
+    if (props.length < 5)
+        throw new errors_1.DataError('LZMA properties are cut short');
+    const dictSize = props[1] + props[2] * 2 ** 8 + props[3] * 2 ** 16 + props[4] * 2 ** 24;
+    const out = [];
+    const dec = new lzma1_stream_1.Lzma1Stream((0, lzma1_stream_1.decodeProps)(props[0], dictSize), size, chunk => out.push(chunk.slice()), false);
+    for await (const chunk of input) {
+        for (let p = 0; p < chunk.length && !dec.done; p += LZMA1_SLICE) {
+            dec.write(chunk.subarray(p, p + LZMA1_SLICE));
+            (0, errors_1.checkTime)(deadline);
+            for (const c of out.splice(0))
+                yield c;
+        }
+        if (dec.done)
+            break;
+    }
+    dec.end();
+    for (const c of out.splice(0))
+        yield c;
+}
+async function* lzma2Decode(input, props, deadline) {
+    const dict = props.length === 1 ? lzma2DictSize(props[0]) : undefined;
+    if (dict === undefined)
+        throw new errors_1.DataError('invalid LZMA2 properties');
+    const feeder = new Lzma2Feeder(dict);
+    for await (const chunk of input) {
+        for (let used = 0; used < chunk.length && !feeder.ended;) {
+            used += feeder.push(chunk.subarray(used, used + READ_SIZE));
+            (0, errors_1.checkTime)(deadline);
+            for (const c of feeder.take())
+                yield c;
+        }
+        if (feeder.ended)
+            break;
+    }
+    feeder.end();
+}
+async function* transform(input, t) {
+    for await (const chunk of input) {
+        // The transform changes its input in place, and the chunk may be a view of bytes someone else holds. A Buffer's
+        // slice() is such a view too, so the copy is made explicitly.
+        const out = t.push(new Uint8Array(chunk));
+        if (out.length)
+            yield out;
+    }
+    const rest = t.end();
+    if (rest.length)
+        yield rest;
+}
+/** Inflates raw Deflate data through Node's zlib. */
+async function* inflate(input) {
+    const src = node_stream_1.Readable.from(input);
+    const z = zlib.createInflateRaw();
+    let failure;
+    (0, node_stream_1.pipeline)(src, z, e => {
+        if (e)
+            failure ??= e;
+    });
+    try {
+        for await (const chunk of z)
+            yield chunk;
+    }
+    catch (e) {
+        // zlib's own errors carry a Z_ code. Anything else, such as a limit or bad data before the inflate, passes unchanged.
+        const code = e?.code;
+        if (typeof code === 'string' && code.startsWith('Z_'))
+            throw new errors_1.DataError(`Deflate data does not inflate: ${String(e.message)}`);
+        throw e;
+    }
+    finally {
+        src.destroy();
+        z.destroy();
+    }
+    if (failure !== undefined)
+        throw failure;
+}
+/** Yields exactly `size` bytes of `input`, and stops reading it there. */
+async function* exactly(input, size) {
+    let n = 0;
+    if (size > 0) {
+        for await (const chunk of input) {
+            const room = size - n;
+            if (chunk.length >= room) {
+                if (room > 0)
+                    yield chunk.subarray(0, room);
+                n = size;
+                break;
+            }
+            n += chunk.length;
+            yield chunk;
+        }
+    }
+    if (n < size)
+        throw new errors_1.DataError('a coder decodes to less than its declared size', true);
+}
+const METHODS = {
+    '00': { name: 'Copy', numIn: 1 },
+    '03': { name: 'Delta', numIn: 1 },
+    '04': { name: 'BCJ', numIn: 1, branch: 'x86' },
+    '03030103': { name: 'BCJ', numIn: 1, branch: 'x86' },
+    '05': { name: 'PPC', numIn: 1, branch: 'powerpc' },
+    '03030205': { name: 'PPC', numIn: 1, branch: 'powerpc' },
+    '06': { name: 'IA64', numIn: 1, branch: 'ia64' },
+    '03030401': { name: 'IA64', numIn: 1, branch: 'ia64' },
+    '07': { name: 'ARM', numIn: 1, branch: 'arm' },
+    '03030501': { name: 'ARM', numIn: 1, branch: 'arm' },
+    '08': { name: 'ARMT', numIn: 1, branch: 'armthumb' },
+    '03030701': { name: 'ARMT', numIn: 1, branch: 'armthumb' },
+    '09': { name: 'SPARC', numIn: 1, branch: 'sparc' },
+    '03030805': { name: 'SPARC', numIn: 1, branch: 'sparc' },
+    '0a': { name: 'ARM64', numIn: 1, branch: 'arm64' },
+    '0b': { name: 'RISCV', numIn: 1, branch: 'riscv' },
+    '0303011b': { name: 'BCJ2', numIn: 4 },
+    '030101': { name: 'LZMA', numIn: 1 },
+    '21': { name: 'LZMA2', numIn: 1 },
+    '040108': { name: 'Deflate', numIn: 1 },
+    '040109': { name: 'Deflate64', numIn: 1 },
+    '040202': { name: 'BZip2', numIn: 1 },
+    '06f10701': { name: '7zAES', numIn: 1 },
+};
+/** Names of methods this package knows but does not decode, for the finding. */
+const UNSUPPORTED = {
+    '030401': 'PPMd',
+    '04f71101': 'Zstandard',
+    '04f71102': 'Brotli',
+    '04f71104': 'LZ4',
+    '04f71105': 'LZ5',
+    '04f71106': 'Lizard',
+    '04f71107': 'Fast LZMA2',
+    '03030601': 'M68',
+    '03030301': 'Alpha',
+    '020302': 'Swap2',
+    '020304': 'Swap4',
+};
+const methodName = (id) => METHODS[id]?.name ?? UNSUPPORTED[id] ?? `method ${id}`;
+exports.methodName = methodName;
+const isAes = (c) => c.method === '06f10701';
+exports.isAes = isAes;
+/**
+ * Checks that every coder of `folder` is one this package decodes, with valid properties, and that no coder's output
+ * and no dictionary goes over the limits. Returns the dictionary or size that went over, for the caller's finding.
+ */
+function checkFolder(folder, limits) {
+    // The coders of a folder decode together, so their dictionaries and probability tables count together.
+    let memory = 0;
+    for (let c = 0; c < folder.coders.length; c++) {
+        const coder = folder.coders[c];
+        const m = METHODS[coder.method];
+        if (!m)
+            throw new errors_1.UnsupportedError(`7z method ${(0, exports.methodName)(coder.method)}`, true, { method: (0, exports.methodName)(coder.method) });
+        if (coder.numIn !== m.numIn || coder.numOut !== 1)
+            throw new errors_1.ParseError(`the ${m.name} coder has the wrong number of streams`);
+        const size = folder.unpackSizes[(0, sevenzip_1.firstStream)(folder, c, 'out')];
+        if (size > limits.decompressedBytes)
+            return { limit: 'decompressed', value: size };
+        if (coder.method === '030101') {
+            if (coder.props.length < 5)
+                throw new errors_1.ParseError('LZMA properties are cut short');
+            const p = (0, lzma1_stream_1.decodeProps)(coder.props[0], 0);
+            const dict = coder.props[1] + coder.props[2] * 2 ** 8 + coder.props[3] * 2 ** 16 + coder.props[4] * 2 ** 24;
+            memory += (0, lzma1_stream_1.effectiveDictSize)(dict, size) + 2 * 0x300 * 2 ** (p.lc + p.lp);
+            if (memory > limits.dictionaryBytes)
+                return { limit: 'dictionary', value: memory };
+        }
+        else if (coder.method === '21') {
+            const dict = coder.props.length === 1 ? lzma2DictSize(coder.props[0]) : undefined;
+            if (dict === undefined)
+                throw new errors_1.ParseError('invalid LZMA2 properties');
+            memory += (0, lzma1_stream_1.effectiveDictSize)(dict, size);
+            if (memory > limits.dictionaryBytes)
+                return { limit: 'dictionary', value: memory };
+        }
+        else if (coder.method === '03') {
+            if (coder.props.length !== 1)
+                throw new errors_1.ParseError('invalid Delta properties');
+        }
+        else if (m.branch && coder.props.length !== 0 && coder.props.length !== 4) {
+            throw new errors_1.ParseError(`invalid ${m.name} properties`);
+        }
+        else if ((0, exports.isAes)(coder))
+            (0, aes7z_1.parseAesProps)(coder.props);
+    }
+    return undefined;
+}
+function runCoder(coder, inputs, size, env) {
+    const m = METHODS[coder.method];
+    const start = coder.props.length === 4 ? (coder.props[0] | (coder.props[1] << 8) | (coder.props[2] << 16) | (coder.props[3] << 24)) >>> 0 : 0;
+    if (m.branch)
+        return transform(inputs[0], new filters_1.SimpleFilterStream(m.branch, start));
+    switch (coder.method) {
+        case '00':
+            return inputs[0];
+        case '03':
+            return transform(inputs[0], new filters_1.DeltaStream(coder.props[0] + 1));
+        case '0303011b':
+            return (0, bcj2_1.decodeBcj2)(inputs[0], inputs[1], inputs[2], inputs[3], size);
+        case '030101':
+            return lzma1Decode(inputs[0], coder.props, size, env.deadline);
+        case '21':
+            return lzma2Decode(inputs[0], coder.props, env.deadline);
+        case '040108':
+            return inflate(inputs[0]);
+        case '040109':
+            return (0, inflate64_1.inflate64)(inputs[0], undefined, env.deadline);
+        case '040202':
+            // Streams after the first decode too instead of failing the folder. The folder's declared size bounds the output.
+            return (0, bzip2_1.bunzip2)(inputs[0], { streams: [], trailing: 0, trailingZeros: true }, true);
+        default: {
+            const props = (0, aes7z_1.parseAesProps)(coder.props);
+            return (0, aes7z_1.decryptAes)(inputs[0], env.key(props), props.iv);
+        }
+    }
+}
+/**
+ * Decodes a folder checked with checkFolder: its main output, exactly as long as declared. `packOffsets` are the
+ * absolute offsets of the folder's packed streams.
+ */
+function decodeFolder(folder, packOffsets, packSizes, env) {
+    const outStream = (outIndex) => {
+        const { coder: c } = (0, sevenzip_1.coderOf)(folder, outIndex, 'out');
+        const coder = folder.coders[c];
+        const first = (0, sevenzip_1.firstStream)(folder, c, 'in');
+        const inputs = [];
+        for (let i = 0; i < coder.numIn; i++) {
+            const inIndex = first + i;
+            const bp = folder.bindPairs.find(p => p.inIndex === inIndex);
+            if (bp)
+                inputs.push(outStream(bp.outIndex));
+            else {
+                const k = folder.packedStreams.indexOf(inIndex);
+                inputs.push(packStream(env.source, packOffsets[k], packSizes[k], env.onPacked, env.deadline));
+            }
+        }
+        const size = folder.unpackSizes[outIndex];
+        return exactly(runCoder(coder, inputs, size, env), size);
+    };
+    return outStream(folder.mainOut);
+}

package/dist/crc32.d.ts

@@ -0,0 +1,8 @@
+/** Continues a CRC-32, the one ZIP uses, over `bytes`, with a lookup table. Start from 0. */
+export declare function tableCrc32(bytes: Uint8Array, crc?: number): number;
+/**
+ * Continues a CRC-32, the one ZIP uses, over `bytes`. Start from 0. This is zlib.crc32 where Node has it, about 50
+ * times faster, and the table otherwise. Node 18 and early releases of Node 20 and 22 lack it. The choice is made
+ * once, when the module loads.
+ */
+export declare const crc32: (bytes: Uint8Array, crc?: number) => number;

package/dist/crc32.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crc32 = void 0;
+exports.tableCrc32 = tableCrc32;
+// Copied from office-defuse src/crc32.ts.
+const zlib = __importStar(require("node:zlib"));
+const TABLE = new Uint32Array(256);
+for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++)
+        c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    TABLE[n] = c >>> 0;
+}
+/** Continues a CRC-32, the one ZIP uses, over `bytes`, with a lookup table. Start from 0. */
+function tableCrc32(bytes, crc = 0) {
+    let c = ~crc >>> 0;
+    for (const b of bytes)
+        c = TABLE[(c ^ b) & 0xff] ^ (c >>> 8);
+    return ~c >>> 0;
+}
+/**
+ * Continues a CRC-32, the one ZIP uses, over `bytes`. Start from 0. This is zlib.crc32 where Node has it, about 50
+ * times faster, and the table otherwise. Node 18 and early releases of Node 20 and 22 lack it. The choice is made
+ * once, when the module loads.
+ */
+exports.crc32 = zlib.crc32 ?? tableCrc32;

package/dist/detect.d.ts

@@ -0,0 +1,10 @@
+import type { ByteSource, DetectOptions, FormatDetection } from './types';
+/**
+ * Whether archive-defuse reads `source`, and in which format: what the inspection's own format selection picks, from
+ * the content alone, except that Brotli, which has no signature, counts only when the name or the declared type says
+ * Brotli. A format detected only to be rejected, such as RAR, is not claimed. A ZIP archive found from its end record starts where the ZIP reader finds its first entry, or at
+ * 0 when the reader cannot open it. The source stays open.
+ */
+export declare function detectArchiveSource(source: ByteSource, options?: DetectOptions): Promise<FormatDetection | undefined>;
+/** `detectArchiveSource` over bytes in memory. */
+export declare function detectArchive(bytes: Uint8Array, options?: DetectOptions): Promise<FormatDetection | undefined>;

package/dist/detect.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectArchiveSource = detectArchiveSource;
+exports.detectArchive = detectArchive;
+const engine_1 = require("./engine");
+const errors_1 = require("./errors");
+const formats_1 = require("./formats");
+const io_1 = require("./io");
+const sniff_1 = require("./sniff");
+const zip_1 = require("./zip");
+/** Each format's MIME type and extension, the names sniff.ts gives them. */
+const TYPES = {
+    zip: { mimeType: 'application/zip', extension: 'zip' },
+    tar: { mimeType: 'application/x-tar', extension: 'tar' },
+    gzip: { mimeType: 'application/gzip', extension: 'gz' },
+    bzip2: { mimeType: 'application/x-bzip2', extension: 'bz2' },
+    zstd: { mimeType: 'application/zstd', extension: 'zst' },
+    brotli: { mimeType: 'application/x-brotli', extension: 'br' },
+    cab: { mimeType: 'application/vnd.ms-cab-compressed', extension: 'cab' },
+    '7z': { mimeType: 'application/x-7z-compressed', extension: '7z' },
+    xz: { mimeType: 'application/x-xz', extension: 'xz' },
+    lzma: { mimeType: 'application/x-lzma', extension: 'lzma' },
+};
+/**
+ * `source` without its close(), checking the deadline before every call and keeping the first error any call throws.
+ * The Brotli test catches every error, so the kept one is how a failed read or the deadline still gets out.
+ */
+function watch(source, deadline) {
+    const failed = {};
+    const keep = async (op) => {
+        try {
+            (0, errors_1.checkTime)(deadline);
+            return await op();
+        }
+        catch (e) {
+            failed.error ??= e;
+            throw e;
+        }
+    };
+    return { source: { size: () => keep(() => source.size()), read: (offset, length) => keep(() => source.read(offset, length)) }, failed };
+}
+const BROTLI_TYPES = new Set(['application/x-brotli', 'application/brotli']);
+const saysBrotli = (o) => (0, sniff_1.typeFromName)(o.name) === 'application/x-brotli' || BROTLI_TYPES.has((o.declaredType ?? '').toLowerCase().split(';')[0].trim());
+/**
+ * Whether archive-defuse reads `source`, and in which format: what the inspection's own format selection picks, from
+ * the content alone, except that Brotli, which has no signature, counts only when the name or the declared type says
+ * Brotli. A format detected only to be rejected, such as RAR, is not claimed. A ZIP archive found from its end record starts where the ZIP reader finds its first entry, or at
+ * 0 when the reader cannot open it. The source stays open.
+ */
+async function detectArchiveSource(source, options = {}) {
+    const watched = watch(source, options.deadline);
+    const pass = (e) => {
+        if (watched.failed.error !== undefined)
+            throw watched.failed.error;
+        if ((0, errors_1.stopsTree)(e) || (0, errors_1.isIoError)(e))
+            throw e;
+    };
+    let picked;
+    try {
+        (0, errors_1.checkTime)(options.deadline);
+        picked = await (0, formats_1.select)(watched.source);
+        pass(undefined);
+    }
+    catch (e) {
+        pass(e);
+        // Any other failure, as in an inspection, means archive-defuse does not read the file.
+        return undefined;
+    }
+    if (picked === undefined)
+        return undefined;
+    // Brotli has no signature, and a one-byte file such as "7" decodes as an empty stream. Without a name or declared
+    // type that says Brotli, archive-defuse cannot know the file is one, so it does not claim it.
+    if (picked.format === 'brotli' && !saysBrotli(options))
+        return undefined;
+    let offset = picked.offset;
+    if (offset === undefined) {
+        try {
+            offset = (await zip_1.ZipArchive.open(watched.source, engine_1.DEFAULT_LIMITS, options.deadline)).start;
+            pass(undefined);
+        }
+        catch (e) {
+            pass(e);
+            // The selection picked ZIP, so the file is one, which the inspection rejects with its own finding.
+            offset = 0;
+        }
+    }
+    const found = { ...TYPES[picked.format], offset };
+    if (picked.heuristic !== undefined)
+        found.heuristic = picked.heuristic;
+    return found;
+}
+/** `detectArchiveSource` over bytes in memory. */
+function detectArchive(bytes, options = {}) {
+    return detectArchiveSource((0, io_1.bufferSource)(bytes), options);
+}

package/dist/encoder.d.ts

@@ -0,0 +1,44 @@
+/** lc, lp and pb of everything this package encodes: lzma1's defaults, and xz's. */
+export declare const LC = 3;
+export declare const LP = 0;
+export declare const PB = 2;
+/** The properties byte of an LZMA header or 7z coder for LC, LP and PB. */
+export declare const PROPS_BYTE: number;
+/**
+ * The smallest dictionary that covers `size` bytes, at most 1 MiB and at least 4 KiB, rounded up to 2^n or 2^n +
+ * 2^(n-1) as decoders of the .lzma format expect.
+ */
+export declare function fitDictSize(size: number): number;
+/**
+ * Encodes raw LZMA data of a known size, without an end marker, with lzma1's encoder at its preset 1. The output is
+ * the range coder's bytes, as a 7z LZMA coder and the data of an .lzma file hold them.
+ */
+export declare class RawLzmaEncoder {
+    private rc;
+    private readonly lzma;
+    readonly dictSize: number;
+    /** `size` is the input's whole length, or undefined to encode pieces with restart(). */
+    constructor(size: number | undefined, dictSize?: number);
+    /** Encodes `input` and returns the bytes ready so far. */
+    write(input: Uint8Array): Uint8Array;
+    /** Encodes what is left and returns the last bytes. */
+    finish(): Uint8Array;
+    /** Starts an independent input with the same encoder, whose tables need no new allocation. */
+    restart(): void;
+}
+/** Dictionary of the LZMA2 chunks below: every chunk resets it, and no chunk holds more than this. */
+export declare const LZMA2_DICT_SIZE: number;
+/** The LZMA2 properties byte for LZMA2_DICT_SIZE: (2 | (p & 1)) << (p / 2 + 11) is 64 KiB for 8. */
+export declare const LZMA2_DICT_PROP = 8;
+/**
+ * Writes raw LZMA2 data as independent chunks of at most 64 KiB, each compressed by the LZMA1 encoder above, or
+ * stored when that does not make it smaller. Every chunk resets the dictionary and the state, which LZMA2 allows, so
+ * the encoder needs no knowledge of LZMA2. `forceCompressed` keeps a chunk compressed even when that is larger, so the
+ * stored bytes of the content do not show at the start of a file, where other readers look for their own signatures.
+ */
+export declare class Lzma2ChunkWriter {
+    private readonly encoder;
+    private used;
+    /** The chunks for one piece of at most 64 KiB. With `store`, a piece not forced compressed is stored as it is. */
+    chunk(piece: Uint8Array, forceCompressed: boolean, store?: boolean): Uint8Array;
+}