zapo-js 0.3.0 → 1.0.0

package/dist/esm/media/WaMediaCrypto.js

@@ -1,499 +0,0 @@
-import { createHash, createHmac } from 'node:crypto';
-import { once } from 'node:events';
-import { createWriteStream } from 'node:fs';
-import { stat, unlink } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-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, SIDECAR_CHUNK_SIZE, SIDECAR_HMAC_SIZE } from './constants.js';
-import { getWaMediaHkdfInfo, WA_APP_STATE_KEY_TYPES } from '../protocol/constants.js';
-import { assertByteLength, concatBytes, EMPTY_BYTES, toBytesView, toChunkBytes, uint8Equal, uint8TimingSafeEqual } from '../util/bytes.js';
-import { toError } from '../util/primitives.js';
-const AES_BLOCK_SIZE = 16;
-const PKCS7_FULL_BLOCK = new Uint8Array(AES_BLOCK_SIZE).fill(AES_BLOCK_SIZE);
-async function aesCbcEncryptChunk(key, iv, chunk, isFinal) {
-    const encrypted = await aesCbcEncrypt(key, iv, chunk);
-    if (isFinal) {
-        return {
-            ciphertext: encrypted,
-            nextIv: encrypted.subarray(encrypted.byteLength - AES_BLOCK_SIZE)
-        };
-    }
-    const ciphertext = encrypted.subarray(0, encrypted.byteLength - AES_BLOCK_SIZE);
-    return {
-        ciphertext,
-        nextIv: ciphertext.subarray(ciphertext.byteLength - AES_BLOCK_SIZE)
-    };
-}
-async function aesCbcDecryptChunk(key, iv, ciphertext, isFinal) {
-    const nextIv = toBytesView(ciphertext.subarray(ciphertext.byteLength - AES_BLOCK_SIZE));
-    if (isFinal) {
-        return { plaintext: await aesCbcDecrypt(key, iv, ciphertext), nextIv };
-    }
-    const padBlock = (await aesCbcEncrypt(key, nextIv, PKCS7_FULL_BLOCK)).subarray(0, AES_BLOCK_SIZE);
-    const withPad = concatBytes([ciphertext, padBlock]);
-    return { plaintext: await aesCbcDecrypt(key, iv, withPad), nextIv };
-}
-async function computeFirstFrameSidecar(macKey, ivCiphertext, firstFrameLength) {
-    const aligned = Math.ceil(firstFrameLength / AES_BLOCK_SIZE) * AES_BLOCK_SIZE;
-    const slice = ivCiphertext.subarray(0, IV_SIZE + aligned);
-    const key = await importHmacKey(macKey);
-    const digest = await hmacSign(key, slice);
-    return digest.subarray(0, 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(IV_SIZE + SIDECAR_CHUNK_SIZE);
-        const estimated = Math.max(Math.ceil(estimatedSize / SIDECAR_CHUNK_SIZE) + 1, 16);
-        this.result = new Uint8Array(estimated * SIDECAR_HMAC_SIZE);
-    }
-    push(data) {
-        let srcOffset = 0;
-        while (srcOffset < data.byteLength) {
-            const windowEnd = this.nextChunkStart + IV_SIZE + 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 = createHmac('sha256', this.macKey)
-            .update(this.window.subarray(0, this.windowOffset))
-            .digest();
-        if (this.resultOffset + 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, SIDECAR_HMAC_SIZE), this.resultOffset);
-        this.resultOffset += SIDECAR_HMAC_SIZE;
-        this.nextChunkStart += SIDECAR_CHUNK_SIZE;
-        const overlapSrc = this.window.subarray(this.windowOffset - IV_SIZE, this.windowOffset);
-        this.window.set(overlapSrc, 0);
-        this.windowOffset = IV_SIZE;
-    }
-}
-export class WaMediaCrypto {
-    static async generateMediaKey() {
-        return randomBytesAsync(32);
-    }
-    static async deriveKeys(mediaType, mediaKey) {
-        assertByteLength(mediaKey, 32, `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, options) {
-        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
-        const [aesKey, hmacKey] = 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(hmacKey, ivCiphertext);
-        const signature = mac.subarray(0, HMAC_TRUNCATED_SIZE);
-        const ciphertextHmac = concatBytes([ciphertext, signature]);
-        let streamingSidecar;
-        if (options?.sidecar !== false) {
-            const acc = new SidecarAccumulator(keys.macKey);
-            acc.push(keys.iv);
-            acc.push(ciphertext);
-            acc.push(signature);
-            streamingSidecar = acc.finish();
-        }
-        const firstFrameSidecar = options?.firstFrameLength !== undefined
-            ? await computeFirstFrameSidecar(keys.macKey, ivCiphertext, options.firstFrameLength)
-            : undefined;
-        const [fileSha256, fileEncSha256] = await Promise.all([
-            sha256(plaintext),
-            sha256(ciphertextHmac)
-        ]);
-        return {
-            ciphertextHmac,
-            fileSha256,
-            fileEncSha256,
-            streamingSidecar,
-            firstFrameSidecar
-        };
-    }
-    static async decryptBytes(mediaType, mediaKey, ciphertextHmac, expectedFileSha256, expectedFileEncSha256, skipMacVerification = false) {
-        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 [aesKey, hmacKey] = await Promise.all([
-            importAesCbcKey(keys.encKey),
-            importHmacKey(keys.macKey)
-        ]);
-        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]);
-        if (!skipMacVerification) {
-            const mac = await hmacSign(hmacKey, 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, options) {
-        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
-        const encrypted = new PassThrough();
-        const metadata = pumpEncryption(plaintext, encrypted, keys, options?.sidecar !== false, options?.firstFrameLength);
-        return { encrypted, metadata };
-    }
-    static async encryptToFile(mediaType, mediaKey, plaintext, options) {
-        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
-        const filePath = join(tmpdir(), `zapo-enc-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-        const output = createWriteStream(filePath);
-        try {
-            const metadata = await pumpEncryptionToWritable(plaintext, output, keys, options?.sidecar !== false, options?.firstFrameLength);
-            const fileSize = (await stat(filePath)).size;
-            return { filePath, fileSize, ...metadata };
-        }
-        catch (error) {
-            await unlink(filePath).catch(() => undefined);
-            throw error;
-        }
-    }
-    static async cleanupEncryptedFile(filePath) {
-        await unlink(filePath).catch(() => undefined);
-    }
-    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, computeSidecar, firstFrameLength) {
-    const aesKey = await importAesCbcKey(keys.encKey);
-    const plainHash = createHash('sha256');
-    const encHash = createHash('sha256');
-    const hmac = createHmac('sha256', keys.macKey);
-    const sidecar = computeSidecar ? new SidecarAccumulator(keys.macKey) : null;
-    const ffTarget = firstFrameLength !== undefined
-        ? IV_SIZE + Math.ceil(firstFrameLength / AES_BLOCK_SIZE) * AES_BLOCK_SIZE
-        : 0;
-    let ffCollected = 0;
-    const ffChunks = ffTarget > 0 ? [keys.iv] : [];
-    if (ffTarget > 0)
-        ffCollected = IV_SIZE;
-    let plaintextLength = 0;
-    let currentIv = keys.iv;
-    let pending = EMPTY_BYTES;
-    hmac.update(keys.iv);
-    sidecar?.push(keys.iv);
-    try {
-        for await (const chunk of plaintext) {
-            const plainChunk = toChunkBytes(chunk);
-            if (plainChunk.byteLength === 0)
-                continue;
-            plaintextLength += plainChunk.byteLength;
-            plainHash.update(plainChunk);
-            const combined = pending.byteLength > 0
-                ? concatBytes([pending, plainChunk])
-                : toBytesView(plainChunk);
-            const aligned = combined.byteLength - (combined.byteLength % AES_BLOCK_SIZE);
-            if (aligned === 0) {
-                pending = combined;
-                continue;
-            }
-            const toEncrypt = toBytesView(combined.subarray(0, aligned));
-            pending = toBytesView(combined.subarray(aligned));
-            const { ciphertext, nextIv } = await aesCbcEncryptChunk(aesKey, currentIv, toEncrypt, false);
-            currentIv = nextIv;
-            hmac.update(ciphertext);
-            encHash.update(ciphertext);
-            sidecar?.push(ciphertext);
-            if (ffCollected < ffTarget) {
-                const need = ffTarget - ffCollected;
-                ffChunks.push(ciphertext.subarray(0, Math.min(need, ciphertext.byteLength)));
-                ffCollected += ciphertext.byteLength;
-            }
-            await writeChunk(encrypted, ciphertext);
-        }
-        const { ciphertext: finalCiphertext } = await aesCbcEncryptChunk(aesKey, currentIv, pending, true);
-        hmac.update(finalCiphertext);
-        encHash.update(finalCiphertext);
-        sidecar?.push(finalCiphertext);
-        if (ffCollected < ffTarget) {
-            const need = ffTarget - ffCollected;
-            ffChunks.push(finalCiphertext.subarray(0, Math.min(need, finalCiphertext.byteLength)));
-        }
-        await writeChunk(encrypted, finalCiphertext);
-        const signature = toBytesView(hmac.digest().subarray(0, HMAC_TRUNCATED_SIZE));
-        encHash.update(signature);
-        sidecar?.push(signature);
-        await writeChunk(encrypted, signature);
-        encrypted.end();
-        let firstFrameSidecar;
-        if (ffTarget > 0) {
-            const ivCiphertextSlice = concatBytes(ffChunks);
-            const ffKey = await importHmacKey(keys.macKey);
-            const ffDigest = await hmacSign(ffKey, ivCiphertextSlice);
-            firstFrameSidecar = ffDigest.subarray(0, SIDECAR_HMAC_SIZE);
-        }
-        return {
-            fileSha256: toBytesView(plainHash.digest()),
-            fileEncSha256: toBytesView(encHash.digest()),
-            plaintextLength,
-            streamingSidecar: sidecar?.finish(),
-            firstFrameSidecar
-        };
-    }
-    catch (error) {
-        const normalized = toError(error);
-        encrypted.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 pumpEncryptionToWritable(plaintext, output, keys, computeSidecar, firstFrameLength) {
-    const aesKey = await importAesCbcKey(keys.encKey);
-    const plainHash = createHash('sha256');
-    const encHash = createHash('sha256');
-    const hmac = createHmac('sha256', keys.macKey);
-    const sidecar = computeSidecar ? new SidecarAccumulator(keys.macKey) : null;
-    const ffTarget = firstFrameLength !== undefined
-        ? IV_SIZE + Math.ceil(firstFrameLength / AES_BLOCK_SIZE) * AES_BLOCK_SIZE
-        : 0;
-    let ffCollected = 0;
-    const ffChunks = ffTarget > 0 ? [keys.iv] : [];
-    if (ffTarget > 0)
-        ffCollected = IV_SIZE;
-    let plaintextLength = 0;
-    let currentIv = keys.iv;
-    let pending = EMPTY_BYTES;
-    hmac.update(keys.iv);
-    sidecar?.push(keys.iv);
-    try {
-        for await (const chunk of plaintext) {
-            const plainChunk = toChunkBytes(chunk);
-            if (plainChunk.byteLength === 0)
-                continue;
-            plaintextLength += plainChunk.byteLength;
-            plainHash.update(plainChunk);
-            const combined = pending.byteLength > 0
-                ? concatBytes([pending, plainChunk])
-                : toBytesView(plainChunk);
-            const aligned = combined.byteLength - (combined.byteLength % AES_BLOCK_SIZE);
-            if (aligned === 0) {
-                pending = combined;
-                continue;
-            }
-            const toEncrypt = toBytesView(combined.subarray(0, aligned));
-            pending = toBytesView(combined.subarray(aligned));
-            const { ciphertext, nextIv } = await aesCbcEncryptChunk(aesKey, currentIv, toEncrypt, false);
-            currentIv = nextIv;
-            hmac.update(ciphertext);
-            encHash.update(ciphertext);
-            sidecar?.push(ciphertext);
-            if (ffCollected < ffTarget) {
-                const need = ffTarget - ffCollected;
-                ffChunks.push(ciphertext.subarray(0, Math.min(need, ciphertext.byteLength)));
-                ffCollected += ciphertext.byteLength;
-            }
-            await writeChunkToWritable(output, ciphertext);
-        }
-        const { ciphertext: finalCiphertext } = await aesCbcEncryptChunk(aesKey, currentIv, pending, true);
-        hmac.update(finalCiphertext);
-        encHash.update(finalCiphertext);
-        sidecar?.push(finalCiphertext);
-        if (ffCollected < ffTarget) {
-            const need = ffTarget - ffCollected;
-            ffChunks.push(finalCiphertext.subarray(0, Math.min(need, finalCiphertext.byteLength)));
-        }
-        await writeChunkToWritable(output, finalCiphertext);
-        const signature = toBytesView(hmac.digest().subarray(0, HMAC_TRUNCATED_SIZE));
-        encHash.update(signature);
-        sidecar?.push(signature);
-        await writeChunkToWritable(output, signature);
-        await endWritable(output);
-        let firstFrameSidecar;
-        if (ffTarget > 0) {
-            const ivCiphertextSlice = concatBytes(ffChunks);
-            const ffKey = await importHmacKey(keys.macKey);
-            const ffDigest = await hmacSign(ffKey, ivCiphertextSlice);
-            firstFrameSidecar = ffDigest.subarray(0, SIDECAR_HMAC_SIZE);
-        }
-        return {
-            fileSha256: toBytesView(plainHash.digest()),
-            fileEncSha256: toBytesView(encHash.digest()),
-            plaintextLength,
-            streamingSidecar: sidecar?.finish(),
-            firstFrameSidecar
-        };
-    }
-    catch (error) {
-        const normalized = toError(error);
-        output.destroy(normalized);
-        throw normalized;
-    }
-}
-async function pumpDecryption(encrypted, plaintext, keys, options) {
-    const aesKey = await importAesCbcKey(keys.encKey);
-    const plainHash = createHash('sha256');
-    const encHash = createHash('sha256');
-    const hmac = createHmac('sha256', keys.macKey);
-    let currentIv = keys.iv;
-    let pending = EMPTY_BYTES;
-    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 combined = pending.byteLength > 0
-                ? concatBytes([pending, ciphertextChunk])
-                : toBytesView(ciphertextChunk);
-            const aligned = combined.byteLength - (combined.byteLength % AES_BLOCK_SIZE);
-            if (aligned > AES_BLOCK_SIZE) {
-                const toDecrypt = combined.subarray(0, aligned - AES_BLOCK_SIZE);
-                const { plaintext: plainChunk, nextIv } = await aesCbcDecryptChunk(aesKey, currentIv, toDecrypt, false);
-                currentIv = nextIv;
-                if (plainChunk.byteLength > 0) {
-                    plainHash.update(plainChunk);
-                    await writeChunk(plaintext, plainChunk);
-                }
-                pending = toBytesView(combined.subarray(aligned - AES_BLOCK_SIZE));
-            }
-            else {
-                pending = combined;
-            }
-        }
-        if (trailing.byteLength !== HMAC_TRUNCATED_SIZE) {
-            throw new Error(`ciphertext too short: ${trailing.byteLength}`);
-        }
-        if (!options.skipMacVerification) {
-            const signature = hmac.digest().subarray(0, HMAC_TRUNCATED_SIZE);
-            if (!uint8TimingSafeEqual(signature, trailing)) {
-                throw new Error('media MAC mismatch');
-            }
-        }
-        if (pending.byteLength < AES_BLOCK_SIZE || pending.byteLength % AES_BLOCK_SIZE !== 0) {
-            throw new Error(`invalid ciphertext length: ${pending.byteLength}`);
-        }
-        const { plaintext: plainFinal } = await aesCbcDecryptChunk(aesKey, currentIv, pending, true);
-        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/message/phash.js

@@ -1,47 +0,0 @@
-import { sha256 } from '../crypto/core/index.js';
-import { bytesToBase64, TEXT_ENCODER } from '../util/bytes.js';
-export async function computePhashV2(participants) {
-    if (participants.length === 0) {
-        return '2:';
-    }
-    const canonical = new Array(participants.length);
-    for (let i = 0; i < participants.length; i += 1)
-        canonical[i] = toPhashCanonicalWid(participants[i]);
-    const joined = canonical.sort().join('');
-    const digest = await sha256(TEXT_ENCODER.encode(joined));
-    return `2:${bytesToBase64(digest.subarray(0, 6))}`;
-}
-function toPhashCanonicalWid(jid) {
-    const atIndex = jid.indexOf('@');
-    if (atIndex < 1 || atIndex >= jid.length - 1)
-        return jid;
-    const colonIndex = jid.indexOf(':', 0);
-    const userEnd = colonIndex >= 0 && colonIndex < atIndex ? colonIndex : atIndex;
-    const hasZeroAgent = userEnd >= 2 && jid.charCodeAt(userEnd - 2) === 46 && jid.charCodeAt(userEnd - 1) === 48;
-    const baseUserEnd = hasZeroAgent ? userEnd - 2 : userEnd;
-    const baseUser = jid.slice(0, baseUserEnd);
-    let device = 0;
-    if (colonIndex >= 0 && colonIndex < atIndex) {
-        for (let i = colonIndex + 1; i < atIndex; i += 1) {
-            const digit = jid.charCodeAt(i) - 48;
-            if (digit < 0 || digit > 9) {
-                device = 0;
-                break;
-            }
-            device = device * 10 + digit;
-            if (device > Number.MAX_SAFE_INTEGER) {
-                device = 0;
-                break;
-            }
-        }
-    }
-    const serverStart = atIndex + 1;
-    const serverLen = jid.length - serverStart;
-    const isCUs = serverLen === 4 &&
-        jid.charCodeAt(serverStart) === 99 &&
-        jid.charCodeAt(serverStart + 1) === 46 &&
-        jid.charCodeAt(serverStart + 2) === 117 &&
-        jid.charCodeAt(serverStart + 3) === 115;
-    const normalizedServer = isCUs ? 's.whatsapp.net' : jid.slice(serverStart);
-    return `${baseUser}.0:${device}@${normalizedServer}`;
-}

package/dist/esm/store/locks/participants.lock.js

@@ -1,20 +0,0 @@
-import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
-import { StoreLock } from '../../infra/perf/StoreLock.js';
-const WA_PARTICIPANTS_CLEAR_KEY = 'participants:clear';
-const WA_PARTICIPANTS_CLEANUP_KEY = 'participants:cleanup';
-export function withParticipantsLock(store) {
-    const lock = new StoreLock();
-    const gate = new SharedExclusiveGate();
-    return {
-        destroy: async () => {
-            await gate.close();
-            await lock.shutdown();
-            await store.destroy?.();
-        },
-        upsertGroupParticipants: (snapshot) => gate.runShared(() => lock.run(`participants:group:${snapshot.groupJid}`, () => store.upsertGroupParticipants(snapshot))),
-        getGroupParticipants: (groupJid, nowMs) => gate.runShared(() => store.getGroupParticipants(groupJid, nowMs)),
-        deleteGroupParticipants: (groupJid) => gate.runShared(() => lock.run(`participants:group:${groupJid}`, () => store.deleteGroupParticipants(groupJid))),
-        cleanupExpired: (nowMs) => gate.runExclusive(() => lock.run(WA_PARTICIPANTS_CLEANUP_KEY, () => store.cleanupExpired(nowMs))),
-        clear: () => gate.runExclusive(() => lock.run(WA_PARTICIPANTS_CLEAR_KEY, () => store.clear()))
-    };
-}

package/dist/esm/store/providers/memory/contact.store.js

@@ -1,28 +0,0 @@
-import { resolvePositive } from '../../../util/coercion.js';
-import { setBoundedMapEntry } from '../../../util/collections.js';
-const DEFAULT_CONTACT_MEMORY_STORE_LIMITS = Object.freeze({
-    contacts: 20000
-});
-export class WaContactMemoryStore {
-    constructor(options = {}) {
-        this.contacts = new Map();
-        this.maxContacts = resolvePositive(options.maxContacts, DEFAULT_CONTACT_MEMORY_STORE_LIMITS.contacts, 'WaContactMemoryStoreOptions.maxContacts');
-    }
-    async upsert(record) {
-        setBoundedMapEntry(this.contacts, record.jid, record, this.maxContacts);
-    }
-    async upsertBatch(records) {
-        for (const record of records) {
-            setBoundedMapEntry(this.contacts, record.jid, record, this.maxContacts);
-        }
-    }
-    async getByJid(jid) {
-        return this.contacts.get(jid) ?? null;
-    }
-    async deleteByJid(jid) {
-        return this.contacts.delete(jid) ? 1 : 0;
-    }
-    async clear() {
-        this.contacts.clear();
-    }
-}

package/dist/esm/store/providers/memory/device-list.store.js

@@ -1,67 +0,0 @@
-import { resolvePositive } from '../../../util/coercion.js';
-import { resolveCleanupIntervalMs, setBoundedMapEntry } from '../../../util/collections.js';
-const DEFAULTS = Object.freeze({
-    ttlMs: 5 * 60 * 1000,
-    maxUsers: 16384
-});
-export class WaDeviceListMemoryStore {
-    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
-        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
-            throw new Error('device-list ttlMs must be a positive finite number');
-        }
-        this.records = new Map();
-        this.ttlMs = ttlMs;
-        this.maxUsers = resolvePositive(options.maxUsers, DEFAULTS.maxUsers, 'WaDeviceListMemoryStoreOptions.maxUsers');
-        this.cleanupTimer = setInterval(() => {
-            void this.cleanupExpired(Date.now());
-        }, resolveCleanupIntervalMs(ttlMs));
-        this.cleanupTimer.unref();
-    }
-    async upsertUserDevicesBatch(snapshots) {
-        for (let index = 0; index < snapshots.length; index += 1) {
-            const snapshot = snapshots[index];
-            setBoundedMapEntry(this.records, snapshot.userJid, {
-                ...snapshot,
-                expiresAtMs: snapshot.updatedAtMs + this.ttlMs
-            }, this.maxUsers);
-        }
-    }
-    async getUserDevicesBatch(userJids, nowMs = Date.now()) {
-        const snapshots = new Array(userJids.length);
-        for (let index = 0; index < userJids.length; index += 1) {
-            const userJid = userJids[index];
-            const record = this.records.get(userJid);
-            if (!record) {
-                snapshots[index] = null;
-                continue;
-            }
-            if (record.expiresAtMs <= nowMs) {
-                this.records.delete(userJid);
-                snapshots[index] = null;
-                continue;
-            }
-            snapshots[index] = record;
-        }
-        return snapshots;
-    }
-    async deleteUserDevices(userJid) {
-        return this.records.delete(userJid) ? 1 : 0;
-    }
-    async cleanupExpired(nowMs) {
-        let removed = 0;
-        for (const [userJid, record] of this.records) {
-            if (record.expiresAtMs > nowMs)
-                continue;
-            this.records.delete(userJid);
-            removed += 1;
-        }
-        return removed;
-    }
-    async clear() {
-        this.records.clear();
-    }
-    async destroy() {
-        clearInterval(this.cleanupTimer);
-        await this.clear();
-    }
-}

package/dist/esm/transport/node/mex/persist-ids.js

@@ -1,10 +0,0 @@
-export const WA_MEX_PERSIST_IDS = Object.freeze({
-    WWWGetCertificates: Object.freeze({
-        docId: '25094190163544446',
-        clientDocId: '16428758503015954638431529919'
-    }),
-    WWWCreateUser: Object.freeze({
-        docId: '8548056818544135',
-        clientDocId: '25777518041400352865446016972'
-    })
-});