@patrickdk77/office-defuse 0.0.0-stage → 0.1.0

package/dist/zip-writer.d.ts

@@ -0,0 +1,38 @@
+import type { ByteSink } from './types';
+/** What the central directory says of an entry whose compressed bytes are copied unchanged. */
+export interface CopiedEntry {
+    name: string;
+    /** 0 stored, 8 deflate. */
+    method: number;
+    crc: number;
+    compressedSize: number;
+    size: number;
+    dosTime?: number;
+    dosDate?: number;
+}
+/**
+ * Writes a ZIP archive to an append-only sink. Local headers carry the CRC and sizes, so no entry needs a data
+ * descriptor. ZIP64 records appear only where a size, an offset or the entry count needs them.
+ */
+export declare class ZipWriter {
+    private readonly sink;
+    private readonly options;
+    private offset;
+    private readonly central;
+    private readonly names;
+    /** `forceZip64` writes ZIP64 records for every entry and the end of the archive, as a test of readers. */
+    constructor(sink: ByteSink, options?: {
+        forceZip64?: boolean;
+    });
+    private put;
+    /** Adds an entry from bytes in memory, deflated unless `compress` is false. A name ending in "/" is a directory. */
+    add(name: string, data: Uint8Array, options?: {
+        compress?: boolean;
+        dosTime?: number;
+        dosDate?: number;
+    }): Promise<void>;
+    /** Adds an entry whose compressed bytes come from `chunks` unchanged, such as an entry of the archive being rewritten. */
+    copy(info: CopiedEntry, chunks: AsyncIterable<Uint8Array>): Promise<void>;
+    /** Writes the central directory and the end records. The caller closes the sink. */
+    finish(): Promise<void>;
+}

package/dist/zip-writer.js

@@ -0,0 +1,182 @@
+"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.ZipWriter = void 0;
+const zlib = __importStar(require("node:zlib"));
+const crc32_1 = require("./crc32");
+const MAX16 = 0xffff;
+const MAX32 = 0xffffffff;
+/** 1980-01-01 00:00, the earliest date a ZIP header holds, so new entries do not depend on the clock. */
+const DOS_DATE = (0 << 9) | (1 << 5) | 1;
+class Builder {
+    parts = [];
+    u16(v) {
+        this.parts.push(v & 0xff, (v >>> 8) & 0xff);
+        return this;
+    }
+    u32(v) {
+        return this.u16(v & 0xffff).u16(Math.floor(v / 0x10000) & 0xffff);
+    }
+    u64(v) {
+        return this.u32(v % 0x100000000).u32(Math.floor(v / 0x100000000));
+    }
+    bytes(b) {
+        for (const x of b)
+            this.parts.push(x);
+        return this;
+    }
+    build() {
+        return Uint8Array.from(this.parts);
+    }
+}
+/**
+ * Writes a ZIP archive to an append-only sink. Local headers carry the CRC and sizes, so no entry needs a data
+ * descriptor. ZIP64 records appear only where a size, an offset or the entry count needs them.
+ */
+class ZipWriter {
+    sink;
+    options;
+    offset = 0;
+    central = [];
+    names = new Set();
+    /** `forceZip64` writes ZIP64 records for every entry and the end of the archive, as a test of readers. */
+    constructor(sink, options = {}) {
+        this.sink = sink;
+        this.options = options;
+    }
+    async put(b) {
+        await this.sink.write(b);
+        this.offset += b.length;
+    }
+    /** Adds an entry from bytes in memory, deflated unless `compress` is false. A name ending in "/" is a directory. */
+    async add(name, data, options = {}) {
+        const compress = (options.compress ?? true) && data.length > 0;
+        const body = compress ? zlib.deflateRawSync(data) : data;
+        const info = { name, method: compress ? 8 : 0, crc: (0, crc32_1.crc32)(data), compressedSize: body.length, size: data.length, dosTime: options.dosTime, dosDate: options.dosDate };
+        await this.copy(info, (async function* () {
+            yield body;
+        })());
+    }
+    /** Adds an entry whose compressed bytes come from `chunks` unchanged, such as an entry of the archive being rewritten. */
+    async copy(info, chunks) {
+        if (this.names.has(info.name))
+            throw new Error(`Entry ${info.name} is already in the archive`);
+        this.names.add(info.name);
+        const name = Buffer.from(info.name, 'utf8');
+        const flags = /^[\x20-\x7e]*$/.test(info.name) ? 0 : 0x0800;
+        const big = this.options.forceZip64 === true || info.size >= MAX32 || info.compressedSize >= MAX32;
+        const localOffset = this.offset;
+        const time = info.dosTime ?? 0;
+        const date = info.dosDate ?? DOS_DATE;
+        const local = new Builder()
+            .u32(0x04034b50)
+            .u16(big ? 45 : 20)
+            .u16(flags)
+            .u16(info.method)
+            .u16(time)
+            .u16(date)
+            .u32(info.crc)
+            .u32(big ? MAX32 : info.compressedSize)
+            .u32(big ? MAX32 : info.size)
+            .u16(name.length)
+            .u16(big ? 20 : 0)
+            .bytes(name);
+        if (big)
+            local.u16(0x0001).u16(16).u64(info.size).u64(info.compressedSize);
+        await this.put(local.build());
+        let written = 0;
+        for await (const c of chunks) {
+            written += c.length;
+            await this.put(c);
+        }
+        if (written !== info.compressedSize)
+            throw new Error(`Entry ${info.name} has ${written} compressed bytes, not ${info.compressedSize}`);
+        const farOffset = this.options.forceZip64 === true || localOffset >= MAX32;
+        const extra = new Builder();
+        if (big)
+            extra.u64(info.size).u64(info.compressedSize);
+        if (farOffset)
+            extra.u64(localOffset);
+        const extraBytes = extra.build();
+        const version = big || farOffset ? 45 : 20;
+        const central = new Builder()
+            .u32(0x02014b50)
+            .u16(version)
+            .u16(version)
+            .u16(flags)
+            .u16(info.method)
+            .u16(time)
+            .u16(date)
+            .u32(info.crc)
+            .u32(big ? MAX32 : info.compressedSize)
+            .u32(big ? MAX32 : info.size)
+            .u16(name.length)
+            .u16(extraBytes.length ? extraBytes.length + 4 : 0)
+            .u16(0)
+            .u16(0)
+            .u16(0)
+            .u32(0)
+            .u32(farOffset ? MAX32 : localOffset)
+            .bytes(name);
+        if (extraBytes.length)
+            central.u16(0x0001).u16(extraBytes.length).bytes(extraBytes);
+        this.central.push(central.build());
+    }
+    /** Writes the central directory and the end records. The caller closes the sink. */
+    async finish() {
+        const dirOffset = this.offset;
+        for (const c of this.central)
+            await this.put(c);
+        const dirSize = this.offset - dirOffset;
+        const count = this.central.length;
+        const big = this.options.forceZip64 === true || count >= MAX16 || dirOffset >= MAX32 || dirSize >= MAX32;
+        if (big) {
+            const end64 = this.offset;
+            await this.put(new Builder().u32(0x06064b50).u64(44).u16(45).u16(45).u32(0).u32(0).u64(count).u64(count).u64(dirSize).u64(dirOffset).build());
+            await this.put(new Builder().u32(0x07064b50).u32(0).u64(end64).u32(1).build());
+        }
+        await this.put(new Builder()
+            .u32(0x06054b50)
+            .u16(0)
+            .u16(0)
+            .u16(big ? MAX16 : count)
+            .u16(big ? MAX16 : count)
+            .u32(big ? MAX32 : dirSize)
+            .u32(big ? MAX32 : dirOffset)
+            .u16(0)
+            .build());
+    }
+}
+exports.ZipWriter = ZipWriter;

