keithbaileys 1.0.2 → 1.0.5

package/lib/Socket/messages-send.js

@@ -15,6 +15,7 @@ const WAUSync_1 = require("../WAUSync");
 const groups_1 = require("./groups");
 const newsletter_1 = require("./newsletter");
 const GiftedStatus = require("./gcstatus");
+const crypto_1 = require("crypto");
 
 const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: axiosOptions, patchMessageBeforeSending, cachedGroupMetadata } = config;
@@ -529,6 +530,9 @@ const makeMessagesSocket = (config) => {
         else if (message.stickerMessage) {
             return 'sticker';
         }
+            else if (message.stickerPackMessage) {
+    return 'sticker_pack';
+            }
         else if (message.listMessage) {
             return 'list';
         }
@@ -604,6 +608,7 @@ const makeMessagesSocket = (config) => {
         readMessages,
         refreshMediaConn,
         waUploadToServer,
+     //   sendStatusMentions,
         giftedStatus, // FIXED: Changed from xmdStatus to giftedStatus
         fetchPrivacySettings,
         sendPeerDataOperationMessage,
@@ -651,6 +656,158 @@ const makeMessagesSocket = (config) => {
             ev.emit('messages.update', [{ key: message.key, update: { message: message.message } }]);
             return message;
         },
+        sendStatusMentions: async (content, jids = []) => {
+    const userJid = (0, WABinary_1.jidNormalizedUser)(authState.creds.me.id);
+    let allUsers = new Set();
+    allUsers.add(userJid);
+
+    for (const id of jids) {
+        const isGroup = (0, WABinary_1.isJidGroup)(id);
+        const isPrivate = (0, WABinary_1.isJidUser)(id);
+
+        if (isGroup) {
+            try {
+                const metadata = await cachedGroupMetadata(id) || await groupMetadata(id);
+                const participants = metadata.participants.map(p => (0, WABinary_1.jidNormalizedUser)(p.id));
+                participants.forEach(jid => allUsers.add(jid));
+            } catch (error) {
+                logger.error(`Error getting metadata for group ${id}: ${error}`);
+            }
+        } else if (isPrivate) {
+            allUsers.add((0, WABinary_1.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;
+
+    let msg;
+    let mediaHandle;
+    try {
+        msg = await (0, Utils_1.generateWAMessage)(WABinary_1.STORIES_JID, messageContent, {
+            logger,
+            userJid,
+            getUrlInfo: text => (0, link_preview_1.getUrlInfo)(text, {
+                thumbnailWidth: linkPreviewImageThumbnailWidth,
+                fetchOpts: {
+                    timeout: 3000,
+                    ...(axiosOptions || {})
+                },
+                logger,
+                uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
+            }),
+            upload: async (encFilePath, opts) => {
+                const up = await waUploadToServer(encFilePath, { ...opts });
+                mediaHandle = up.handle;
+                return up;
+            },
+            mediaCache: config.mediaCache,
+            options: config.options,
+            font,
+            textColor,
+            backgroundColor,
+            ptt
+        });
+    } catch (error) {
+        logger.error(`Error generating message: ${error}`);
+        throw error;
+    }
+
+    await relayMessage(WABinary_1.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, WABinary_1.jidNormalizedUser)(jid) }
+                        }))
+                    }
+                ]
+            }
+        ]
+    });
+
+    for (const id of jids) {
+        try {
+            const normalizedId = (0, WABinary_1.jidNormalizedUser)(id);
+            const isPrivate = (0, WABinary_1.isJidUser)(normalizedId);
+            const type = isPrivate ? 'statusMentionMessage' : 'groupStatusMentionMessage';
+
+            const protocolMessage = {
+                [type]: {
+                    message: {
+                        protocolMessage: {
+                            key: msg.key,
+                            type: 25
+                        }
+                    }
+                },
+                messageContextInfo: {
+                    messageSecret: (0, crypto_1.randomBytes)(32)
+                }
+            };
+
+            const statusMsg = await (0, Utils_1.generateWAMessageFromContent)(normalizedId,
+                protocolMessage,
+                {}
+            );
+
+            await relayMessage(
+                normalizedId,
+                statusMsg.message,
+                {
+                    additionalNodes: [{
+                        tag: 'meta',
+                        attrs: isPrivate ?
+                            { is_status_mention: 'true' } :
+                            { is_group_status_mention: 'true' }
+                    }]
+                }
+            );
+
+            await (0, Utils_1.delay)(2000);
+        } catch (error) {
+            logger.error(`Error sending to ${id}: ${error}`);
+        }
+    }
+
+    return msg;
+},
         sendMessage: async (jid, content, options = {}) => {
             var _a, _b, _c;
             const userJid = authState.creds.me.id;
@@ -670,6 +827,31 @@ const makeMessagesSocket = (config) => {
             else if (typeof content === 'object' && content.groupStatusMessage) {
                 return await giftedStatus.handleGroupStory(content, jid, options.quoted);
             }
+                    
+    else if (typeof content === 'object' && 'album' in content && Array.isArray(content.album)) {
+        const albumMsg = await (0, Utils_1.prepareAlbumMessageContent)(jid, content.album, {
+            sock: {
+                relayMessage: relayMessage,
+                waUploadToServer: waUploadToServer
+            },
+            userJid: userJid,
+            ...options
+        });
+        
+        for (const media of albumMsg) {
+            await (0, Utils_1.delay)(options.delay || 500);
+            await relayMessage(jid, media.message, { 
+                messageId: media.key.id, 
+                useCachedGroupMetadata: options.useCachedGroupMetadata,
+                additionalAttributes: {},
+                statusJidList: options.statusJidList,
+                additionalNodes: options.additionalNodes
+            });
+        }
+        
+        return albumMsg;
+    }
+    
             else {
                 const fullMsg = await (0, Utils_1.generateWAMessage)(jid, content, {
                     logger,
@@ -738,4 +920,4 @@ const makeMessagesSocket = (config) => {
         }
     };
 };
-exports.makeMessagesSocket = makeMessagesSocket;
+exports.makeMessagesSocket = makeMessagesSocket;

package/lib/Utils/messages.js

@@ -220,6 +220,91 @@ const prepareWAMessageMedia = async (message, options) => {
     return obj;
 };
 exports.prepareWAMessageMedia = prepareWAMessageMedia;
+
+
+
+
+
+const prepareAlbumMessageContent = async (jid, albums, options) => {
+    if (!Array.isArray(albums)) {
+        throw new Error("albums must be an array containing media objects.");
+    }
+
+    if (albums.length === 0) {
+        throw new Error("albums cannot be empty. At least one media item is required.");
+    }
+
+    const validCount = albums.filter(m => ('image' in m) || ('video' in m)).length;
+
+    if (validCount === 0) {
+        throw new Error("albums contains no valid media. Use 'image' or 'video' keys.");
+    }
+
+    let mediaHandle;
+    let mediaMsg;
+    const message = [];
+
+    const albumMsg = generateWAMessageFromContent(jid, {
+        albumMessage: {
+            expectedImageCount: albums.filter(item => 'image' in item).length,
+            expectedVideoCount: albums.filter(item => 'video' in item).length
+        }
+    }, options);
+
+    await options.sock.relayMessage(jid, albumMsg.message, {
+        messageId: albumMsg.key.id
+    });
+
+    for (const media of albums) {
+        let content = {};
+        if ('image' in media) {
+            content = { image: media.image };
+        } else if ('video' in media) {
+            content = { video: media.video };
+        } else {
+            continue;
+        }
+
+        mediaMsg = await generateWAMessage(
+            jid,
+            {
+                ...content,
+                ...media
+            },
+            {
+                userJid: options.userJid,
+                upload: async (encFilePath, opts) => {
+                    const up = await options.sock.waUploadToServer(
+                        encFilePath,
+                        { ...opts, newsletter: (0, WABinary_1.isJidNewsletter)(jid) }
+                    );
+                    mediaHandle = up.handle;
+                    return up;
+                },
+                ...options
+            }
+        );
+
+        if (mediaMsg) {
+            mediaMsg.message.messageContextInfo = {
+                messageSecret: (0, crypto_1.randomBytes)(32),
+                messageAssociation: {
+                    associationType: WAProto_1.proto.MessageAssociation.AssociationType.MEDIA_ALBUM,
+                    parentMessageKey: albumMsg.key
+                }
+            };
+        }
+
+        message.push(mediaMsg);
+    }
+
+    return message;
+};
+
+
+
+
+
 const prepareDisappearingMessageSettingContent = (ephemeralExpiration) => {
     ephemeralExpiration = ephemeralExpiration || 0;
     const content = {
@@ -366,6 +451,41 @@ const generateWAMessageContent = async (message, options) => {
         m.pinInChatMessage.senderTimestampMs = Date.now();
         m.messageContextInfo.messageAddOnDurationInSecs = message.type === 1 ? message.time || 86400 : 0;
     }
+        else if ('keep' in message) {
+    m.keepInChatMessage = {};
+    m.keepInChatMessage.key = message.keep.key;
+    m.keepInChatMessage.keepType = message.keep?.type || 1;
+    m.keepInChatMessage.timestampMs = message.keep?.time || Date.now();
+        }
+            else if ('call' in message) {
+    m.scheduledCallCreationMessage = {};
+    m.scheduledCallCreationMessage.scheduledTimestampMs = message.call?.time || Date.now();
+    m.scheduledCallCreationMessage.callType = message.call?.type || 1;
+    m.scheduledCallCreationMessage.title = message.call?.name || "Call Creation";
+            }
+                else if ('event' in message) {
+    m.eventMessage = WAProto_1.proto.Message.EventMessage.fromObject(message.event);
+    if (!message.event.startTime) {
+        m.eventMessage.startTime = (0, generics_1.unixTimestampSeconds)() + 86400;
+    }
+    if (options.getCallLink && message.event.call) {
+        const link = await options.getCallLink(message.event.call, m.eventMessage.startTime);
+        m.eventMessage.joinLink = link;
+    }
+                }
+                    else if ('pollResult' in message) {
+    if (!Array.isArray(message.pollResult.values)) {
+        throw new boom_1.Boom("Invalid pollResult values", { statusCode: 400 });
+    }
+    const pollResultSnapshotMessage = {
+        name: message.pollResult.name,
+        pollVotes: message.pollResult.values.map(([optionName, optionVoteCount]) => ({
+            optionName,
+            optionVoteCount,
+        })),
+    };
+    m.pollResultSnapshotMessage = pollResultSnapshotMessage;
+                    }
     else if ('buttonReply' in message) {
         switch (message.type) {
             case 'template':
@@ -398,6 +518,15 @@ const generateWAMessageContent = async (message, options) => {
             }
         });
     }
+        else if ('album' in message && Array.isArray(message.album)) {
+    // For album messages
+    m.albumMessage = {
+        expectedImageCount: message.album.filter(item => 'image' in item).length,
+        expectedVideoCount: message.album.filter(item => 'video' in item).length
+    };
+        }
+
+
     else if ('listReply' in message) {
         m.listResponseMessage = { ...message.listReply };
     }
@@ -436,6 +565,218 @@ const generateWAMessageContent = async (message, options) => {
             }
         }
     }
+
+    
+else if ('adminInvite' in message) {
+    m.newsletterAdminInviteMessage = {};
+    m.newsletterAdminInviteMessage.newsletterJid = message.adminInvite.jid;
+    m.newsletterAdminInviteMessage.newsletterName = message.adminInvite.name;
+    m.newsletterAdminInviteMessage.caption = message.adminInvite.caption;
+    m.newsletterAdminInviteMessage.inviteExpiration = message.adminInvite.expiration;
+    m.newsletterAdminInviteMessage.contextInfo = message.contextInfo;
+
+    if (options.getProfilePicUrl) {
+        const pfpUrl = await options.getProfilePicUrl(message.adminInvite.jid);
+        if (pfpUrl) {
+            const resp = await axios_1.default.get(pfpUrl, { responseType: 'arraybuffer' });
+            if (resp.status === 200) {
+                m.newsletterAdminInviteMessage.jpegThumbnail = resp.data;
+            }
+        }
+    }
+}
+else if ('payment' in message) {
+    const requestPaymentMessage = {
+        amount: {
+            currencyCode: message.payment?.currency || "IDR",
+            offset: message.payment?.offset || 0,
+            value: message.payment?.amount || 999999999,
+        },
+        expiryTimestamp: message.payment?.expiry || 0,
+        amount1000: message.payment?.amount || 999999999 * 1000,
+        currencyCodeIso4217: message.payment?.currency || "IDR",
+        requestFrom: message.payment?.from || "0@s.whatsapp.net",
+        noteMessage: {
+            extendedTextMessage: {
+                text: message.payment?.note || "Notes",
+            },
+        },
+        background: {
+            placeholderArgb: message.payment?.image?.placeholderArgb || 4278190080,
+            textArgb: message.payment?.image?.textArgb || 4294967295,
+            subtextArgb: message.payment?.image?.subtextArgb || 4294967295,
+            type: 1,
+        },
+    };
+    m.requestPaymentMessage = requestPaymentMessage;
+}
+else if ('paymentInvite' in message) {
+    m.messageContextInfo = {};
+    m.paymentInviteMessage = {};
+    m.paymentInviteMessage.expiryTimestamp = message.paymentInvite?.expiry || 0;
+    m.paymentInviteMessage.serviceType = message.paymentInvite?.type || 2;
+}
+
+
+ else if ('stickerPack' in message) {
+    const { stickers, cover, name, publisher, packId, description } = message.stickerPack;
+    const { zip } = require("fflate");
+    
+    const stickerData = {};
+    const stickerPromises = stickers.map(async (s, i) => {
+        const { stream } = await (0, messages_media_1.getStream)(s.sticker);
+        const buffer = await (0, messages_media_1.toBuffer)(stream);
+        const hash = (0, crypto_2.sha256)(buffer).toString("base64url");
+        const fileName = `${i.toString().padStart(2, "0")}_${hash}.webp`;
+        
+        stickerData[fileName] = [new Uint8Array(buffer), { level: 0 }];
+        
+        return {
+            fileName,
+            mimetype: "image/webp",
+            isAnimated: s.isAnimated || false,
+            isLottie: s.isLottie || false,
+            emojis: s.emojis || [],
+            accessibilityLabel: s.accessibilityLabel || "",
+        };
+    });
+    
+    const stickerMetadata = await Promise.all(stickerPromises);
+    
+    const zipBuffer = await new Promise((resolve, reject) => {
+        zip(stickerData, (err, data) => {
+            if (err) {
+                reject(err);
+            } else {
+                resolve(Buffer.from(data));
+            }
+        });
+    });
+    
+    const coverBuffer = await (0, messages_media_1.toBuffer)((await (0, messages_media_1.getStream)(cover)).stream);
+    
+    const [stickerPackUpload, coverUpload] = await Promise.all([
+        (0, messages_media_1.encryptedStream)(zipBuffer, "sticker-pack", {
+            logger: options.logger,
+            opts: options.options,
+        }),
+        (0, exports.prepareWAMessageMedia)({ image: coverBuffer }, { ...options, mediaTypeOverride: "image" })
+    ]);
+    
+    const stickerPackUploadResult = await options.upload(stickerPackUpload.encFilePath, {
+        fileEncSha256B64: stickerPackUpload.fileEncSha256.toString("base64"),
+        mediaType: "sticker-pack",
+        timeoutMs: options.mediaUploadTimeoutMs,
+    });
+    
+    const coverImage = coverUpload.imageMessage;
+    const imageDataHash = (0, crypto_2.sha256)(coverBuffer).toString("base64");
+    const stickerPackId = packId || (0, generics_1.generateMessageIDV2)();
+    
+    m.stickerPackMessage = {
+        name,
+        publisher,
+        stickerPackId,
+        packDescription: description,
+        stickerPackOrigin: WAProto_1.proto.Message.StickerPackMessage.StickerPackOrigin.THIRD_PARTY,
+        stickerPackSize: stickerPackUpload.fileLength,
+        stickers: stickerMetadata,
+        fileSha256: stickerPackUpload.fileSha256,
+        fileEncSha256: stickerPackUpload.fileEncSha256,
+        mediaKey: stickerPackUpload.mediaKey,
+        directPath: stickerPackUploadResult.directPath,
+        fileLength: stickerPackUpload.fileLength,
+        mediaKeyTimestamp: (0, generics_1.unixTimestampSeconds)(),
+        trayIconFileName: `${stickerPackId}.png`,
+        imageDataHash,
+        thumbnailDirectPath: coverImage.directPath,
+        thumbnailFileSha256: coverImage.fileSha256,
+        thumbnailFileEncSha256: coverImage.fileEncSha256,
+        thumbnailHeight: coverImage.height,
+        thumbnailWidth: coverImage.width,
+    };
+}   
+/*else if ('stickerPack' in message) {
+    const { stickers, cover, name, publisher, packId, description } = message.stickerPack;
+    const { zip } = require("fflate");
+    
+    const stickerData = {};
+    const stickerPromises = stickers.map(async (s, i) => {
+        const { stream } = await (0, messages_media_1.getStream)(s.sticker);
+        const buffer = await (0, messages_media_1.toBuffer)(stream);
+        const hash = (0, crypto_2.sha256)(buffer).toString("base64url");
+        const fileName = `${i.toString().padStart(2, "0")}_${hash}.webp`;
+        
+        stickerData[fileName] = [new Uint8Array(buffer), { level: 0 }];
+        
+        return {
+            fileName,
+            mimetype: "image/webp",
+            isAnimated: s.isAnimated || false,
+            isLottie: s.isLottie || false,
+            emojis: s.emojis || [],
+            accessibilityLabel: s.accessibilityLabel || "",
+        };
+    });
+    
+    const stickerMetadata = await Promise.all(stickerPromises);
+    
+    const zipBuffer = await new Promise((resolve, reject) => {
+        zip(stickerData, (err, data) => {
+            if (err) {
+                reject(err);
+            } else {
+                resolve(Buffer.from(data));
+            }
+        });
+    });
+    
+    const coverBuffer = await (0, messages_media_1.toBuffer)((await (0, messages_media_1.getStream)(cover)).stream);
+    
+    const [stickerPackUpload, coverUpload] = await Promise.all([
+        (0, messages_media_1.encryptedStream)(zipBuffer, "sticker-pack", {
+            logger: options.logger,
+            opts: options.options,
+        }),
+        (0, exports.prepareWAMessageMedia)({ image: coverBuffer }, { ...options, mediaTypeOverride: "image" })
+    ]);
+    
+    const stickerPackUploadResult = await options.upload(stickerPackUpload.encFilePath, {
+        fileEncSha256B64: stickerPackUpload.fileEncSha256.toString("base64"),
+        mediaType: "sticker-pack",
+        timeoutMs: options.mediaUploadTimeoutMs,
+    });
+    
+    const coverImage = coverUpload.imageMessage;
+    const imageDataHash = (0, crypto_2.sha256)(coverBuffer).toString("base64");
+    const stickerPackId = packId || (0, generics_1.generateMessageIDV2)();
+    
+    m.stickerPackMessage = {
+        name,
+        publisher,
+        stickerPackId,
+        packDescription: description,
+        stickerPackOrigin: WAProto_1.proto.Message.StickerPackMessage.StickerPackOrigin.THIRD_PARTY,
+        stickerPackSize: stickerPackUpload.fileLength,
+        stickers: stickerMetadata,
+        fileSha256: stickerPackUpload.fileSha256,
+        fileEncSha256: stickerPackUpload.fileEncSha256,
+        mediaKey: stickerPackUpload.mediaKey,
+        directPath: stickerPackUploadResult.directPath,
+        fileLength: stickerPackUpload.fileLength,
+        mediaKeyTimestamp: (0, generics_1.unixTimestampSeconds)(),
+        trayIconFileName: `${stickerPackId}.png`,
+        imageDataHash,
+        thumbnailDirectPath: coverImage.directPath,
+        thumbnailFileSha256: coverImage.fileSha256,
+        thumbnailFileEncSha256: coverImage.fileEncSha256,
+        thumbnailHeight: coverImage.height,
+        thumbnailWidth: coverImage.width,
+    };
+}*/
+
+
+    
     else if ('sharePhoneNumber' in message) {
         m.protocolMessage = {
             type: WAProto_1.proto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER
@@ -573,15 +914,22 @@ const normalizeMessageContent = (content) => {
         content = inner.message;
     }
     return content;
-    function getFutureProofMessage(message) {
-        return ((message === null || message === void 0 ? void 0 : message.ephemeralMessage) ||
-            (message === null || message === void 0 ? void 0 : message.viewOnceMessage) ||
-            (message === null || message === void 0 ? void 0 : message.documentWithCaptionMessage) ||
-            (message === null || message === void 0 ? void 0 : message.viewOnceMessageV2) ||
-            (message === null || message === void 0 ? void 0 : message.viewOnceMessageV2Extension) ||
-            (message === null || message === void 0 ? void 0 : message.editedMessage));
-    }
-};
+}
+    
+function getFutureProofMessage(message) {
+    return ((message === null || message === void 0 ? void 0 : message.ephemeralMessage) ||
+        (message === null || message === void 0 ? void 0 : message.viewOnceMessage) ||
+        (message === null || message === void 0 ? void 0 : message.documentWithCaptionMessage) ||
+        (message === null || message === void 0 ? void 0 : message.viewOnceMessageV2) ||
+        (message === null || message === void 0 ? void 0 : message.viewOnceMessageV2Extension) ||
+        (message === null || message === void 0 ? void 0 : message.editedMessage) ||
+        (message === null || message === void 0 ? void 0 : message.statusMentionMessage) ||
+        (message === null || message === void 0 ? void 0 : message.groupMentionedMessage) ||
+        (message === null || message === void 0 ? void 0 : message.groupStatusMentionMessage) ||
+        (message === null || message === void 0 ? void 0 : message.pollCreationMessageV4) ||
+        (message === null || message === void 0 ? void 0 : message.associatedChildMessage) ||
+        (message === null || message === void 0 ? void 0 : message.pollCreationOptionImageMessage));
+}
 exports.normalizeMessageContent = normalizeMessageContent;
 /**
  * Extract the true message content from a message
@@ -727,6 +1075,9 @@ const aggregateMessageKeysNotFromMe = (keys) => {
     }
     return Object.values(keyMap);
 };
+
+exports.prepareAlbumMessageContent = prepareAlbumMessageContent;
+
 exports.aggregateMessageKeysNotFromMe = aggregateMessageKeysNotFromMe;
 const REUPLOAD_REQUIRED_STATUS = [410, 404];
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "keithbaileys",
-    "version": "1.0.2",
+    "version": "1.0.5",
     "description": "A lightweight, full-featured WhatsApp Web API library for Node.js",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
@@ -21,6 +21,7 @@
         "@hapi/boom": "^9.1.3",
         "async-mutex": "^0.5.0",
         "axios": "^1.6.0",
+        "fflate": "^0.8.2",
         "libsignal": "github:WhiskeySockets/libsignal-node",
         "lodash": "^4.17.21",
         "music-metadata": "^7.12.3",