@patrickdk77/archive-defuse 0.0.0-stage → 0.1.1

package/dist/io.js

@@ -0,0 +1,379 @@
+"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.SpillSink = exports.TempDir = exports.Reader = void 0;
+exports.bufferSource = bufferSource;
+exports.fileSource = fileSource;
+exports.bufferSink = bufferSink;
+exports.fileSink = fileSink;
+exports.writableSink = writableSink;
+exports.copyToSink = copyToSink;
+// Copied from office-defuse src/io.ts. Changed: the TempDir prefix, and bufferSource and fileSource read only whole offsets inside the source, as pdf-defuse's do.
+const crypto = __importStar(require("node:crypto"));
+const fsp = __importStar(require("node:fs/promises"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+/**
+ * The bytes [start, end) a read covers in a source of `size` bytes, or undefined when it covers none. Offsets read
+ * from a file can be negative or fractional, and such a read gets no bytes rather than bytes from somewhere else.
+ */
+function span(offset, length, size) {
+    if (!Number.isSafeInteger(offset) || offset < 0 || offset >= size || !(length >= 1))
+        return undefined;
+    return [offset, Math.min(size, offset + Math.floor(length))];
+}
+/** A source over bytes already in memory. Reads return views, not copies. */
+function bufferSource(bytes) {
+    return {
+        size: async () => bytes.length,
+        read: async (offset, length) => {
+            const s = span(offset, length, bytes.length);
+            return s ? bytes.subarray(s[0], s[1]) : new Uint8Array(0);
+        },
+    };
+}
+/** A source over a local file, read at offsets through one file handle. */
+function fileSource(filePath) {
+    // The pending open is shared, so concurrent first calls get one handle and close() closes it.
+    let opening;
+    let size;
+    const open = () => {
+        opening ??= fsp.open(filePath, 'r');
+        return opening;
+    };
+    const getSize = async () => {
+        size ??= (await (await open()).stat()).size;
+        return size;
+    };
+    return {
+        size: getSize,
+        async read(offset, length) {
+            const h = await open();
+            // Node reads position -1 from the file's current position, so a negative offset never reaches it.
+            const s = span(offset, length, await getSize());
+            if (!s)
+                return Buffer.alloc(0);
+            const n = s[1] - offset;
+            const buf = Buffer.allocUnsafe(n);
+            let done = 0;
+            while (done < n) {
+                const { bytesRead } = await h.read(buf, done, n - done, offset + done);
+                if (bytesRead === 0)
+                    break;
+                done += bytesRead;
+            }
+            return buf.subarray(0, done);
+        },
+        async close() {
+            const p = opening;
+            opening = undefined;
+            await p?.then(h => h.close(), () => {
+                // An open that failed left nothing to close.
+            });
+        },
+    };
+}
+/**
+ * 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.
+ */
+class Reader {
+    source;
+    size;
+    blockSize;
+    maxBlocks;
+    /** Blocks by index, oldest first. */
+    cache = new Map();
+    constructor(source, size, blockSize = 65536, maxBlocks = 16) {
+        this.source = source;
+        this.size = size;
+        this.blockSize = blockSize;
+        this.maxBlocks = maxBlocks;
+    }
+    async block(index) {
+        const hit = this.cache.get(index);
+        if (hit)
+            return hit;
+        const data = await this.source.read(index * this.blockSize, Math.min(this.blockSize, this.size - index * this.blockSize));
+        if (this.cache.size >= this.maxBlocks) {
+            for (const oldest of this.cache.keys()) {
+                this.cache.delete(oldest);
+                break;
+            }
+        }
+        this.cache.set(index, data);
+        return data;
+    }
+    /** Reads up to `length` bytes at `offset`; shorter only at the end of the source. */
+    async read(offset, length) {
+        const end = Math.min(this.size, offset + length);
+        if (end <= offset)
+            return new Uint8Array(0);
+        const first = Math.floor(offset / this.blockSize);
+        const last = Math.floor((end - 1) / this.blockSize);
+        const out = new Uint8Array(end - offset);
+        for (let i = first; i <= last; i++) {
+            const b = await this.block(i);
+            const from = i === first ? offset - first * this.blockSize : 0;
+            const to = i === last ? end - i * this.blockSize : b.length;
+            out.set(b.subarray(from, to), i === first ? 0 : i * this.blockSize - offset);
+        }
+        return out;
+    }
+    /** Yields the range in chunks without caching them. */
+    async *chunks(offset, length, chunkSize = 262144) {
+        const end = Math.min(this.size, offset + length);
+        for (let pos = offset; pos < end; pos += chunkSize)
+            yield this.source.read(pos, Math.min(chunkSize, end - pos));
+    }
+}
+exports.Reader = Reader;
+/** Collects output in memory. */
+function bufferSink() {
+    const chunks = [];
+    let size = 0;
+    return {
+        async write(chunk) {
+            chunks.push(Buffer.from(chunk));
+            size += chunk.length;
+        },
+        async close() {
+            // Nothing to release. The chunks stay for result().
+        },
+        result: () => Buffer.concat(chunks),
+        size: () => size,
+    };
+}
+/** FileHandle.write may write less than asked, for example at a file size limit; the next write then reports why. */
+async function writeAll(handle, chunk) {
+    for (let done = 0; done < chunk.length;)
+        done += (await handle.write(chunk, done, chunk.length - done)).bytesWritten;
+}
+/** Writes to a local file. The file is created on the first write. */
+function fileSink(filePath) {
+    let handle;
+    return {
+        async write(chunk) {
+            handle ??= await fsp.open(filePath, 'w');
+            await writeAll(handle, chunk);
+        },
+        async close() {
+            handle ??= await fsp.open(filePath, 'w');
+            await handle.close();
+        },
+        async abort() {
+            const h = handle;
+            handle = undefined;
+            if (!h)
+                return;
+            // A partial regular file goes. abort() never unlinks a device or pipe the caller named.
+            const partial = (await h.stat().catch(() => undefined))?.isFile();
+            await h.close().catch(() => {
+                // abort() runs after a failure, which is the error to report.
+            });
+            if (partial)
+                await fsp.rm(filePath, { force: true });
+        },
+    };
+}
+/**
+ * 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.
+ */
+function writableSink(stream) {
+    let failure;
+    const pending = new Set();
+    const fail = (e) => {
+        failure ??= e;
+        for (const reject of pending)
+            reject(failure);
+        pending.clear();
+    };
+    // Node emits some errors after the write callback, and an 'error' with no listener crashes the process, so this
+    // listener stays for the stream's whole life.
+    stream.on('error', fail);
+    stream.on('close', () => {
+        if (!stream.writableFinished)
+            fail(stream.errored ?? new Error('The output stream closed before all data was written'));
+    });
+    const settle = (start) => new Promise((resolve, reject) => {
+        if (failure)
+            return reject(failure);
+        if (stream.destroyed)
+            return reject(stream.errored ?? new Error('The output stream was destroyed'));
+        pending.add(reject);
+        start(err => {
+            pending.delete(reject);
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+    return {
+        write: chunk => settle(done => (stream.write(chunk) ? done() : stream.once('drain', () => done()))),
+        close: () => settle(done => stream.end((err) => done(err))),
+        // The reader sees an error instead of an end, so it cannot mistake a partial output for a whole one.
+        abort: async (error) => {
+            stream.destroy(error instanceof Error ? error : new Error(String(error)));
+        },
+    };
+}
+/** A private temporary directory, removed by cleanup(). It also keeps the run's first I/O error. */
+class TempDir {
+    base;
+    // The pending mkdtemp is shared, so concurrent first calls make one directory and cleanup() removes it.
+    dir;
+    seq = 0;
+    /** The first error from a temporary file, which the engine throws instead of a verdict on the file. */
+    ioError;
+    constructor(base = os.tmpdir()) {
+        this.base = base;
+    }
+    async file(suffix = '.bin') {
+        this.dir ??= fsp.mkdtemp(path.join(this.base, 'archive-defuse-'));
+        return path.join(await this.dir, `${this.seq++}${suffix}`);
+    }
+    async cleanup() {
+        const dir = await this.dir?.catch(() => undefined);
+        this.dir = undefined;
+        if (dir)
+            await fsp.rm(dir, { recursive: true, force: true });
+    }
+}
+exports.TempDir = TempDir;
+/**
+ * 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.
+ */
+class SpillSink {
+    temp;
+    threshold;
+    chunks = [];
+    size = 0;
+    filePath;
+    handle;
+    md5 = crypto.createHash('md5');
+    hex;
+    spilled = false;
+    constructor(temp, threshold) {
+        this.temp = temp;
+        this.threshold = threshold;
+    }
+    async write(chunk) {
+        this.md5.update(chunk);
+        this.size += chunk.length;
+        if (!this.handle && this.size <= this.threshold) {
+            this.chunks.push(Buffer.from(chunk));
+            return;
+        }
+        try {
+            if (!this.handle) {
+                this.filePath = await this.temp.file('.spill');
+                this.handle = await fsp.open(this.filePath, 'w');
+                this.spilled = true;
+                for (const c of this.chunks)
+                    await writeAll(this.handle, c);
+                this.chunks = [];
+            }
+            await writeAll(this.handle, chunk);
+        }
+        catch (e) {
+            this.temp.ioError ??= e;
+            throw e;
+        }
+    }
+    async close() {
+        await this.handle?.close();
+        this.handle = undefined;
+    }
+    /** Closes the sink and deletes its temporary file, once nothing will read what it holds again. */
+    async dispose() {
+        await this.close();
+        this.chunks = [];
+        const file = this.filePath;
+        this.filePath = undefined;
+        if (file === undefined)
+            return;
+        try {
+            await fsp.rm(file, { force: true });
+        }
+        catch (e) {
+            this.temp.ioError ??= e;
+            throw e;
+        }
+    }
+    get length() {
+        return this.size;
+    }
+    digest() {
+        this.hex ??= this.md5.digest('hex');
+        return this.hex;
+    }
+    /** A source over what was written. Call after close(). */
+    source() {
+        return this.filePath ? fileSource(this.filePath) : bufferSource(Buffer.concat(this.chunks));
+    }
+    /** What was written, in chunks. Call after close(). */
+    async *read(chunkSize = 262144) {
+        const src = this.source();
+        // A consumer that stops early, such as a failed output write, still closes the file.
+        try {
+            const total = await src.size();
+            for (let pos = 0; pos < total; pos += chunkSize)
+                yield await src.read(pos, Math.min(chunkSize, total - pos));
+        }
+        finally {
+            await src.close?.();
+        }
+    }
+}
+exports.SpillSink = SpillSink;
+/**
+ * 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.
+ */
+async function copyToSink(source, sink, checkTime) {
+    const total = await source.size();
+    const chunk = 262144;
+    for (let pos = 0; pos < total; pos += chunk) {
+        checkTime?.();
+        const want = Math.min(chunk, total - pos);
+        const b = await source.read(pos, want);
+        if (b.length !== want)
+            throw Object.assign(new Error(`The source returned ${b.length} bytes at offset ${pos} where ${want} were expected`), { code: 'EIO' });
+        await sink.write(b);
+    }
+}

package/dist/lzma-formats.d.ts

@@ -0,0 +1,75 @@
+import { type Reader as ByteReader } from './io';
+import { type Archive, type Entry, type Meter, type Note, type WriteContext, type WritePlan } from './model';
+import { type SevenEntry } from './seven';
+import type { Limits } from './stream-meter';
+import { type ByteSink, type ByteSource } from './types';
+export interface SevenZipEntry extends Entry {
+    seven: SevenEntry;
+}
+export declare class SevenZipArchive implements Archive<SevenZipEntry> {
+    private readonly reader;
+    private readonly seven;
+    readonly notes: Note[];
+    private readonly passwords;
+    readonly format = "7z";
+    readonly single = false;
+    readonly nameless: boolean;
+    readonly lateNotes: Note[];
+    readonly entries: SevenZipEntry[];
+    private readonly contents;
+    private constructor();
+    static open(source: ByteSource, limits: Limits, deadline: number | undefined, passwords: string[]): Promise<SevenZipArchive>;
+    hasMetadata(): boolean;
+    unlock(e: SevenZipEntry, password: string): Promise<boolean>;
+    read(e: SevenZipEntry, meter: Meter, password?: string): AsyncGenerator<Uint8Array>;
+    /** A symbolic link's target, which a 7z archive keeps as the link's content. */
+    linkTarget(e: SevenZipEntry, meter: Meter): Promise<string | undefined>;
+    write(plan: WritePlan<SevenZipEntry>, sink: ByteSink, context: WriteContext): Promise<void>;
+    /** One kept entry as the writer takes it, with its name and permissions as the rules left them. */
+    private out;
+}
+interface LzmaSingleEntry extends Entry {
+    decoded?: number;
+}
+/** A file that compresses one file: its one entry has no name, and its content goes to the plugins like any other. */
+declare abstract class LzmaSingle implements Archive<LzmaSingleEntry> {
+    protected readonly reader: ByteReader;
+    protected readonly limits: Limits;
+    abstract readonly format: 'xz' | 'lzma';
+    readonly single = true;
+    readonly notes: Note[];
+    readonly lateNotes: Note[];
+    readonly entries: LzmaSingleEntry[];
+    /** Set once the entry has been read: where data after the stream starts, when the file goes on. */
+    protected trailingAt?: number;
+    /** Set once the entry has been read and nothing about the stream needs writing again: it can be copied as it is. */
+    protected copyable: boolean;
+    constructor(reader: ByteReader, limits: Limits);
+    unlock(): Promise<boolean>;
+    hasMetadata(): boolean;
+    abstract read(e: LzmaSingleEntry, meter: Meter): AsyncGenerator<Uint8Array>;
+    /** Writes `content` in the format. With `store`, a format that can store data uncompressed does. */
+    protected abstract encode(content: ByteSource | undefined, sink: ByteSink, time: () => void, store: boolean): Promise<void>;
+    /** True when encode() can store data uncompressed. */
+    protected readonly canStore: boolean;
+    /** Notes what the read found besides the content, and whether the stream can be copied as it is. */
+    protected finishRead(e: LzmaSingleEntry, total: number, notes: Note[], oneStream: boolean, trailingAt: number | undefined): Promise<void>;
+    write(plan: WritePlan<LzmaSingleEntry>, sink: ByteSink, context: WriteContext): Promise<void>;
+    private writeContent;
+}
+export declare class XzArchive extends LzmaSingle {
+    readonly format = "xz";
+    /** The check the rewrite writes: the one every stream used when this package can compute it, else CRC64. */
+    private checkId;
+    static open(source: ByteSource, limits: Limits): Promise<XzArchive>;
+    read(e: LzmaSingleEntry, meter: Meter): AsyncGenerator<Uint8Array>;
+    protected readonly canStore = true;
+    protected encode(content: ByteSource | undefined, sink: ByteSink, time: () => void, store: boolean): Promise<void>;
+}
+export declare class LzmaArchive extends LzmaSingle {
+    readonly format = "lzma";
+    static open(source: ByteSource, limits: Limits): Promise<LzmaArchive>;
+    read(e: LzmaSingleEntry, meter: Meter): AsyncGenerator<Uint8Array>;
+    protected encode(content: ByteSource | undefined, sink: ByteSink, time: () => void): Promise<void>;
+}
+export {};