zapo-js 0.1.0

package/dist/esm/media/WaMediaCrypto.js

@@ -0,0 +1,224 @@
+import { createCipheriv, createDecipheriv, createHash, createHmac } from 'node:crypto';
+import { once } from 'node:events';
+import { PassThrough } from 'node:stream';
+import { hkdf } from '../crypto/core/hkdf.js';
+import { aesCbcDecrypt, aesCbcEncrypt, hmacSign, importAesCbcKey, importHmacKey, sha256 } from '../crypto/core/primitives.js';
+import { randomBytesAsync } from '../crypto/core/random.js';
+import { ENC_KEY_END, ENC_KEY_START, HMAC_TRUNCATED_SIZE, IV_SIZE, MAC_KEY_END, MAC_KEY_START, MEDIA_HKDF_SIZE } from './constants.js';
+import { WA_APP_STATE_KEY_TYPES, getWaMediaHkdfInfo } from '../protocol/constants.js';
+import { concatBytes, EMPTY_BYTES, readAllBytes, toChunkBytes, toBytesView, uint8Equal, uint8TimingSafeEqual } from '../util/bytes.js';
+import { toError } from '../util/primitives.js';
+export class WaMediaCrypto {
+    static async generateMediaKey() {
+        return randomBytesAsync(32);
+    }
+    static async deriveKeys(mediaType, mediaKey) {
+        if (mediaKey.byteLength !== 32) {
+            throw new Error(`invalid media key length ${mediaKey.byteLength}, expected 32`);
+        }
+        const info = mediaTypeToHkdfInfo(mediaType);
+        const expanded = await hkdf(mediaKey, null, info, MEDIA_HKDF_SIZE);
+        return {
+            iv: expanded.subarray(0, IV_SIZE),
+            encKey: expanded.subarray(ENC_KEY_START, ENC_KEY_END),
+            macKey: expanded.subarray(MAC_KEY_START, MAC_KEY_END),
+            refKey: expanded.subarray(MAC_KEY_END, MEDIA_HKDF_SIZE)
+        };
+    }
+    static async encryptBytes(mediaType, mediaKey, plaintext) {
+        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const [aesKey, macKey] = await Promise.all([
+            importAesCbcKey(keys.encKey),
+            importHmacKey(keys.macKey)
+        ]);
+        const ciphertext = await aesCbcEncrypt(aesKey, keys.iv, plaintext);
+        const ivCiphertext = concatBytes([keys.iv, ciphertext]);
+        const mac = await hmacSign(macKey, ivCiphertext);
+        const signature = mac.subarray(0, HMAC_TRUNCATED_SIZE);
+        const ciphertextHmac = concatBytes([ciphertext, signature]);
+        const [fileSha256, fileEncSha256] = await Promise.all([
+            sha256(plaintext),
+            sha256(ciphertextHmac)
+        ]);
+        return { ciphertextHmac, fileSha256, fileEncSha256 };
+    }
+    static async decryptBytes(mediaType, mediaKey, ciphertextHmac, expectedFileSha256, expectedFileEncSha256) {
+        if (ciphertextHmac.byteLength < HMAC_TRUNCATED_SIZE) {
+            throw new Error(`ciphertext too short: ${ciphertextHmac.byteLength}`);
+        }
+        if (expectedFileEncSha256) {
+            const computedEncHash = await sha256(ciphertextHmac);
+            if (!uint8Equal(computedEncHash, expectedFileEncSha256)) {
+                throw new Error('encrypted file hash mismatch');
+            }
+        }
+        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const ciphertext = ciphertextHmac.subarray(0, ciphertextHmac.byteLength - HMAC_TRUNCATED_SIZE);
+        const expectedMac = ciphertextHmac.subarray(ciphertextHmac.byteLength - HMAC_TRUNCATED_SIZE);
+        const ivCiphertext = concatBytes([keys.iv, ciphertext]);
+        const [macKey, aesKey] = await Promise.all([
+            importHmacKey(keys.macKey),
+            importAesCbcKey(keys.encKey)
+        ]);
+        const mac = await hmacSign(macKey, ivCiphertext);
+        const signature = mac.subarray(0, HMAC_TRUNCATED_SIZE);
+        if (!uint8TimingSafeEqual(signature, expectedMac)) {
+            throw new Error('media MAC mismatch');
+        }
+        const plaintext = await aesCbcDecrypt(aesKey, keys.iv, ciphertext);
+        const fileSha256 = await sha256(plaintext);
+        if (expectedFileSha256 && !uint8Equal(fileSha256, expectedFileSha256)) {
+            throw new Error('plaintext file hash mismatch');
+        }
+        const fileEncSha256 = expectedFileEncSha256 ?? (await sha256(ciphertextHmac));
+        return { plaintext, fileSha256, fileEncSha256 };
+    }
+    static async encryptReadable(mediaType, mediaKey, plaintext) {
+        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const encrypted = new PassThrough();
+        const metadata = pumpEncryption(plaintext, encrypted, keys);
+        return { encrypted, metadata };
+    }
+    static async decryptReadableToBytes(encrypted, options) {
+        const decrypted = await WaMediaCrypto.decryptReadable(encrypted, options);
+        const [plaintext, metadata] = await Promise.all([
+            readAllBytes(decrypted.plaintext),
+            decrypted.metadata
+        ]);
+        return {
+            plaintext,
+            fileSha256: metadata.fileSha256,
+            fileEncSha256: metadata.fileEncSha256
+        };
+    }
+    static async decryptReadable(encrypted, options) {
+        const keys = await WaMediaCrypto.deriveKeys(options.mediaType, options.mediaKey);
+        const plaintext = new PassThrough();
+        const metadata = pumpDecryption(encrypted, plaintext, keys, options);
+        return { plaintext, metadata };
+    }
+    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 + HMAC_TRUNCATED_SIZE;
+    }
+}
+async function pumpEncryption(plaintext, encrypted, keys) {
+    const plainHash = createHash('sha256');
+    const encHash = createHash('sha256');
+    const hmac = createHmac('sha256', keys.macKey);
+    const cipher = createCipheriv('aes-256-cbc', keys.encKey, keys.iv);
+    hmac.update(keys.iv);
+    try {
+        for await (const chunk of plaintext) {
+            const plainChunk = toChunkBytes(chunk);
+            if (plainChunk.byteLength === 0) {
+                continue;
+            }
+            plainHash.update(plainChunk);
+            const encryptedChunk = cipher.update(plainChunk);
+            if (encryptedChunk.byteLength > 0) {
+                hmac.update(encryptedChunk);
+                encHash.update(encryptedChunk);
+                await writeChunk(encrypted, encryptedChunk);
+            }
+        }
+        const encryptedFinal = cipher.final();
+        if (encryptedFinal.byteLength > 0) {
+            hmac.update(encryptedFinal);
+            encHash.update(encryptedFinal);
+            await writeChunk(encrypted, encryptedFinal);
+        }
+        const signature = hmac.digest().subarray(0, HMAC_TRUNCATED_SIZE);
+        encHash.update(signature);
+        await writeChunk(encrypted, signature);
+        encrypted.end();
+        return {
+            fileSha256: toBytesView(plainHash.digest()),
+            fileEncSha256: toBytesView(encHash.digest())
+        };
+    }
+    catch (error) {
+        const normalized = toError(error);
+        encrypted.destroy(normalized);
+        throw normalized;
+    }
+}
+async function pumpDecryption(encrypted, plaintext, keys, options) {
+    const plainHash = createHash('sha256');
+    const encHash = createHash('sha256');
+    const hmac = createHmac('sha256', keys.macKey);
+    const decipher = createDecipheriv('aes-256-cbc', keys.encKey, keys.iv);
+    hmac.update(keys.iv);
+    try {
+        let trailing = EMPTY_BYTES;
+        for await (const chunk of encrypted) {
+            const bytes = toChunkBytes(chunk);
+            if (bytes.byteLength === 0) {
+                continue;
+            }
+            encHash.update(bytes);
+            const merged = trailing.byteLength === 0 ? bytes : concatBytes([trailing, bytes]);
+            if (merged.byteLength <= HMAC_TRUNCATED_SIZE) {
+                trailing = merged;
+                continue;
+            }
+            const ciphertextChunk = merged.subarray(0, merged.byteLength - HMAC_TRUNCATED_SIZE);
+            trailing = merged.subarray(merged.byteLength - HMAC_TRUNCATED_SIZE);
+            hmac.update(ciphertextChunk);
+            const plainChunk = decipher.update(ciphertextChunk);
+            if (plainChunk.byteLength > 0) {
+                plainHash.update(plainChunk);
+                await writeChunk(plaintext, plainChunk);
+            }
+        }
+        if (trailing.byteLength !== HMAC_TRUNCATED_SIZE) {
+            throw new Error(`ciphertext too short: ${trailing.byteLength}`);
+        }
+        const signature = hmac.digest().subarray(0, HMAC_TRUNCATED_SIZE);
+        if (!uint8TimingSafeEqual(signature, trailing)) {
+            throw new Error('media MAC mismatch');
+        }
+        const plainFinal = decipher.final();
+        if (plainFinal.byteLength > 0) {
+            plainHash.update(plainFinal);
+            await writeChunk(plaintext, plainFinal);
+        }
+        const fileSha256 = toBytesView(plainHash.digest());
+        const fileEncSha256 = toBytesView(encHash.digest());
+        if (options.expectedFileEncSha256 &&
+            !uint8Equal(fileEncSha256, options.expectedFileEncSha256)) {
+            throw new Error('encrypted file hash mismatch');
+        }
+        if (options.expectedFileSha256 && !uint8Equal(fileSha256, options.expectedFileSha256)) {
+            throw new Error('plaintext file hash mismatch');
+        }
+        plaintext.end();
+        return { fileSha256, fileEncSha256 };
+    }
+    catch (error) {
+        const normalized = toError(error);
+        plaintext.destroy(normalized);
+        throw normalized;
+    }
+}
+function mediaTypeToHkdfInfo(mediaType) {
+    if (mediaType === 'ptv') {
+        return getWaMediaHkdfInfo('video');
+    }
+    if (mediaType === 'history') {
+        return getWaMediaHkdfInfo(WA_APP_STATE_KEY_TYPES.MD_MSG_HIST);
+    }
+    return getWaMediaHkdfInfo(mediaType);
+}
+async function writeChunk(stream, chunk) {
+    if (chunk.byteLength === 0) {
+        return;
+    }
+    if (stream.write(chunk)) {
+        return;
+    }
+    await once(stream, 'drain');
+}

