@patrickdk77/archive-defuse 0.0.0-stage → 0.1.1

package/dist/zip-lzma.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipLzma = zipLzma;
+exports.zipXz = zipXz;
+const coders_1 = require("./coders");
+const errors_1 = require("./errors");
+const io_1 = require("./io");
+const lzma1_stream_1 = require("./lzma1-stream");
+const types_1 = require("./types");
+const xz_1 = require("./xz");
+/** Input handed to the LZMA decoder per step, so one step decodes a bounded amount. */
+const SLICE = 1024;
+/** APPNOTE 5.8.8: two version bytes, a two-byte properties size, then the five bytes of LZMA properties. */
+const HEADER = 9;
+const concat = (a, b) => {
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a, 0);
+    out.set(b, a.length);
+    return out;
+};
+/**
+ * Decodes a method 14 entry: the LZMA header APPNOTE 5.8.8 gives, then raw LZMA data of the entry's size, which may
+ * end with an end marker. `consumed.bytes` follows the input the data took, so the caller can see bytes after it.
+ */
+async function* zipLzma(chunks, size, consumed, dictionaryBytes) {
+    const it = chunks[Symbol.asyncIterator]();
+    let head = new Uint8Array(0);
+    try {
+        while (head.length < HEADER) {
+            const r = await it.next();
+            if (r.done)
+                throw new errors_1.DataError('the LZMA header is cut short', true);
+            head = concat(head, r.value);
+        }
+        const propsSize = head[2] | (head[3] << 8);
+        if (propsSize !== 5)
+            throw new errors_1.DataError(`LZMA properties of ${propsSize} bytes, not 5`);
+        const dict = (head[5] | (head[6] << 8) | (head[7] << 16) | (head[8] << 24)) >>> 0;
+        const need = (0, lzma1_stream_1.effectiveDictSize)(dict, size);
+        if (need > dictionaryBytes)
+            throw new errors_1.StopError(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.DictionarySize, 'Dictionary size limit exceeded', { limit: dictionaryBytes, dictionary: need });
+        const out = [];
+        let stream;
+        try {
+            stream = new lzma1_stream_1.Lzma1Stream((0, lzma1_stream_1.decodeProps)(head[4], dict), size, c => out.push(c.slice()), true);
+        }
+        catch (e) {
+            throw (0, coders_1.lzmaError)(e);
+        }
+        let fed = HEADER;
+        consumed.bytes = HEADER;
+        let rest = head.subarray(HEADER);
+        for (;;) {
+            for (let p = 0; p < rest.length; p += SLICE) {
+                const piece = rest.subarray(p, p + SLICE);
+                try {
+                    stream.write(piece);
+                }
+                catch (e) {
+                    throw (0, coders_1.lzmaError)(e);
+                }
+                fed += piece.length;
+                if (!stream.done)
+                    consumed.bytes = fed;
+                yield* out.splice(0);
+            }
+            const r = await it.next();
+            if (r.done)
+                break;
+            rest = r.value;
+        }
+        try {
+            stream.end();
+        }
+        catch (e) {
+            throw (0, coders_1.lzmaError)(e);
+        }
+        yield* out.splice(0);
+        consumed.bytes = HEADER + stream.consumed;
+    }
+    finally {
+        await it.return?.();
+    }
+}
+/** The engine's meter in the shape the xz reader counts through. */
+function counter(meter) {
+    let decoded = 0;
+    let compressed = 0;
+    return {
+        get decoded() {
+            return decoded;
+        },
+        get compressed() {
+            return compressed;
+        },
+        tick: () => meter.time(),
+        packed: n => {
+            compressed += n;
+        },
+        add: n => {
+            decoded += n;
+            meter.add(decoded, compressed);
+        },
+    };
+}
+/**
+ * Decodes a method 95 entry, which holds a whole xz file. The xz reader reads by offset, so the entry's compressed
+ * bytes go to memory or a temporary file first. A file that goes on past its streams, or that has notes the xz reader
+ * makes, such as bad padding, does not decode: an entry is one xz file and nothing else.
+ */
+async function* zipXz(chunks, consumed, meter, temp, threshold, limits) {
+    const spill = new io_1.SpillSink(temp, threshold);
+    try {
+        for await (const c of chunks) {
+            meter.time();
+            await spill.write(c);
+        }
+        await spill.close();
+        const source = spill.source();
+        try {
+            const info = { streams: 0, checks: [], notes: [] };
+            yield* (0, xz_1.readXz)({ reader: new io_1.Reader(source, spill.length), size: spill.length, limits, meter: counter(meter) }, info);
+            const end = info.trailingAt ?? spill.length;
+            consumed.bytes = end;
+            // Padding between streams and a stream with no check are well formed; the entry's CRC covers the data.
+            const faults = info.notes.filter(n => n.detail !== types_1.ArchiveDetail.StreamPadding && n.detail !== types_1.ArchiveDetail.NoCheck);
+            if (faults.length)
+                throw new errors_1.DataError(`the xz data is not well formed: ${faults.map(n => `${n.category}/${n.detail}`).join(', ')}`);
+        }
+        finally {
+            await source.close?.();
+        }
+    }
+    finally {
+        await spill.dispose();
+    }
+}

