@patrickdk77/archive-defuse 0.0.0-stage → 0.1.0

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>;