package/dist/esm/media/WaMediaTransferClient.js

@@ -0,0 +1,361 @@
+import { Readable } from 'node:stream';
+import { DEFAULT_MEDIA_HOSTS } from './constants.js';
+import { WaMediaCrypto } from './WaMediaCrypto.js';
+import { WA_DEFAULTS } from '../protocol/constants.js';
+import { EMPTY_BYTES, readAllBytes } from '../util/bytes.js';
+import { toError } from '../util/primitives.js';
+export class WaMediaTransferClient {
+    constructor(options = {}) {
+        this.logger = options.logger;
+        this.defaultHosts = options.defaultHosts ?? DEFAULT_MEDIA_HOSTS;
+        this.defaultTimeoutMs = options.defaultTimeoutMs ?? WA_DEFAULTS.MEDIA_TIMEOUT_MS;
+        this.defaultMaxReadBytes = options.defaultMaxReadBytes;
+        this.defaultHeaders = options.defaultHeaders ?? {};
+    }
+    async downloadStream(request) {
+        const { urls, headers, timeoutMs } = this.resolveTransferRequest(request);
+        this.logger?.debug('media download stream start', {
+            urls: urls.length,
+            timeoutMs
+        });
+        return this.executeTransfer(urls, timeoutMs, request.signal, {
+            responseLog: 'media download stream response',
+            send: (url, signal) => fetch(url, {
+                method: 'GET',
+                headers,
+                signal
+            })
+        });
+    }
+    async downloadBytes(request) {
+        const response = await this.downloadStream(request);
+        await this.assertSuccessfulResponse(response);
+        if (!response.body) {
+            return EMPTY_BYTES;
+        }
+        return this.readAllBytesWithLimit(response.body, request.maxBytes);
+    }
+    async uploadStream(request) {
+        const bodyIsBytes = request.body instanceof Uint8Array;
+        const { urls, headers, timeoutMs } = this.resolveTransferRequest(request, {
+            'content-type': request.contentType,
+            'content-length': request.contentLength !== null && request.contentLength !== undefined
+                ? String(request.contentLength)
+                : undefined
+        });
+        const uploadUrls = bodyIsBytes ? urls : urls.slice(0, 1);
+        if (!bodyIsBytes && urls.length > 1) {
+            this.logger?.warn('upload stream fallback disabled for non-replayable body', {
+                attemptedHosts: urls.length
+            });
+        }
+        const method = request.method ?? 'POST';
+        this.logger?.debug('media upload stream start', {
+            urls: uploadUrls.length,
+            timeoutMs,
+            method
+        });
+        return this.executeTransfer(uploadUrls, timeoutMs, request.signal, {
+            responseLog: 'media upload stream response',
+            send: async (url, signal) => {
+                if (bodyIsBytes) {
+                    return fetch(url, {
+                        method,
+                        headers,
+                        signal,
+                        body: request.body
+                    });
+                }
+                return fetch(url, {
+                    method,
+                    headers,
+                    signal,
+                    body: request.body,
+                    duplex: 'half'
+                });
+            }
+        });
+    }
+    async uploadEncrypted(request) {
+        this.logger?.info('media encrypted upload start', {
+            mediaType: request.mediaType
+        });
+        const mediaKey = request.mediaKey ?? (await WaMediaCrypto.generateMediaKey());
+        const prepared = await this.prepareEncryptedUpload(request, mediaKey);
+        let transfer;
+        try {
+            transfer = await this.uploadStream({
+                url: request.url,
+                directPath: request.directPath,
+                hosts: request.hosts,
+                headers: request.headers,
+                timeoutMs: request.timeoutMs,
+                signal: request.signal,
+                method: request.method,
+                body: prepared.body,
+                contentLength: prepared.contentLength,
+                contentType: request.contentType
+            });
+        }
+        catch (error) {
+            await prepared.cleanup(toError(error));
+            throw error;
+        }
+        const metadata = await prepared.metadata;
+        this.logger?.info('media encrypted upload completed', {
+            status: transfer.status
+        });
+        return {
+            transfer,
+            mediaKey,
+            fileSha256: metadata.fileSha256,
+            fileEncSha256: metadata.fileEncSha256
+        };
+    }
+    async downloadAndDecrypt(request) {
+        this.logger?.info('media encrypted download start', {
+            mediaType: request.mediaType
+        });
+        const decrypted = await this.downloadAndDecryptStream(request);
+        try {
+            const [plaintext] = await Promise.all([
+                this.readAllBytesWithLimit(decrypted.plaintext, request.maxBytes),
+                decrypted.metadata
+            ]);
+            this.logger?.info('media encrypted download completed', {
+                byteLength: plaintext.byteLength
+            });
+            return plaintext;
+        }
+        catch (error) {
+            decrypted.plaintext.destroy(toError(error));
+            throw error;
+        }
+    }
+    async downloadAndDecryptStream(request) {
+        const response = await this.downloadStream(request);
+        await this.assertSuccessfulResponse(response);
+        const body = this.requireResponseBody(response);
+        const decrypted = await WaMediaCrypto.decryptReadable(body, {
+            mediaType: request.mediaType,
+            mediaKey: request.mediaKey,
+            expectedFileSha256: request.fileSha256,
+            expectedFileEncSha256: request.fileEncSha256
+        });
+        decrypted.metadata.catch(() => undefined);
+        this.logger?.debug('media encrypted download stream ready', {
+            mediaType: request.mediaType
+        });
+        return {
+            plaintext: decrypted.plaintext,
+            metadata: decrypted.metadata
+        };
+    }
+    async readResponseBytes(response, maxBytes) {
+        if (!response.body) {
+            return EMPTY_BYTES;
+        }
+        return this.readAllBytesWithLimit(response.body, maxBytes);
+    }
+    resolveTransferRequest(request, extraHeaders) {
+        const headers = this.mergeHeaders(request.headers);
+        for (const [key, value] of Object.entries(extraHeaders ?? {})) {
+            if (value !== undefined) {
+                headers[key.toLowerCase()] = value;
+            }
+        }
+        return {
+            urls: this.resolveUrls(request.url, request.directPath, request.hosts),
+            headers,
+            timeoutMs: request.timeoutMs ?? this.defaultTimeoutMs
+        };
+    }
+    async executeTransfer(urls, timeoutMs, signal, options) {
+        const result = await this.fetchWithFallback(urls, timeoutMs, signal, options.send);
+        this.logger?.trace(options.responseLog, {
+            url: result.url,
+            status: result.response.status
+        });
+        return this.toResponse(result.url, result.response);
+    }
+    async prepareEncryptedUpload(request, mediaKey) {
+        if (request.plaintext instanceof Uint8Array) {
+            const encrypted = await WaMediaCrypto.encryptBytes(request.mediaType, mediaKey, request.plaintext);
+            return {
+                body: encrypted.ciphertextHmac,
+                contentLength: encrypted.ciphertextHmac.byteLength,
+                metadata: Promise.resolve({
+                    fileSha256: encrypted.fileSha256,
+                    fileEncSha256: encrypted.fileEncSha256
+                }),
+                cleanup: async () => undefined
+            };
+        }
+        const prepared = await WaMediaCrypto.encryptReadable(request.mediaType, mediaKey, request.plaintext);
+        return {
+            body: prepared.encrypted,
+            contentLength: request.contentLength !== null && request.contentLength !== undefined
+                ? WaMediaCrypto.encryptedLength(request.contentLength)
+                : undefined,
+            metadata: prepared.metadata,
+            cleanup: async (error) => {
+                prepared.encrypted.destroy(error);
+                await prepared.metadata.catch(() => undefined);
+            }
+        };
+    }
+    async assertSuccessfulResponse(response) {
+        if (response.ok) {
+            return;
+        }
+        await this.drainBody(response.body);
+        throw new Error(`download failed with status ${response.status} for ${response.url}`);
+    }
+    requireResponseBody(response) {
+        if (response.body) {
+            return response.body;
+        }
+        throw new Error(`download response body is empty for ${response.url}`);
+    }
+    resolveUrls(url, directPath, hosts) {
+        const resolved = [];
+        if (url) {
+            resolved.push(url);
+        }
+        if (directPath) {
+            if (directPath.startsWith('https://') || directPath.startsWith('http://')) {
+                resolved.push(directPath);
+            }
+            else {
+                const normalizedPath = directPath.startsWith('/') ? directPath : `/${directPath}`;
+                for (const host of hosts ?? this.defaultHosts) {
+                    resolved.push(`https://${host}${normalizedPath}`);
+                }
+            }
+        }
+        if (resolved.length === 0) {
+            throw new Error('missing transfer url/directPath');
+        }
+        return Array.from(new Set(resolved));
+    }
+    mergeHeaders(headers) {
+        const merged = {};
+        for (const [key, value] of Object.entries(this.defaultHeaders)) {
+            merged[key.toLowerCase()] = value;
+        }
+        for (const [key, value] of Object.entries(headers ?? {})) {
+            merged[key.toLowerCase()] = value;
+        }
+        return merged;
+    }
+    readAllBytesWithLimit(stream, maxBytes) {
+        return readAllBytes(stream, {
+            maxBytes: maxBytes ?? this.defaultMaxReadBytes
+        });
+    }
+    async fetchWithFallback(urls, timeoutMs, signal, send) {
+        let lastError = null;
+        for (let index = 0; index < urls.length; index += 1) {
+            const url = urls[index];
+            const abort = this.createAbortContext(timeoutMs, signal);
+            try {
+                const response = await send(url, abort.signal);
+                const shouldFallback = response.status >= 500 && index < urls.length - 1;
+                if (!shouldFallback) {
+                    return { url, response };
+                }
+                await this.cancelWebBody(response.body);
+                this.logger?.warn('transfer fallback to next host', {
+                    url,
+                    status: response.status
+                });
+            }
+            catch (error) {
+                const normalized = toError(error);
+                lastError = normalized;
+                if (abort.signal.aborted && signal?.aborted) {
+                    throw normalized;
+                }
+                if (index === urls.length - 1) {
+                    throw normalized;
+                }
+                this.logger?.warn('transfer host failed, trying next host', {
+                    url,
+                    message: normalized.message
+                });
+            }
+            finally {
+                abort.cleanup();
+            }
+        }
+        throw lastError ?? new Error('transfer failed');
+    }
+    createAbortContext(timeoutMs, externalSignal) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => {
+            controller.abort(new Error(`transfer timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timer.unref?.();
+        let onExternalAbort = null;
+        if (externalSignal) {
+            onExternalAbort = () => controller.abort(externalSignal.reason);
+            if (externalSignal.aborted) {
+                onExternalAbort();
+            }
+            else {
+                externalSignal.addEventListener('abort', onExternalAbort, { once: true });
+            }
+        }
+        return {
+            signal: controller.signal,
+            cleanup: () => {
+                clearTimeout(timer);
+                if (externalSignal && onExternalAbort) {
+                    externalSignal.removeEventListener('abort', onExternalAbort);
+                }
+            }
+        };
+    }
+    toResponse(url, response) {
+        return {
+            url,
+            status: response.status,
+            ok: response.ok,
+            headers: this.headersToRecord(response.headers),
+            body: response.body
+                ? Readable.fromWeb(response.body)
+                : null
+        };
+    }
+    headersToRecord(headers) {
+        const output = {};
+        for (const [key, value] of headers.entries()) {
+            output[key] = value;
+        }
+        return output;
+    }
+    async cancelWebBody(body) {
+        if (!body) {
+            return;
+        }
+        try {
+            await body.cancel();
+        }
+        catch {
+            // ignore cancel errors from remote resets
+        }
+    }
+    async drainBody(body) {
+        if (!body) {
+            return;
+        }
+        try {
+            for await (const chunk of body) {
+                void chunk;
+            }
+        }
+        catch {
+            // ignore drain errors
+        }
+    }
+}

package/dist/esm/media/conn.js

@@ -0,0 +1,33 @@
+import { WA_NODE_TAGS } from '../protocol/constants.js';
+import { findNodeChild, getNodeChildrenByTag } from '../transport/node/helpers.js';
+import { assertIqResult } from '../transport/node/query.js';
+export function parseMediaConnResponse(node, nowMs) {
+    assertIqResult(node, 'media_conn');
+    const mediaConnNode = findNodeChild(node, WA_NODE_TAGS.MEDIA_CONN);
+    if (!mediaConnNode) {
+        throw new Error('media_conn response is missing media_conn node');
+    }
+    const auth = mediaConnNode.attrs.auth;
+    if (!auth) {
+        throw new Error('media_conn response is missing auth');
+    }
+    const ttlRaw = Number.parseInt(mediaConnNode.attrs.ttl ?? '0', 10);
+    if (!Number.isFinite(ttlRaw) || ttlRaw <= 0) {
+        throw new Error('media_conn response has invalid ttl');
+    }
+    const expiresAtMs = ttlRaw >= 1000000000 ? ttlRaw * 1000 : nowMs + ttlRaw * 1000;
+    const hosts = getNodeChildrenByTag(mediaConnNode, WA_NODE_TAGS.HOST)
+        .map((host) => ({
+        hostname: host.attrs.hostname ?? '',
+        isFallback: host.attrs.type === 'fallback'
+    }))
+        .filter((host) => host.hostname.length > 0);
+    if (hosts.length === 0) {
+        throw new Error('media_conn response contains no hosts');
+    }
+    return {
+        auth,
+        expiresAtMs,
+        hosts
+    };
+}

package/dist/esm/media/constants.js

@@ -0,0 +1,18 @@
+export const DEFAULT_MEDIA_HOSTS = ['mmg.whatsapp.net', 'mmg-fallback.whatsapp.net'];
+export const MEDIA_CONN_CACHE_GRACE_MS = 30000;
+export const MEDIA_HKDF_SIZE = 112;
+export const IV_SIZE = 16;
+export const ENC_KEY_START = 16;
+export const ENC_KEY_END = 48;
+export const MAC_KEY_START = 48;
+export const MAC_KEY_END = 80;
+export const HMAC_TRUNCATED_SIZE = 10;
+export const MEDIA_UPLOAD_PATHS = Object.freeze({
+    image: '/mms/image',
+    video: '/mms/video',
+    audio: '/mms/audio',
+    document: '/mms/document',
+    sticker: '/mms/sticker',
+    gif: '/mms/gif',
+    ptt: '/mms/ptt'
+});

package/dist/esm/media/index.js

@@ -0,0 +1,3 @@
+export { WaMediaTransferClient } from './WaMediaTransferClient.js';
+export { parseMediaConnResponse } from './conn.js';
+export { WaMediaCrypto } from './WaMediaCrypto.js';

package/dist/esm/media/types.js

@@ -0,0 +1 @@
+export {};