jsdecryptor 4.0.3

package/davelib/antibadword.js

@@ -0,0 +1,278 @@
+const { getGroupConfig, setGroupConfig } = require('../Database/settingsStore');
+const db = require('../Database/database');
+const { getBotName } = require('./botConfig');
+
+function createFakeContact(participantId = '0') {
+    const botName = getBotName();
+    const cleanId = String(participantId).split('@')[0] || '0';
+    
+    return {
+        key: {
+            participants: "0@s.whatsapp.net",
+            remoteJid: "0@s.whatsapp.net",
+            fromMe: false
+        },
+        message: {
+            contactMessage: {
+                displayName: botName,
+                vcard: `BEGIN:VCARD\nVERSION:3.0\nN:;${botName};;;\nFN:${botName}\nitem1.TEL;waid=${cleanId}:${cleanId}\nitem1.X-ABLabel:Phone\nEND:VCARD`
+            }
+        },
+        participant: "0@s.whatsapp.net"
+    };
+}
+
+const DEFAULT_BAD_WORDS = [
+    'gandu', 'madarchod', 'bhosdike', 'bsdk', 'fucker', 'bhosda', 
+    'lauda', 'laude', 'betichod', 'chutiya', 'behenchod', 
+    'randi', 'chuchi', 'boobs', 'idiot', 'nigga', 'fuck', 
+    'dick', 'bitch', 'bastard', 'asshole', 'lund', 'mc', 'lodu',
+    'shit', 'damn', 'piss', 'crap', 'slut', 'whore', 'prick',
+    'motherfucker', 'cock', 'cunt', 'pussy', 'twat', 'wanker',
+    'chut', 'harami', 'kameena', 'haramzada'
+];
+
+async function handleAntiBadwordCommand(sock, chatId, message, match) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const botName = getBotName();
+    const fake = createFakeContact(senderId);
+    const config = getGroupConfig(chatId, 'antibadword') || {};
+    
+    if (!match) {
+        const customWords = config.words || [];
+        return sock.sendMessage(chatId, {
+            text: `*${botName} ANTIBADWORD*\n\n` +
+                  `Status: ${config.enabled ? 'ON' : 'OFF'}\n` +
+                  `Action: ${config.action || 'delete'}\n` +
+                  `Max Warnings: ${config.maxWarnings || 3}\n` +
+                  `Custom Words: ${customWords.length}\n\n` +
+                  `*Commands:*\n` +
+                  `.antibadword on - Enable\n` +
+                  `.antibadword off - Disable\n` +
+                  `.antibadword set <action> - delete/kick/warn\n` +
+                  `.antibadword add <word1, word2> - Add bad words\n` +
+                  `.antibadword remove <word> - Remove a word\n` +
+                  `.antibadword list - List custom words\n` +
+                  `.antibadword reset - Reset to default words`
+        }, { quoted: fake });
+    }
+
+    if (match === 'on') {
+        if (config?.enabled) {
+            return sock.sendMessage(chatId, { text: `*${botName}*\nAntiBadword already enabled!` }, { quoted: fake });
+        }
+        setGroupConfig(chatId, 'antibadword', { ...config, enabled: true, action: config.action || 'delete' });
+        return sock.sendMessage(chatId, { text: `*${botName}*\nAntiBadword ENABLED!` }, { quoted: fake });
+    }
+
+    if (match === 'off') {
+        if (!config?.enabled) {
+            return sock.sendMessage(chatId, { text: `*${botName}*\nAntiBadword already disabled!` }, { quoted: fake });
+        }
+        setGroupConfig(chatId, 'antibadword', { ...config, enabled: false });
+        return sock.sendMessage(chatId, { text: `*${botName}*\nAntiBadword DISABLED!` }, { quoted: fake });
+    }
+
+    if (match.startsWith('set ')) {
+        const action = match.split(' ')[1];
+        if (!action || !['delete', 'kick', 'warn'].includes(action)) {
+            return sock.sendMessage(chatId, { text: `*${botName}*\nInvalid action!\nChoose: delete, kick, or warn` }, { quoted: fake });
+        }
+        setGroupConfig(chatId, 'antibadword', { ...config, enabled: true, action });
+        return sock.sendMessage(chatId, { text: `*${botName}*\nAction set to: ${action}` }, { quoted: fake });
+    }
+
+    if (match.startsWith('add ')) {
+        const wordsInput = match.slice(4).trim();
+        if (!wordsInput) {
+            return sock.sendMessage(chatId, { text: `*${botName}*\nProvide words to add!\nExample: .antibadword add word1, word2, word3` }, { quoted: fake });
+        }
+        const newWords = wordsInput.split(/[,\s]+/).map(w => w.trim().toLowerCase()).filter(w => w.length > 0);
+        if (newWords.length === 0) {
+            return sock.sendMessage(chatId, { text: `*${botName}*\nNo valid words provided!` }, { quoted: fake });
+        }
+        const currentWords = config.words || [...DEFAULT_BAD_WORDS];
+        const addedWords = [];
+        for (const word of newWords) {
+            if (!currentWords.includes(word)) {
+                currentWords.push(word);
+                addedWords.push(word);
+            }
+        }
+        setGroupConfig(chatId, 'antibadword', { ...config, words: currentWords, enabled: true });
+        return sock.sendMessage(chatId, { 
+            text: `*${botName}*\nAdded ${addedWords.length} word(s): ${addedWords.join(', ')}\nTotal words: ${currentWords.length}` 
+        }, { quoted: fake });
+    }
+
+    if (match.startsWith('remove ')) {
+        const wordToRemove = match.slice(7).trim().toLowerCase();
+        if (!wordToRemove) {
+            return sock.sendMessage(chatId, { text: `*${botName}*\nProvide a word to remove!` }, { quoted: fake });
+        }
+        const currentWords = config.words || [...DEFAULT_BAD_WORDS];
+        const idx = currentWords.indexOf(wordToRemove);
+        if (idx === -1) {
+            return sock.sendMessage(chatId, { text: `*${botName}*\nWord "${wordToRemove}" not found in list!` }, { quoted: fake });
+        }
+        currentWords.splice(idx, 1);
+        setGroupConfig(chatId, 'antibadword', { ...config, words: currentWords });
+        return sock.sendMessage(chatId, { text: `*${botName}*\nRemoved "${wordToRemove}"\nTotal words: ${currentWords.length}` }, { quoted: fake });
+    }
+
+    if (match === 'list') {
+        const currentWords = config.words || DEFAULT_BAD_WORDS;
+        const wordList = currentWords.join(', ');
+        return sock.sendMessage(chatId, { 
+            text: `*${botName} BAD WORDS LIST*\n\n${currentWords.length} words:\n${wordList}` 
+        }, { quoted: fake });
+    }
+
+    if (match === 'reset') {
+        setGroupConfig(chatId, 'antibadword', { ...config, words: [...DEFAULT_BAD_WORDS] });
+        return sock.sendMessage(chatId, { 
+            text: `*${botName}*\nBad words reset to defaults (${DEFAULT_BAD_WORDS.length} words)` 
+        }, { quoted: fake });
+    }
+
+    return sock.sendMessage(chatId, { text: `*${botName}*\nInvalid command!\nUse .antibadword for help` }, { quoted: fake });
+}
+
+async function handleBadwordDetection(sock, chatId, message, userMessage, senderId) {
+    try {
+        if (!chatId.endsWith('@g.us')) return;
+        if (message.key.fromMe) return;
+
+        const config = getGroupConfig(chatId, 'antibadword');
+        if (!config?.enabled) return;
+
+        const groupMetadata = await sock.groupMetadata(chatId);
+        const botId = sock.user.id.split(':')[0] + '@s.whatsapp.net';
+        const bot = groupMetadata.participants.find(p => p.id === botId);
+        if (!bot?.admin) return;
+
+        const participant = groupMetadata.participants.find(p => p.id === senderId);
+        if (participant?.admin) return;
+        if (db.isSudo(senderId)) return;
+
+        const cleanMessage = userMessage.toLowerCase()
+            .replace(/[^\w\s]/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+
+        const badWords = config.words?.length > 0 ? config.words : DEFAULT_BAD_WORDS;
+        const messageWords = cleanMessage.split(' ');
+        let containsBadWord = false;
+
+        for (const word of messageWords) {
+            if (word.length < 2) continue;
+            if (badWords.includes(word)) {
+                containsBadWord = true;
+                break;
+            }
+        }
+
+        for (const badWord of badWords) {
+            if (badWord.includes(' ') && cleanMessage.includes(badWord)) {
+                containsBadWord = true;
+                break;
+            }
+        }
+
+        if (!containsBadWord) return;
+
+        const botName = getBotName();
+        const fake = createFakeContact(senderId);
+
+        try {
+            await sock.sendMessage(chatId, { delete: message.key });
+        } catch (err) {
+            console.error('Error deleting message:', err.message);
+            return;
+        }
+
+        const action = config.action || 'delete';
+        const senderNumber = senderId.split('@')[0];
+        const maxWarnings = config.maxWarnings || 3;
+
+        switch (action) {
+            case 'delete':
+                await sock.sendMessage(chatId, {
+                    text: `*${botName}*\n@${senderNumber}, bad words not allowed!\nMessage deleted.`,
+                    mentions: [senderId]
+                }, { quoted: fake });
+                break;
+
+            case 'kick':
+                try {
+                    await sock.groupParticipantsUpdate(chatId, [senderId], 'remove');
+                    await sock.sendMessage(chatId, {
+                        text: `*${botName}*\n@${senderNumber} kicked for bad words!`,
+                        mentions: [senderId]
+                    }, { quoted: fake });
+                } catch (error) {
+                    console.error('Error kicking user:', error.message);
+                }
+                break;
+
+            case 'warn':
+                const warningCount = db.incrementWarning(chatId, senderId);
+                if (warningCount >= maxWarnings) {
+                    try {
+                        await sock.groupParticipantsUpdate(chatId, [senderId], 'remove');
+                        db.resetWarning(chatId, senderId);
+                        await sock.sendMessage(chatId, {
+                            text: `*${botName}*\n@${senderNumber} kicked after ${maxWarnings} warnings!`,
+                            mentions: [senderId]
+                        }, { quoted: fake });
+                    } catch (error) {
+                        console.error('Error kicking user after warnings:', error.message);
+                    }
+                } else {
+                    await sock.sendMessage(chatId, {
+                        text: `*${botName}*\n@${senderNumber} warning ${warningCount}/${maxWarnings}!\nBad words not allowed.`,
+                        mentions: [senderId]
+                    }, { quoted: fake });
+                }
+                break;
+        }
+    } catch (err) {
+        console.error('Error in handleBadwordDetection:', err.message, 'Line:', err.stack?.split('\n')[1]);
+    }
+}
+
+async function setAntiBadword(groupId, type, action) {
+    setGroupConfig(groupId, 'antibadword', {
+        enabled: type === 'on',
+        action: action || 'delete'
+    });
+    return true;
+}
+
+async function getAntiBadword(groupId) {
+    return getGroupConfig(groupId, 'antibadword');
+}
+
+async function removeAntiBadword(groupId) {
+    setGroupConfig(groupId, 'antibadword', { enabled: false, action: 'delete' });
+    return true;
+}
+
+function incrementWarningCount(groupId, userId) {
+    return db.incrementWarning(groupId, userId);
+}
+
+function resetWarningCount(groupId, userId) {
+    db.resetWarning(groupId, userId);
+    return true;
+}
+
+module.exports = {
+    handleAntiBadwordCommand,
+    handleBadwordDetection,
+    setAntiBadword,
+    getAntiBadword,
+    removeAntiBadword,
+    incrementWarningCount,
+    resetWarningCount
+};

package/davelib/antilink.js

@@ -0,0 +1,88 @@
+const { isJidGroup } = require('@whiskeysockets/baileys');
+const { getAntilink, incrementWarningCount, resetWarningCount, isSudo } = require('../davelib/index');
+const config = require('../config');
+
+const WARN_COUNT = config.WARN_COUNT || 3;
+
+/**
+ * Checks if a string contains a URL.
+ *
+ * @param {string} str - The string to check.
+ * @returns {boolean} - True if the string contains a URL, otherwise false.
+ */
+function containsURL(str) {
+	const urlRegex = /(https?:\/\/)?([a-z0-9-]+\.)+[a-z]{2,}(\/[^\s]*)?/i;
+	return urlRegex.test(str);
+}
+
+/**
+ * Handles the Antilink functionality for group chats.
+ *
+ * @param {object} msg - The message object to process.
+ * @param {object} sock - The socket object to use for sending messages.
+ */
+async function Antilink(msg, sock) {
+	const jid = msg.key.remoteJid;
+	if (!isJidGroup(jid)) return;
+
+	const SenderMessage = msg.message?.conversation || 
+						 msg.message?.extendedTextMessage?.text || '';
+	if (!SenderMessage || typeof SenderMessage !== 'string') return;
+
+	const sender = msg.key.participant;
+	if (!sender) return;
+	
+	// Skip if sender is admin or sudo
+	const isAdmin = await isSudo(sender);
+	if (isAdmin) return;
+
+	if (!containsURL(SenderMessage.trim())) return;
+	
+	const antilinkConfig = await getAntilink(jid, 'on');
+	if (!antilinkConfig) return;
+
+	const action = antilinkConfig.action;
+	
+	try {
+		// Delete message first
+		await sock.sendMessage(jid, { delete: msg.key });
+
+		switch (action) {
+			case 'delete':
+				await sock.sendMessage(jid, { 
+					text: `\`\`\`@${sender.split('@')[0]} link are not allowed here\`\`\``,
+					mentions: [sender] 
+				});
+				break;
+
+			case 'kick':
+				await sock.groupParticipantsUpdate(jid, [sender], 'remove');
+				await sock.sendMessage(jid, {
+					text: `\`\`\`@${sender.split('@')[0]} has been kicked for sending links\`\`\``,
+					mentions: [sender]
+				});
+				break;
+
+			case 'warn':
+				const warningCount = await incrementWarningCount(jid, sender);
+				if (warningCount >= WARN_COUNT) {
+					await sock.groupParticipantsUpdate(jid, [sender], 'remove');
+					await resetWarningCount(jid, sender);
+					await sock.sendMessage(jid, {
+						text: `\`\`\`@${sender.split('@')[0]} has been kicked after ${WARN_COUNT} warnings\`\`\``,
+						mentions: [sender]
+					});
+				} else {
+					await sock.sendMessage(jid, {
+						text: `\`\`\`@${sender.split('@')[0]} warning ${warningCount}/${WARN_COUNT} for sending links\`\`\``,
+						mentions: [sender]
+					});
+				}
+				break;
+		}
+	} catch (error) {
+		console.error('Error in Antilink:', error);
+	}
+}
+
+module.exports = { Antilink };

package/davelib/antilinkHelper.js

@@ -0,0 +1,48 @@
+const { getGroupConfig, setGroupConfig } = require('../Database/settingsStore');
+
+function getAntilinkSetting(groupId) {
+    try {
+        const config = getGroupConfig(groupId, 'antilink');
+        if (!config || !config.enabled) return 'off';
+        return config.action || 'delete';
+    } catch (error) {
+        console.error('Error getting antilink setting:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        return 'off';
+    }
+}
+
+function setAntilinkSetting(groupId, type) {
+    try {
+        if (type === 'off') {
+            setGroupConfig(groupId, 'antilink', { enabled: false, action: 'delete' });
+        } else {
+            setGroupConfig(groupId, 'antilink', { enabled: true, action: type });
+        }
+    } catch (error) {
+        console.error('Error setting antilink setting:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+function getAntilinkConfig(groupId) {
+    try {
+        return getGroupConfig(groupId, 'antilink') || { enabled: false, action: 'delete', warnCount: 3 };
+    } catch (error) {
+        console.error('Error getting antilink config:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        return { enabled: false, action: 'delete', warnCount: 3 };
+    }
+}
+
+function setAntilinkConfig(groupId, config) {
+    try {
+        setGroupConfig(groupId, 'antilink', config);
+    } catch (error) {
+        console.error('Error setting antilink config:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+module.exports = {
+    setAntilinkSetting,
+    getAntilinkSetting,
+    getAntilinkConfig,
+    setAntilinkConfig
+};

package/davelib/botConfig.js

@@ -0,0 +1,71 @@
+const { getOwnerConfig, setOwnerConfig } = require('../Database/settingsStore');
+
+const defaultConfig = {
+    botName: 'DAVE-X',
+    menuImage: '',
+    menuVideo: '',
+    ownerName: 'Dave',
+    welcomeMessage: 'Welcome to the group!',
+    goodbyeMessage: 'Goodbye!',
+    antideletePrivate: true,
+    botFont: 'none'
+};
+
+function getConfig() {
+    try {
+        const stored = getOwnerConfig('botconfig');
+        return { ...defaultConfig, ...(stored || {}) };
+    } catch (error) {
+        console.error('Error getting bot config:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        return defaultConfig;
+    }
+}
+
+function saveConfig(config) {
+    try {
+        setOwnerConfig('botconfig', config);
+    } catch (error) {
+        console.error('Error saving bot config:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+function getBotName()       { return getConfig().botName; }
+function setBotName(name)   { const c = getConfig(); c.botName = name; saveConfig(c); }
+
+function getMenuImage()     { return getConfig().menuImage; }
+function setMenuImage(url)  { const c = getConfig(); c.menuImage = url; saveConfig(c); }
+
+function getMenuVideo()     { return getConfig().menuVideo || ''; }
+function setMenuVideo(url)  { const c = getConfig(); c.menuVideo = url; saveConfig(c); }
+
+function getOwnerName()     { return getConfig().ownerName; }
+function setOwnerName(name) { const c = getConfig(); c.ownerName = name; saveConfig(c); }
+
+function isAntideletePrivateEnabled()    { return getConfig().antideletePrivate !== false; }
+function setAntideletePrivate(enabled)   { const c = getConfig(); c.antideletePrivate = enabled; saveConfig(c); }
+
+function getBotFont()       { return getConfig().botFont || 'none'; }
+function setBotFont(font)   { const c = getConfig(); c.botFont = font; saveConfig(c); }
+
+function updateConfig(updates) {
+    const config = getConfig();
+    Object.assign(config, updates);
+    saveConfig(config);
+}
+
+module.exports = {
+    getBotName,
+    setBotName,
+    getMenuImage,
+    setMenuImage,
+    getMenuVideo,
+    setMenuVideo,
+    getOwnerName,
+    setOwnerName,
+    isAntideletePrivateEnabled,
+    setAntideletePrivate,
+    getBotFont,
+    setBotFont,
+    getConfig,
+    updateConfig
+};

package/davelib/connect4.js

@@ -0,0 +1,111 @@
+class ConnectFour {
+    constructor(playerRed, playerYellow) {
+        this.rows = 6;
+        this.cols = 7;
+        this.board = Array(this.rows).fill().map(() => Array(this.cols).fill(null));
+        this.playerRed = playerRed;
+        this.playerYellow = playerYellow;
+        this.currentTurn = playerRed; // Red starts
+        this.moves = 0;
+        this.winner = null;
+        this.lastMove = null;
+    }
+
+    dropDisc(isYellow, col) {
+        // Validate column
+        if (col < 0 || col >= this.cols) return false;
+        if (this.winner) return false;
+        
+        // Find first empty row from bottom
+        for (let row = this.rows - 1; row >= 0; row--) {
+            if (this.board[row][col] === null) {
+                this.board[row][col] = isYellow ? 'Y' : 'R';
+                this.moves++;
+                this.lastMove = {row, col};
+                
+                // Check for win
+                if (this.checkWin(row, col)) {
+                    this.winner = isYellow ? this.playerYellow : this.playerRed;
+                }
+                
+                // Switch turn
+                this.currentTurn = isYellow ? this.playerRed : this.playerYellow;
+                return true;
+            }
+        }
+        return false; // Column is full
+    }
+
+    checkWin(row, col) {
+        const player = this.board[row][col];
+        if (!player) return false;
+
+        // Directions: horizontal, vertical, diagonal down-right, diagonal up-right
+        const directions = [
+            [0, 1],   // right
+            [1, 0],   // down
+            [1, 1],   // down-right
+            [-1, 1]   // up-right
+        ];
+
+        for (const [dr, dc] of directions) {
+            let count = 1;
+            
+            // Check positive direction
+            for (let i = 1; i < 4; i++) {
+                const newRow = row + dr * i;
+                const newCol = col + dc * i;
+                if (newRow < 0 || newRow >= this.rows || newCol < 0 || newCol >= this.cols) break;
+                if (this.board[newRow][newCol] === player) count++;
+                else break;
+            }
+            
+            // Check negative direction
+            for (let i = 1; i < 4; i++) {
+                const newRow = row - dr * i;
+                const newCol = col - dc * i;
+                if (newRow < 0 || newRow >= this.rows || newCol < 0 || newCol >= this.cols) break;
+                if (this.board[newRow][newCol] === player) count++;
+                else break;
+            }
+            
+            if (count >= 4) return true;
+        }
+        
+        return false;
+    }
+
+    isDraw() {
+        return this.moves === this.rows * this.cols && !this.winner;
+    }
+
+    render() {
+        let boardStr = '⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯\n';
+        
+        // Top column numbers
+        boardStr += '1️⃣2️⃣3️⃣4️⃣5️⃣6️⃣7️⃣\n';
+        boardStr += '⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯\n';
+        
+        // Board
+        for (let row = 0; row < this.rows; row++) {
+            for (let col = 0; col < this.cols; col++) {
+                const cell = this.board[row][col];
+                if (cell === 'R') boardStr += '🔴';
+                else if (cell === 'Y') boardStr += '🟡';
+                else boardStr += '⚪';
+            }
+            boardStr += '\n';
+        }
+        
+        // Bottom border
+        boardStr += '⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯\n';
+        
+        return boardStr;
+    }
+
+    getBoard() {
+        return this.board.map(row => [...row]);
+    }
+}
+
+module.exports = ConnectFour;

package/davelib/converter.js

@@ -0,0 +1,89 @@
+const fs = require('fs')
+const path = require('path')
+const { spawn } = require('child_process')
+
+function ffmpeg(buffer, args = [], ext = '', ext2 = '') {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const tempDir = path.join(__dirname, '../temp')
+      if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true })
+      }
+      let tmp = path.join(tempDir, Date.now() + '.' + ext)
+      let out = tmp + '.' + ext2
+      await fs.promises.writeFile(tmp, buffer)
+      spawn('ffmpeg', [
+        '-y',
+        '-i', tmp,
+        ...args,
+        out
+      ])
+        .on('error', reject)
+        .on('close', async (code) => {
+          try {
+            await fs.promises.unlink(tmp)
+            if (code !== 0) return reject(code)
+            resolve(await fs.promises.readFile(out))
+            await fs.promises.unlink(out)
+          } catch (e) {
+            reject(e)
+          }
+        })
+    } catch (e) {
+      reject(e)
+    }
+  })
+}
+
+/**
+ * Convert Audio to Playable WhatsApp Audio
+ * @param {Buffer} buffer Audio Buffer
+ * @param {String} ext File Extension 
+ */
+function toAudio(buffer, ext) {
+  return ffmpeg(buffer, [
+    '-vn',
+    '-ac', '2',
+    '-b:a', '128k',
+    '-ar', '44100',
+    '-f', 'mp3'
+  ], ext, 'mp3')
+}
+
+/**
+ * Convert Audio to Playable WhatsApp PTT
+ * @param {Buffer} buffer Audio Buffer
+ * @param {String} ext File Extension 
+ */
+function toPTT(buffer, ext) {
+  return ffmpeg(buffer, [
+    '-vn',
+    '-c:a', 'libopus',
+    '-b:a', '128k',
+    '-vbr', 'on',
+    '-compression_level', '10'
+  ], ext, 'opus')
+}
+
+/**
+ * Convert Audio to Playable WhatsApp Video
+ * @param {Buffer} buffer Video Buffer
+ * @param {String} ext File Extension 
+ */
+function toVideo(buffer, ext) {
+  return ffmpeg(buffer, [
+    '-c:v', 'libx264',
+    '-c:a', 'aac',
+    '-ab', '128k',
+    '-ar', '44100',
+    '-crf', '32',
+    '-preset', 'slow'
+  ], ext, 'mp4')
+}
+
+module.exports = {
+  toAudio,
+  toPTT,
+  toVideo,
+  ffmpeg,
+}