@vanzxy/baileys 1.4.0 → 1.4.2

package/cjs/lib/Socket/dugong.js

@@ -0,0 +1,753 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dugong = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const index_js_1 = require("../../WAProto/index.js");
+const index_js_2 = require("../Utils/index.js");
+const index_js_3 = require("../WABinary/index.js");
+class Dugong {
+    constructor(waUploadToServer, relayMessageFn, config, sock) {
+        this.relayMessage = relayMessageFn;
+        this.waUploadToServer = waUploadToServer;
+        this.config = config;
+        this.sock = sock;
+    }
+    detectType(content) {
+        if (content.requestPaymentMessage)
+            return "PAYMENT";
+        if (content.productMessage)
+            return "PRODUCT";
+        if (content.groupInviteMessage)
+            return "GROUP_INVITE"; // Vanz@Fix (bug: field name mismatch — real message content is `groupInviteMessage`, not `groupInvite`, so this never actually matched a received message)
+        if (content.interactiveButtons)
+            return "INTERACTIVE_BUTTONS";
+        if (content.interactiveMessage?.carouselMessage)
+            return "CAROUSEL";
+        if (content.interactiveMessage)
+            return "INTERACTIVE";
+        if (content.albumMessage || content.album)
+            return "ALBUM";
+        if (content.eventMessage)
+            return "EVENT";
+        if (content.pollResultMessage)
+            return "POLL_RESULT";
+        if (content.groupStatusMessage)
+            return "GROUP_STORY";
+        return null;
+    }
+    async handlePayment(content, quoted) {
+        const data = content.requestPaymentMessage;
+        let notes = {};
+        if (data.sticker?.stickerMessage) {
+            notes = {
+                stickerMessage: {
+                    ...data.sticker.stickerMessage,
+                    contextInfo: {
+                        stanzaId: quoted?.key?.id,
+                        participant: quoted?.key?.participant || content.sender,
+                        quotedMessage: quoted?.message,
+                    },
+                },
+            };
+        }
+        else if (data.note) {
+            notes = {
+                extendedTextMessage: {
+                    text: data.note,
+                    contextInfo: {
+                        stanzaId: quoted?.key?.id,
+                        participant: quoted?.key?.participant || content.sender,
+                        quotedMessage: quoted?.message,
+                    },
+                },
+            };
+        }
+        return {
+            requestPaymentMessage: index_js_1.proto.Message.RequestPaymentMessage.fromObject({
+                expiryTimestamp: data.expiry || 0,
+                amount1000: data.amount || 0,
+                currencyCodeIso4217: data.currency || "IDR",
+                requestFrom: data.from || "0@s.whatsapp.net",
+                noteMessage: notes,
+                background: data.background ?? {
+                    id: "DEFAULT",
+                    placeholderArgb: 0xfff0f0f0,
+                },
+            }),
+        };
+    }
+    async handleProduct(content, _jid, _quoted) {
+        const { title, description, thumbnail, productId, retailerId, url, body = "", footer = "", buttons = [], priceAmount1000 = null, currencyCode = "IDR", } = content.productMessage;
+        let productImage;
+        if (Buffer.isBuffer(thumbnail)) {
+            const { imageMessage } = await (0, index_js_2.generateWAMessageContent)({ image: thumbnail }, { upload: this.waUploadToServer });
+            productImage = imageMessage;
+        }
+        else if (typeof thumbnail === "object" && thumbnail.url) {
+            const { imageMessage } = await (0, index_js_2.generateWAMessageContent)({ image: { url: thumbnail.url } }, { upload: this.waUploadToServer });
+            productImage = imageMessage;
+        }
+        return {
+            viewOnceMessage: {
+                message: {
+                    interactiveMessage: {
+                        body: { text: body },
+                        footer: { text: footer },
+                        header: {
+                            title,
+                            hasMediaAttachment: true,
+                            productMessage: {
+                                product: {
+                                    productImage,
+                                    productId,
+                                    title,
+                                    description,
+                                    currencyCode,
+                                    priceAmount1000,
+                                    retailerId,
+                                    url,
+                                    productImageCount: 1,
+                                },
+                                businessOwnerJid: "0@s.whatsapp.net",
+                            },
+                        },
+                        nativeFlowMessage: { buttons },
+                    },
+                },
+            },
+        };
+    }
+    async handleInteractive(content, _jid, _quoted) {
+        const { title, footer, thumbnail, image, video, document, mimetype, fileName, jpegThumbnail, contextInfo, externalAdReply, buttons = [], nativeFlowMessage, header, } = content.interactiveMessage;
+        let media = null;
+        let _mediaType = null;
+        if (thumbnail) {
+            media = await (0, index_js_2.prepareWAMessageMedia)({ image: { url: thumbnail } }, { upload: this.waUploadToServer });
+            _mediaType = "image";
+        }
+        else if (image) {
+            const src = typeof image === "object" && image.url
+                ? { image: { url: image.url } }
+                : { image };
+            media = await (0, index_js_2.prepareWAMessageMedia)(src, {
+                upload: this.waUploadToServer,
+            });
+            _mediaType = "image";
+        }
+        else if (video) {
+            const src = typeof video === "object" && video.url
+                ? { video: { url: video.url } }
+                : { video };
+            media = await (0, index_js_2.prepareWAMessageMedia)(src, {
+                upload: this.waUploadToServer,
+            });
+            _mediaType = "video";
+        }
+        else if (document) {
+            const docPayload = { document };
+            if (jpegThumbnail) {
+                docPayload.jpegThumbnail =
+                    typeof jpegThumbnail === "object" && jpegThumbnail.url
+                        ? { url: jpegThumbnail.url }
+                        : jpegThumbnail;
+            }
+            media = await (0, index_js_2.prepareWAMessageMedia)(docPayload, {
+                upload: this.waUploadToServer,
+            });
+            if (fileName)
+                media.documentMessage.fileName = fileName;
+            if (mimetype)
+                media.documentMessage.mimetype = mimetype;
+            _mediaType = "document";
+        }
+        const interactiveMessage = {
+            body: { text: title || "" },
+            footer: { text: footer || "" },
+        };
+        if (buttons && buttons.length > 0) {
+            interactiveMessage.nativeFlowMessage = { buttons };
+            if (nativeFlowMessage) {
+                interactiveMessage.nativeFlowMessage = {
+                    ...interactiveMessage.nativeFlowMessage,
+                    ...nativeFlowMessage,
+                };
+            }
+        }
+        else if (nativeFlowMessage) {
+            interactiveMessage.nativeFlowMessage = nativeFlowMessage;
+        }
+        if (media) {
+            interactiveMessage.header = {
+                title: header || "",
+                hasMediaAttachment: true,
+                ...media,
+            };
+        }
+        else {
+            interactiveMessage.header = {
+                title: header || "",
+                hasMediaAttachment: false,
+            };
+        }
+        const finalContextInfo = {};
+        if (contextInfo) {
+            Object.assign(finalContextInfo, {
+                mentionedJid: contextInfo.mentionedJid || [],
+                forwardingScore: contextInfo.forwardingScore || 0,
+                isForwarded: contextInfo.isForwarded || false,
+                ...contextInfo,
+            });
+        }
+        if (externalAdReply) {
+            finalContextInfo.externalAdReply = {
+                title: externalAdReply.title || "",
+                body: externalAdReply.body || "",
+                mediaType: externalAdReply.mediaType || 1,
+                thumbnailUrl: externalAdReply.thumbnailUrl || "",
+                mediaUrl: externalAdReply.mediaUrl || "",
+                sourceUrl: externalAdReply.sourceUrl || "",
+                showAdAttribution: externalAdReply.showAdAttribution || false,
+                renderLargerThumbnail: externalAdReply.renderLargerThumbnail || false,
+                ...externalAdReply,
+            };
+        }
+        if (Object.keys(finalContextInfo).length > 0) {
+            interactiveMessage.contextInfo = finalContextInfo;
+        }
+        return { interactiveMessage };
+    }
+    async handleInteractiveButtons(content, _jid, _quoted) {
+        const { text, caption, title, subtitle, footer, interactiveButtons, hasMediaAttachment, image, video, document, mimetype, jpegThumbnail, location, product, businessOwnerJid, } = content;
+        const bodyText = text || caption || "";
+        const buttons = interactiveButtons.map((btn) => ({
+            name: btn.name,
+            buttonParamsJson: typeof btn.buttonParamsJson === "string"
+                ? btn.buttonParamsJson
+                : JSON.stringify(btn.buttonParamsJson),
+        }));
+        let headerContent = {};
+        let mediaAttached = typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : false;
+        if (image) {
+            const src = typeof image === "object" && image.url
+                ? { image: { url: image.url } }
+                : { image };
+            const uploaded = await (0, index_js_2.prepareWAMessageMedia)(src, {
+                upload: this.waUploadToServer,
+            });
+            headerContent = { ...uploaded };
+            mediaAttached =
+                typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : true;
+        }
+        else if (video) {
+            const src = typeof video === "object" && video.url
+                ? { video: { url: video.url } }
+                : { video };
+            const uploaded = await (0, index_js_2.prepareWAMessageMedia)(src, {
+                upload: this.waUploadToServer,
+            });
+            headerContent = { ...uploaded };
+            mediaAttached =
+                typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : true;
+        }
+        else if (document) {
+            const docPayload = typeof document === "object" && document.url
+                ? { document: { url: document.url } }
+                : { document };
+            if (mimetype)
+                docPayload.mimetype = mimetype;
+            const uploaded = await (0, index_js_2.prepareWAMessageMedia)(docPayload, {
+                upload: this.waUploadToServer,
+            });
+            if (jpegThumbnail) {
+                uploaded.documentMessage.jpegThumbnail =
+                    typeof jpegThumbnail === "string"
+                        ? Buffer.from(jpegThumbnail, "base64")
+                        : jpegThumbnail;
+            }
+            headerContent = { ...uploaded };
+            mediaAttached =
+                typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : true;
+        }
+        else if (location) {
+            headerContent = {
+                locationMessage: {
+                    degreesLatitude: location.degressLatitude || location.degreesLatitude || 0,
+                    degreesLongitude: location.degressLongitude || location.degreesLongitude || 0,
+                    name: location.name || "",
+                },
+            };
+            mediaAttached =
+                typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : true;
+        }
+        else if (product) {
+            let productImage;
+            if (product.productImage) {
+                const imgSrc = typeof product.productImage === "object" && product.productImage.url
+                    ? { image: { url: product.productImage.url } }
+                    : { image: product.productImage };
+                const uploaded = await (0, index_js_2.prepareWAMessageMedia)(imgSrc, {
+                    upload: this.waUploadToServer,
+                });
+                productImage = uploaded.imageMessage;
+            }
+            headerContent = {
+                productMessage: {
+                    product: {
+                        productImage,
+                        productId: product.productId,
+                        title: product.title,
+                        description: product.description,
+                        currencyCode: product.currencyCode || "IDR",
+                        priceAmount1000: product.priceAmount1000,
+                        retailerId: product.retailerId,
+                        url: product.url,
+                        productImageCount: product.productImageCount || 1,
+                    },
+                    businessOwnerJid: businessOwnerJid || "0@s.whatsapp.net",
+                },
+            };
+            mediaAttached =
+                typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : true;
+        }
+        const interactiveMessage = {
+            body: { text: bodyText },
+            footer: { text: footer || "" },
+            header: {
+                title: title || "",
+                subtitle: subtitle || "",
+                hasMediaAttachment: mediaAttached,
+                ...headerContent,
+            },
+            nativeFlowMessage: { buttons },
+        };
+        return {
+            viewOnceMessage: {
+                message: {
+                    messageContextInfo: {
+                        deviceListMetadata: {},
+                        deviceListMetadataVersion: 2,
+                        messageSecret: crypto_1.default.randomBytes(32),
+                    },
+                    interactiveMessage,
+                },
+            },
+        };
+    }
+    async handleCarousel(content, _jid, _quoted) {
+        const { interactiveMessage } = content;
+        const { body, footer, header, carouselMessage, contextInfo } = interactiveMessage;
+        const processedCards = [];
+        for (const card of carouselMessage.cards) {
+            const cardMsg = {
+                body: card.body || { text: "" },
+                footer: card.footer || { text: "" },
+                header: {
+                    title: card.header?.title || "",
+                    hasMediaAttachment: false,
+                },
+            };
+            if (card.nativeFlowMessage) {
+                cardMsg.nativeFlowMessage = card.nativeFlowMessage;
+            }
+            if (card.header?.imageMessage ||
+                card.header?.videoMessage ||
+                card.header?.documentMessage) {
+                let headerContent = {};
+                let mediaAttached = true;
+                if (card.header.imageMessage) {
+                    const url = card.header.imageMessage.url || card.header.imageMessage;
+                    const src = typeof url === "string" ? { image: { url } } : { image: url };
+                    const uploaded = await (0, index_js_2.prepareWAMessageMedia)(src, {
+                        upload: this.waUploadToServer,
+                    });
+                    headerContent = { ...uploaded };
+                }
+                else if (card.header.videoMessage) {
+                    const url = card.header.videoMessage.url || card.header.videoMessage;
+                    const src = typeof url === "string" ? { video: { url } } : { video: url };
+                    const uploaded = await (0, index_js_2.prepareWAMessageMedia)(src, {
+                        upload: this.waUploadToServer,
+                    });
+                    headerContent = { ...uploaded };
+                }
+                else if (card.header.documentMessage) {
+                    const url = card.header.documentMessage.url || card.header.documentMessage;
+                    const src = typeof url === "string" ? { document: { url } } : { document: url };
+                    const uploaded = await (0, index_js_2.prepareWAMessageMedia)(src, {
+                        upload: this.waUploadToServer,
+                    });
+                    headerContent = { ...uploaded };
+                }
+                cardMsg.header = {
+                    title: card.header?.title || "",
+                    hasMediaAttachment: mediaAttached,
+                    ...headerContent,
+                };
+            }
+            processedCards.push(cardMsg);
+        }
+        const interactiveMsg = {
+            body: body || { text: "" },
+            footer: footer || { text: "" },
+            header: header || { title: "", hasMediaAttachment: false },
+            carouselMessage: {
+                cards: processedCards,
+                messageVersion: carouselMessage.messageVersion || 1,
+                carouselCardType: carouselMessage.carouselCardType ?? 1,
+            },
+        };
+        if (contextInfo) {
+            interactiveMsg.contextInfo = contextInfo;
+        }
+        return {
+            viewOnceMessage: {
+                message: {
+                    messageContextInfo: {
+                        deviceListMetadata: {},
+                        deviceListMetadataVersion: 2,
+                        messageSecret: crypto_1.default.randomBytes(32),
+                    },
+                    interactiveMessage: interactiveMsg,
+                },
+            },
+        };
+    }
+    async handleAlbum(content, jid, quoted) {
+        const array = content.albumMessage || content.album;
+        const ctxInfo = content.contextInfo || {};
+        const album = await (0, index_js_2.generateWAMessageFromContent)(jid, {
+            messageContextInfo: {
+                messageSecret: crypto_1.default.randomBytes(32),
+            },
+            albumMessage: {
+                expectedImageCount: array.filter((a) => "image" in a).length,
+                expectedVideoCount: array.filter((a) => "video" in a).length,
+            },
+        }, {
+            userJid: (0, index_js_3.jidNormalizedUser)(this.sock.authState?.creds?.me?.id || ""),
+            quoted,
+            upload: this.waUploadToServer,
+        });
+        await this.relayMessage(jid, album.message, {
+            messageId: album.key.id,
+        });
+        for (let item of array) {
+            if (ctxInfo && Object.keys(ctxInfo).length > 0 && !item.contextInfo) {
+                item = { ...item, contextInfo: ctxInfo };
+            }
+            try { // Vanz@Fix: per-item try-catch so one failed upload doesn't abort the whole album
+                const img = await (0, index_js_2.generateWAMessage)(jid, item, {
+                    upload: this.waUploadToServer,
+                    userJid: (0, index_js_3.jidNormalizedUser)(this.sock.authState?.creds?.me?.id || ""),
+                });
+                img.message.messageContextInfo = {
+                    messageSecret: crypto_1.default.randomBytes(32),
+                    messageAssociation: {
+                        associationType: 1,
+                        parentMessageKey: album.key,
+                    },
+                };
+                await this.relayMessage(jid, img.message, {
+                    messageId: img.key.id,
+                });
+            }
+            catch (err) {
+                this.config.logger?.error(`handleAlbum: failed to send item — ${err}`);
+            }
+            await (0, index_js_2.delay)(300); // Vanz@Fix: prevent WA rate-limit / out-of-order delivery
+        }
+        return album;
+    }
+    async handleEvent(content, jid, quoted) {
+        const eventData = content.eventMessage;
+        const msg = await (0, index_js_2.generateWAMessageFromContent)(jid, {
+            viewOnceMessage: {
+                message: {
+                    messageContextInfo: {
+                        deviceListMetadata: {},
+                        deviceListMetadataVersion: 2,
+                        messageSecret: crypto_1.default.randomBytes(32),
+                    },
+                    eventMessage: {
+                        isCanceled: eventData.isCanceled || false,
+                        name: eventData.name,
+                        description: eventData.description,
+                        location: eventData.location || {
+                            degreesLatitude: 0,
+                            degreesLongitude: 0,
+                            name: "Location",
+                        },
+                        joinLink: eventData.joinLink || "",
+                        startTime: typeof eventData.startTime === "string"
+                            ? parseInt(eventData.startTime)
+                            : eventData.startTime || Date.now(),
+                        endTime: typeof eventData.endTime === "string"
+                            ? parseInt(eventData.endTime)
+                            : eventData.endTime || Date.now() + 3600000,
+                        extraGuestsAllowed: eventData.extraGuestsAllowed !== false,
+                    },
+                },
+            },
+        }, {
+            quoted,
+            userJid: (0, index_js_3.jidNormalizedUser)(this.sock.authState?.creds?.me?.id || ""),
+        });
+        await this.relayMessage(jid, msg.message, {
+            messageId: msg.key.id,
+        });
+        return msg;
+    }
+    async handlePollResult(content, jid, quoted) {
+        const pollData = content.pollResultMessage;
+        const msg = await (0, index_js_2.generateWAMessageFromContent)(jid, {
+            pollResultSnapshotMessage: {
+                name: pollData.name,
+                pollVotes: pollData.pollVotes.map((vote) => ({
+                    optionName: vote.optionName,
+                    optionVoteCount: typeof vote.optionVoteCount === "number"
+                        ? vote.optionVoteCount.toString()
+                        : vote.optionVoteCount,
+                })),
+            },
+        }, {
+            quoted,
+            userJid: (0, index_js_3.jidNormalizedUser)(this.sock.authState?.creds?.me?.id || ""),
+        });
+        await this.relayMessage(jid, msg.message, {
+            messageId: msg.key.id,
+        });
+        return msg;
+    }
+    async handleGroupInvite(content, jid, quoted) {
+        const inviteData = content.groupInviteMessage;
+        const msg = await (0, index_js_2.generateWAMessageFromContent)(jid, {
+            groupInviteMessage: {
+                groupJid: inviteData.groupJid,
+                inviteCode: inviteData.inviteCode,
+                inviteExpiration: inviteData.inviteExpiration ?? 0,
+                groupName: inviteData.groupName,
+                jpegThumbnail: inviteData.jpegThumbnail,
+                caption: inviteData.caption,
+                groupType: inviteData.groupType,
+            },
+        }, {
+            quoted,
+            userJid: (0, index_js_3.jidNormalizedUser)(this.sock.authState?.creds?.me?.id || ""),
+        });
+        await this.relayMessage(jid, msg.message, {
+            messageId: msg.key.id,
+        });
+        return msg;
+    }
+    async handleGroupStory(content, jid, _quoted, options = {}) {
+        const storyData = content.groupStatusMessage;
+        let waMsgContent;
+        if (storyData.message) {
+            waMsgContent = storyData;
+        }
+        else {
+            waMsgContent = await (0, index_js_2.generateWAMessageContent)(storyData, {
+                upload: this.waUploadToServer,
+            });
+        }
+        const innerMsg = waMsgContent.message || waMsgContent;
+        const msgKey = Object.keys(innerMsg).find((k) => innerMsg[k] && typeof innerMsg[k] === "object");
+        if (msgKey) {
+            innerMsg[msgKey].contextInfo = innerMsg[msgKey].contextInfo || {};
+            innerMsg[msgKey].contextInfo.isGroupStatus = true;
+            if (!innerMsg[msgKey].contextInfo.statusSourceType) {
+                if (innerMsg.imageMessage)
+                    innerMsg[msgKey].contextInfo.statusSourceType = 0;
+                else if (innerMsg.videoMessage)
+                    innerMsg[msgKey].contextInfo.statusSourceType = 1;
+                else if (innerMsg.audioMessage)
+                    innerMsg[msgKey].contextInfo.statusSourceType = 3;
+                else if (innerMsg.extendedTextMessage)
+                    innerMsg[msgKey].contextInfo.statusSourceType = 4;
+            }
+        }
+        const finalMsg = {
+            groupStatusMessageV2: {
+                message: innerMsg,
+            },
+        };
+        return await this.relayMessage(jid, finalMsg, {
+            messageId: (0, index_js_2.generateMessageID)(),
+        });
+    }
+    async sendStatusWhatsApp(content, jids = []) {
+        const userJid = (0, index_js_3.jidNormalizedUser)(this.sock.authState.creds.me.id);
+        const allUsers = new Set();
+        allUsers.add(userJid);
+        for (const id of jids) {
+            if ((0, index_js_3.isJidGroup)(id)) {
+                try {
+                    const metadata = await this.sock.groupMetadata(id);
+                    metadata.participants.forEach((p) => allUsers.add((0, index_js_3.jidNormalizedUser)(p.id)));
+                }
+                catch (error) {
+                    this.config.logger.error(`Error getting metadata for group ${id}: ${error}`);
+                }
+            }
+            else if ((0, index_js_3.isPnUser)(id)) {
+                allUsers.add((0, index_js_3.jidNormalizedUser)(id));
+            }
+        }
+        const uniqueUsers = Array.from(allUsers);
+        const getRandomHexColor = () => "#" +
+            Math.floor(Math.random() * 16777215)
+                .toString(16)
+                .padStart(6, "0");
+        const isMedia = content.image || content.video || content.audio;
+        const isAudio = !!content.audio;
+        const messageContent = { ...content };
+        if (isMedia && !isAudio) {
+            if (messageContent.text) {
+                messageContent.caption = messageContent.text;
+                delete messageContent.text;
+            }
+            delete messageContent.ptt;
+            delete messageContent.font;
+            delete messageContent.backgroundColor;
+            delete messageContent.textColor;
+        }
+        if (isAudio) {
+            delete messageContent.text;
+            delete messageContent.caption;
+            delete messageContent.font;
+            delete messageContent.textColor;
+        }
+        const font = !isMedia
+            ? content.font || Math.floor(Math.random() * 9)
+            : undefined;
+        const textColor = !isMedia
+            ? content.textColor || getRandomHexColor()
+            : undefined;
+        const backgroundColor = !isMedia || isAudio
+            ? content.backgroundColor || getRandomHexColor()
+            : undefined;
+        const ptt = isAudio
+            ? typeof content.ptt === "boolean"
+                ? content.ptt
+                : true
+            : undefined;
+        const { getUrlInfo } = await Promise.resolve().then(() => __importStar(require("../Utils/link-preview.js")));
+        const msg = await (0, index_js_2.generateWAMessage)(index_js_3.STORIES_JID, messageContent, {
+            logger: this.config.logger,
+            userJid,
+            getUrlInfo: (text) => getUrlInfo(text, {
+                thumbnailWidth: this.config.linkPreviewImageThumbnailWidth,
+                fetchOpts: { timeout: 3000, ...(this.config.options || {}) },
+                logger: this.config.logger,
+                uploadImage: this.config.generateHighQualityLinkPreview
+                    ? this.waUploadToServer
+                    : undefined,
+            }),
+            upload: this.waUploadToServer,
+            mediaCache: this.config.mediaCache,
+            options: this.config.options,
+            font,
+            textColor,
+            backgroundColor,
+            ptt,
+        });
+        await this.relayMessage(index_js_3.STORIES_JID, msg.message, {
+            messageId: msg.key.id,
+            statusJidList: uniqueUsers,
+            additionalNodes: [
+                {
+                    tag: "meta",
+                    attrs: {},
+                    content: [
+                        {
+                            tag: "mentioned_users",
+                            attrs: {},
+                            content: jids.map((jid) => ({
+                                tag: "to",
+                                attrs: { jid: (0, index_js_3.jidNormalizedUser)(jid) },
+                            })),
+                        },
+                    ],
+                },
+            ],
+        });
+        for (const id of jids) {
+            try {
+                const normalizedId = (0, index_js_3.jidNormalizedUser)(id);
+                const isPrivate = (0, index_js_3.isPnUser)(normalizedId);
+                const type = isPrivate
+                    ? "statusMentionMessage"
+                    : "groupStatusMentionMessage";
+                const protocolMessage = {
+                    [type]: {
+                        message: {
+                            protocolMessage: {
+                                key: msg.key,
+                                type: 25,
+                            },
+                        },
+                    },
+                    messageContextInfo: {
+                        messageSecret: crypto_1.default.randomBytes(32),
+                    },
+                };
+                const statusMsg = await (0, index_js_2.generateWAMessageFromContent)(normalizedId, protocolMessage, {
+                    userJid: (0, index_js_3.jidNormalizedUser)(this.sock.authState?.creds?.me?.id || ""),
+                });
+                await this.relayMessage(normalizedId, statusMsg.message, {
+                    additionalNodes: [
+                        {
+                            tag: "meta",
+                            attrs: isPrivate
+                                ? { is_status_mention: "true" }
+                                : { is_group_status_mention: "true" },
+                        },
+                    ],
+                });
+                await (0, index_js_2.delay)(2000);
+            }
+            catch (error) {
+                this.config.logger.error(`Error sending to ${id}: ${error}`);
+            }
+        }
+        return msg;
+    }
+}
+exports.Dugong = Dugong;
+//# sourceMappingURL=dugong.js.map