@patrickdk77/archive-defuse 0.0.0-stage → 0.1.0

package/dist/inflate64.js

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inflate64 = inflate64;
+const errors_1 = require("./errors");
+const WINDOW = 65536;
+const MAXBITS = 15;
+const FAST = 9;
+/** Base and extra bits of literal/length codes 257..285. */
+const LBASE = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 3];
+const LEXT = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 16];
+/** Base and extra bits of distance codes 0..31. */
+const DBASE = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 32769, 49153];
+const DEXT = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14];
+const CL_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+/** A canonical Huffman code: counts per length, symbols by (length, value), and a 9-bit lookup for short codes. */
+class Huffman {
+    count = new Uint16Array(MAXBITS + 1);
+    symbol = new Uint16Array(288);
+    /** (symbol << 4) | length for codes of at most FAST bits, 0 otherwise. */
+    fast = new Int32Array(1 << FAST);
+    maxLen = 0;
+}
+const offs = new Uint16Array(MAXBITS + 2);
+/** Builds `h` from `n` lengths at `lens[at]`. Returns an error message, or undefined. Work is bounded by 288 + 512. */
+function build(h, lens, at, n, kind) {
+    const count = h.count;
+    count.fill(0);
+    for (let i = 0; i < n; i++)
+        count[lens[at + i]]++;
+    let max = MAXBITS;
+    while (max >= 1 && count[max] === 0)
+        max--;
+    h.maxLen = max;
+    h.fast.fill(0);
+    if (max === 0)
+        return kind === 'dists' ? undefined : 'no codes';
+    let left = 1;
+    for (let len = 1; len <= MAXBITS; len++) {
+        left = (left << 1) - count[len];
+        if (left < 0)
+            return 'over-subscribed code';
+    }
+    if (left > 0 && (kind === 'codes' || max !== 1))
+        return 'incomplete code';
+    count[0] = 0;
+    offs[1] = 0;
+    for (let len = 1; len < MAXBITS; len++)
+        offs[len + 1] = offs[len] + count[len];
+    for (let i = 0; i < n; i++) {
+        const len = lens[at + i];
+        if (len !== 0)
+            h.symbol[offs[len]++] = i;
+    }
+    // Canonical codes in symbol order: the first code of each length, then reversed into the LSB-first lookup.
+    let code = 0;
+    let index = 0;
+    for (let len = 1; len <= FAST && len <= max; len++) {
+        for (let k = 0; k < count[len]; k++) {
+            let rev = 0;
+            for (let b = 0; b < len; b++)
+                rev |= ((code >>> b) & 1) << (len - 1 - b);
+            const entry = (h.symbol[index + k] << 4) | len;
+            for (let j = rev; j < 1 << FAST; j += 1 << len)
+                h.fast[j] = entry;
+            code++;
+        }
+        index += count[len];
+        code <<= 1;
+    }
+    return undefined;
+}
+/** Result of a decode or bit read that needs input the current chunk does not have. */
+const NEED = -2;
+/** Result of decoding bits that are no code. */
+const INVALID = -1;
+const fixedLen = new Huffman();
+const fixedDist = new Huffman();
+{
+    const l = new Uint8Array(320);
+    l.fill(8, 0, 144);
+    l.fill(9, 144, 256);
+    l.fill(7, 256, 280);
+    l.fill(8, 280, 288);
+    l.fill(5, 288, 320);
+    build(fixedLen, l, 0, 288, 'lens');
+    build(fixedDist, l, 288, 32, 'dists');
+}
+/**
+ * The decoder proper, as a synchronous generator. It yields an output chunk, or null when it needs the next input
+ * chunk, which the caller passes back through next(); undefined there means the input has ended.
+ */
+function* decoder(consumed, deadline) {
+    let buf = new Uint8Array(0);
+    let pos = 0;
+    let taken = 0;
+    let hold = 0;
+    let bits = 0;
+    const win = new Uint8Array(WINDOW);
+    let wpos = 0;
+    let total = 0;
+    const lens = new Uint8Array(286 + 32);
+    const lenCode = new Huffman();
+    const distCode = new Huffman();
+    const clCode = new Huffman();
+    /** Takes bytes from the current chunk until `n` bits are held or the chunk runs out. n is at most 16. */
+    const fill = (n) => {
+        while (bits < n && pos < buf.length) {
+            hold |= buf[pos++] << bits;
+            bits += 8;
+            taken++;
+        }
+        return bits >= n;
+    };
+    const drop = (n) => {
+        hold >>>= n;
+        bits -= n;
+    };
+    const used = () => {
+        consumed.bytes = taken - (bits >>> 3);
+    };
+    /** Decodes one symbol from the bits held, or returns NEED or INVALID. Consumes nothing unless it succeeds. */
+    const decode = (h) => {
+        fill(MAXBITS);
+        if (bits >= FAST) {
+            const e = h.fast[hold & ((1 << FAST) - 1)];
+            if (e !== 0) {
+                drop(e & 15);
+                return e >>> 4;
+            }
+        }
+        let code = 0;
+        let first = 0;
+        let index = 0;
+        for (let len = 1; len <= h.maxLen; len++) {
+            if (bits < len)
+                return NEED;
+            code |= (hold >>> (len - 1)) & 1;
+            const count = h.count[len];
+            if (code - count < first) {
+                drop(len);
+                return h.symbol[index + code - first];
+            }
+            index += count;
+            first = (first + count) << 1;
+            code <<= 1;
+        }
+        return INVALID;
+    };
+    // Pulls the next chunk from the caller. Used as `yield* more()`, which happens once per input chunk.
+    function* more() {
+        used();
+        const next = yield null;
+        if (next === undefined)
+            throw new errors_1.DataError('Deflate64 stream ends before its final block', true);
+        buf = next;
+        pos = 0;
+    }
+    let last = false;
+    while (!last) {
+        (0, errors_1.checkTime)(deadline);
+        while (!fill(3))
+            yield* more();
+        last = (hold & 1) === 1;
+        const type = (hold >>> 1) & 3;
+        drop(3);
+        if (type === 0) {
+            drop(bits & 7);
+            while (!fill(16))
+                yield* more();
+            const len = hold & 0xffff;
+            drop(16);
+            while (!fill(16))
+                yield* more();
+            const nlen = hold & 0xffff;
+            drop(16);
+            if (len !== (~nlen & 0xffff))
+                throw new errors_1.DataError('Deflate64 stored block lengths do not match');
+            let left = len;
+            // Whole bytes still held come first; bits is a multiple of 8 here.
+            while (left > 0 && bits > 0) {
+                win[wpos++] = hold & 0xff;
+                drop(8);
+                left--;
+                total++;
+                if (wpos === WINDOW) {
+                    used();
+                    yield win.slice(0, WINDOW);
+                    (0, errors_1.checkTime)(deadline);
+                    wpos = 0;
+                }
+            }
+            while (left > 0) {
+                if (pos === buf.length)
+                    yield* more();
+                const n = Math.min(left, buf.length - pos, WINDOW - wpos);
+                win.set(buf.subarray(pos, pos + n), wpos);
+                pos += n;
+                taken += n;
+                wpos += n;
+                total += n;
+                left -= n;
+                if (wpos === WINDOW) {
+                    used();
+                    yield win.slice(0, WINDOW);
+                    (0, errors_1.checkTime)(deadline);
+                    wpos = 0;
+                }
+            }
+            continue;
+        }
+        if (type === 3)
+            throw new errors_1.DataError('Deflate64 block type 3 is invalid');
+        let lc = fixedLen;
+        let dc = fixedDist;
+        if (type === 2) {
+            while (!fill(14))
+                yield* more();
+            const nlen = (hold & 31) + 257;
+            const ndist = ((hold >>> 5) & 31) + 1;
+            const ncode = ((hold >>> 10) & 15) + 4;
+            drop(14);
+            if (nlen > 286)
+                throw new errors_1.DataError('Deflate64 block has too many literal/length codes');
+            lens.fill(0, 0, 19);
+            for (let i = 0; i < ncode; i++) {
+                while (!fill(3))
+                    yield* more();
+                lens[CL_ORDER[i]] = hold & 7;
+                drop(3);
+            }
+            const clErr = build(clCode, lens, 0, 19, 'codes');
+            if (clErr !== undefined)
+                throw new errors_1.DataError(`Deflate64 code-length code is invalid: ${clErr}`);
+            const want = nlen + ndist;
+            let have = 0;
+            // lens is reused: the code-length code is already built from its first 19 entries.
+            while (have < want) {
+                let sym = decode(clCode);
+                while (sym === NEED) {
+                    yield* more();
+                    sym = decode(clCode);
+                }
+                if (sym === INVALID)
+                    throw new errors_1.DataError('Deflate64 code-length code has no meaning');
+                if (sym < 16) {
+                    lens[have++] = sym;
+                    continue;
+                }
+                let rep;
+                let value = 0;
+                if (sym === 16) {
+                    if (have === 0)
+                        throw new errors_1.DataError('Deflate64 repeat code with no previous length');
+                    value = lens[have - 1];
+                    while (!fill(2))
+                        yield* more();
+                    rep = 3 + (hold & 3);
+                    drop(2);
+                }
+                else if (sym === 17) {
+                    while (!fill(3))
+                        yield* more();
+                    rep = 3 + (hold & 7);
+                    drop(3);
+                }
+                else {
+                    while (!fill(7))
+                        yield* more();
+                    rep = 11 + (hold & 127);
+                    drop(7);
+                }
+                if (have + rep > want)
+                    throw new errors_1.DataError('Deflate64 code lengths run past HLIT + HDIST');
+                lens.fill(value, have, have + rep);
+                have += rep;
+            }
+            if (lens[256] === 0)
+                throw new errors_1.DataError('Deflate64 block has no end-of-block code');
+            const lErr = build(lenCode, lens, 0, nlen, 'lens');
+            if (lErr !== undefined)
+                throw new errors_1.DataError(`Deflate64 literal/length code is invalid: ${lErr}`);
+            const dErr = build(distCode, lens, nlen, ndist, 'dists');
+            if (dErr !== undefined)
+                throw new errors_1.DataError(`Deflate64 distance code is invalid: ${dErr}`);
+            lc = lenCode;
+            dc = distCode;
+        }
+        for (;;) {
+            let sym = decode(lc);
+            while (sym === NEED) {
+                yield* more();
+                sym = decode(lc);
+            }
+            if (sym === INVALID)
+                throw new errors_1.DataError('Deflate64 literal/length code has no meaning');
+            if (sym < 256) {
+                win[wpos++] = sym;
+                total++;
+                if (wpos === WINDOW) {
+                    used();
+                    yield win.slice(0, WINDOW);
+                    (0, errors_1.checkTime)(deadline);
+                    wpos = 0;
+                }
+                continue;
+            }
+            if (sym === 256)
+                break;
+            sym -= 257;
+            if (sym >= 29)
+                throw new errors_1.DataError('Deflate64 literal/length code 286 or 287 is invalid');
+            let length = LBASE[sym];
+            const lx = LEXT[sym];
+            if (lx > 0) {
+                while (!fill(lx))
+                    yield* more();
+                length += hold & ((1 << lx) - 1);
+                drop(lx);
+            }
+            let dsym = decode(dc);
+            while (dsym === NEED) {
+                yield* more();
+                dsym = decode(dc);
+            }
+            if (dsym === INVALID)
+                throw new errors_1.DataError('Deflate64 distance code has no meaning');
+            let dist = DBASE[dsym];
+            const dx = DEXT[dsym];
+            if (dx > 0) {
+                while (!fill(dx))
+                    yield* more();
+                dist += hold & ((1 << dx) - 1);
+                drop(dx);
+            }
+            if (dist > total)
+                throw new errors_1.DataError('Deflate64 distance reaches before the start of the output');
+            total += length;
+            // dist <= WINDOW, so the source byte is always still in the window. Byte by byte, so an overlapping match repeats.
+            let from = (wpos - dist) & (WINDOW - 1);
+            while (length > 0) {
+                win[wpos++] = win[from];
+                from = (from + 1) & (WINDOW - 1);
+                length--;
+                if (wpos === WINDOW) {
+                    used();
+                    yield win.slice(0, WINDOW);
+                    (0, errors_1.checkTime)(deadline);
+                    wpos = 0;
+                }
+            }
+        }
+    }
+    used();
+    if (wpos > 0)
+        yield win.slice(0, wpos);
+}
+/**
+ * Decodes a raw Deflate64 stream. Stops after the final block; consumed.bytes then counts the input bytes the stream
+ * used, so bytes after it are the caller's. Output comes in chunks of at most 64 KiB.
+ */
+async function* inflate64(chunks, consumed, deadline) {
+    const count = consumed ?? { bytes: 0 };
+    count.bytes = 0;
+    const it = chunks[Symbol.asyncIterator]();
+    const core = decoder(count, deadline);
+    let finished = false;
+    try {
+        let r = core.next(undefined);
+        while (r.done !== true) {
+            if (r.value === null) {
+                let next = await it.next();
+                while (next.done !== true && next.value.length === 0)
+                    next = await it.next();
+                r = core.next(next.done === true ? undefined : next.value);
+            }
+            else {
+                yield r.value;
+                r = core.next(undefined);
+            }
+        }
+        finished = true;
+    }
+    finally {
+        core.return(undefined);
+        if (!finished)
+            await it.return?.();
+    }
+}

