@badzz88/baileys 8.4.6 → 8.4.9

package/lib/Utils/generics.js

@@ -1,399 +0,0 @@
-import { Boom } from '@hapi/boom';
-import { createHash, randomBytes } from 'crypto';
-import { proto } from '../../WAProto/index.js';
-const baileysVersion = [2, 3000, 1035194821];
-import { DisconnectReason } from '../Types/index.js';
-import { getAllBinaryNodeChildren, jidDecode } from '../WABinary/index.js';
-import { sha256 } from './crypto.js';
-export const BufferJSON = {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    replacer: (k, value) => {
-        if (Buffer.isBuffer(value) || value instanceof Uint8Array || value?.type === 'Buffer') {
-            return { type: 'Buffer', data: Buffer.from(value?.data || value).toString('base64') };
-        }
-        return value;
-    },
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    reviver: (_, value) => {
-        if (typeof value === 'object' && value !== null && value.type === 'Buffer' && typeof value.data === 'string') {
-            return Buffer.from(value.data, 'base64');
-        }
-        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-            const keys = Object.keys(value);
-            if (keys.length > 0 && keys.every(k => !isNaN(parseInt(k, 10)))) {
-                const values = Object.values(value);
-                if (values.every(v => typeof v === 'number')) {
-                    return Buffer.from(values);
-                }
-            }
-        }
-        return value;
-    }
-};
-export const getKeyAuthor = (key, meId = 'me') => (key?.fromMe ? meId : key?.participantAlt || key?.remoteJidAlt || key?.participant || key?.remoteJid) || '';
-export const isStringNullOrEmpty = (value) => 
-// eslint-disable-next-line eqeqeq
-value == null || value === '';
-export const writeRandomPadMax16 = (msg) => {
-    const pad = randomBytes(1);
-    const padLength = (pad[0] & 0x0f) + 1;
-    return Buffer.concat([msg, Buffer.alloc(padLength, padLength)]);
-};
-export const unpadRandomMax16 = (e) => {
-    const t = new Uint8Array(e);
-    if (0 === t.length) {
-        throw new Error('unpadPkcs7 given empty bytes');
-    }
-    var r = t[t.length - 1];
-    if (r > t.length) {
-        throw new Error(`unpad given ${t.length} bytes, but pad is ${r}`);
-    }
-    return new Uint8Array(t.buffer, t.byteOffset, t.length - r);
-};
-// code is inspired by whatsmeow
-export const generateParticipantHashV2 = (participants) => {
-    participants.sort();
-    const sha256Hash = sha256(Buffer.from(participants.join(''))).toString('base64');
-    return '2:' + sha256Hash.slice(0, 6);
-};
-export const encodeWAMessage = (message) => writeRandomPadMax16(proto.Message.encode(message).finish());
-export const generateRegistrationId = () => {
-    return Uint16Array.from(randomBytes(2))[0] & 16383;
-};
-export const encodeBigEndian = (e, t = 4) => {
-    let r = e;
-    const a = new Uint8Array(t);
-    for (let i = t - 1; i >= 0; i--) {
-        a[i] = 255 & r;
-        r >>>= 8;
-    }
-    return a;
-};
-export const toNumber = (t) => typeof t === 'object' && t ? ('toNumber' in t ? t.toNumber() : t.low) : t || 0;
-/** unix timestamp of a date in seconds */
-export const unixTimestampSeconds = (date = new Date()) => Math.floor(date.getTime() / 1000);
-export const debouncedTimeout = (intervalMs = 1000, task) => {
-    let timeout;
-    return {
-        start: (newIntervalMs, newTask) => {
-            task = newTask || task;
-            intervalMs = newIntervalMs || intervalMs;
-            timeout && clearTimeout(timeout);
-            timeout = setTimeout(() => task?.(), intervalMs);
-        },
-        cancel: () => {
-            timeout && clearTimeout(timeout);
-            timeout = undefined;
-        },
-        setTask: (newTask) => (task = newTask),
-        setInterval: (newInterval) => (intervalMs = newInterval)
-    };
-};
-export const delay = (ms) => delayCancellable(ms).delay;
-export const delayCancellable = (ms) => {
-    const stack = new Error().stack;
-    let timeout;
-    let reject;
-    const delay = new Promise((resolve, _reject) => {
-        timeout = setTimeout(resolve, ms);
-        reject = _reject;
-    });
-    const cancel = () => {
-        clearTimeout(timeout);
-        reject(new Boom('Cancelled', {
-            statusCode: 500,
-            data: {
-                stack
-            }
-        }));
-    };
-    return { delay, cancel };
-};
-export async function promiseTimeout(ms, promise) {
-    if (!ms) {
-        return new Promise(promise);
-    }
-    const stack = new Error().stack;
-    // Create a promise that rejects in <ms> milliseconds
-    const { delay, cancel } = delayCancellable(ms);
-    const p = new Promise((resolve, reject) => {
-        delay
-            .then(() => reject(new Boom('Timed Out', {
-            statusCode: DisconnectReason.timedOut,
-            data: {
-                stack
-            }
-        })))
-            .catch(err => reject(err));
-        promise(resolve, reject);
-    }).finally(cancel);
-    return p;
-}
-
-export const generateMessageIDV2 = (userId) => {
-    const data = Buffer.alloc(8 + 20 + 16);
-    data.writeBigUInt64BE(BigInt(Math.floor(Date.now() / 1000)));
-    if (userId) {
-        const id = jidDecode(userId);
-        if (id?.user) {
-            data.write(id.user, 8);
-            data.write('@c.us', 8 + id.user.length);
-        }
-    }
-    const random = randomBytes(16);
-    random.copy(data, 28);
-    const hash = createHash('sha256').update(data).digest();
-    return 'B4DZZN3-' + hash.toString('hex').toUpperCase().substring(0, 18);
-};
-
-export const generateMessageID = () => 'B4DZZN3-' + randomBytes(18).toString('hex').toUpperCase();
-export function bindWaitForEvent(ev, event) {
-    return async (check, timeoutMs) => {
-        let listener;
-        let closeListener;
-        await promiseTimeout(timeoutMs, (resolve, reject) => {
-            closeListener = ({ connection, lastDisconnect }) => {
-                if (connection === 'close') {
-                    reject(lastDisconnect?.error || new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed }));
-                }
-            };
-            ev.on('connection.update', closeListener);
-            listener = async (update) => {
-                if (await check(update)) {
-                    resolve();
-                }
-            };
-            ev.on(event, listener);
-        }).finally(() => {
-            ev.off(event, listener);
-            ev.off('connection.update', closeListener);
-        });
-    };
-}
-export const generateIOSMessageID = () => {
-    const prefix = '3A';
-    const random = randomBytes(10);
-    return (prefix + random.toString('hex')).toUpperCase().substring(0, 21);
-};
-export const generateAndroMessageID = () => {
-    const prefix = '3A';
-    const random = randomBytes(16);
-    return (random.toString('hex')).toUpperCase().substring(0, 21);
-};
-export const bindWaitForConnectionUpdate = (ev) => bindWaitForEvent(ev, 'connection.update');
-
-export const fetchLatestBaileysVersion = async (options = {}) => {
-    const URL = 'https://raw.githubusercontent.com/WhiskeySockets/Baileys/master/src/Defaults/index.ts';
-    try {
-        const response = await fetch(URL, {
-            dispatcher: options.dispatcher,
-            method: 'GET',
-            headers: options.headers
-        });
-        if (!response.ok) {
-            throw new Boom(`Failed to fetch latest Baileys version: ${response.statusText}`, { statusCode: response.status });
-        }
-        const text = await response.text();
-        // Extract version from line 7 (const version = [...])
-        const lines = text.split('\n');
-        const versionLine = lines[6]; // Line 7 (0-indexed)
-        const versionMatch = versionLine.match(/const version = \[(\d+),\s*(\d+),\s*(\d+)\]/);
-        if (versionMatch) {
-            const version = [parseInt(versionMatch[1]), parseInt(versionMatch[2]), parseInt(versionMatch[3])];
-            return {
-                version,
-                isLatest: true
-            };
-        }
-        else {
-            throw new Error('Could not parse version from Defaults/index.ts');
-        }
-    }
-    catch (error) {
-        return {
-            version: baileysVersion,
-            isLatest: false,
-            error
-        };
-    }
-};
-/**
- * A utility that fetches the latest web version of whatsapp.
- * Use to ensure your WA connection is always on the latest version
- */
-export const fetchLatestWaWebVersion = async (options = {}) => {
-    try {
-        // Absolute minimal headers required to bypass anti-bot detection
-        const defaultHeaders = {
-            'sec-fetch-site': 'none',
-            'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36'
-        };
-        const headers = { ...defaultHeaders, ...options.headers };
-        const response = await fetch('https://web.whatsapp.com/sw.js', {
-            ...options,
-            method: 'GET',
-            headers
-        });
-        if (!response.ok) {
-            throw new Boom(`Failed to fetch sw.js: ${response.statusText}`, { statusCode: response.status });
-        }
-        const data = await response.text();
-        const regex = /\\?"client_revision\\?":\s*(\d+)/;
-        const match = data.match(regex);
-        if (!match?.[1]) {
-            return {
-                version: baileysVersion,
-                isLatest: false,
-                error: {
-                    message: 'Could not find client revision in the fetched content'
-                }
-            };
-        }
-        const clientRevision = match[1];
-        return {
-            version: [2, 3000, +clientRevision],
-            isLatest: true
-        };
-    }
-    catch (error) {
-        return {
-            version: baileysVersion,
-            isLatest: false,
-            error
-        };
-    }
-};
-/** unique message tag prefix for MD clients */
-export const generateMdTagPrefix = () => {
-    const bytes = randomBytes(4);
-    return `${bytes.readUInt16BE()}.${bytes.readUInt16BE(2)}-`;
-};
-const STATUS_MAP = {
-    sender: proto.WebMessageInfo.Status.SERVER_ACK,
-    played: proto.WebMessageInfo.Status.PLAYED,
-    read: proto.WebMessageInfo.Status.READ,
-    'read-self': proto.WebMessageInfo.Status.READ
-};
-/**
- * Given a type of receipt, returns what the new status of the message should be
- * @param type type from receipt
- */
-export const getStatusFromReceiptType = (type) => {
-    const status = STATUS_MAP[type];
-    if (typeof type === 'undefined') {
-        return proto.WebMessageInfo.Status.DELIVERY_ACK;
-    }
-    return status;
-};
-const CODE_MAP = {
-    conflict: DisconnectReason.connectionReplaced
-};
-/**
- * Stream errors generally provide a reason, map that to a baileys DisconnectReason
- * @param reason the string reason given, eg. "conflict"
- */
-export const getErrorCodeFromStreamError = (node) => {
-    const [reasonNode] = getAllBinaryNodeChildren(node);
-    let reason = reasonNode?.tag || 'unknown';
-    const statusCode = +(node.attrs.code || CODE_MAP[reason] || DisconnectReason.badSession);
-    if (statusCode === DisconnectReason.restartRequired) {
-        reason = 'restart required';
-    }
-    return {
-        reason,
-        statusCode
-    };
-};
-export const getCallStatusFromNode = ({ tag, attrs }) => {
-    let status;
-    switch (tag) {
-        case 'offer':
-        case 'offer_notice':
-            status = 'offer';
-            break;
-        case 'terminate':
-            if (attrs.reason === 'timeout') {
-                status = 'timeout';
-            }
-            else {
-                //fired when accepted/rejected/timeout/caller hangs up
-                status = 'terminate';
-            }
-            break;
-        case 'preaccept':
-            status = 'preaccept';
-            break;
-        case 'transport':
-            status = 'transport';
-            break;
-        case 'relaylatency':
-            status = 'relaylatency';
-            break;
-        case 'reject':
-            status = 'reject';
-            break;
-        case 'accept':
-            status = 'accept';
-            break;
-        default:
-            status = 'ringing';
-            break;
-    }
-    return status;
-};
-const UNEXPECTED_SERVER_CODE_TEXT = 'Unexpected server response: ';
-export const getCodeFromWSError = (error) => {
-    let statusCode = 500;
-    if (error?.message?.includes(UNEXPECTED_SERVER_CODE_TEXT)) {
-        const code = +error?.message.slice(UNEXPECTED_SERVER_CODE_TEXT.length);
-        if (!Number.isNaN(code) && code >= 400) {
-            statusCode = code;
-        }
-    }
-    else if (
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    error?.code?.startsWith('E') ||
-        error?.message?.includes('timed out')) {
-        // handle ETIMEOUT, ENOTFOUND etc
-        statusCode = 408;
-    }
-    return statusCode;
-};
-/**
- * Is the given platform WA business
- * @param platform AuthenticationCreds.platform
- */
-export const isWABusinessPlatform = (platform) => {
-    return platform === 'smbi' || platform === 'smba';
-};
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function trimUndefined(obj) {
-    for (const key in obj) {
-        if (typeof obj[key] === 'undefined') {
-            delete obj[key];
-        }
-    }
-    return obj;
-}
-const CROCKFORD_CHARACTERS = '123456789ABCDEFGHJKLMNPQRSTVWXYZ';
-export function bytesToCrockford(buffer) {
-    let value = 0;
-    let bitCount = 0;
-    const crockford = [];
-    for (const element of buffer) {
-        value = (value << 8) | (element & 0xff);
-        bitCount += 8;
-        while (bitCount >= 5) {
-            crockford.push(CROCKFORD_CHARACTERS.charAt((value >>> (bitCount - 5)) & 31));
-            bitCount -= 5;
-        }
-    }
-    if (bitCount > 0) {
-        crockford.push(CROCKFORD_CHARACTERS.charAt((value << (5 - bitCount)) & 31));
-    }
-    return crockford.join('');
-}
-export function encodeNewsletterMessage(message) {
-    return proto.Message.encode(message).finish();
-}
-//# sourceMappingURL=generics.js.map