package/dist/zip.d.ts

@@ -0,0 +1,55 @@
+import { type ByteSource, OfficeDetail as D } from './types';
+export interface ZipLimits {
+    entries: number;
+    decompressedBytes: number;
+    totalDecompressedBytes: number;
+}
+export interface ZipEntry {
+    /** Position in the central directory. */
+    index: number;
+    name: string;
+    /** A directory entry, whose name ends in "/". */
+    directory: boolean;
+    flags: number;
+    /** 0 stored, 8 deflate. */
+    method: number;
+    dosTime: number;
+    dosDate: number;
+    crc: number;
+    compressedSize: number;
+    size: number;
+    localOffset: number;
+    dataOffset: number;
+    /** Where the entry ends, after any data descriptor. */
+    end: number;
+    /** The local header has an extra field. ODF wants none on the mimetype entry. */
+    localExtra: boolean;
+}
+/** Something the reader saw that it does not refuse. Each is a strip finding, since the rewrite drops the bytes. */
+export interface ZipNote {
+    detail: D.LeadingBytes | D.HiddenData | D.TrailingBytes;
+    bytes: number;
+}
+/** The key two names collide on: percent-decoded, NFC and lowercase, without a directory's slash. */
+export declare function nameKey(name: string): string;
+/**
+ * A ZIP archive read from its central directory, after every local header was checked against it. Reading an entry
+ * inflates it in chunks and checks its size and CRC.
+ */
+export declare class ZipArchive {
+    private readonly reader;
+    readonly entries: ZipEntry[];
+    readonly notes: ZipNote[];
+    private readonly deadline;
+    private readonly byKey;
+    private constructor();
+    /** The entry with this name, compared as entry names collide: ignoring case. */
+    get(name: string): ZipEntry | undefined;
+    static open(source: ByteSource, limits: ZipLimits, deadline?: number): Promise<ZipArchive>;
+    /** Checks a local header and any data descriptor against the central directory, and fills in where the entry's data and the entry end. */
+    private static checkLocal;
+    /** The compressed bytes of an entry, as stored. */
+    raw(e: ZipEntry): AsyncGenerator<Uint8Array>;
+    /** The entry's content in chunks. Its size, its CRC and, for deflate, the compressed bytes consumed must all agree with the central directory. */
+    read(e: ZipEntry): AsyncGenerator<Uint8Array>;
+}