zapo-js 0.2.0 → 1.0.0

package/dist/media/crypto/WaMediaCrypto.js

@@ -0,0 +1,378 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaMediaCrypto = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_stream_1 = require("node:stream");
+const hkdf_1 = require("../../crypto/core/hkdf");
+const primitives_1 = require("../../crypto/core/primitives");
+const random_1 = require("../../crypto/core/random");
+const constants_1 = require("../constants");
+const constants_2 = require("../../protocol/constants");
+const bytes_1 = require("../../util/bytes");
+const primitives_2 = require("../../util/primitives");
+const AES_BLOCK_SIZE = 16;
+function computeFirstFrameSidecar(macKey, iv, ciphertext, firstFrameLength) {
+    const aligned = Math.ceil(firstFrameLength / AES_BLOCK_SIZE) * AES_BLOCK_SIZE;
+    const digest = (0, primitives_1.hmacSha256Sign)(macKey, [iv, ciphertext.subarray(0, aligned)]);
+    return digest.subarray(0, constants_1.SIDECAR_HMAC_SIZE);
+}
+class SidecarAccumulator {
+    constructor(macKey, estimatedSize = 0) {
+        this.resultOffset = 0;
+        this.totalPushed = 0;
+        this.windowOffset = 0;
+        this.nextChunkStart = 0;
+        this.macKey = macKey;
+        this.window = new Uint8Array(constants_1.IV_SIZE + constants_1.SIDECAR_CHUNK_SIZE);
+        const safeEstimate = Number.isFinite(estimatedSize) && estimatedSize > 0 ? estimatedSize : 0;
+        const estimated = Math.max(Math.ceil(safeEstimate / constants_1.SIDECAR_CHUNK_SIZE) + 1, 16);
+        this.result = new Uint8Array(estimated * constants_1.SIDECAR_HMAC_SIZE);
+    }
+    push(data) {
+        let srcOffset = 0;
+        while (srcOffset < data.byteLength) {
+            const windowEnd = this.nextChunkStart + constants_1.IV_SIZE + constants_1.SIDECAR_CHUNK_SIZE;
+            const remaining = windowEnd - this.totalPushed;
+            const toCopy = Math.min(remaining, data.byteLength - srcOffset);
+            this.window.set(data.subarray(srcOffset, srcOffset + toCopy), this.windowOffset);
+            this.windowOffset += toCopy;
+            this.totalPushed += toCopy;
+            srcOffset += toCopy;
+            if (this.totalPushed === windowEnd) {
+                this.flushChunk();
+            }
+        }
+    }
+    finish() {
+        if (this.windowOffset > 0) {
+            this.flushChunk();
+        }
+        return this.result.subarray(0, this.resultOffset);
+    }
+    flushChunk() {
+        const digest = (0, node_crypto_1.createHmac)('sha256', this.macKey)
+            .update(this.window.subarray(0, this.windowOffset))
+            .digest();
+        if (this.resultOffset + constants_1.SIDECAR_HMAC_SIZE > this.result.byteLength) {
+            const grown = new Uint8Array(this.result.byteLength * 2);
+            grown.set(this.result);
+            this.result = grown;
+        }
+        this.result.set(digest.subarray(0, constants_1.SIDECAR_HMAC_SIZE), this.resultOffset);
+        this.resultOffset += constants_1.SIDECAR_HMAC_SIZE;
+        this.nextChunkStart += constants_1.SIDECAR_CHUNK_SIZE;
+        const overlapSrc = this.window.subarray(this.windowOffset - constants_1.IV_SIZE, this.windowOffset);
+        this.window.set(overlapSrc, 0);
+        this.windowOffset = constants_1.IV_SIZE;
+    }
+}
+/**
+ * WhatsApp media payload encryption/decryption (AES-256-CBC + HMAC-SHA-256 +
+ * SHA-256 hashes + streaming sidecar). Buffer-only and streaming variants are
+ * provided for upload, download, and disk-staged encryption.
+ */
+class WaMediaCrypto {
+    /** Generates a fresh 32-byte media key suitable for {@link deriveKeys}. */
+    static async generateMediaKey() {
+        return (0, random_1.randomBytesAsync)(32);
+    }
+    /**
+     * Derives the per-type AES IV, AES key, and MAC key from `mediaKey` using
+     * HKDF with the {@link getWaMediaHkdfInfo} context.
+     */
+    static deriveKeys(mediaType, mediaKey) {
+        (0, bytes_1.assertByteLength)(mediaKey, 32, `invalid media key length ${mediaKey.byteLength}, expected 32`);
+        const info = mediaTypeToHkdfInfo(mediaType);
+        const expanded = (0, hkdf_1.hkdf)(mediaKey, null, info, constants_1.MEDIA_HKDF_SIZE);
+        return {
+            iv: expanded.subarray(0, constants_1.IV_SIZE),
+            encKey: expanded.subarray(constants_1.ENC_KEY_START, constants_1.ENC_KEY_END),
+            macKey: expanded.subarray(constants_1.MAC_KEY_START, constants_1.MAC_KEY_END)
+        };
+    }
+    /**
+     * Encrypts an in-memory buffer with the streaming sidecar (unless disabled)
+     * and an optional first-frame sidecar for instant-thumbnail playback.
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async encryptBytes(mediaType, mediaKey, plaintext, options) {
+        const keys = WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const ciphertext = (0, primitives_1.aesCbcEncrypt)(keys.encKey, keys.iv, plaintext);
+        const mac = (0, primitives_1.hmacSha256Sign)(keys.macKey, [keys.iv, ciphertext]);
+        const signature = mac.subarray(0, constants_1.HMAC_TRUNCATED_SIZE);
+        const ciphertextHmac = (0, bytes_1.concatBytes)([ciphertext, signature]);
+        let streamingSidecar;
+        if (options?.sidecar !== false) {
+            const acc = new SidecarAccumulator(keys.macKey, plaintext.byteLength);
+            acc.push(keys.iv);
+            acc.push(ciphertext);
+            acc.push(signature);
+            streamingSidecar = acc.finish();
+        }
+        const firstFrameSidecar = options?.firstFrameLength !== undefined
+            ? computeFirstFrameSidecar(keys.macKey, keys.iv, ciphertext, options.firstFrameLength)
+            : undefined;
+        const fileSha256 = (0, primitives_1.sha256)(plaintext);
+        const fileEncSha256 = (0, primitives_1.sha256)(ciphertextHmac);
+        return {
+            ciphertextHmac,
+            fileSha256,
+            fileEncSha256,
+            streamingSidecar,
+            firstFrameSidecar
+        };
+    }
+    /**
+     * Decrypts an in-memory `ciphertext||mac` buffer. Verifies the encrypted
+     * SHA-256, the MAC, and (when supplied) the plaintext SHA-256. Pass
+     * `skipMacVerification` only when the MAC was checked elsewhere.
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async decryptBytes(mediaType, mediaKey, ciphertextHmac, expectedFileSha256, expectedFileEncSha256, skipMacVerification = false) {
+        if (ciphertextHmac.byteLength < constants_1.HMAC_TRUNCATED_SIZE) {
+            throw new Error(`ciphertext too short: ${ciphertextHmac.byteLength}`);
+        }
+        if (expectedFileEncSha256) {
+            const computedEncHash = (0, primitives_1.sha256)(ciphertextHmac);
+            if (!(0, bytes_1.uint8TimingSafeEqual)(computedEncHash, expectedFileEncSha256)) {
+                throw new Error('encrypted file hash mismatch');
+            }
+        }
+        const keys = WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const ciphertext = ciphertextHmac.subarray(0, ciphertextHmac.byteLength - constants_1.HMAC_TRUNCATED_SIZE);
+        const expectedMac = ciphertextHmac.subarray(ciphertextHmac.byteLength - constants_1.HMAC_TRUNCATED_SIZE);
+        if (!skipMacVerification) {
+            const mac = (0, primitives_1.hmacSha256Sign)(keys.macKey, [keys.iv, ciphertext]);
+            const signature = mac.subarray(0, constants_1.HMAC_TRUNCATED_SIZE);
+            if (!(0, bytes_1.uint8TimingSafeEqual)(signature, expectedMac)) {
+                throw new Error('media MAC mismatch');
+            }
+        }
+        const plaintext = (0, primitives_1.aesCbcDecrypt)(keys.encKey, keys.iv, ciphertext);
+        const fileSha256 = (0, primitives_1.sha256)(plaintext);
+        if (expectedFileSha256 && !(0, bytes_1.uint8TimingSafeEqual)(fileSha256, expectedFileSha256)) {
+            throw new Error('plaintext file hash mismatch');
+        }
+        const fileEncSha256 = expectedFileEncSha256 ?? (0, primitives_1.sha256)(ciphertextHmac);
+        return { plaintext, fileSha256, fileEncSha256 };
+    }
+    /**
+     * Streaming encrypt – returns an `encrypted` Readable plus a `metadata`
+     * promise that resolves with hashes/sidecars after the stream ends.
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async encryptReadable(mediaType, mediaKey, plaintext, options) {
+        const keys = WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const encrypted = new node_stream_1.PassThrough();
+        const metadata = pumpEncryption(plaintext, encrypted, keys, options?.sidecar !== false, options?.firstFrameLength, options?.expectedFileSize);
+        return { encrypted, metadata };
+    }
+    /**
+     * Encrypts `plaintext` to a temporary file in `tmpdir()` and returns its
+     * path/size/hashes. The file is removed on failure; call
+     * {@link cleanupEncryptedFile} after a successful upload.
+     */
+    static async encryptToFile(mediaType, mediaKey, plaintext, options) {
+        const keys = WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const filePath = (0, node_path_1.join)((0, node_os_1.tmpdir)(), `zapo-enc-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+        const output = (0, node_fs_1.createWriteStream)(filePath);
+        try {
+            const metadata = await pumpEncryption(plaintext, output, keys, options?.sidecar !== false, options?.firstFrameLength, options?.expectedFileSize);
+            const fileSize = (await (0, promises_1.stat)(filePath)).size;
+            return { filePath, fileSize, ...metadata };
+        }
+        catch (error) {
+            await (0, promises_1.unlink)(filePath).catch(() => undefined);
+            throw error;
+        }
+    }
+    /** Removes a temporary file produced by {@link encryptToFile}; missing files are ignored. */
+    static async cleanupEncryptedFile(filePath) {
+        await (0, promises_1.unlink)(filePath).catch(() => undefined);
+    }
+    /**
+     * Streaming decrypt – returns a `plaintext` Readable plus a `metadata`
+     * promise that resolves with the verified hashes after the stream ends
+     * (or rejects on MAC/hash failure).
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async decryptReadable(encrypted, options) {
+        const keys = WaMediaCrypto.deriveKeys(options.mediaType, options.mediaKey);
+        const plaintext = new node_stream_1.PassThrough();
+        const metadata = pumpDecryption(encrypted, plaintext, keys, options);
+        return { plaintext, metadata };
+    }
+    /** Returns the ciphertext byte length (AES-CBC padded + 10-byte MAC) for a given plaintext size. */
+    static encryptedLength(plaintextLength) {
+        if (!Number.isFinite(plaintextLength) || plaintextLength < 0) {
+            throw new Error(`invalid plaintext length ${plaintextLength}`);
+        }
+        const paddedLength = Math.ceil((plaintextLength + 1) / 16) * 16;
+        return paddedLength + constants_1.HMAC_TRUNCATED_SIZE;
+    }
+}
+exports.WaMediaCrypto = WaMediaCrypto;
+async function pumpEncryption(plaintext, output, keys, computeSidecar, firstFrameLength, expectedFileSize) {
+    const cipher = (0, node_crypto_1.createCipheriv)('aes-256-cbc', keys.encKey, keys.iv);
+    const plainHash = (0, node_crypto_1.createHash)('sha256');
+    const encHash = (0, node_crypto_1.createHash)('sha256');
+    const hmac = (0, node_crypto_1.createHmac)('sha256', keys.macKey);
+    const sidecar = computeSidecar ? new SidecarAccumulator(keys.macKey, expectedFileSize) : null;
+    const ffTarget = firstFrameLength !== undefined
+        ? constants_1.IV_SIZE + Math.ceil(firstFrameLength / AES_BLOCK_SIZE) * AES_BLOCK_SIZE
+        : 0;
+    const ffChunks = ffTarget > 0 ? [keys.iv] : [];
+    let ffCollected = ffTarget > 0 ? constants_1.IV_SIZE : 0;
+    let plaintextLength = 0;
+    hmac.update(keys.iv);
+    sidecar?.push(keys.iv);
+    const consumeCiphertext = async (raw) => {
+        if (raw.byteLength === 0)
+            return;
+        const bytes = (0, bytes_1.toBytesView)(raw);
+        hmac.update(bytes);
+        encHash.update(bytes);
+        sidecar?.push(bytes);
+        if (ffCollected < ffTarget) {
+            const need = ffTarget - ffCollected;
+            ffChunks.push(bytes.subarray(0, Math.min(need, bytes.byteLength)));
+            ffCollected += bytes.byteLength;
+        }
+        await writeChunkToWritable(output, bytes);
+    };
+    try {
+        for await (const chunk of plaintext) {
+            const plainChunk = (0, bytes_1.toChunkBytes)(chunk);
+            if (plainChunk.byteLength === 0)
+                continue;
+            plaintextLength += plainChunk.byteLength;
+            plainHash.update(plainChunk);
+            await consumeCiphertext(cipher.update(plainChunk));
+        }
+        await consumeCiphertext(cipher.final());
+        const signature = (0, bytes_1.toBytesView)(hmac.digest().subarray(0, constants_1.HMAC_TRUNCATED_SIZE));
+        encHash.update(signature);
+        sidecar?.push(signature);
+        await writeChunkToWritable(output, signature);
+        await endWritable(output);
+        let firstFrameSidecar;
+        if (ffTarget > 0) {
+            const ffDigest = (0, primitives_1.hmacSha256Sign)(keys.macKey, ffChunks);
+            firstFrameSidecar = ffDigest.subarray(0, constants_1.SIDECAR_HMAC_SIZE);
+        }
+        return {
+            fileSha256: (0, bytes_1.toBytesView)(plainHash.digest()),
+            fileEncSha256: (0, bytes_1.toBytesView)(encHash.digest()),
+            plaintextLength,
+            streamingSidecar: sidecar?.finish(),
+            firstFrameSidecar
+        };
+    }
+    catch (error) {
+        const normalized = (0, primitives_2.toError)(error);
+        output.destroy(normalized);
+        throw normalized;
+    }
+}
+async function writeChunkToWritable(stream, chunk) {
+    if (chunk.byteLength === 0) {
+        return;
+    }
+    if (stream.write(chunk)) {
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        const onDrain = () => {
+            stream.off('error', onError);
+            resolve();
+        };
+        const onError = (err) => {
+            stream.off('drain', onDrain);
+            reject(err);
+        };
+        stream.once('drain', onDrain);
+        stream.once('error', onError);
+    });
+}
+async function endWritable(stream) {
+    return new Promise((resolve, reject) => {
+        stream.on('error', reject);
+        stream.end(() => resolve());
+    });
+}
+async function pumpDecryption(encrypted, plaintext, keys, options) {
+    const decipher = (0, node_crypto_1.createDecipheriv)('aes-256-cbc', keys.encKey, keys.iv);
+    const plainHash = (0, node_crypto_1.createHash)('sha256');
+    const encHash = (0, node_crypto_1.createHash)('sha256');
+    const hmac = (0, node_crypto_1.createHmac)('sha256', keys.macKey);
+    let trailing = bytes_1.EMPTY_BYTES;
+    hmac.update(keys.iv);
+    try {
+        for await (const chunk of encrypted) {
+            const bytes = (0, bytes_1.toChunkBytes)(chunk);
+            if (bytes.byteLength === 0) {
+                continue;
+            }
+            encHash.update(bytes);
+            const merged = trailing.byteLength === 0 ? bytes : (0, bytes_1.concatBytes)([trailing, bytes]);
+            if (merged.byteLength <= constants_1.HMAC_TRUNCATED_SIZE) {
+                trailing = merged;
+                continue;
+            }
+            const ciphertextChunk = merged.subarray(0, merged.byteLength - constants_1.HMAC_TRUNCATED_SIZE);
+            trailing = (0, bytes_1.toBytesView)(merged.subarray(merged.byteLength - constants_1.HMAC_TRUNCATED_SIZE));
+            hmac.update(ciphertextChunk);
+            const dec = decipher.update(ciphertextChunk);
+            if (dec.byteLength > 0) {
+                const decBytes = (0, bytes_1.toBytesView)(dec);
+                plainHash.update(decBytes);
+                await writeChunkToWritable(plaintext, decBytes);
+            }
+        }
+        if (trailing.byteLength !== constants_1.HMAC_TRUNCATED_SIZE) {
+            throw new Error(`ciphertext too short: ${trailing.byteLength}`);
+        }
+        if (!options.skipMacVerification) {
+            const signature = hmac.digest().subarray(0, constants_1.HMAC_TRUNCATED_SIZE);
+            if (!(0, bytes_1.uint8TimingSafeEqual)(signature, trailing)) {
+                throw new Error('media MAC mismatch');
+            }
+        }
+        const finalDec = decipher.final();
+        if (finalDec.byteLength > 0) {
+            const bytes = (0, bytes_1.toBytesView)(finalDec);
+            plainHash.update(bytes);
+            await writeChunkToWritable(plaintext, bytes);
+        }
+        const fileSha256 = (0, bytes_1.toBytesView)(plainHash.digest());
+        const fileEncSha256 = (0, bytes_1.toBytesView)(encHash.digest());
+        if (options.expectedFileEncSha256 &&
+            !(0, bytes_1.uint8TimingSafeEqual)(fileEncSha256, options.expectedFileEncSha256)) {
+            throw new Error('encrypted file hash mismatch');
+        }
+        if (options.expectedFileSha256 &&
+            !(0, bytes_1.uint8TimingSafeEqual)(fileSha256, options.expectedFileSha256)) {
+            throw new Error('plaintext file hash mismatch');
+        }
+        plaintext.end();
+        return { fileSha256, fileEncSha256 };
+    }
+    catch (error) {
+        const normalized = (0, primitives_2.toError)(error);
+        plaintext.destroy(normalized);
+        throw normalized;
+    }
+}
+function mediaTypeToHkdfInfo(mediaType) {
+    if (mediaType === 'ptv') {
+        return (0, constants_2.getWaMediaHkdfInfo)('video');
+    }
+    if (mediaType === 'history') {
+        return (0, constants_2.getWaMediaHkdfInfo)(constants_2.WA_APP_STATE_KEY_TYPES.MD_MSG_HIST);
+    }
+    return (0, constants_2.getWaMediaHkdfInfo)(mediaType);
+}

package/dist/media/index.js

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WaMediaCrypto = exports.parseMediaConnResponse = exports.WaMediaTransferClient = void 0;
-var WaMediaTransferClient_1 = require("./WaMediaTransferClient");
+exports.WaMediaCrypto = exports.PPS_UPLOAD_PATHS = exports.NEWSLETTER_MEDIA_UPLOAD_PATHS = exports.MEDIA_UPLOAD_PATHS = exports.DEFAULT_MEDIA_HOSTS = exports.parseMediaConnResponse = exports.WaMediaTransferClient = void 0;
+var WaMediaTransferClient_1 = require("./transfer/WaMediaTransferClient");
 Object.defineProperty(exports, "WaMediaTransferClient", { enumerable: true, get: function () { return WaMediaTransferClient_1.WaMediaTransferClient; } });
-var conn_1 = require("./conn");
+var conn_1 = require("./transfer/conn");
 Object.defineProperty(exports, "parseMediaConnResponse", { enumerable: true, get: function () { return conn_1.parseMediaConnResponse; } });
-var WaMediaCrypto_1 = require("./WaMediaCrypto");
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "DEFAULT_MEDIA_HOSTS", { enumerable: true, get: function () { return constants_1.DEFAULT_MEDIA_HOSTS; } });
+Object.defineProperty(exports, "MEDIA_UPLOAD_PATHS", { enumerable: true, get: function () { return constants_1.MEDIA_UPLOAD_PATHS; } });
+Object.defineProperty(exports, "NEWSLETTER_MEDIA_UPLOAD_PATHS", { enumerable: true, get: function () { return constants_1.NEWSLETTER_MEDIA_UPLOAD_PATHS; } });
+Object.defineProperty(exports, "PPS_UPLOAD_PATHS", { enumerable: true, get: function () { return constants_1.PPS_UPLOAD_PATHS; } });
+var WaMediaCrypto_1 = require("./crypto/WaMediaCrypto");
 Object.defineProperty(exports, "WaMediaCrypto", { enumerable: true, get: function () { return WaMediaCrypto_1.WaMediaCrypto; } });

package/dist/media/processor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/media/sticker/sticker-pack.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStickerPackZipStream = createStickerPackZipStream;
+const promises_1 = require("node:fs/promises");
+const node_stream_1 = require("node:stream");
+const bytes_1 = require("../../util/bytes");
+const SIGNATURE_LOCAL_FILE = 0x04034b50;
+const SIGNATURE_CENTRAL_DIR = 0x02014b50;
+const SIGNATURE_END_OF_CENTRAL_DIR = 0x06054b50;
+const COMPRESSION_STORED = 0;
+const VERSION_NEEDED = 20;
+const LOCAL_HEADER_SIZE = 30;
+const CENTRAL_HEADER_SIZE = 46;
+const EOCD_SIZE = 22;
+const CRC32_TABLE = (() => {
+    const table = new Array(256);
+    for (let i = 0; i < 256; i += 1) {
+        let c = i;
+        for (let k = 0; k < 8; k += 1) {
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+        table[i] = c >>> 0;
+    }
+    return table;
+})();
+function crc32(bytes) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < bytes.byteLength; i += 1) {
+        crc = CRC32_TABLE[(crc ^ bytes[i]) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function validateEntries(entries) {
+    if (entries.length === 0) {
+        throw new Error('sticker pack zip requires at least one entry');
+    }
+    const seen = new Set();
+    for (const entry of entries) {
+        if (!entry.fileName) {
+            throw new Error('sticker pack zip entry requires a non-empty fileName');
+        }
+        if (seen.has(entry.fileName)) {
+            throw new Error(`sticker pack zip has duplicate fileName: ${entry.fileName}`);
+        }
+        seen.add(entry.fileName);
+    }
+}
+async function loadEntryBytes(source) {
+    if (typeof source === 'string') {
+        const buf = await (0, promises_1.readFile)(source);
+        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    return source;
+}
+function buildLocalHeader(name, crc, dataLength) {
+    const out = new Uint8Array(LOCAL_HEADER_SIZE + name.byteLength);
+    const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+    view.setUint32(0, SIGNATURE_LOCAL_FILE, true);
+    view.setUint16(4, VERSION_NEEDED, true);
+    view.setUint16(6, 0, true);
+    view.setUint16(8, COMPRESSION_STORED, true);
+    view.setUint16(10, 0, true);
+    view.setUint16(12, 0, true);
+    view.setUint32(14, crc, true);
+    view.setUint32(18, dataLength, true);
+    view.setUint32(22, dataLength, true);
+    view.setUint16(26, name.byteLength, true);
+    view.setUint16(28, 0, true);
+    out.set(name, LOCAL_HEADER_SIZE);
+    return out;
+}
+function buildCentralDirectory(entries) {
+    let totalSize = 0;
+    for (const entry of entries)
+        totalSize += CENTRAL_HEADER_SIZE + entry.name.byteLength;
+    const out = new Uint8Array(totalSize);
+    const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+    let offset = 0;
+    for (const entry of entries) {
+        view.setUint32(offset, SIGNATURE_CENTRAL_DIR, true);
+        view.setUint16(offset + 4, VERSION_NEEDED, true);
+        view.setUint16(offset + 6, VERSION_NEEDED, true);
+        view.setUint16(offset + 8, 0, true);
+        view.setUint16(offset + 10, COMPRESSION_STORED, true);
+        view.setUint16(offset + 12, 0, true);
+        view.setUint16(offset + 14, 0, true);
+        view.setUint32(offset + 16, entry.crc, true);
+        view.setUint32(offset + 20, entry.dataLength, true);
+        view.setUint32(offset + 24, entry.dataLength, true);
+        view.setUint16(offset + 28, entry.name.byteLength, true);
+        view.setUint16(offset + 30, 0, true);
+        view.setUint16(offset + 32, 0, true);
+        view.setUint16(offset + 34, 0, true);
+        view.setUint16(offset + 36, 0, true);
+        view.setUint32(offset + 38, 0, true);
+        view.setUint32(offset + 42, entry.localOffset, true);
+        offset += CENTRAL_HEADER_SIZE;
+        out.set(entry.name, offset);
+        offset += entry.name.byteLength;
+    }
+    return out;
+}
+function buildEocd(entryCount, centralDirSize, centralDirOffset) {
+    const out = new Uint8Array(EOCD_SIZE);
+    const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+    view.setUint32(0, SIGNATURE_END_OF_CENTRAL_DIR, true);
+    view.setUint16(4, 0, true);
+    view.setUint16(6, 0, true);
+    view.setUint16(8, entryCount, true);
+    view.setUint16(10, entryCount, true);
+    view.setUint32(12, centralDirSize, true);
+    view.setUint32(16, centralDirOffset, true);
+    view.setUint16(20, 0, true);
+    return out;
+}
+function createStickerPackZipStream(entries) {
+    validateEntries(entries);
+    return node_stream_1.Readable.from(zipChunks(entries));
+}
+async function* zipChunks(entries) {
+    const central = [];
+    let offset = 0;
+    for (const entry of entries) {
+        const data = await loadEntryBytes(entry.source);
+        const name = bytes_1.TEXT_ENCODER.encode(entry.fileName);
+        const crc = crc32(data);
+        const header = buildLocalHeader(name, crc, data.byteLength);
+        yield header;
+        yield data;
+        central.push({ name, crc, dataLength: data.byteLength, localOffset: offset });
+        offset += header.byteLength + data.byteLength;
+    }
+    const centralDir = buildCentralDirectory(central);
+    yield centralDir;
+    yield buildEocd(central.length, centralDir.byteLength, offset);
+}