package/lib/Utils/history.js

@@ -1,134 +0,0 @@
-import { pipeline } from 'stream/promises';
-import { promisify } from 'util';
-import { createInflate, inflate } from 'zlib';
-import { proto } from '../../WAProto/index.js';
-import { WAMessageStubType } from '../Types/index.js';
-import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser } from '../WABinary/index.js';
-import { toNumber } from './generics.js';
-import { normalizeMessageContent } from './messages.js';
-import { downloadContentFromMessage } from './messages-media.js';
-const inflatePromise = promisify(inflate);
-const extractPnFromMessages = (messages) => {
-    for (const msgItem of messages) {
-        const message = msgItem.message;
-        // Only extract from outgoing messages (fromMe: true) in 1:1 chats
-        // because userReceipt.userJid is the recipient's JID
-        if (!message?.key?.fromMe || !message.userReceipt?.length) {
-            continue;
-        }
-        const userJid = message.userReceipt[0]?.userJid;
-        if (userJid && (isPnUser(userJid) || isHostedPnUser(userJid))) {
-            return userJid;
-        }
-    }
-    return undefined;
-};
-export const downloadHistory = async (msg, options) => {
-    const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options });
-    // Pipe decrypted stream directly through zlib inflate
-    // This avoids allocating an intermediate buffer for the compressed data
-    const inflater = createInflate();
-    const chunks = [];
-    inflater.on('data', (chunk) => chunks.push(chunk));
-    await pipeline(stream, inflater);
-    const buffer = Buffer.concat(chunks);
-    const syncData = proto.HistorySync.decode(buffer);
-    return syncData;
-};
-export const processHistoryMessage = (item, logger) => {
-    const messages = [];
-    const contacts = [];
-    const chats = [];
-    const lidPnMappings = [];
-    logger?.trace({ progress: item.progress }, 'processing history of type ' + item.syncType?.toString());
-    // Extract LID-PN mappings for all sync types
-    for (const m of item.phoneNumberToLidMappings || []) {
-        if (m.lidJid && m.pnJid) {
-            lidPnMappings.push({ lid: m.lidJid, pn: m.pnJid });
-        }
-    }
-    switch (item.syncType) {
-        case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
-        case proto.HistorySync.HistorySyncType.RECENT:
-        case proto.HistorySync.HistorySyncType.FULL:
-        case proto.HistorySync.HistorySyncType.ON_DEMAND:
-            for (const chat of item.conversations) {
-                contacts.push({
-                    id: chat.id,
-                    name: chat.displayName || chat.name || chat.username || undefined,
-                    username: chat.username || undefined,
-                    lid: chat.lidJid || chat.accountLid || undefined,
-                    phoneNumber: chat.pnJid || undefined
-                });
-                const chatId = chat.id;
-                const isLid = isLidUser(chatId) || isHostedLidUser(chatId);
-                const isPn = isPnUser(chatId) || isHostedPnUser(chatId);
-                if (isLid && chat.pnJid) {
-                    lidPnMappings.push({ lid: chatId, pn: chat.pnJid });
-                }
-                else if (isPn && chat.lidJid) {
-                    lidPnMappings.push({ lid: chat.lidJid, pn: chatId });
-                }
-                else if (isLid && !chat.pnJid) {
-                    // Fallback: extract PN from userReceipt in messages when pnJid is missing
-                    const pnFromReceipt = extractPnFromMessages(chat.messages || []);
-                    if (pnFromReceipt) {
-                        lidPnMappings.push({ lid: chatId, pn: pnFromReceipt });
-                    }
-                }
-                const msgs = chat.messages || [];
-                delete chat.messages;
-                for (const item of msgs) {
-                    const message = item.message;
-                    messages.push(message);
-                    if (!chat.messages?.length) {
-                        // keep only the most recent message in the chat array
-                        chat.messages = [{ message }];
-                    }
-                    if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
-                        chat.lastMessageRecvTimestamp = toNumber(message.messageTimestamp);
-                    }
-                    if ((message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP ||
-                        message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) &&
-                        message.messageStubParameters?.[0]) {
-                        contacts.push({
-                            id: message.key.participant || message.key.remoteJid,
-                            verifiedName: message.messageStubParameters?.[0]
-                        });
-                    }
-                }
-                chats.push(chat);
-            }
-            break;
-        case proto.HistorySync.HistorySyncType.PUSH_NAME:
-            for (const c of item.pushnames) {
-                contacts.push({ id: c.id, notify: c.pushname });
-            }
-            break;
-    }
-    return {
-        chats,
-        contacts,
-        messages,
-        lidPnMappings,
-        pastParticipants: item.pastParticipants,
-        syncType: item.syncType,
-        progress: item.progress
-    };
-};
-export const downloadAndProcessHistorySyncNotification = async (msg, options, logger) => {
-    let historyMsg;
-    if (msg.initialHistBootstrapInlinePayload) {
-        historyMsg = proto.HistorySync.decode(await inflatePromise(msg.initialHistBootstrapInlinePayload));
-    }
-    else {
-        historyMsg = await downloadHistory(msg, options);
-    }
-    return processHistoryMessage(historyMsg, logger);
-};
-export const getHistoryMsg = (message) => {
-    const normalizedContent = !!message ? normalizeMessageContent(message) : undefined;
-    const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification;
-    return anyHistoryMsg;
-};
-//# sourceMappingURL=history.js.map

