rn-update-cli 1.0.0

package/lib/utils/zip-range.js

@@ -0,0 +1,581 @@
+"use strict";
+/**
+ * [INPUT]: 依赖 HTTP Range/If-Range 响应、ZIP 中央目录、流与 ZIP 条目读取器
+ * [OUTPUT]: 对外提供远程 ZIP 定位、范围读取、缓存读取器和协议错误类型
+ * [POS]: CLI 远程制品按需读取底座，减少 Hermes base 与 bundle 获取的网络/磁盘开销
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRangeReader = exports.RangeUnsupportedError = exports.ZIP_DEFLATED = exports.ZIP_STORED = void 0;
+exports.locateZipEntry = locateZipEntry;
+exports.readZipEntryWithLocation = readZipEntryWithLocation;
+exports.bundleLocationFields = bundleLocationFields;
+exports.parseContentRange = parseContentRange;
+exports.rangeValidator = rangeValidator;
+exports.fetchZipEntryData = fetchZipEntryData;
+exports.parseEndOfCentralDirectory = parseEndOfCentralDirectory;
+exports.openRemoteZip = openRemoteZip;
+exports.readRemoteZipEntry = readRemoteZipEntry;
+// Byte-range access to zip archives.
+//
+// Two halves of the same trick: at publish time `locateZipEntry` records where
+// the bundle's compressed bytes sit inside the ppk (so the server can hand
+// that location to the next build), and at build time `fetchZipEntryData` /
+// `openRemoteZip` read just the bundle of a remote archive through HTTP Range
+// requests instead of downloading the whole ppk / apk / ipa. Every helper
+// throws on anything unexpected; callers fall back to a full download.
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const stream_1 = require("stream");
+const yauzl_1 = require("yauzl");
+const zlib_1 = require("zlib");
+const runtime_1 = require("./runtime");
+const zip_entries_1 = require("./zip-entries");
+exports.ZIP_STORED = 0;
+exports.ZIP_DEFLATED = 8;
+const LOCAL_HEADER_SIGNATURE = 0x04034b50;
+const LOCAL_HEADER_SIZE = 30;
+/**
+ * Exactly what yauzl reads to find the EOCD (22 + 65535 comment + 20 zip64
+ * locator), so its first read is a cache hit; small archives fit entirely.
+ */
+const TAIL_BYTES = 22 + 0xffff + 20;
+/** minimum span fetched for header reads, so header + directory share a request */
+const CHUNK_BYTES = 64 * 1024;
+/** extra bytes past a hinted entry, covering a longer local extra field */
+const HINT_SLACK_BYTES = 4 * 1024;
+/** Data location of the first entry matching `matches` in a local zip. */
+async function locateZipEntry(zipPath, matches) {
+    const found = await openFirstEntry(zipPath, matches);
+    if (!found)
+        return null;
+    found.zipFile.close();
+    return locationOfEntry(zipPath, found.entry);
+}
+/**
+ * Content and data location of the first matching entry in one pass over the
+ * archive (publish needs both: the bundle to hash and cache, its location to
+ * report to the server).
+ */
+async function readZipEntryWithLocation(zipPath, matches) {
+    const found = await openFirstEntry(zipPath, matches);
+    if (!found)
+        return null;
+    let data;
+    try {
+        data = await (0, zip_entries_1.readEntry)(found.entry, found.zipFile);
+    }
+    finally {
+        found.zipFile.close();
+    }
+    return { data, location: await locationOfEntry(zipPath, found.entry) };
+}
+async function locationOfEntry(zipPath, entry) {
+    const header = Buffer.alloc(LOCAL_HEADER_SIZE);
+    const fd = await fs_extra_1.default.open(zipPath, 'r');
+    try {
+        const { bytesRead } = await fs_extra_1.default.read(fd, header, 0, LOCAL_HEADER_SIZE, entry.relativeOffsetOfLocalHeader);
+        if (bytesRead !== LOCAL_HEADER_SIZE) {
+            throw new Error('truncated local file header');
+        }
+    }
+    finally {
+        await fs_extra_1.default.close(fd);
+    }
+    if (header.readUInt32LE(0) !== LOCAL_HEADER_SIGNATURE) {
+        throw new Error('invalid local file header signature');
+    }
+    const fileNameLength = header.readUInt16LE(26);
+    const extraFieldLength = header.readUInt16LE(28);
+    return {
+        fileName: entry.fileName,
+        dataOffset: entry.relativeOffsetOfLocalHeader +
+            LOCAL_HEADER_SIZE +
+            fileNameLength +
+            extraFieldLength,
+        compressedSize: entry.compressedSize,
+        uncompressedSize: entry.uncompressedSize,
+        compressionMethod: entry.compressionMethod,
+    };
+}
+/** Open a local zip and stop at the first matching entry (caller closes). */
+function openFirstEntry(zipPath, matches) {
+    return new Promise((resolve, reject) => {
+        (0, yauzl_1.open)(zipPath, { lazyEntries: true, autoClose: false }, (err, zipFile) => {
+            if (err)
+                return reject(err);
+            let settled = false;
+            zipFile.on('error', (error) => {
+                if (!settled) {
+                    settled = true;
+                    reject(error);
+                }
+            });
+            zipFile.on('end', () => {
+                if (!settled) {
+                    settled = true;
+                    zipFile.close();
+                    resolve(null);
+                }
+            });
+            zipFile.on('entry', (entry) => {
+                if (settled)
+                    return;
+                if (matches(entry.fileName)) {
+                    settled = true;
+                    resolve({ zipFile, entry });
+                    return;
+                }
+                zipFile.readEntry();
+            });
+            zipFile.readEntry();
+        });
+    });
+}
+/**
+ * The `bundleOffset` / `bundleCompressedSize` / `bundleCompression` fields for
+ * version/create and package/create, or nothing when the entry cannot be
+ * fetched by a single Range request (unknown, empty or exotic compression).
+ */
+function bundleLocationFields(location) {
+    if (!location ||
+        location.compressedSize <= 0 ||
+        (location.compressionMethod !== exports.ZIP_STORED &&
+            location.compressionMethod !== exports.ZIP_DEFLATED)) {
+        return {};
+    }
+    return {
+        bundleOffset: location.dataOffset,
+        bundleCompressedSize: location.compressedSize,
+        bundleCompression: location.compressionMethod,
+    };
+}
+const DEFAULT_HEADER_TIMEOUT_MS = 20_000;
+const DEFAULT_DATA_TIMEOUT_MS = 30_000;
+const DEFAULT_DATA_TIMEOUT_PER_MB_MS = 1_000;
+/** deadline for a request of `bytes`: flat for header-sized reads, scaled otherwise */
+function timeoutFor(bytes, options) {
+    if (bytes <= CHUNK_BYTES) {
+        return options.headerTimeoutMs ?? DEFAULT_HEADER_TIMEOUT_MS;
+    }
+    return ((options.dataTimeoutMs ?? DEFAULT_DATA_TIMEOUT_MS) +
+        ((options.dataTimeoutPerMbMs ?? DEFAULT_DATA_TIMEOUT_PER_MB_MS) * bytes) /
+            (1024 * 1024));
+}
+/** The server answered a Range request with the whole body (HTTP 200). */
+class RangeUnsupportedError extends Error {
+    response;
+    constructor(response) {
+        super(`HTTP ${response.status} without Content-Range`);
+        this.response = response;
+        this.name = 'RangeUnsupportedError';
+    }
+}
+exports.RangeUnsupportedError = RangeUnsupportedError;
+function parseContentRange(header) {
+    const match = /^bytes\s+(\d+)-(\d+)\/(\d+)$/i.exec(header?.trim() ?? '');
+    if (!match)
+        return null;
+    const [start, end, total] = match.slice(1).map(Number);
+    if (end < start || end >= total)
+        return null;
+    return { start, end, total };
+}
+/**
+ * The validator to send as `If-Range` on later requests for the same object,
+ * so a replaced archive answers 200 (handled like a server without Range)
+ * instead of mixing bytes of two versions. Weak ETags are not allowed there.
+ */
+function rangeValidator(headers) {
+    const etag = headers.get('etag')?.trim();
+    if (etag && !/^W\//i.test(etag))
+        return etag;
+    return headers.get('last-modified')?.trim() || undefined;
+}
+/** An aborted fetch as a plain Error (never mistaken for a 200 answer). */
+function describeAbort(error, what, timeoutMs) {
+    const name = error?.name;
+    if (name === 'TimeoutError' || name === 'AbortError') {
+        return new Error(`timed out after ${timeoutMs} ms fetching ${what}`);
+    }
+    return error instanceof Error ? error : new Error(String(error));
+}
+/** One Range request; `end` is exclusive. Resolves with a 206 response. */
+async function fetchRange(url, start, end, options) {
+    const what = `bytes=${start}-${end - 1}`;
+    const headers = {
+        Range: what,
+        'Accept-Encoding': 'identity',
+    };
+    if (options.ifRange)
+        headers['If-Range'] = options.ifRange;
+    let response;
+    try {
+        response = await (0, runtime_1.webFetch)(url, {
+            headers,
+            signal: AbortSignal.timeout(options.timeoutMs),
+        });
+    }
+    catch (error) {
+        throw describeAbort(error, what, options.timeoutMs);
+    }
+    if (response.status === 200)
+        throw new RangeUnsupportedError(response);
+    if (response.status !== 206 || !response.body) {
+        await response.body?.cancel().catch(() => { });
+        throw new Error(`HTTP ${response.status} for ${what}`);
+    }
+    const range = parseContentRange(response.headers.get('content-range'));
+    if (!range || range.start !== start || range.end !== end - 1) {
+        await response.body.cancel().catch(() => { });
+        throw new Error(`unexpected Content-Range ${response.headers.get('content-range')}`);
+    }
+    if (options.expectTotal !== undefined &&
+        range.total !== options.expectTotal) {
+        await response.body.cancel().catch(() => { });
+        throw new Error(`archive size changed: ${range.total} bytes, expected ${options.expectTotal}`);
+    }
+    return Object.assign(response, { range });
+}
+async function fetchRangeBuffer(url, start, end, options) {
+    const response = await fetchRange(url, start, end, options);
+    let data;
+    try {
+        // Buffer.from(ArrayBuffer) is a view: the body is held exactly once
+        data = Buffer.from(await response.arrayBuffer());
+    }
+    catch (error) {
+        throw describeAbort(error, `bytes=${start}-${end - 1}`, options.timeoutMs);
+    }
+    if (data.length !== end - start) {
+        throw new Error(`range returned ${data.length} bytes, expected ${end - start}`);
+    }
+    return { data, total: response.range.total };
+}
+/**
+ * Fetch one entry whose compressed bytes are already located (the ppk's own
+ * publish-time report) and decompress it. Returns the raw entry content.
+ */
+async function fetchZipEntryData(url, location, options = {}) {
+    const { dataOffset, compressedSize, compressionMethod } = location;
+    if (compressionMethod !== exports.ZIP_STORED && compressionMethod !== exports.ZIP_DEFLATED) {
+        throw new Error(`unsupported compression method ${compressionMethod}`);
+    }
+    if (!Number.isInteger(dataOffset) ||
+        !Number.isInteger(compressedSize) ||
+        dataOffset < 0 ||
+        compressedSize <= 0) {
+        throw new Error('invalid bundle location');
+    }
+    const { data, total } = await fetchRangeBuffer(url, dataOffset, dataOffset + compressedSize, { timeoutMs: timeoutFor(compressedSize, options) });
+    return {
+        data: compressionMethod === exports.ZIP_DEFLATED ? (0, zlib_1.inflateRawSync)(data) : data,
+        fetchedBytes: compressedSize,
+        totalBytes: total,
+    };
+}
+/**
+ * yauzl reader over HTTP Range. Header reads (EOCD, central directory, local
+ * file headers) are widened to CHUNK_BYTES and cached. Chunks are kept as
+ * fetched — only overlapping ones are merged, touching ones are read across —
+ * so an entry's bytes are held once, and a read reuses whatever prefix the
+ * cache holds (typically the bytes following the local file header) before
+ * requesting the rest. Every request after the first carries If-Range and
+ * must report the same archive size.
+ */
+class HttpRangeReader extends yauzl_1.RandomAccessReader {
+    url;
+    totalSize;
+    options;
+    /** sorted by `start`, never overlapping */
+    chunks = [];
+    /** span a header read inside it should widen to (see `hintEntry`) */
+    hint = null;
+    requests = 0;
+    fetchedBytes = 0;
+    constructor(url, totalSize, tail, options = {}) {
+        super();
+        this.url = url;
+        this.totalSize = totalSize;
+        this.options = options;
+        if (tail)
+            this.addChunk(tail.start, tail.data);
+    }
+    /**
+     * The next entry to be read: yauzl first reads its local file header, and
+     * widening that read to the entry's data makes the data stream a cache hit
+     * — one request for header + bundle instead of two. The central directory
+     * may understate the local header's extra field, hence the slack.
+     */
+    hintEntry(entry) {
+        const start = entry.relativeOffsetOfLocalHeader;
+        const end = start +
+            LOCAL_HEADER_SIZE +
+            entry.fileNameLength +
+            entry.extraFieldLength +
+            entry.compressedSize +
+            HINT_SLACK_BYTES;
+        this.hint = { start, end: Math.min(end, this.totalSize) };
+    }
+    /** Cache `data` at `start`, merging with any chunk it overlaps. */
+    addChunk(start, data) {
+        if (data.length === 0)
+            return;
+        let lo = start;
+        let hi = start + data.length;
+        const pieces = [{ start, data }];
+        const rest = [];
+        for (const chunk of this.chunks) {
+            const chunkEnd = chunk.start + chunk.data.length;
+            if (chunk.start < hi && chunkEnd > lo) {
+                pieces.push(chunk);
+                lo = Math.min(lo, chunk.start);
+                hi = Math.max(hi, chunkEnd);
+            }
+            else {
+                rest.push(chunk);
+            }
+        }
+        if (pieces.length === 1) {
+            rest.push(pieces[0]);
+        }
+        else {
+            const merged = Buffer.alloc(hi - lo);
+            // the new data is written last so it wins over stale overlaps
+            for (const piece of pieces.reverse()) {
+                piece.data.copy(merged, piece.start - lo);
+            }
+            rest.push({ start: lo, data: merged });
+        }
+        rest.sort((a, b) => a.start - b.start);
+        this.chunks = rest;
+    }
+    /** Fetch `[start, end)` into the cache in one request. */
+    async prefetch(start, end) {
+        this.addChunk(start, await this.fetchBuffer(start, end));
+    }
+    requestOptions(bytes) {
+        return {
+            timeoutMs: timeoutFor(bytes, this.options),
+            ifRange: this.options.ifRange,
+            expectTotal: this.totalSize,
+        };
+    }
+    async fetchBuffer(start, end) {
+        this.requests++;
+        const { data } = await fetchRangeBuffer(this.url, start, end, this.requestOptions(end - start));
+        this.fetchedBytes += data.length;
+        return data;
+    }
+    /**
+     * Contiguous cached pieces starting exactly at `start`, up to `end`: views
+     * into one chunk or into a run of touching chunks, possibly ending short.
+     */
+    cachedPieces(start, end) {
+        const pieces = [];
+        let at = start;
+        for (const chunk of this.chunks) {
+            const chunkEnd = chunk.start + chunk.data.length;
+            if (chunkEnd <= at)
+                continue;
+            if (chunk.start > at)
+                break;
+            const stop = Math.min(end, chunkEnd);
+            pieces.push(chunk.data.subarray(at - chunk.start, stop - chunk.start));
+            at = stop;
+            if (at >= end)
+                break;
+        }
+        return pieces;
+    }
+    /** start of the cached run (touching chunks) holding byte `end - 1` */
+    cachedSuffixStart(end) {
+        let i = this.chunks.findIndex((c) => end - 1 >= c.start && end - 1 < c.start + c.data.length);
+        if (i < 0)
+            return null;
+        while (i > 0 &&
+            this.chunks[i - 1].start + this.chunks[i - 1].data.length ===
+                this.chunks[i].start) {
+            i--;
+        }
+        return this.chunks[i].start;
+    }
+    /** start of the first cached chunk at or after `position` */
+    nextCachedStart(position) {
+        const chunk = this.chunks.find((c) => c.start >= position);
+        return chunk ? chunk.start : null;
+    }
+    _readStreamForRange(start, end) {
+        const pieces = this.cachedPieces(start, end);
+        const have = pieces.reduce((sum, piece) => sum + piece.length, 0);
+        if (have === end - start)
+            return stream_1.Readable.from(pieces);
+        const out = new stream_1.PassThrough();
+        for (const piece of pieces)
+            out.write(piece);
+        const from = start + have;
+        const options = this.requestOptions(end - from);
+        this.requests++;
+        fetchRange(this.url, from, end, options)
+            .then((response) => {
+            this.fetchedBytes += end - from;
+            const body = stream_1.Readable.fromWeb(response.body);
+            body.on('error', (error) => out.destroy(describeAbort(error, `bytes=${from}-${end - 1}`, options.timeoutMs)));
+            body.pipe(out);
+        })
+            .catch((error) => out.destroy(error));
+        return out;
+    }
+    read(buffer, offset, length, position, callback) {
+        const requestEnd = position + length;
+        const copyOut = (pieces) => {
+            let at = offset;
+            for (const piece of pieces) {
+                piece.copy(buffer, at);
+                at += piece.length;
+            }
+            return at - offset === length;
+        };
+        const cached = this.cachedPieces(position, requestEnd);
+        if (copyOut(cached)) {
+            setImmediate(() => callback(null, length));
+            return;
+        }
+        // fetch only what the cache lacks: skip the cached prefix, stop at a
+        // cached suffix (yauzl's EOCD read may just exceed the tail), and
+        // otherwise widen so the next header read is free — to exactly the hinted
+        // entry when the hint covers this read, else by CHUNK_BYTES — but never
+        // into bytes already cached beyond the request
+        const from = position + cached.reduce((sum, piece) => sum + piece.length, 0);
+        const suffixStart = this.cachedSuffixStart(requestEnd);
+        let end;
+        if (suffixStart !== null && suffixStart > from) {
+            end = suffixStart;
+        }
+        else {
+            const hinted = this.hint !== null &&
+                position >= this.hint.start &&
+                requestEnd <= this.hint.end;
+            end = hinted
+                ? this.hint.end
+                : Math.max(requestEnd, from + CHUNK_BYTES);
+            end = Math.min(end, this.totalSize);
+            const next = this.nextCachedStart(requestEnd);
+            if (next !== null && next < end)
+                end = next;
+        }
+        this.fetchBuffer(from, end).then((data) => {
+            this.addChunk(from, data);
+            if (!copyOut(this.cachedPieces(position, requestEnd))) {
+                callback(new Error('range read did not cover the requested bytes'));
+                return;
+            }
+            callback(null, length);
+        }, (error) => callback(error));
+    }
+}
+exports.HttpRangeReader = HttpRangeReader;
+/** End-of-central-directory record: where the central directory lives. */
+const EOCD_SIGNATURE = 0x06054b50;
+const EOCD_SIZE = 22;
+function parseEndOfCentralDirectory(tail) {
+    for (let i = tail.length - EOCD_SIZE; i >= 0; i--) {
+        if (tail.readUInt32LE(i) !== EOCD_SIGNATURE)
+            continue;
+        const commentLength = tail.readUInt16LE(i + 20);
+        if (i + EOCD_SIZE + commentLength !== tail.length)
+            continue;
+        const cdSize = tail.readUInt32LE(i + 12);
+        const cdOffset = tail.readUInt32LE(i + 16);
+        // zip64 markers: let yauzl resolve the real values itself
+        if (cdSize === 0xffffffff || cdOffset === 0xffffffff)
+            return null;
+        return { cdOffset, cdSize };
+    }
+    return null;
+}
+/**
+ * Open a remote zip by fetching its tail (EOCD + central directory for
+ * typical archives) and letting yauzl read the rest on demand.
+ */
+async function openRemoteZip(url, options = {}) {
+    const timeoutMs = timeoutFor(TAIL_BYTES, options);
+    let response;
+    try {
+        response = await (0, runtime_1.webFetch)(url, {
+            headers: { Range: `bytes=-${TAIL_BYTES}`, 'Accept-Encoding': 'identity' },
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+    }
+    catch (error) {
+        throw describeAbort(error, `bytes=-${TAIL_BYTES}`, timeoutMs);
+    }
+    if (!response.ok || !response.body) {
+        await response.body?.cancel().catch(() => { });
+        throw new Error(`HTTP ${response.status}`);
+    }
+    if (response.status !== 206)
+        return { kind: 'full', response };
+    const range = parseContentRange(response.headers.get('content-range'));
+    if (!range) {
+        await response.body.cancel().catch(() => { });
+        throw new Error(`unexpected Content-Range ${response.headers.get('content-range')}`);
+    }
+    let data;
+    try {
+        data = Buffer.from(await response.arrayBuffer());
+    }
+    catch (error) {
+        throw describeAbort(error, `bytes=-${TAIL_BYTES}`, timeoutMs);
+    }
+    if (data.length !== range.end - range.start + 1) {
+        throw new Error(`tail returned ${data.length} bytes, expected ${range.end - range.start + 1}`);
+    }
+    const reader = new HttpRangeReader(url, range.total, { start: range.start, data }, { ...options, ifRange: rangeValidator(response.headers) });
+    reader.requests = 1;
+    reader.fetchedBytes = data.length;
+    // Large archives (apk / ipa with thousands of files) keep their central
+    // directory well before the tail; yauzl would otherwise page it in with one
+    // sequential request per CHUNK_BYTES. Fetch the missing part at once — one
+    // buffer of exactly its size — as long as the EOCD describes a directory
+    // that ends inside the tail (a corrupt record could claim the whole file).
+    const eocd = parseEndOfCentralDirectory(data);
+    if (eocd &&
+        eocd.cdOffset < range.start &&
+        eocd.cdOffset + eocd.cdSize >= range.start &&
+        eocd.cdOffset + eocd.cdSize <= range.total - EOCD_SIZE) {
+        await reader.prefetch(eocd.cdOffset, range.start);
+    }
+    const zipFile = await new Promise((resolve, reject) => {
+        (0, yauzl_1.fromRandomAccessReader)(reader, range.total, { lazyEntries: true, autoClose: false }, (err, file) => (err ? reject(err) : resolve(file)));
+    });
+    return { kind: 'zip', zipFile, reader };
+}
+/**
+ * Read the first matching entry of an opened remote zip, then close it. With
+ * `reader` given, the entry's header and data are fetched in one request.
+ */
+function readRemoteZipEntry(zipFile, matches, reader) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (error, result = null) => {
+            if (settled)
+                return;
+            settled = true;
+            zipFile.close();
+            error ? reject(error) : resolve(result);
+        };
+        zipFile.on('error', (error) => finish(error));
+        zipFile.on('end', () => finish(null, null));
+        zipFile.on('entry', (entry) => {
+            if (!matches(entry.fileName)) {
+                zipFile.readEntry();
+                return;
+            }
+            reader?.hintEntry(entry);
+            (0, zip_entries_1.readEntry)(entry, zipFile).then((data) => finish(null, data), (error) => finish(error));
+        });
+        zipFile.readEntry();
+    });
+}