package/dist/io.d.ts

@@ -0,0 +1,78 @@
+import type { Writable } from 'node:stream';
+import type { ByteSink, ByteSource } from './types';
+/** A source over bytes already in memory. Reads return views, not copies. */
+export declare function bufferSource(bytes: Uint8Array): ByteSource;
+/** A source over a local file, read at offsets through one file handle. */
+export declare function fileSource(filePath: string): ByteSource;
+/**
+ * Random-access reader with a small block cache, so the ZIP reader can ask for small overlapping windows cheaply. Its
+ * reads span at most a few blocks: a header, a name and its extra field, or the end of the file.
+ */
+export declare class Reader {
+    readonly source: ByteSource;
+    readonly size: number;
+    private readonly blockSize;
+    private readonly maxBlocks;
+    /** Blocks by index, oldest first. */
+    private readonly cache;
+    constructor(source: ByteSource, size: number, blockSize?: number, maxBlocks?: number);
+    private block;
+    /** Reads up to `length` bytes at `offset`; shorter only at the end of the source. */
+    read(offset: number, length: number): Promise<Uint8Array>;
+    /** Yields the range in chunks without caching them. */
+    chunks(offset: number, length: number, chunkSize?: number): AsyncGenerator<Uint8Array>;
+}
+/** Collects output in memory. */
+export declare function bufferSink(): ByteSink & {
+    result(): Uint8Array;
+    size(): number;
+};
+/** Writes to a local file. The file is created on the first write. */
+export declare function fileSink(filePath: string): ByteSink;
+/**
+ * Wraps any Node Writable, waiting for 'drain' when it applies backpressure. The stream's first error, or its
+ * closing before the end, fails the pending write and every later one.
+ */
+export declare function writableSink(stream: Writable): ByteSink;
+/** A private temporary directory, removed by cleanup(). It also keeps the run's first I/O error. */
+export declare class TempDir {
+    private readonly base;
+    private dir?;
+    private seq;
+    /** The first error from a temporary file, which the engine throws instead of a verdict on the file. */
+    ioError?: unknown;
+    constructor(base?: string);
+    file(suffix?: string): Promise<string>;
+    cleanup(): Promise<void>;
+}
+/**
+ * A sink that keeps what it is given in memory up to `threshold` bytes and in a temporary file past that, with the MD5
+ * of the bytes, which tells the output check that a file inside is the one a plugin returned.
+ */
+export declare class SpillSink implements ByteSink {
+    private readonly temp;
+    private readonly threshold;
+    private chunks;
+    private size;
+    private filePath?;
+    private handle?;
+    private readonly md5;
+    private hex?;
+    spilled: boolean;
+    constructor(temp: TempDir, threshold: number);
+    write(chunk: Uint8Array): Promise<void>;
+    close(): Promise<void>;
+    /** Closes the sink and deletes its temporary file, once nothing will read what it holds again. */
+    dispose(): Promise<void>;
+    get length(): number;
+    digest(): string;
+    /** A source over what was written. Call after close(). */
+    source(): ByteSource;
+    /** What was written, in chunks. Call after close(). */
+    read(chunkSize?: number): AsyncGenerator<Uint8Array>;
+}
+/**
+ * Copies a whole source, calling `checkTime` before each chunk. A read that returns more or fewer bytes than it asked
+ * for fails the copy, which would otherwise shift every byte after it.
+ */
+export declare function copyToSink(source: ByteSource, sink: ByteSink, checkTime?: () => void): Promise<void>;