@patrickdk77/archive-defuse 0.0.0-stage → 0.1.1

package/dist/alone.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAlone = readAlone;
+const errors_1 = require("./errors");
+const header_1 = require("./lzma1/header");
+const lzma1_stream_1 = require("./lzma1-stream");
+const types_1 = require("./types");
+/** Bytes of input decoded per step. LZMA decodes to at most about 7,000 times its input. */
+const SLICE = 1024;
+/**
+ * Decodes an .lzma file: a 13-byte header with the properties, the dictionary size and the decoded size or all ones
+ * for unknown, then raw LZMA data. An end marker before the declared size is a size mismatch; data that goes on past
+ * it, or a stream without its end marker when the size is unknown, does not decode.
+ */
+async function* readAlone(env, info) {
+    const { reader, size, meter } = env;
+    const head = await reader.read(0, header_1.HEADER_SIZE);
+    if (head.length < header_1.HEADER_SIZE)
+        throw new errors_1.DataError('the file ends in its header', true);
+    let header;
+    try {
+        header = (0, header_1.decodeHeader)(head);
+    }
+    catch (e) {
+        throw new errors_1.DataError(String(e.message).replace(/^(Corrupted|Unsupported) input: /, ''));
+    }
+    const declared = header.uncompressedSize === header_1.UNKNOWN_SIZE ? undefined : header.uncompressedSize;
+    if (declared !== undefined && declared > 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 });
+    }
+    const need = (0, lzma1_stream_1.effectiveDictSize)(header.dictSize, declared);
+    if (need > env.limits.dictionaryBytes)
+        throw new errors_1.StopError(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.DictionarySize, 'Dictionary size limit exceeded', { limit: env.limits.dictionaryBytes, dictionary: need });
+    const out = [];
+    const stream = new lzma1_stream_1.Lzma1Stream(header, declared, chunk => out.push(chunk.slice()), true);
+    let pos = header_1.HEADER_SIZE;
+    while (!stream.done && pos < size) {
+        const chunk = await reader.read(pos, 65536);
+        // Once the data ends, the rest of the chunk goes to the stream for the end-marker check.
+        for (let p = 0; p < chunk.length; p += SLICE) {
+            if (!stream.done)
+                meter.packed(Math.min(SLICE, chunk.length - p));
+            stream.write(chunk.subarray(p, p + SLICE));
+            for (const c of out.splice(0)) {
+                meter.add(c.length);
+                yield c;
+            }
+        }
+        pos += chunk.length;
+    }
+    // The end-marker check needs a few bytes past the end of the data.
+    if (stream.done && pos < size)
+        stream.write(await reader.read(pos, 256));
+    stream.end();
+    for (const c of out.splice(0)) {
+        meter.add(c.length);
+        yield c;
+    }
+    if (declared !== undefined && stream.decoded < declared) {
+        info.notes.push({ category: types_1.ArchiveCategory.Structure, detail: types_1.ArchiveDetail.SizeMismatch, data: { reason: 'an end marker comes before the declared size', declared, actual: stream.decoded } });
+    }
+    const end = header_1.HEADER_SIZE + stream.consumed;
+    if (end < size)
+        info.trailingAt = end;
+}

package/dist/bcj2.d.ts

@@ -0,0 +1,21 @@
+/** Reads an async stream of chunks byte by byte or a chunk at a time. */
+export declare class PullReader {
+    private readonly it;
+    private buf;
+    private pos;
+    private ended;
+    constructor(source: AsyncIterable<Uint8Array>);
+    /** The unread part of the current chunk, after fetching one if it is used up. Empty at the end of the stream. */
+    peek(): Promise<Uint8Array>;
+    skip(n: number): void;
+    /** The next byte. Throws at the end of the stream. */
+    byte(): Promise<number>;
+    /** Stops reading the stream. */
+    close(): Promise<void>;
+}
+/**
+ * Decodes 7-Zip's BCJ2 filter, which moves the targets of x86 calls and jumps into streams of their own. The main
+ * stream holds the code, the call and jump streams the big-endian absolute targets, and a range coder stream says
+ * which E8, E9 and Jcc opcodes were converted. This follows Bcj2_Decode of the LZMA SDK 9.20 (public domain).
+ */
+export declare function decodeBcj2(main: AsyncIterable<Uint8Array>, call: AsyncIterable<Uint8Array>, jump: AsyncIterable<Uint8Array>, rcStream: AsyncIterable<Uint8Array>, outSize: number): AsyncGenerator<Uint8Array>;

