whatsapp-reader 0.0.3

package/.utils/utils.js

@@ -0,0 +1,84 @@
+module.exports = async (AntonThomzz, m) => {
+    const type = Object.keys(m.message)[0];
+    const botNumber = await AntonThomzz.decodeJid(AntonThomzz.user.id);
+    const isOwner = AntonThomzz.owner.number.includes(m.sender);
+    
+    let body;
+    switch (m.mtype) {
+        case "conversation":
+            body = m.message.conversation;
+            break;
+        case "imageMessage":
+            body = m.message.imageMessage.caption;
+            break;
+        case "videoMessage":
+            body = m.message.videoMessage.caption;
+            break;
+        case "extendedTextMessage":
+            body = m.message.extendedTextMessage.text;
+            break;
+        case "buttonsResponseMessage":
+            body = m.message.buttonsResponseMessage.selectedButtonId;
+            break;
+        case "listResponseMessage":
+            body = m.message.listResponseMessage.singleSelectReply.selectedRowId;
+            break;
+        case "templateButtonReplyMessage":
+            body = m.message.templateButtonReplyMessage.selectedId;
+            break;
+        case "interactiveResponseMessage":
+            body = JSON.parse(m.msg.nativeFlowResponseMessage.paramsJson).id;
+            break;
+        case "messageContextInfo":
+            body = m.message.buttonsResponseMessage?.selectedButtonId ||
+                m.message.listResponseMessage?.singleSelectReply.selectedRowId ||
+                m.text || "";
+            break;
+        default:
+            body = "";
+    }
+
+    const prefix = /^[°zZ#^]/.test(body) ? body.match(/^[°zZ#^]/gi) : '.';
+    const isCmd = body.startsWith(prefix);
+    const command = isCmd ? body.slice(prefix.length).trim().split(' ').shift().toLowerCase() : '';
+    const args = body.trim().split(/ +/).slice(1);
+    const text = q = args.join(" ");
+    const quoted = m.quoted ? m.quoted : m;
+    const mime = (quoted.msg || quoted).mimetype || '';
+
+    const ton_verif = {
+        key: {
+            participant: `0@s.whatsapp.net`,
+            ...(m.chat ? { remoteJid: "status@broadcast" } : {})
+        },
+        message: {
+            listResponseMessage: {
+                title: `Bots`
+            }
+        }
+    };
+    
+    const reply = (text) => AntonThomzz.sendMessage(m.chat, { text }, { quoted: ton_verif });
+    const imgg = (a) => AntonThomzz.sendMessage(m.chat, { image: { url: a } });
+    const audi = (a) => AntonThomzz.sendMessage(m.chat, { audio: { url: a }, fileName: "a.mp3",mimetype: "audio/mpeg"});
+    const vid = (a,b) => AntonThomzz.sendMessage(m.chat, { video: { url: a }, caption: b});
+    
+    const proses = () => AntonThomzz.sendMessage(m.chat, { react: { text: `⏱️`, key: m.key }});
+    
+    return { 
+    body, 
+    prefix, 
+    isCmd, 
+    command, 
+    args, 
+    text, 
+    quoted, 
+    mime, 
+    ton_verif,
+    reply,
+    imgg,
+    audi,
+    vid,
+    proses
+    };
+};

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 AntonThomzz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,48 @@
+
+# WhatsApp Reader
+
+`whatsapp-reader` is a module that simplifies interacting with WhatsApp via a bot. This module allows developers to easily integrate the ability to send and receive messages through the WhatsApp API.
+
+## Features
+
+- Send and receive text messages on WhatsApp
+- Easy integration with Node.js projects
+- Comprehensive documentation for usage and configuration
+
+## Installation
+
+To install this module, make sure you have [Node.js](https://nodejs.org/) and [npm](https://www.npmjs.com/) installed. Then, run the following command to install `whatsapp-reader`:
+
+```bash
+npm install whatsapp-reader
+```
+
+## Usage
+
+After installation, you can use this module to send and receive WhatsApp messages. Here's an example of how to use it:
+
+```javascript
+// Import the whatsapp-reader module
+const antonStart = require('whatsapp-reader');
+
+// Start the bot
+antonStart();
+```
+
+This will initialize the bot and start interacting with WhatsApp.
+
+## Configuration
+
+Make sure you have a valid API configuration to use this module. Follow the instructions provided by the WhatsApp API documentation to set up your bot.
+
+## License
+
+This project is licensed under the **MIT License**. See the `LICENSE` file for more details.
+
+## Contributing
+
+If you'd like to contribute to this project, feel free to fork this repository, make changes, and submit a pull request.
+
+## Contact
+
+For further questions or issues regarding the usage of this module, please contact us via [email/contact](mailto:example@domain.com).

package/feature.js

@@ -0,0 +1,175 @@
+require("./lib/modules");
+module.exports = async (AntonThomzz, m, store) => {
+    const {
+        body,
+        command,
+        text, 
+        quoted, 
+        mime,
+        reply,
+        imgg,
+        vid,
+        audi,
+        proses
+    } = await processMessage(AntonThomzz, m);
+    try {
+
+        switch (command) {
+            case "allmenu": case "menu": case "help":
+                const teks = `
+# *AutoRead Status:* ${global.autoreadsw ? "Aktif" : "nonaktif"}
+# *AutoRead Chats:* ${global.autoread ? "Aktif" : "nonaktif"}
+
+• remini
+• tourl1
+• tourl2
+• tourl3
+• tourl4
+• tiktok
+• waifu
+• maid
+• marin-kitagawa
+• mori-calliope
+• raiden-shogun
+• oppai
+• selfies
+• uniform
+• kamisato-ayaka
+• hentai
+• ass
+• milf
+• oral
+• paizuri
+• ecchi
+• ero`;
+                reply(teks);
+                break;
+
+
+            case "tourl": case "tourl1":
+                if (!/image/.test(mime)) return reply("Please send an image.");
+                if (!quoted) return reply("No media to download.");
+                   proses();
+                   AntonThomzz.downloadAndSaveMediaMessage(quoted)
+                      .then(filePath => upload.Lurkmore(filePath))
+                      .then(data => reply(data))
+                      .catch(err => reply(err.message || err));
+                break;
+
+
+            case "tourl2":
+                if (!isOwner) return reply("You are not authorized to use this command.");
+                if (!/image|video/.test(mime)) return reply("Please send an image or video.");
+                if (!quoted) return reply("No media to download.");
+                   proses();
+                   AntonThomzz.downloadAndSaveMediaMessage(quoted)
+                      .then(filePath => upload.Pomf2(filePath))
+                      .then(data => reply(data))
+                      .catch(err => reply(err.message || err));
+                break;
+
+
+            case "tourl3":
+                if (!isOwner) return reply("You are not authorized to use this command.");
+                if (!/image|video/.test(mime)) return reply("Please send an image or video.");
+                if (!quoted) return reply("No media to download.");
+                   proses();
+                   AntonThomzz.downloadAndSaveMediaMessage(quoted)
+                      .then(filePath => upload.Imgur(filePath))
+                      .then(data => reply(data))
+                      .catch(err => reply(err.message || err));
+                break;
+
+
+            case "tourl4":
+                if (!isOwner) return reply("You are not authorized to use this command.");
+                if (!/image|video/.test(mime)) return reply("Please send an image or video.");
+                if (!quoted) return reply("No media to download.");
+                   proses();
+                   AntonThomzz.downloadAndSaveMediaMessage(quoted)
+                      .then(filePath => {
+                         const cloudName = 'ddwxu3hhz';
+                         const apiKey = '257292411556524';
+                         const apiSecret = 'bYP8i-wX0htRGNfUag0w28j1VUE';
+                         if (!cloudName || !apiKey || !apiSecret) {
+                            throw new Error('Cloudinary credentials are missing.');
+                         }
+                         return upload.Cloudinary(filePath, cloudName, apiKey, apiSecret);
+                      })
+                      .then(cloudinaryUrl => reply(cloudinaryUrl))
+                      .catch(err => reply(err.message || err));
+                break;
+
+
+            case 'ttmp4': case 'tiktokmp4': case "tt": case "tiktok":
+                if (!text) return reply('Enter the TikTok video URL');
+                   proses();
+                   axios.get(`https://www.antoncodder.online/api/tiktok?url=${text}`)
+                      .then(({ data }) => vid(data.video.url, data.video.title))
+                      .catch(err => reply(err.message || err));
+                break;
+
+
+            case 'ttmp3': case 'tiktokmp3':
+                if (!text) return reply('Enter the TikTok video URL');
+                   proses();
+                   axios.get(`https://www.antoncodder.online/api/tiktok?url=${text}`)
+                      .then(({ data }) => audi(data.video.music))
+                      .catch(err => reply(err.message || err));
+                break;
+
+
+            case 'hd': case 'remini':
+                if (!/image/.test(mime)) return reply("just for pictures");
+                   proses();
+                   const media = await quoted.download();
+                   const remini = require("./lib/remini");
+                   const data = await remini(media, "enhance");
+                   AntonThomzz.sendMessage(m.chat, { image: data });
+                break;
+
+
+            case "waifu": case "maid": case "marin-kitagawa": case "mori-calliope": 
+            case "raiden-shogun": case "oppai": case "selfies": case "uniform": 
+            case "kamisato-ayaka":
+            // NSFW
+            case "hentai": case "ass": case "milf":
+            case "oral": case "paizuri": case "ecchi": 
+            case "ero":
+                proses();
+                axios.get(`https://api.waifu.im/search/?included_tags=${command}`)
+                    .then((response) => imgg(response.data.images[0]?.url))
+                    .catch(err => reply(err.message || err));
+                break;
+
+
+            // LANJUT TAMBAHKAN FITUR DI SINI
+
+
+            default:
+            if (/^(magic|open|buka|-sS|ss|tsu)/.test(body)) {
+               if (!isOwner) return;
+                  return viewonce(m, quoted, AntonThomzz);
+            }
+            if (/^(ton|bro|pp|Bro|anton|Ton)/.test(body)) {
+               AntonThomzz.sendMessage(
+                  m.chat, { 
+                     audio: fs.readFileSync(`./lib/salam.mp3`),
+                     ptt: true
+                  }
+               );
+            }
+                break;
+        }
+    } catch (err) {
+        console.error(err.message || err);
+    }
+};
+
+const file = require.resolve(__filename);
+fs.watchFile(file, () => {
+    fs.unwatchFile(file);
+    console.log(`Update File ${__filename}`);
+    delete require.cache[file];
+    require(file);
+});

package/index.js

@@ -0,0 +1,134 @@
+require("./lib/modules");
+const smsg = require("./lib/smsg");
+const { handlePairingCode } = require("./lib/pairingCodeHandler");
+const useCODE = process.argv.includes("--code");
+const useQR = !useCODE;
+
+const store = makeInMemoryStore({
+    logger: pino({
+        level: "fatal"
+    }).child({
+        level: "fatal"
+    })
+});
+
+async function antonStart() {
+    process.on("unhandledRejection", error => console.error(error));
+    const { state, saveCreds } = await useMultiFileAuthState("./tmp/session");
+    const { version, isLatest } = await fetchLatestBaileysVersion();
+    const nodeCache = new NodeCache();
+
+    const AntonThomzz = makeWASocket({
+        version,
+        keepAliveInternalMs: 30000,
+        printQRInTerminal: useQR && !useCODE,
+        generateHighQualityLinkPreview: true,
+        msgRetryCounterCache: nodeCache,
+        markOnlineOnConnect: true,
+        defaultQueryTimeoutMs: undefined,
+        logger: pino({ level: "fatal" }),
+        auth: state,
+        browser: Browsers.ubuntu('CHROME')
+    });
+
+    store.bind(AntonThomzz.ev);
+    setInterval(() => store.writeToFile("./tmp/store.json"), 10000);
+    await handlePairingCode(AntonThomzz, useCODE);
+
+    AntonThomzz.ev.on("connection.update", ({ connection }) => {
+        switch (connection) {
+            case "open":
+                console.log(`Connected as: ${AntonThomzz.user?.id.split(":")[0]}`);
+                break;
+            case "close":
+                reconnect();
+                break;
+            case "connecting":
+                console.log(AntonThomzz.user ? `Reconnecting... User ID: ${AntonThomzz.user.id.split(":")[0]}` : "Authentication required.");
+                break;
+        }
+    });
+
+    AntonThomzz.ev.process(async (events) => {
+        if (events['messages.upsert']) {
+            const upsert = events['messages.upsert'];
+            for (let msg of upsert.messages) {
+                if (!msg.message) return;
+                if (msg.key && !msg.key.fromMe && msg.key.remoteJid === 'status@broadcast') {
+                    await AntonThomzz.readMessages([msg.key]);
+                    console.log(`Successfully viewed status: ${msg.pushName}`);
+                }
+                if (global.autoread) {
+                    await AntonThomzz.readMessages([msg.key]);
+                }
+                const m = smsg(AntonThomzz, msg)
+                require("./feature")(AntonThomzz, m, store)
+            }
+        }
+    });
+
+    AntonThomzz.ev.on('creds.update', saveCreds)
+    AntonThomzz.number = AntonThomzz.user?.["id"]["split"](":")[0] + "@s.whatsapp.net"
+    AntonThomzz.owner = {
+      "name": `Anton`,
+      "number": `6283198645688@s.whatsapp.net`
+    }
+
+    AntonThomzz.decodeJid = (jid) => {
+    if (!jid) return jid
+    if (/:\d+@/gi.test(jid)) {
+    let decode = jidDecode(jid) || {}
+    return decode.user && decode.server && decode.user + '@' + decode.server || jid
+    } else return jid
+    }
+
+    AntonThomzz.downloadM = async (m, type, filename = '') => {
+    if (!m || !(m.url || m.directPath)) return Buffer.alloc(0)
+    const stream = await downloadContentFromMessage(m, type)
+    let buffer = Buffer.from([])
+    for await (const chunk of stream) {
+    buffer = Buffer.concat([buffer, chunk])
+    }
+    if (filename) await fs.promises.writeFile(filename, buffer)
+    return filename && fs.existsSync(filename) ? filename : buffer
+    }
+
+    AntonThomzz.downloadMediaMessage = async (message) => {
+    let quoted = message.msg ? message.msg : message
+    let mime = (message.msg || message).mimetype || ''
+    let messageType = message.mtype ? message.mtype.replace(/Message/gi, '') : mime.split('/')[0]
+    const stream = await downloadContentFromMessage(quoted, messageType)
+    let buffer = Buffer.from([])
+    for await(const chunk of stream) {
+    buffer = Buffer.concat([buffer, chunk])
+    }
+    return buffer
+    }
+
+    AntonThomzz.downloadAndSaveMediaMessage = async (message, filename, attachExtension = true) => {
+    let quoted = message.msg ? message.msg : message
+    let mime = (message.msg || message).mimetype || ''
+    let messageType = message.mtype ? message.mtype.replace(/Message/gi, '') : mime.split('/')[0]
+    const stream = await downloadContentFromMessage(quoted, messageType)
+    let buffer = Buffer.from([])
+    for await(const chunk of stream) {
+    buffer = Buffer.concat([buffer, chunk])
+    }
+    let type = await FileType.fromBuffer(buffer)
+    trueFileName = attachExtension ? (filename + '.' + type.ext) : filename
+    await fs.writeFileSync(trueFileName, buffer)
+    return trueFileName
+    }
+
+    return AntonThomzz;
+}
+
+let retryCount = 0;
+const reconnect = async () => {
+    if (retryCount >= 5) return;
+    retryCount++;
+    await new Promise(resolve => setTimeout(resolve, 5000 * Math.pow(2, retryCount)));
+    await antonStart();
+}
+
+module.exports = antonStart;

package/lib/modules.js

@@ -0,0 +1,83 @@
+const fs = require("fs");
+const readline = require("readline");
+const pino = require("pino");
+const NodeCache = require("node-cache");
+const FileType = require("file-type");
+const axios = require('axios');
+const FormData = require('form-data');
+
+global.fs = fs;
+global.readline = readline;
+global.pino = pino;
+global.NodeCache = NodeCache;
+global.FileType = FileType;
+global.axios = axios;
+global.FormData = FormData;
+
+const {
+  default: makeWASocket,
+  prepareWAMessageMedia,
+  downloadMediaMessage,
+  makeWALegacySocket,
+  BufferJSON,
+  Browsers,
+  initInMemoryStore,
+  extractMessageContent,
+  makeInMemoryStore,
+  proto,
+  delay,
+  DisconnectReason,
+  useMultiFileAuthState,
+  fetchLatestBaileysVersion,
+  jidDecode,
+  areJidsSameUser,
+  PHONENUMBER_MCC,
+  WA_DEFAULT_EPHEMERAL,
+  relayMessage,
+  getContentType,
+  generateWAMessage,
+  generateWAMessageContent,
+  generateForwardMessageContent,
+  downloadContentFromMessage,
+  generateWAMessageFromContent
+} = require("@adiwajshing/baileys");
+
+global.generateWAMessageFromContent = generateWAMessageFromContent;
+global.makeWASocket = makeWASocket;
+global.prepareWAMessageMedia = prepareWAMessageMedia;
+global.makeWALegacySocket = makeWALegacySocket;
+global.BufferJSON = BufferJSON;
+global.Browsers = Browsers;
+global.initInMemoryStore = initInMemoryStore;
+global.extractMessageContent = extractMessageContent;
+global.makeInMemoryStore = makeInMemoryStore;
+global.proto = proto;
+global.delay = delay;
+global.DisconnectReason = DisconnectReason;
+global.useMultiFileAuthState = useMultiFileAuthState;
+global.fetchLatestBaileysVersion = fetchLatestBaileysVersion;
+global.jidDecode = jidDecode;
+global.areJidsSameUser = areJidsSameUser;
+global.PHONENUMBER_MCC = PHONENUMBER_MCC;
+global.WA_DEFAULT_EPHEMERAL = WA_DEFAULT_EPHEMERAL;
+global.relayMessage = relayMessage;
+global.getContentType = getContentType;
+global.generateWAMessage = generateWAMessage;
+global.generateWAMessageContent = generateWAMessageContent;
+global.generateForwardMessageContent = generateForwardMessageContent;
+global.downloadContentFromMessage = downloadContentFromMessage;
+
+global.viewonce = require("./viewonce");
+global.upload = require("./tourl/index");
+global.processMessage = require('../.utils/utils');
+
+global.autoreadsw = true;
+global.autoread = true;
+
+const file = require.resolve(__filename);
+fs.watchFile(file, () => {
+  fs.unwatchFile(file);
+  console.log(`Update File ${__filename}`);
+  delete require.cache[file];
+  require(file);
+});

package/lib/pairingCodeHandler.js

@@ -0,0 +1,25 @@
+const { input, closeQuestionInterface } = require('./question');
+const chalk = require("chalk");
+
+const handlePairingCode = async (AntonThomzz, usePairingCode) => {
+    if (usePairingCode && !AntonThomzz.authState.creds.registered) {
+        const phoneNumber = await input('WhatsApp Number: ');
+
+        if (!/^\d+$/.test(phoneNumber)) {
+            return console.error('INVALID_NUMBER');
+        }
+
+        if (await input(`type ${chalk.green('ANTON')} to continue: `) !== 'ANTON') {
+            return console.error('INVALID');
+        }
+
+        const cleanedPhoneNumber = phoneNumber.replace(/\D/g, '');
+        const code = await AntonThomzz.requestPairingCode(cleanedPhoneNumber);
+
+        console.log(`Code: ${code.match(/.{1,4}/g).join('-')}`);
+    }
+
+    closeQuestionInterface();
+};
+
+module.exports = { handlePairingCode };

package/lib/question.js

@@ -0,0 +1,7 @@
+const readline = require("readline");
+
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+const input = (text) => new Promise(resolve => rl.question(text, resolve));
+const closeQuestionInterface = () => rl.close();
+
+module.exports = { input, closeQuestionInterface };

package/lib/remini.js

@@ -0,0 +1,42 @@
+require("./modules");
+async function remini(imageBuffer, model = 'enhance') {
+  const validModels = ['enhance', 'recolor', 'dehaze'];
+  if (!validModels.includes(model)) {
+    throw new Error(`Invalid model selected. Valid options are: ${validModels.join(', ')}`);
+  }
+
+  const formData = new FormData();
+  formData.append("model_version", "1");
+  formData.append("image", imageBuffer, "enhance_image_body.jpg");
+
+  try {
+    const response = await axios.post(
+      `https://inferenceengine.vyro.ai/${model}`,
+      formData,
+      {
+        headers: {
+          ...formData.getHeaders(),
+          'User-Agent': 'okhttp/4.9.3',
+          'Connection': 'Keep-Alive',
+          'Accept-Encoding': 'gzip',
+        },
+        responseType: 'arraybuffer',
+      }
+    );
+
+    return response.data;
+  } catch (error) {
+    console.error('Error processing image:', error.message);
+    throw new Error('Failed to process image');
+  }
+}
+
+module.exports = remini;
+
+const file = require.resolve(__filename);
+fs.watchFile(file, () => {
+  fs.unwatchFile(file);
+  console.log(`Update File ${__filename}`);
+  delete require.cache[file];
+  require(file);
+});

package/lib/smsg.js

@@ -0,0 +1,60 @@
+module.exports = (AntonThomzz, msg) => {
+let M = proto.WebMessageInfo
+msg = M.fromObject(msg)
+if (msg.key) {
+msg.id = msg.key.id
+msg.isBaileys = msg.id && msg.id.length === 16 || msg.id.startsWith('3EB0') && msg.id.length === 12 || false
+msg.chat = AntonThomzz.decodeJid(msg.key.remoteJid || message.message?.senderKeyDistributionMessage?.groupId || '')
+msg.now = msg.messageTimestamp
+msg.isGroup = msg.chat.endsWith('@g.us')
+msg.sender = AntonThomzz.decodeJid(msg.key.fromMe && AntonThomzz.user.id || msg.participant || msg.key.participant || msg.chat || '')
+}
+if (msg.message) {
+let mtype = Object.keys(msg.message)
+msg.mtype = (!['senderKeyDistributionMessage', 'messageContextInfo'].includes(mtype[0]) && mtype[0]) || 
+(mtype.length >= 3 && mtype[1] !== 'messageContextInfo' && mtype[1]) || 
+mtype[mtype.length - 1]
+msg.type = getContentType(msg.message)
+msg.msg = (msg.mtype == 'viewOnceMessage' ? msg.message[msg.mtype].message[getContentType(msg.message[msg.mtype].message)] : msg.message[msg.type])
+if (msg.chat == 'status@broadcast' && ['protocolMessage', 'senderKeyDistributionMessage'].includes(msg.mtype)) msg.chat = (msg.key.remoteJid !== 'status@broadcast' && msg.key.remoteJid) || msg.sender
+if (msg.mtype == 'protocolMessage' && msg.msg.key) {
+if (msg.msg.key.remoteJid == 'status@broadcast') msg.msg.key.remoteJid = msg.chat
+if (!msg.msg.key.participant || msg.msg.key.participant == 'status_me') msg.msg.key.participant = msg.sender
+msg.msg.key.fromMe = AntonThomzz.decodeJid(msg.msg.key.participant) === AntonThomzz.decodeJid(AntonThomzz.user.id)
+if (!msg.msg.key.fromMe && msg.msg.key.remoteJid === AntonThomzz.decodeJid(AntonThomzz.user.id)) msg.msg.key.remoteJid = msg.sender
+}
+msg.text = msg.msg || ''
+msg.mentionedJid = msg.msg?.contextInfo?.mentionedJid?.length && msg.msg.contextInfo.mentionedJid || []
+let quoted = msg.quoted = msg.msg?.contextInfo?.quotedMessage ? msg.msg.contextInfo.quotedMessage : null
+if (msg.quoted) {
+let type = Object.keys(msg.quoted)[0]
+msg.quoted = msg.quoted[type]
+if (typeof msg.quoted === 'string') msg.quoted = { text: msg.quoted }
+msg.quoted.mtype = type
+msg.quoted.id = msg.msg.contextInfo.stanzaId
+msg.quoted.chat = AntonThomzz.decodeJid(msg.msg.contextInfo.remoteJid || msg.chat || msg.sender)
+msg.quoted.isBaileys = msg.quoted.id && msg.quoted.id.length === 16 || false
+msg.quoted.sender = AntonThomzz.decodeJid(msg.msg.contextInfo.participant)
+msg.quoted.text = msg.quoted.text || msg.quoted.caption || msg.quoted.contentText || ''
+msg.quoted.mentionedJid = msg.quoted.contextInfo?.mentionedJid?.length && msg.quoted.contextInfo.mentionedJid || []
+let vM = msg.quoted.fakeObj = M.fromObject({
+key: {
+fromMe: msg.quoted.fromMe,
+remoteJid: msg.quoted.chat,
+id: msg.quoted.id
+},
+message: quoted,
+...(msg.isGroup ? { participant: msg.quoted.sender } : {})
+})
+msg.getQuotedObj = msg.getQuotedMessage = async () => {
+if (!msg.quoted.id) return null
+let q = M.fromObject(vM)
+return smsg(AntonThomzz, q)
+}
+if (msg.quoted.url || msg.quoted.directPath) msg.quoted.download = () => AntonThomzz.downloadMediaMessage(msg.quoted)
+msg.quoted.copy = () => smsg(AntonThomzz, M.fromObject(M.toObject(vM)))
+}
+}
+if (msg.msg && msg.msg.url) msg.download = (saveToFile = false) => AntonThomzz.downloadM(msg.msg, msg.mtype.replace(/message/i, ''), saveToFile)
+return msg
+}