package/lib/Utils/identity-change-handler.js

@@ -1,50 +0,0 @@
-import NodeCache from '@cacheable/node-cache';
-import { areJidsSameUser, getBinaryNodeChild, jidDecode } from '../WABinary/index.js';
-import { isStringNullOrEmpty } from './generics.js';
-export async function handleIdentityChange(node, ctx) {
-    const from = node.attrs.from;
-    if (!from) {
-        return { action: 'invalid_notification' };
-    }
-    const identityNode = getBinaryNodeChild(node, 'identity');
-    if (!identityNode) {
-        return { action: 'no_identity_node' };
-    }
-    ctx.logger.info({ jid: from }, 'identity changed');
-    const decoded = jidDecode(from);
-    if (decoded?.device && decoded.device !== 0) {
-        ctx.logger.debug({ jid: from, device: decoded.device }, 'ignoring identity change from companion device');
-        return { action: 'skipped_companion_device', device: decoded.device };
-    }
-    const isSelfPrimary = ctx.meId && (areJidsSameUser(from, ctx.meId) || (ctx.meLid && areJidsSameUser(from, ctx.meLid)));
-    if (isSelfPrimary) {
-        ctx.logger.info({ jid: from }, 'self primary identity changed');
-        return { action: 'skipped_self_primary' };
-    }
-    if (ctx.debounceCache.get(from)) {
-        ctx.logger.debug({ jid: from }, 'skipping identity assert (debounced)');
-        return { action: 'debounced' };
-    }
-    ctx.debounceCache.set(from, true);
-    const isOfflineNotification = !isStringNullOrEmpty(node.attrs.offline);
-    const hasExistingSession = await ctx.validateSession(from);
-    if (!hasExistingSession.exists) {
-        ctx.logger.debug({ jid: from }, 'no old session, skipping session refresh');
-        return { action: 'skipped_no_session' };
-    }
-    ctx.logger.debug({ jid: from }, 'old session exists, will refresh session');
-    if (isOfflineNotification) {
-        ctx.logger.debug({ jid: from }, 'skipping session refresh during offline processing');
-        return { action: 'skipped_offline' };
-    }
-    ctx.onBeforeSessionRefresh?.(from);
-    try {
-        await ctx.assertSessions([from], true);
-        return { action: 'session_refreshed' };
-    }
-    catch (error) {
-        ctx.logger.warn({ error, jid: from }, 'failed to assert sessions after identity change');
-        return { action: 'session_refresh_failed', error };
-    }
-}
-//# sourceMappingURL=identity-change-handler.js.map