package/dist/bcj2.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PullReader = void 0;
+exports.decodeBcj2 = decodeBcj2;
+const errors_1 = require("./errors");
+/** Reads an async stream of chunks byte by byte or a chunk at a time. */
+class PullReader {
+    it;
+    buf = new Uint8Array(0);
+    pos = 0;
+    ended = false;
+    constructor(source) {
+        this.it = source[Symbol.asyncIterator]();
+    }
+    /** The unread part of the current chunk, after fetching one if it is used up. Empty at the end of the stream. */
+    async peek() {
+        while (this.pos >= this.buf.length && !this.ended) {
+            const r = await this.it.next();
+            if (r.done)
+                this.ended = true;
+            else {
+                this.buf = r.value;
+                this.pos = 0;
+            }
+        }
+        return this.buf.subarray(this.pos);
+    }
+    skip(n) {
+        this.pos += n;
+    }
+    /** The next byte. Throws at the end of the stream. */
+    async byte() {
+        const b = await this.peek();
+        if (b.length === 0)
+            throw new errors_1.DataError('a BCJ2 stream ends early', true);
+        this.pos++;
+        return b[0];
+    }
+    /** Stops reading the stream. */
+    async close() {
+        await this.it.return?.();
+    }
+}
+exports.PullReader = PullReader;
+const TOP = 1 << 24;
+const isJ = (b0, b1) => (b1 & 0xfe) === 0xe8 || (b0 === 0x0f && (b1 & 0xf0) === 0x80);
+/**
+ * Decodes 7-Zip's BCJ2 filter, which moves the targets of x86 calls and jumps into streams of their own. The main
+ * stream holds the code, the call and jump streams the big-endian absolute targets, and a range coder stream says
+ * which E8, E9 and Jcc opcodes were converted. This follows Bcj2_Decode of the LZMA SDK 9.20 (public domain).
+ */
+async function* decodeBcj2(main, call, jump, rcStream, outSize) {
+    const m = new PullReader(main);
+    const c = new PullReader(call);
+    const j = new PullReader(jump);
+    const r = new PullReader(rcStream);
+    try {
+        const probs = new Uint16Array(256 + 2).fill(1024);
+        let range = 0xffffffff;
+        let code = 0;
+        for (let i = 0; i < 5; i++)
+            code = ((code << 8) | (await r.byte())) >>> 0;
+        let prevByte = 0;
+        let outPos = 0;
+        const out = new Uint8Array(1 << 16);
+        let o = 0;
+        const flush = () => {
+            const chunk = out.slice(0, o);
+            o = 0;
+            return chunk;
+        };
+        while (outPos < outSize) {
+            // Copy from the main stream up to and including the next opcode that may have been converted.
+            const chunk = await m.peek();
+            if (chunk.length === 0)
+                break;
+            let i = 0;
+            let found = false;
+            const limit = Math.min(chunk.length, outSize - outPos);
+            while (i < limit) {
+                const b = chunk[i++];
+                out[o++] = b;
+                outPos++;
+                if (o === out.length)
+                    yield flush();
+                if (isJ(prevByte, b)) {
+                    found = true;
+                    break;
+                }
+                prevByte = b;
+            }
+            m.skip(i);
+            if (!found || outPos === outSize)
+                continue;
+            const b = chunk[i - 1];
+            const index = b === 0xe8 ? prevByte : b === 0xe9 ? 256 : 257;
+            const prob = probs[index];
+            const bound = (range >>> 11) * prob;
+            let converted;
+            if (code < bound) {
+                range = bound;
+                probs[index] = prob + ((2048 - prob) >>> 5);
+                converted = false;
+            }
+            else {
+                range = (range - bound) >>> 0;
+                code = (code - bound) >>> 0;
+                probs[index] = prob - (prob >>> 5);
+                converted = true;
+            }
+            if (range < TOP) {
+                range = (range << 8) >>> 0;
+                code = ((code << 8) | (await r.byte())) >>> 0;
+            }
+            if (!converted) {
+                prevByte = b;
+                continue;
+            }
+            const from = b === 0xe8 ? c : j;
+            let src = 0;
+            for (let k = 0; k < 4; k++)
+                src = ((src << 8) | (await from.byte())) >>> 0;
+            const dest = (src - (outPos + 4)) >>> 0;
+            for (let k = 0; k < 4 && outPos < outSize; k++) {
+                out[o++] = (dest >>> (8 * k)) & 0xff;
+                outPos++;
+                if (o === out.length)
+                    yield flush();
+            }
+            prevByte = dest >>> 24;
+        }
+        if (o > 0)
+            yield flush();
+        if (outPos !== outSize)
+            throw new errors_1.DataError('the BCJ2 main stream ends early', true);
+    }
+    finally {
+        await Promise.all([m.close(), c.close(), j.close(), r.close()]);
+    }
+}

package/dist/bzip2.d.ts

@@ -0,0 +1,21 @@
+import type { Consumed } from './codecs';
+/** Where each stream of a bzip2 file sits, and what follows the last. */
+export interface Bzip2Info {
+    streams: Array<{
+        start: number;
+        end: number;
+        level: number;
+    }>;
+    /** Bytes after the last stream. */
+    trailing: number;
+    /** True when every trailing byte is zero. */
+    trailingZeros: boolean;
+}
+/**
+ * Decodes bzip2 data. With `multi`, streams that follow each other decode as one, the way bzip2 reads them, and
+ * `info` records where each sits and what follows the last. Without it the data must be one stream and nothing
+ * after it, as in a ZIP entry. Corrupt or cut-short data throws DataError.
+ */
+export declare function bunzip2(chunks: AsyncIterable<Uint8Array>, info: Bzip2Info, multi: boolean, consumed?: Consumed): AsyncGenerator<Uint8Array>;
+/** Compresses `chunks` as one bzip2 stream with blocks of `level` hundred thousand bytes. */
+export declare function bzip2(chunks: AsyncIterable<Uint8Array>, level?: number): AsyncGenerator<Uint8Array>;