@badzz88/baileys 8.5.6 → 8.5.7

package/src/Utils/reporting-utils.js

@@ -1,261 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.getMessageReportingToken = exports.shouldIncludeReportingToken = void 0;
-const Crypto_1 = require('./crypto');
-const crypto_2 = require('./crypto');
-const reportingFields = [
-    { f: 1 },
-    {
-        f: 3,
-        s: [{ f: 2 }, { f: 3 }, { f: 8 }, { f: 11 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 25 }]
-    },
-    { f: 4, s: [{ f: 1 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
-    { f: 5, s: [{ f: 3 }, { f: 4 }, { f: 5 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
-    { f: 6, s: [{ f: 1 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 30 }] },
-    { f: 7, s: [{ f: 2 }, { f: 7 }, { f: 10 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
-    { f: 8, s: [{ f: 2 }, { f: 7 }, { f: 9 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 21 }] },
-    { f: 9, s: [{ f: 2 }, { f: 6 }, { f: 7 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
-    { f: 12, s: [{ f: 1 }, { f: 2 }, { f: 14, m: true }, { f: 15 }] },
-    { f: 18, s: [{ f: 6 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
-    { f: 26, s: [{ f: 4 }, { f: 5 }, { f: 8 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
-    { f: 28, s: [{ f: 1 }, { f: 2 }, { f: 4 }, { f: 5 }, { f: 6 }, { f: 7, s: [{ f: 21 }, { f: 22 }] }] },
-    { f: 37, s: [{ f: 1, m: true }] },
-    {
-        f: 49,
-        s: [
-            { f: 2 },
-            { f: 3, s: [{ f: 1 }, { f: 2 }] },
-            { f: 5, s: [{ f: 21 }, { f: 22 }] },
-            { f: 8, s: [{ f: 1 }, { f: 2 }] }
-        ]
-    },
-    { f: 53, s: [{ f: 1, m: true }] },
-    { f: 55, s: [{ f: 1, m: true }] },
-    { f: 58, s: [{ f: 1, m: true }] },
-    { f: 59, s: [{ f: 1, m: true }] },
-    {
-        f: 60,
-        s: [
-            { f: 2 },
-            { f: 3, s: [{ f: 1 }, { f: 2 }] },
-            { f: 5, s: [{ f: 21 }, { f: 22 }] },
-            { f: 8, s: [{ f: 1 }, { f: 2 }] }
-        ]
-    },
-    {
-        f: 64,
-        s: [
-            { f: 2 },
-            { f: 3, s: [{ f: 1 }, { f: 2 }] },
-            { f: 5, s: [{ f: 21 }, { f: 22 }] },
-            { f: 8, s: [{ f: 1 }, { f: 2 }] }
-        ]
-    },
-    { f: 66, s: [{ f: 2 }, { f: 6 }, { f: 7 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
-    { f: 74, s: [{ f: 1, m: true }] },
-    { f: 87, s: [{ f: 1, m: true }] },
-    { f: 88, s: [{ f: 1 }, { f: 2, s: [{ f: 1 }] }, { f: 3, s: [{ f: 21 }, { f: 22 }] }] },
-    { f: 92, s: [{ f: 1, m: true }] },
-    { f: 93, s: [{ f: 1, m: true }] },
-    { f: 94, s: [{ f: 1, m: true }] }
-];
-const compileReportingFields = fields => {
-    const map = new Map();
-    for (const f of fields) {
-        map.set(f.f, {
-            m: f.m,
-            children: f.s ? compileReportingFields(f.s) : undefined
-        });
-    }
-    return map;
-};
-const compiledReportingFields = compileReportingFields(reportingFields);
-const EMPTY_MAP = new Map();
-const ENC_SECRET_REPORT_TOKEN = 'Report Token';
-const WIRE = {
-    VARINT: 0,
-    FIXED64: 1,
-    BYTES: 2,
-    FIXED32: 5
-};
-const shouldIncludeReportingToken = message => !message.reactionMessage &&
-    !message.encReactionMessage &&
-    !message.encEventResponseMessage &&
-    !message.pollUpdateMessage;
-exports.shouldIncludeReportingToken = shouldIncludeReportingToken;
-const generateMsgSecretKey = (modificationType, origMsgId, origMsgSender, modificationSender, origMsgSecret) => {
-    const useCaseSecret = Buffer.concat([
-        Buffer.from(origMsgId, 'utf8'),
-        Buffer.from(origMsgSender, 'utf8'),
-        Buffer.from(modificationSender, 'utf8'),
-        Buffer.from(modificationType, 'utf8')
-    ]);
-    return (0, crypto_2.hkdf)(origMsgSecret, 32, { info: useCaseSecret.toString('latin1') });
-};
-const extractReportingTokenContent = (data, cfg) => {
-    const out = [];
-    let i = 0;
-    while (i < data.length) {
-        const tag = decodeVarint(data, i);
-        if (!tag.ok) {
-            return null;
-        }
-        const fieldNum = tag.value >> 3;
-        const wireType = tag.value & 0x7;
-        const fieldStart = i;
-        i += tag.bytes;
-        const fieldCfg = cfg.get(fieldNum);
-        const pushSlice = end => {
-            if (end > data.length) {
-                return false;
-            }
-            out.push({ num: fieldNum, bytes: data.subarray(fieldStart, end) });
-            i = end;
-            return true;
-        };
-        const skip = end => {
-            if (end > data.length) {
-                return false;
-            }
-            i = end;
-            return true;
-        };
-        if (wireType === WIRE.VARINT) {
-            const v = decodeVarint(data, i);
-            if (!v.ok) {
-                return null;
-            }
-            const end = i + v.bytes;
-            if (!fieldCfg) {
-                if (!skip(end)) {
-                    return null;
-                }
-                continue;
-            }
-            if (!pushSlice(end)) {
-                return null;
-            }
-            continue;
-        }
-        if (wireType === WIRE.FIXED64) {
-            const end = i + 8;
-            if (!fieldCfg) {
-                if (!skip(end)) {
-                    return null;
-                }
-                continue;
-            }
-            if (!pushSlice(end)) {
-                return null;
-            }
-            continue;
-        }
-        if (wireType === WIRE.FIXED32) {
-            const end = i + 4;
-            if (!fieldCfg) {
-                if (!skip(end)) {
-                    return null;
-                }
-                continue;
-            }
-            if (!pushSlice(end)) {
-                return null;
-            }
-            continue;
-        }
-        if (wireType === WIRE.BYTES) {
-            const len = decodeVarint(data, i);
-            if (!len.ok) {
-                return null;
-            }
-            const valStart = i + len.bytes;
-            const valEnd = valStart + len.value;
-            if (valEnd > data.length) {
-                return null;
-            }
-            if (!fieldCfg) {
-                i = valEnd;
-                continue;
-            }
-            if (fieldCfg.m || fieldCfg.children) {
-                const sub = extractReportingTokenContent(data.subarray(valStart, valEnd), fieldCfg.children ?? EMPTY_MAP);
-                if (sub === null) {
-                    return null;
-                }
-                if (sub.length > 0) {
-                    const newTag = encodeVarint(tag.value);
-                    const newLen = encodeVarint(sub.length);
-                    out.push({
-                        num: fieldNum,
-                        bytes: Buffer.concat([newTag, newLen, sub])
-                    });
-                }
-                i = valEnd;
-                continue;
-            }
-            out.push({ num: fieldNum, bytes: data.subarray(fieldStart, valEnd) });
-            i = valEnd;
-            continue;
-        }
-        return null;
-    }
-    if (out.length === 0) {
-        return Buffer.alloc(0);
-    }
-    out.sort((a, b) => a.num - b.num);
-    return Buffer.concat(out.map(f => f.bytes));
-};
-const decodeVarint = (buffer, offset) => {
-    let value = 0;
-    let bytes = 0;
-    let shift = 0;
-    while (offset + bytes < buffer.length) {
-        const current = buffer[offset + bytes];
-        value |= (current & 0x7f) << shift;
-        bytes++;
-        if ((current & 0x80) === 0) {
-            return { value, bytes, ok: true };
-        }
-        shift += 7;
-        if (shift > 35) {
-            return { value: 0, bytes: 0, ok: false };
-        }
-    }
-    return { value: 0, bytes: 0, ok: false };
-};
-const encodeVarint = value => {
-    const parts = [];
-    let remaining = value >>> 0;
-    while (remaining > 0x7f) {
-        parts.push((remaining & 0x7f) | 0x80);
-        remaining >>>= 7;
-    }
-    parts.push(remaining);
-    return Buffer.from(parts);
-};
-const getMessageReportingToken = async (msgProtobuf, message, key) => {
-    const msgSecret = message.messageContextInfo?.messageSecret;
-    if (!msgSecret || !key.id) {
-        return null;
-    }
-    const from = key.fromMe ? key.remoteJid : key.participant || key.remoteJid;
-    const to = key.fromMe ? key.participant || key.remoteJid : key.remoteJid;
-    const reportingSecret = generateMsgSecretKey(ENC_SECRET_REPORT_TOKEN, key.id, from, to, msgSecret);
-    const content = extractReportingTokenContent(msgProtobuf, compiledReportingFields);
-    if (!content || content.length === 0) {
-        return null;
-    }
-    const reportingToken = Buffer.from(Crypto_1.hmacSign(content, reportingSecret)).subarray(0, 16);
-    return {
-        tag: 'reporting',
-        attrs: {},
-        content: [
-            {
-                tag: 'reporting_token',
-                attrs: { v: '2' },
-                content: reportingToken
-            }
-        ]
-    };
-};
-exports.getMessageReportingToken = getMessageReportingToken;

package/src/Utils/session-pool.d.ts

@@ -1,14 +0,0 @@
-export interface SessionPoolOptions {
-    makeSocket: (sessionId: string) => Promise<any> | any;
-    logger?: any;
-    maxBackoffMs?: number;
-    onSessionUpdate?: (sessionId: string, sock: any) => void;
-    onLoggedOut?: (sessionId: string) => void;
-}
-export interface SessionPool {
-    add: (sessionId: string) => Promise<void>;
-    remove: (sessionId: string) => void;
-    get: (sessionId: string) => any;
-    list: () => string[];
-}
-export function createSessionPool(options: SessionPoolOptions): SessionPool;

package/src/Utils/session-pool.js

@@ -1,70 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.createSessionPool = void 0;
-const DISCONNECT_REASON_LOGGED_OUT = 401;
-const createSessionPool = options => {
-    const logger = options.logger;
-    const maxBackoffMs = options.maxBackoffMs ?? 60000;
-    const sessions = new Map();
-    const computeBackoffMs = attempts => {
-        const base = Math.min(1000 * 2 ** attempts, maxBackoffMs);
-        return base + Math.floor(Math.random() * (base * 0.2));
-    };
-    const start = async (sessionId) => {
-        const entry = sessions.get(sessionId) || { attempts: 0, stopped: false };
-        sessions.set(sessionId, entry);
-        if (entry.stopped)
-            return;
-        try {
-            const sock = await options.makeSocket(sessionId);
-            entry.sock = sock;
-            options.onSessionUpdate?.(sessionId, sock);
-            sock.ev.on('connection.update', update => {
-                if (update.connection === 'open') {
-                    entry.attempts = 0;
-                }
-                if (update.connection === 'close') {
-                    const statusCode = update.lastDisconnect?.error?.output?.statusCode;
-                    if (statusCode === DISCONNECT_REASON_LOGGED_OUT) {
-                        logger?.info?.({ sessionId }, 'session logged out, removing from pool');
-                        sessions.delete(sessionId);
-                        options.onLoggedOut?.(sessionId);
-                        return;
-                    }
-                    if (entry.stopped)
-                        return;
-                    entry.attempts += 1;
-                    const backoffMs = computeBackoffMs(entry.attempts);
-                    logger?.warn?.({ sessionId, attempt: entry.attempts, backoffMs }, 'session disconnected, reconnecting with backoff');
-                    setTimeout(() => start(sessionId), backoffMs);
-                }
-            });
-        }
-        catch (error) {
-            entry.attempts += 1;
-            const backoffMs = computeBackoffMs(entry.attempts);
-            logger?.error?.({ error, sessionId, backoffMs }, 'failed to start session, retrying with backoff');
-            if (!entry.stopped) {
-                setTimeout(() => start(sessionId), backoffMs);
-            }
-        }
-    };
-    const add = sessionId => start(sessionId);
-    const remove = sessionId => {
-        const entry = sessions.get(sessionId);
-        if (!entry)
-            return;
-        entry.stopped = true;
-        if (entry.sock?.end) {
-            try {
-                entry.sock.end(undefined);
-            }
-            catch { }
-        }
-        sessions.delete(sessionId);
-    };
-    const get = sessionId => sessions.get(sessionId)?.sock;
-    const list = () => [...sessions.keys()];
-    return { add, remove, get, list };
-};
-exports.createSessionPool = createSessionPool;

package/src/Utils/signal.js

@@ -1,217 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.getNextPreKeysNode =
-    exports.getNextPreKeys =
-        exports.extractDeviceJids =
-            exports.parseAndInjectE2ESessions =
-                exports.extractE2ESessionFromRetryReceipt =
-                    exports.xmppPreKey =
-                        exports.xmppSignedPreKey =
-                            exports.generateOrGetPreKeys =
-                                exports.getPreKeys =
-                                    exports.createSignalIdentity =
-                                        void 0;
-const Defaults_1 = require('../Defaults');
-const WABinary_1 = require('../WABinary');
-const crypto_1 = require('./crypto');
-const generics_1 = require('./generics');
-function chunk(array, size) {
-    const chunks = [];
-    for (let i = 0; i < array.length; i += size) {
-        chunks.push(array.slice(i, i + size));
-    }
-    return chunks;
-}
-const createSignalIdentity = (wid, accountSignatureKey) => {
-    return {
-        identifier: { name: wid, deviceId: 0 },
-        identifierKey: (0, crypto_1.generateSignalPubKey)(accountSignatureKey)
-    };
-};
-exports.createSignalIdentity = createSignalIdentity;
-const getPreKeys = async ({ get }, min, limit) => {
-    const idList = [];
-    for (let id = min; id < limit; id++) {
-        idList.push(id.toString());
-    }
-    return get('pre-key', idList);
-};
-exports.getPreKeys = getPreKeys;
-const generateOrGetPreKeys = (creds, range) => {
-    const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId;
-    const remaining = range - avaliable;
-    const lastPreKeyId = creds.nextPreKeyId + remaining - 1;
-    const newPreKeys = {};
-    if (remaining > 0) {
-        for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
-            newPreKeys[i] = crypto_1.Curve.generateKeyPair();
-        }
-    }
-    return {
-        newPreKeys,
-        lastPreKeyId,
-        preKeysRange: [creds.firstUnuploadedPreKeyId, range]
-    };
-};
-exports.generateOrGetPreKeys = generateOrGetPreKeys;
-const xmppSignedPreKey = key => ({
-    tag: 'skey',
-    attrs: {},
-    content: [
-        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(key.keyId, 3) },
-        { tag: 'value', attrs: {}, content: key.keyPair.public },
-        { tag: 'signature', attrs: {}, content: key.signature }
-    ]
-});
-exports.xmppSignedPreKey = xmppSignedPreKey;
-const xmppPreKey = (pair, id) => ({
-    tag: 'key',
-    attrs: {},
-    content: [
-        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(id, 3) },
-        { tag: 'value', attrs: {}, content: pair.public }
-    ]
-});
-exports.xmppPreKey = xmppPreKey;
-const isValidUInt = n => typeof n === 'number' && Number.isInteger(n);
-const extractE2ESessionFromRetryReceipt = receipt => {
-    const keysNode = (0, WABinary_1.getBinaryNodeChild)(receipt, 'keys');
-    if (!keysNode)
-        return null;
-    const typeBuf = (0, WABinary_1.getBinaryNodeChildBuffer)(keysNode, 'type');
-    if (!typeBuf || typeBuf.length !== 1 || typeBuf[0] !== Defaults_1.KEY_BUNDLE_TYPE[0])
-        return null;
-    const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(keysNode, 'identity');
-    const skey = (0, WABinary_1.getBinaryNodeChild)(keysNode, 'skey');
-    if (!identity || identity.length !== 32 || !skey)
-        return null;
-    const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(receipt, 'registration', 4);
-    if (!isValidUInt(registrationId))
-        return null;
-    const signedPubKey = (0, WABinary_1.getBinaryNodeChildBuffer)(skey, 'value');
-    const signedSig = (0, WABinary_1.getBinaryNodeChildBuffer)(skey, 'signature');
-    const signedKeyId = (0, WABinary_1.getBinaryNodeChildUInt)(skey, 'id', 3);
-    if (!signedPubKey || signedPubKey.length !== 32 || !signedSig || !isValidUInt(signedKeyId)) {
-        return null;
-    }
-    const preKeyNode = (0, WABinary_1.getBinaryNodeChild)(keysNode, 'key');
-    let preKey;
-    if (preKeyNode) {
-        const preKeyPub = (0, WABinary_1.getBinaryNodeChildBuffer)(preKeyNode, 'value');
-        const preKeyId = (0, WABinary_1.getBinaryNodeChildUInt)(preKeyNode, 'id', 3);
-        if (!preKeyPub || preKeyPub.length !== 32 || !isValidUInt(preKeyId)) {
-            return null;
-        }
-        preKey = { keyId: preKeyId, publicKey: (0, crypto_1.generateSignalPubKey)(preKeyPub) };
-    }
-    return {
-        registrationId,
-        identityKey: (0, crypto_1.generateSignalPubKey)(identity),
-        signedPreKey: {
-            keyId: signedKeyId,
-            publicKey: (0, crypto_1.generateSignalPubKey)(signedPubKey),
-            signature: signedSig
-        },
-        preKey
-    };
-};
-exports.extractE2ESessionFromRetryReceipt = extractE2ESessionFromRetryReceipt;
-const parseAndInjectE2ESessions = async (node, repository) => {
-    const extractKey = key => key
-        ? {
-            keyId: (0, WABinary_1.getBinaryNodeChildUInt)(key, 'id', 3),
-            publicKey: (0, crypto_1.generateSignalPubKey)((0, WABinary_1.getBinaryNodeChildBuffer)(key, 'value')),
-            signature: (0, WABinary_1.getBinaryNodeChildBuffer)(key, 'signature')
-        }
-        : undefined;
-    const nodes = (0, WABinary_1.getBinaryNodeChildren)((0, WABinary_1.getBinaryNodeChild)(node, 'list'), 'user');
-    for (const node of nodes) {
-        ;
-        (0, WABinary_1.assertNodeErrorFree)(node);
-    }
-    const chunkSize = 100;
-    const chunks = chunk(nodes, chunkSize);
-    for (const nodesChunk of chunks) {
-        for (const node of nodesChunk) {
-            const signedKey = (0, WABinary_1.getBinaryNodeChild)(node, 'skey');
-            const key = (0, WABinary_1.getBinaryNodeChild)(node, 'key');
-            const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(node, 'identity');
-            const jid = node.attrs.jid;
-            const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(node, 'registration', 4);
-            await repository.injectE2ESession({
-                jid,
-                session: {
-                    registrationId: registrationId,
-                    identityKey: (0, crypto_1.generateSignalPubKey)(identity),
-                    signedPreKey: extractKey(signedKey),
-                    preKey: extractKey(key)
-                }
-            });
-        }
-    }
-};
-exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions;
-const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
-    const { user: myUser, device: myDevice } = (0, WABinary_1.jidDecode)(myJid);
-    const extracted = [];
-    for (const userResult of result) {
-        const { devices, id } = userResult;
-        const decoded = (0, WABinary_1.jidDecode)(id), { user, server } = decoded;
-        let { domainType } = decoded;
-        const deviceList = devices?.deviceList;
-        if (!Array.isArray(deviceList))
-            continue;
-        for (const { id: device, keyIndex, isHosted } of deviceList) {
-            if ((!excludeZeroDevices || device !== 0) &&
-                ((myUser !== user && myLid !== user) || myDevice !== device) &&
-                (device === 0 || !!keyIndex)) {
-                if (isHosted) {
-                    domainType =
-                        domainType === WABinary_1.WAJIDDomains.LID
-                            ? WABinary_1.WAJIDDomains.HOSTED_LID
-                            : WABinary_1.WAJIDDomains.HOSTED;
-                }
-                extracted.push({
-                    user,
-                    device,
-                    domainType,
-                    server: (0, WABinary_1.getServerFromDomainType)(server, domainType)
-                });
-            }
-        }
-    }
-    return extracted;
-};
-exports.extractDeviceJids = extractDeviceJids;
-const getNextPreKeys = async ({ creds, keys }, count) => {
-    const { newPreKeys, lastPreKeyId, preKeysRange } = (0, exports.generateOrGetPreKeys)(creds, count);
-    const update = {
-        nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
-        firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
-    };
-    await keys.set({ 'pre-key': newPreKeys });
-    const preKeys = await (0, exports.getPreKeys)(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
-    return { update, preKeys };
-};
-exports.getNextPreKeys = getNextPreKeys;
-const getNextPreKeysNode = async (state, count) => {
-    const { creds } = state;
-    const { update, preKeys } = await (0, exports.getNextPreKeys)(state, count);
-    const node = {
-        tag: 'iq',
-        attrs: {
-            xmlns: 'encrypt',
-            type: 'set',
-            to: WABinary_1.S_WHATSAPP_NET
-        },
-        content: [
-            { tag: 'registration', attrs: {}, content: (0, generics_1.encodeBigEndian)(creds.registrationId) },
-            { tag: 'type', attrs: {}, content: Defaults_1.KEY_BUNDLE_TYPE },
-            { tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
-            { tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => (0, exports.xmppPreKey)(preKeys[+k], +k)) },
-            (0, exports.xmppSignedPreKey)(creds.signedPreKey)
-        ]
-    };
-    return { update, node };
-};
-exports.getNextPreKeysNode = getNextPreKeysNode;

package/src/Utils/stanza-ack.js

@@ -1,30 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.buildAckStanza = buildAckStanza;
-function buildAckStanza(node, errorCode, meId) {
-    const { tag, attrs } = node;
-    const stanza = {
-        tag: 'ack',
-        attrs: {
-            id: attrs.id,
-            to: attrs.from,
-            class: tag
-        }
-    };
-    if (errorCode) {
-        stanza.attrs.error = errorCode.toString();
-    }
-    if (attrs.participant) {
-        stanza.attrs.participant = attrs.participant;
-    }
-    if (attrs.recipient) {
-        stanza.attrs.recipient = attrs.recipient;
-    }
-    if (attrs.type) {
-        stanza.attrs.type = attrs.type;
-    }
-    if (tag === 'message' && meId) {
-        stanza.attrs.from = meId;
-    }
-    return stanza;
-}

package/src/Utils/sticker.d.ts

@@ -1,13 +0,0 @@
-export interface StickerMetaOptions {
-    packName?: string;
-    packPublisher?: string;
-    categories?: string[];
-}
-export function addExifToWebp(webpBuffer: Buffer, options?: StickerMetaOptions): Promise<Buffer>;
-export function imageToWebpSticker(imageBuffer: Buffer, options?: StickerMetaOptions & {
-    quality?: number;
-}): Promise<Buffer>;
-export function videoToWebpSticker(videoBuffer: Buffer, options?: StickerMetaOptions & {
-    fps?: number;
-    seconds?: number;
-}): Promise<Buffer>;