package/lib/Utils/index.js

@@ -1,23 +0,0 @@
-export * from './generics.js';
-export * from './decode-wa-message.js';
-export * from './messages.js';
-export * from './messages-media.js';
-export * from './validate-connection.js';
-export * from './crypto.js';
-export * from './signal.js';
-export * from './noise-handler.js';
-export * from './history.js';
-export * from './chat-utils.js';
-export * from './lt-hash.js';
-export * from './auth-utils.js';
-export * from './use-multi-file-auth-state.js';
-export * from './link-preview.js';
-export * from './event-buffer.js';
-export * from './process-message.js';
-export * from './message-retry-manager.js';
-export * from './browser-utils.js';
-export * from './companion-reg-client-utils.js';
-export * from './identity-change-handler.js';
-export * from './stanza-ack.js';
-export * from './message-composer.js';
-//# sourceMappingURL=index.js.map

package/lib/Utils/link-preview.js

@@ -1,85 +0,0 @@
-import { prepareWAMessageMedia } from './messages.js';
-import { extractImageThumb, getHttpStream } from './messages-media.js';
-const THUMBNAIL_WIDTH_PX = 192;
-/** Fetches an image and generates a thumbnail for it */
-const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
-    const stream = await getHttpStream(url, fetchOpts);
-    const result = await extractImageThumb(stream, thumbnailWidth);
-    return result;
-};
-/**
- * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
- * Return undefined if the fetch failed or no URL was found
- * @param text first matched URL in text
- * @returns the URL info required to generate link preview
- */
-export const getUrlInfo = async (text, opts = {
-    thumbnailWidth: THUMBNAIL_WIDTH_PX,
-    fetchOpts: { timeout: 3000 }
-}) => {
-    try {
-        // retries
-        let retries = 0;
-        const maxRetry = 5;
-        const { getLinkPreview } = await import('link-preview-js');
-        let previewLink = text;
-        if (!text.startsWith('https://') && !text.startsWith('http://')) {
-            previewLink = 'https://' + previewLink;
-        }
-        const info = await getLinkPreview(previewLink, {
-            ...opts.fetchOpts,
-            followRedirects: 'follow',
-            handleRedirects: (baseURL, forwardedURL) => {
-                const urlObj = new URL(baseURL);
-                const forwardedURLObj = new URL(forwardedURL);
-                if (retries >= maxRetry) {
-                    return false;
-                }
-                if (forwardedURLObj.hostname === urlObj.hostname ||
-                    forwardedURLObj.hostname === 'www.' + urlObj.hostname ||
-                    'www.' + forwardedURLObj.hostname === urlObj.hostname) {
-                    retries += 1;
-                    return true;
-                }
-                else {
-                    return false;
-                }
-            },
-            headers: opts.fetchOpts?.headers
-        });
-        if (info && 'title' in info && info.title) {
-            const [image] = info.images;
-            const urlInfo = {
-                'canonical-url': info.url,
-                'matched-text': text,
-                title: info.title,
-                description: info.description,
-                originalThumbnailUrl: image
-            };
-            if (opts.uploadImage) {
-                const { imageMessage } = await prepareWAMessageMedia({ image: { url: image } }, {
-                    upload: opts.uploadImage,
-                    mediaTypeOverride: 'thumbnail-link',
-                    options: opts.fetchOpts
-                });
-                urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined;
-                urlInfo.highQualityThumbnail = imageMessage || undefined;
-            }
-            else {
-                try {
-                    urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined;
-                }
-                catch (error) {
-                    opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail');
-                }
-            }
-            return urlInfo;
-        }
-    }
-    catch (error) {
-        if (!error.message.includes('receive a valid')) {
-            throw error;
-        }
-    }
-};
-//# sourceMappingURL=link-preview.js.map