package/dist/zip-writer.d.ts

@@ -0,0 +1,51 @@
+import { type WriteContext, type WritePlan } from './model';
+import type { ByteSink } from './types';
+import type { ZipArchive, ZipEntry } from './zip';
+/** Extra field records that hold only times and owners. The rewrite keeps them unless metadata is stripped. */
+export declare const METADATA_EXTRAS: Set<number>;
+/** What the headers of one written entry say. */
+export interface Written {
+    name: Uint8Array;
+    flags: number;
+    method: number;
+    versionNeeded: number;
+    versionMadeBy: number;
+    externalAttr: number;
+    internalAttr: number;
+    time: number;
+    date: number;
+    crc: number;
+    compressedSize: number;
+    size: number;
+    extras: Uint8Array;
+    comment: Uint8Array;
+}
+/**
+ * Writes the entries of a ZIP archive one after another, then its central directory. 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 ZipOutput {
+    private readonly sink;
+    private offset;
+    private readonly central;
+    constructor(sink: ByteSink);
+    /** Writes bytes as they are, such as data kept before the archive. */
+    put(b: Uint8Array): Promise<void>;
+    /** Writes one entry: its local header, then `chunks`, which must hold exactly `info.compressedSize` bytes. */
+    entry(info: Written, chunks: () => AsyncIterable<Uint8Array>, label: string): Promise<void>;
+    /**
+     * Writes one entry whose sizes are known only once its data has gone out: a local header with the data descriptor
+     * flag and no CRC or sizes, then `chunks`, the compressed data, then a data descriptor with the CRC and the sizes.
+     * `totals` gives the CRC and size of the uncompressed data once `chunks` has ended. An entry of 4 GiB or more gets
+     * eight-byte sizes in its descriptor and a ZIP64 field in the central directory, as archiver writes one.
+     */
+    streamEntry(info: Written, chunks: AsyncIterable<Uint8Array>, totals: () => {
+        crc: number;
+        size: number;
+    }): Promise<void>;
+    /** Writes the central directory and the end records, with the archive's comment. */
+    end(comment: Uint8Array): Promise<void>;
+}
+/** Writes `zip` again with the entries `plan` keeps. */
+export declare function writeZip(zip: ZipArchive, plan: WritePlan<ZipEntry>, sink: ByteSink, context: WriteContext): Promise<void>;