package/lib/utils/zip-raw-writer.d.ts

@@ -0,0 +1,52 @@
+/**
+ * [INPUT]: 依赖源 ZIP 中央目录、可读流、CRC/尺寸元数据与文件系统
+ * [OUTPUT]: 对外提供 RawZipEntry、fitsRawZip、crc32Update 与 RawZipWriter
+ * [POS]: CLI 归档快速重打包底座，原样复制已压缩条目，避免资源二次压缩
+ */
+import type { Readable } from 'stream';
+import type { Entry } from 'yauzl';
+export interface RawZipEntry {
+    fileName: string;
+    compressionMethod: number;
+    crc32: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    lastModFileTime: number;
+    lastModFileDate: number;
+    generalPurposeBitFlag?: number;
+    versionMadeBy?: number;
+    versionNeededToExtract?: number;
+    internalFileAttributes?: number;
+    externalFileAttributes?: number;
+}
+/**
+ * Whether an archive of `sourceSize` bytes with `entryCount` entries can be
+ * (partially) copied without zip64 structures: an output that only keeps a
+ * subset of the entries is never larger than its source.
+ */
+export declare function fitsRawZip(sourceSize: number, entryCount: number): boolean;
+/** CRC-32 (IEEE) continued from `seed` (the running value, not inverted) */
+export declare function crc32Update(seed: number, chunk: Buffer): number;
+export declare class RawZipWriter {
+    readonly output: string;
+    private readonly out;
+    private readonly central;
+    private offset;
+    private count;
+    private failure;
+    private readonly closed;
+    constructor(output: string);
+    /** Copy one entry with its file data exactly as stored in the source. */
+    addRawEntry(meta: RawZipEntry, data: Readable): Promise<void>;
+    /**
+     * Add a local file uncompressed (its CRC is computed in a first pass).
+     * `like` lends its timestamp and attributes, e.g. the archive entry this
+     * file replaces.
+     */
+    addStoredFile(filePath: string, fileName: string, like?: Pick<Entry, 'lastModFileTime' | 'lastModFileDate' | 'externalFileAttributes' | 'versionMadeBy'>): Promise<void>;
+    /** Write the central directory and close the file. */
+    end(): Promise<void>;
+    /** Stop writing and remove the partial output. */
+    abort(): Promise<void>;
+    private write;
+}