package/dist/zip-writer.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipOutput = exports.METADATA_EXTRAS = void 0;
+exports.writeZip = writeZip;
+// Copied from office-defuse src/zip-writer.ts. Changed: an entry keeps its method, times, permissions, comment and the
+// extra fields the plan keeps, and either copies its compressed bytes without their encryption or is compressed again
+// from the content the plan gives. Data the plan keeps before and after the archive is written around it.
+const codecs_1 = require("./codecs");
+const crc32_1 = require("./crc32");
+const io_1 = require("./io");
+const model_1 = require("./model");
+/** Extra field records that hold only times and owners. The rewrite keeps them unless metadata is stripped. */
+exports.METADATA_EXTRAS = new Set([0x5455, 0x000a, 0x7875, 0x5855, 0x7855]);
+const MAX16 = 0xffff;
+const MAX32 = 0xffffffff;
+/** 1980-01-01 00:00, the earliest date a ZIP header holds, for entries whose times are stripped. */
+const DOS_DATE = (0 << 9) | (1 << 5) | 1;
+/** Unix file type bits, for the attributes of an entry that has permissions. */
+const TYPE_BITS = { file: 0o100000, directory: 0o040000, symlink: 0o120000 };
+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);
+    }
+}
+const versionFor = (method) => (method === 93 || method === 14 || method === 95 ? 63 : method === 12 ? 46 : method === 9 ? 21 : 20);
+/**
+ * Writes the entries of a ZIP archive one after another, then its central directory. 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 ZipOutput {
+    sink;
+    offset = 0;
+    central = [];
+    constructor(sink) {
+        this.sink = sink;
+    }
+    /** Writes bytes as they are, such as data kept before the archive. */
+    async put(b) {
+        await this.sink.write(b);
+        this.offset += b.length;
+    }
+    /** Writes one entry: its local header, then `chunks`, which must hold exactly `info.compressedSize` bytes. */
+    async entry(info, chunks, label) {
+        const big = info.size >= MAX32 || info.compressedSize >= MAX32;
+        const localOffset = this.offset;
+        const local = new Builder()
+            .u32(0x04034b50)
+            .u16(big ? Math.max(45, info.versionNeeded) : info.versionNeeded)
+            .u16(info.flags)
+            .u16(info.method)
+            .u16(info.time)
+            .u16(info.date)
+            .u32(info.crc)
+            .u32(big ? MAX32 : info.compressedSize)
+            .u32(big ? MAX32 : info.size)
+            .u16(info.name.length)
+            .u16(info.extras.length + (big ? 20 : 0))
+            .bytes(info.name);
+        if (big)
+            local.u16(0x0001).u16(16).u64(info.size).u64(info.compressedSize);
+        local.bytes(info.extras);
+        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 ${label} has ${written} compressed bytes, not ${info.compressedSize}`);
+        this.central.push(centralRecord(info, localOffset));
+    }
+    /**
+     * Writes one entry whose sizes are known only once its data has gone out: a local header with the data descriptor
+     * flag and no CRC or sizes, then `chunks`, the compressed data, then a data descriptor with the CRC and the sizes.
+     * `totals` gives the CRC and size of the uncompressed data once `chunks` has ended. An entry of 4 GiB or more gets
+     * eight-byte sizes in its descriptor and a ZIP64 field in the central directory, as archiver writes one.
+     */
+    async streamEntry(info, chunks, totals) {
+        const flags = info.flags | 0x0008;
+        const localOffset = this.offset;
+        const local = new Builder()
+            .u32(0x04034b50)
+            .u16(info.versionNeeded)
+            .u16(flags)
+            .u16(info.method)
+            .u16(info.time)
+            .u16(info.date)
+            .u32(0)
+            .u32(0)
+            .u32(0)
+            .u16(info.name.length)
+            .u16(info.extras.length)
+            .bytes(info.name)
+            .bytes(info.extras);
+        await this.put(local.build());
+        let compressedSize = 0;
+        for await (const c of chunks) {
+            compressedSize += c.length;
+            await this.put(c);
+        }
+        const { crc, size } = totals();
+        const descriptor = new Builder().u32(0x08074b50).u32(crc);
+        if (size >= MAX32 || compressedSize >= MAX32)
+            descriptor.u64(compressedSize).u64(size);
+        else
+            descriptor.u32(compressedSize).u32(size);
+        await this.put(descriptor.build());
+        this.central.push(centralRecord({ ...info, flags, crc, size, compressedSize }, localOffset));
+    }
+    /** Writes the central directory and the end records, with the archive's comment. */
+    async end(comment) {
+        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 = 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(comment.length)
+            .bytes(comment)
+            .build());
+    }
+}
+exports.ZipOutput = ZipOutput;
+/** The central directory record of an entry whose local header starts at `localOffset`. */
+function centralRecord(info, localOffset) {
+    const far = localOffset >= MAX32;
+    const z64 = new Builder();
+    if (info.size >= MAX32)
+        z64.u64(info.size);
+    if (info.compressedSize >= MAX32)
+        z64.u64(info.compressedSize);
+    if (far)
+        z64.u64(localOffset);
+    const z64Bytes = z64.build();
+    const needed = z64Bytes.length ? Math.max(45, info.versionNeeded) : info.versionNeeded;
+    const c = new Builder()
+        .u32(0x02014b50)
+        .u16(info.versionMadeBy)
+        .u16(needed)
+        .u16(info.flags)
+        .u16(info.method)
+        .u16(info.time)
+        .u16(info.date)
+        .u32(info.crc)
+        .u32(info.compressedSize >= MAX32 ? MAX32 : info.compressedSize)
+        .u32(info.size >= MAX32 ? MAX32 : info.size)
+        .u16(info.name.length)
+        .u16(info.extras.length + (z64Bytes.length ? z64Bytes.length + 4 : 0))
+        .u16(info.comment.length)
+        .u16(0)
+        .u16(info.internalAttr)
+        .u32(info.externalAttr)
+        .u32(far ? MAX32 : localOffset)
+        .bytes(info.name);
+    if (z64Bytes.length)
+        c.u16(0x0001).u16(z64Bytes.length).bytes(z64Bytes);
+    c.bytes(info.extras).bytes(info.comment);
+    return c.build();
+}
+/** Writes `zip` again with the entries `plan` keeps. */
+async function writeZip(zip, plan, sink, context) {
+    const out = new ZipOutput(sink);
+    if (plan.keepLeading)
+        for await (const c of zip.leading())
+            await out.put(c);
+    for (const k of plan.kept) {
+        context.meter().time();
+        const p = await prepare(zip, k, plan, context);
+        try {
+            await out.entry(p.info, p.chunks, k.name);
+        }
+        finally {
+            await p.spill?.dispose();
+        }
+    }
+    await out.end(plan.stripMetadata ? new Uint8Array(0) : zip.commentBytes);
+    if (plan.keepTrailing)
+        for await (const c of zip.trailing())
+            await out.put(c);
+}
+/**
+ * An extended timestamp record with its flags naming only the times it holds. The rewrite writes the central
+ * directory's record, which may hold the modification time alone, into the local header too, where the flags have to
+ * match the times that follow.
+ */
+function timestampFlags(data) {
+    let count = (data.length - 1) / 4;
+    let flags = 0;
+    for (let bit = 1; bit <= 4 && count > 0; bit <<= 1) {
+        if (data[0] & bit) {
+            flags |= bit;
+            count--;
+        }
+    }
+    if (flags === data[0])
+        return data;
+    const out = Uint8Array.from(data);
+    out[0] = flags;
+    return out;
+}
+/** The headers and data of one kept entry: its own compressed bytes without their encryption, or its content compressed again. */
+async function prepare(zip, k, plan, context) {
+    const e = k.entry;
+    const isDir = e.kind === 'directory';
+    const name = Buffer.from(isDir && !k.name.endsWith('/') ? `${k.name}/` : k.name, 'utf8');
+    const comment = plan.stripMetadata || !e.comment ? Buffer.alloc(0) : Buffer.from(e.comment, 'utf8');
+    const flags = /^[\x20-\x7e]*$/.test(k.name) && /^[\x20-\x7e]*$/.test(e.comment && !plan.stripMetadata ? e.comment : '') ? 0 : 0x0800;
+    const extras = Buffer.concat(e.extras
+        .filter(r => (exports.METADATA_EXTRAS.has(r.id) ? !plan.stripMetadata && (!r.malformed || plan.keepExtraFields) : plan.keepExtraFields))
+        .map(r => new Builder()
+        .u16(r.id)
+        .u16(r.data.length)
+        .bytes(r.id === 0x5455 && !r.malformed ? timestampFlags(r.data) : r.data)
+        .build()));
+    const unix = k.mode !== undefined;
+    const typeBits = TYPE_BITS[e.kind] ?? 0;
+    const info = {
+        name,
+        flags,
+        method: 0,
+        versionNeeded: 20,
+        versionMadeBy: unix ? (3 << 8) | 30 : 20,
+        externalAttr: unix ? (((typeBits | (k.mode ?? 0)) << 16) >>> 0) | (isDir ? 0x10 : 0) : (e.externalAttr & 0xff & ~0x10) | (isDir ? 0x10 : 0),
+        internalAttr: e.internalAttr,
+        time: plan.stripMetadata ? 0 : e.dosTime,
+        date: plan.stripMetadata ? DOS_DATE : e.dosDate,
+        crc: 0,
+        compressedSize: 0,
+        size: 0,
+        extras,
+        comment,
+    };
+    if (isDir)
+        return { info, chunks: model_1.nothing };
+    if (!k.replacement && !k.recompress) {
+        // The compressed bytes are copied, without any encryption they had.
+        info.method = e.methodCode;
+        info.versionNeeded = versionFor(e.methodCode);
+        info.crc = k.crc ?? e.crc;
+        info.size = e.size;
+        info.compressedSize = zip.plainLength(e);
+        return { info, chunks: () => zip.plain(e, k.password) };
+    }
+    // Compressed again: deflate, or stored when deflate gains nothing or would pass the run's ratio limit.
+    const size = (0, model_1.sizeOf)(k);
+    let crc = 0;
+    async function* withCrc(chunks) {
+        for await (const c of chunks) {
+            context.meter().time();
+            crc = (0, crc32_1.crc32)(c, crc);
+            yield c;
+        }
+    }
+    const spill = new io_1.SpillSink(context.temp, context.threshold);
+    try {
+        for await (const c of (0, codecs_1.deflateRaw)(withCrc((0, model_1.contentOf)(zip, k, context))))
+            await spill.write(c);
+        await spill.close();
+    }
+    catch (err) {
+        await spill.dispose();
+        throw err;
+    }
+    info.crc = crc;
+    info.size = size;
+    const passesRatio = size <= 1024 * 1024 || size <= spill.length * plan.ratioLimit;
+    if (size > 0 && spill.length < size && passesRatio) {
+        info.method = 8;
+        info.compressedSize = spill.length;
+        return { info, chunks: () => spill.read(), spill };
+    }
+    await spill.dispose();
+    info.compressedSize = size;
+    return { info, chunks: () => (0, model_1.contentOf)(zip, k, context) };
+}

package/dist/zip.d.ts

@@ -0,0 +1,99 @@
+import type { TempDir } from './io';
+import type { Limits } from './stream-meter';
+import { Reader } from './io';
+import type { Archive, Entry, Meter, Note, WriteContext, WritePlan } from './model';
+import { type ByteSink, type ByteSource } from './types';
+export interface ZipLimits {
+    entries: number;
+    decompressedBytes: number;
+    totalDecompressedBytes: number;
+    compressionRatio: number;
+}
+/** One record of an extra field. */
+export interface ExtraRecord {
+    id: number;
+    data: Uint8Array;
+    /** A times or owners record that does not have its documented layout. */
+    malformed?: boolean;
+}
+export interface ZipEntry extends Entry {
+    rawName: Uint8Array;
+    flags: number;
+    /** The method field of the headers: 99 for AES. */
+    storedMethod: number;
+    /** The method the data is compressed with, inside any encryption. */
+    methodCode: number;
+    versionMadeBy: number;
+    externalAttr: number;
+    internalAttr: number;
+    dosTime: number;
+    dosDate: number;
+    crc: number;
+    localOffset: number;
+    dataOffset: number;
+    /** Where the entry ends, after any data descriptor. */
+    end: number;
+    /** Central directory extra records, apart from the ones the rewrite replaces. */
+    extras: ExtraRecord[];
+    /** The entry's comment as stored. */
+    commentBytes: Uint8Array;
+    /** WinZip AES: 1 for AE-1, which keeps the CRC, 2 for AE-2, which does not. */
+    aesVersion?: number;
+    aesStrength?: number;
+}
+/**
+ * A ZIP archive read from its central directory, with every local header checked against it. Reading an entry
+ * decrypts and decodes it in chunks and checks its size and CRC.
+ */
+export declare class ZipArchive implements Archive<ZipEntry> {
+    readonly reader: Reader;
+    readonly entries: ZipEntry[];
+    readonly notes: Note[];
+    /** Where the archive starts in the file: the first local header, or the directory when there is none. */
+    readonly start: number;
+    /** Where the archive ends: after the end record's comment. */
+    readonly end: number;
+    readonly commentBytes: Uint8Array;
+    /** Where the other end records that lead to a directory sit, which an entry's data can hold. */
+    readonly rivals: number[];
+    readonly format = "zip";
+    readonly single = false;
+    readonly lateNotes: Note[];
+    comment?: string;
+    private constructor();
+    /** What LZMA and XZ entries need from the run: its limits, and a temporary folder for an XZ entry's bytes. */
+    decoders?: {
+        temp: TempDir;
+        threshold: number;
+        limits: Limits;
+    };
+    static open(source: ByteSource, limits: ZipLimits, deadline?: number): Promise<ZipArchive>;
+    /** One entry from its central directory header. */
+    private static central;
+    /** The encryption an entry uses, from its flags and its AES field, which also gives the method inside. */
+    private static encryption;
+    /** 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;
+    /** Bytes before the first entry, bytes between entries and the directory that belong to none, and entries that share bytes. */
+    private static coverage;
+    hasMetadata(): boolean;
+    /** Reads a symbolic link's target, which a ZIP stores as the entry's content. */
+    linkTarget(e: ZipEntry, meter: Meter): Promise<string | undefined>;
+    /** The stored bytes of an entry. */
+    raw(e: ZipEntry): AsyncGenerator<Uint8Array>;
+    /** The bytes before the archive and after it. */
+    leading(): AsyncGenerator<Uint8Array>;
+    trailing(): AsyncGenerator<Uint8Array>;
+    /** The 12-byte ZipCrypto header's check byte: the CRC's high byte, or the time's with a data descriptor. */
+    private checkByte;
+    unlock(e: ZipEntry, password: string): Promise<boolean>;
+    /** The entry's compressed bytes without their encryption, for a rewrite that copies them. Their length comes from `plainLength`. */
+    plain(e: ZipEntry, password?: string): AsyncGenerator<Uint8Array>;
+    /** The length of what plain() yields. */
+    plainLength(e: ZipEntry): number;
+    /** The entry's content in chunks. Its size, its CRC unless AE-2 leaves it out, and the compressed bytes used must all agree with the central directory. */
+    read(e: ZipEntry, meter: Meter, password?: string): AsyncGenerator<Uint8Array>;
+    write(plan: WritePlan<ZipEntry>, sink: ByteSink, context: WriteContext): Promise<void>;
+}
+/** True when the file ends in what may be a ZIP archive: an end record signature in the last 64 KiB. */
+export declare function hasZipEnd(source: ByteSource): Promise<boolean>;