jsdecryptor 4.0.3

package/davelib/dicegame.js

@@ -0,0 +1,114 @@
+class DiceGame {
+    constructor(hostId, maxRounds = 3) {
+        this.host = hostId;
+        this.players = [hostId];
+        this.scores = {};
+        this.scores[hostId] = 0;
+        this.currentPlayerIndex = 0;
+        this.round = 1;
+        this.maxRounds = maxRounds;
+        this.state = 'WAITING';
+        this.lastRoll = null;
+        this.roundRolls = {};
+        this.createdAt = Date.now();
+    }
+
+    addPlayer(playerId) {
+        if (this.players.includes(playerId)) return false;
+        if (this.state !== 'WAITING') return false;
+        this.players.push(playerId);
+        this.scores[playerId] = 0;
+        return true;
+    }
+
+    start() {
+        if (this.players.length < 2) return false;
+        this.state = 'PLAYING';
+        this.currentPlayerIndex = 0;
+        this.roundRolls = {};
+        return true;
+    }
+
+    get currentPlayer() {
+        return this.players[this.currentPlayerIndex];
+    }
+
+    roll(playerId) {
+        if (this.state !== 'PLAYING') return { ok: false, reason: 'Game not active' };
+        if (playerId !== this.currentPlayer) return { ok: false, reason: 'Not your turn' };
+        if (this.roundRolls[playerId]) return { ok: false, reason: 'You already rolled this round' };
+
+        const dice1 = Math.floor(Math.random() * 6) + 1;
+        const dice2 = Math.floor(Math.random() * 6) + 1;
+        const total = dice1 + dice2;
+
+        this.roundRolls[playerId] = { dice1, dice2, total };
+        this.scores[playerId] = (this.scores[playerId] || 0) + total;
+        this.lastRoll = { playerId, dice1, dice2, total };
+
+        this.currentPlayerIndex++;
+
+        let roundComplete = false;
+        let gameOver = false;
+
+        if (this.currentPlayerIndex >= this.players.length) {
+            roundComplete = true;
+            this.round++;
+            if (this.round > this.maxRounds) {
+                this.state = 'ENDED';
+                gameOver = true;
+            } else {
+                this.currentPlayerIndex = 0;
+                this.roundRolls = {};
+            }
+        }
+
+        return {
+            ok: true,
+            dice1,
+            dice2,
+            total,
+            roundComplete,
+            gameOver,
+            round: this.round - (roundComplete ? 1 : 0),
+            nextPlayer: gameOver ? null : this.currentPlayer,
+        };
+    }
+
+    getScoreboard() {
+        return Object.entries(this.scores)
+            .sort((a, b) => b[1] - a[1])
+            .map(([player, score], i) => {
+                const name = player.split(':')[0].split('@')[0];
+                const medal = i === 0 ? '1st' : i === 1 ? '2nd' : i === 2 ? '3rd' : `${i + 1}th`;
+                return `${medal} @${name}: ${score} pts`;
+            })
+            .join('\n');
+    }
+
+    get winner() {
+        if (this.state !== 'ENDED') return null;
+        let maxScore = -1;
+        let winner = null;
+        for (const [player, score] of Object.entries(this.scores)) {
+            if (score > maxScore) {
+                maxScore = score;
+                winner = player;
+            }
+        }
+        return winner;
+    }
+
+    static getDiceEmoji(num) {
+        const emojis = ['', '1', '2', '3', '4', '5', '6'];
+        return emojis[num] || '?';
+    }
+
+    static aiRoll() {
+        const dice1 = Math.floor(Math.random() * 6) + 1;
+        const dice2 = Math.floor(Math.random() * 6) + 1;
+        return { dice1, dice2, total: dice1 + dice2 };
+    }
+}
+
+module.exports = DiceGame;

package/davelib/exif.js

@@ -0,0 +1,138 @@
+
+const fs = require('fs')
+const { tmpdir } = require("os")
+const Crypto = require("crypto")
+const ff = require('fluent-ffmpeg')
+const webp = require("node-webpmux")
+const path = require("path")
+
+
+async function imageToWebp (media) {
+
+    const tmpFileOut = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    const tmpFileIn = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.jpg`)
+
+    fs.writeFileSync(tmpFileIn, media)
+
+    await new Promise((resolve, reject) => {
+        ff(tmpFileIn)
+            .on("error", reject)
+            .on("end", () => resolve(true))
+            .addOutputOptions([
+                "-vcodec",
+                "libwebp",
+                "-vf",
+                "scale='min(320,iw)':min'(320,ih)':force_original_aspect_ratio=decrease,fps=15, pad=320:320:-1:-1:color=white@0.0, split [a][b]; [a] palettegen=reserve_transparent=on:transparency_color=ffffff [p]; [b][p] paletteuse"
+            ])
+            .toFormat("webp")
+            .save(tmpFileOut)
+    })
+
+    const buff = fs.readFileSync(tmpFileOut)
+    fs.unlinkSync(tmpFileOut)
+    fs.unlinkSync(tmpFileIn)
+    return buff
+}
+
+async function videoToWebp (media) {
+
+    const tmpFileOut = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    const tmpFileIn = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.mp4`)
+
+    fs.writeFileSync(tmpFileIn, media)
+
+    await new Promise((resolve, reject) => {
+        ff(tmpFileIn)
+            .on("error", reject)
+            .on("end", () => resolve(true))
+            .addOutputOptions([
+                "-vcodec",
+                "libwebp",
+                "-vf",
+                "scale='min(320,iw)':min'(320,ih)':force_original_aspect_ratio=decrease,fps=15, pad=320:320:-1:-1:color=white@0.0, split [a][b]; [a] palettegen=reserve_transparent=on:transparency_color=ffffff [p]; [b][p] paletteuse",
+                "-loop",
+                "0",
+                "-ss",
+                "00:00:00",
+                "-t",
+                "00:00:05",
+                "-preset",
+                "default",
+                "-an",
+                "-vsync",
+                "0"
+            ])
+            .toFormat("webp")
+            .save(tmpFileOut)
+    })
+
+    const buff = fs.readFileSync(tmpFileOut)
+    fs.unlinkSync(tmpFileOut)
+    fs.unlinkSync(tmpFileIn)
+    return buff
+}
+
+async function writeExifImg (media, metadata) {
+    let wMedia = await imageToWebp(media)
+    const tmpFileIn = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    const tmpFileOut = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    fs.writeFileSync(tmpFileIn, wMedia)
+
+    if (metadata.packname || metadata.author) {
+        const img = new webp.Image()
+        const json = { "sticker-pack-id": `https://github.com/mruniquehacker/Knightbot`, "sticker-pack-name": metadata.packname, "sticker-pack-publisher": metadata.author, "emojis": metadata.categories ? metadata.categories : [""] }
+        const exifAttr = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00])
+        const jsonBuff = Buffer.from(JSON.stringify(json), "utf-8")
+        const exif = Buffer.concat([exifAttr, jsonBuff])
+        exif.writeUIntLE(jsonBuff.length, 14, 4)
+        await img.load(tmpFileIn)
+        fs.unlinkSync(tmpFileIn)
+        img.exif = exif
+        await img.save(tmpFileOut)
+        return tmpFileOut
+    }
+}
+
+async function writeExifVid (media, metadata) {
+    let wMedia = await videoToWebp(media)
+    const tmpFileIn = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    const tmpFileOut = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    fs.writeFileSync(tmpFileIn, wMedia)
+
+    if (metadata.packname || metadata.author) {
+        const img = new webp.Image()
+        const json = { "sticker-pack-id": `https://github.com/Vinpink2/DAVE-X`, "sticker-pack-name": metadata.packname, "sticker-pack-publisher": metadata.author, "emojis": metadata.categories ? metadata.categories : [""] }
+        const exifAttr = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00])
+        const jsonBuff = Buffer.from(JSON.stringify(json), "utf-8")
+        const exif = Buffer.concat([exifAttr, jsonBuff])
+        exif.writeUIntLE(jsonBuff.length, 14, 4)
+        await img.load(tmpFileIn)
+        fs.unlinkSync(tmpFileIn)
+        img.exif = exif
+        await img.save(tmpFileOut)
+        return tmpFileOut
+    }
+}
+
+async function writeExif (media, metadata) {
+    let wMedia = /webp/.test(media.mimetype) ? media.data : /image/.test(media.mimetype) ? await imageToWebp(media.data) : /video/.test(media.mimetype) ? await videoToWebp(media.data) : ""
+    const tmpFileIn = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    const tmpFileOut = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    fs.writeFileSync(tmpFileIn, wMedia)
+
+    if (metadata.packname || metadata.author) {
+        const img = new webp.Image()
+        const json = { "sticker-pack-id": `https://github.com/mruniquehacker/Knightbot`, "sticker-pack-name": metadata.packname, "sticker-pack-publisher": metadata.author, "emojis": metadata.categories ? metadata.categories : [""] }
+        const exifAttr = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00])
+        const jsonBuff = Buffer.from(JSON.stringify(json), "utf-8")
+        const exif = Buffer.concat([exifAttr, jsonBuff])
+        exif.writeUIntLE(jsonBuff.length, 14, 4)
+        await img.load(tmpFileIn)
+        fs.unlinkSync(tmpFileIn)
+        img.exif = exif
+        await img.save(tmpFileOut)
+        return tmpFileOut
+    }
+}
+
+module.exports = { imageToWebp, videoToWebp, writeExifImg, writeExifVid, writeExif }

package/davelib/fakeContact.js

@@ -0,0 +1,85 @@
+const { getBotName, getMenuImage, getOwnerName } = require('./botConfig');
+
+function createFakeContact(participantId = '0') {
+    const botName = getBotName();
+    const cleanId = String(participantId).split(':')[0].split('@')[0] || '0';
+    
+    return {
+        key: {
+            participants: "0@s.whatsapp.net",
+            remoteJid: "0@s.whatsapp.net",
+            fromMe: false,
+            id: "DAVEX" + Math.random().toString(36).substring(2, 12).toUpperCase()
+        },
+        message: {
+            contactMessage: {
+                displayName: botName,
+                vcard: `BEGIN:VCARD\nVERSION:3.0\nN:Sy;Bot;;;\nFN:${botName}\nitem1.TEL;waid=${cleanId}:${cleanId}\nitem1.X-ABLabel:Phone\nEND:VCARD`
+            }
+        },
+        participant: "0@s.whatsapp.net"
+    };
+}
+
+function createStyledMessage(title, content, options = {}) {
+    const { showBorder = true, emoji = '' } = options;
+    
+    let msg = '';
+    if (showBorder) {
+        msg += '━━━━━━━━━━━━━━━━━━━━━\n';
+    }
+    if (emoji) {
+        msg += `${emoji} `;
+    }
+    msg += `*${title}*\n`;
+    if (showBorder) {
+        msg += '━━━━━━━━━━━━━━━━━━━━━\n';
+    }
+    msg += '\n';
+    msg += content;
+    if (showBorder) {
+        msg += '\n━━━━━━━━━━━━━━━━━━━━━';
+    }
+    
+    return msg;
+}
+
+function createSuccessMessage(text) {
+    return `*${text}*`;
+}
+
+function createErrorMessage(text) {
+    return `*${text}*`;
+}
+
+function createInfoMessage(title, details) {
+    let msg = `*${title}*\n\n`;
+    for (const [key, value] of Object.entries(details)) {
+        msg += `${key}: ${value}\n`;
+    }
+    return msg.trim();
+}
+
+async function sendWithFakeContact(sock, chatId, text, message = null) {
+    const fakeContact = createFakeContact(message?.key?.participant || message?.key?.remoteJid);
+    return await sock.sendMessage(chatId, { text }, { quoted: fakeContact });
+}
+
+async function sendStyledWithFakeContact(sock, chatId, title, content, message = null, options = {}) {
+    const fakeContact = createFakeContact(message?.key?.participant || message?.key?.remoteJid);
+    const styledText = createStyledMessage(title, content, options);
+    return await sock.sendMessage(chatId, { text: styledText }, { quoted: fakeContact });
+}
+
+module.exports = {
+    createFakeContact,
+    getBotName,
+    getMenuImage,
+    getOwnerName,
+    createStyledMessage,
+    createSuccessMessage,
+    createErrorMessage,
+    createInfoMessage,
+    sendWithFakeContact,
+    sendStyledWithFakeContact
+};

package/davelib/fontStyles.js

@@ -0,0 +1,237 @@
+// ========== DAVE-X FONT STYLE SYSTEM ==========
+// Converts ASCII text to Unicode font variants for WhatsApp
+
+const FONT_STYLES = {
+    none: {
+        name: 'Default',
+        description: 'Normal text, no style',
+        preview: 'Hello World',
+        convert: (text) => text
+    },
+    bold: {
+        name: 'Bold',
+        description: 'WhatsApp bold formatting',
+        preview: '*Hello World*',
+        convert: (text) => text // Applied via WA markdown prefix/suffix
+    },
+    italic: {
+        name: 'Italic',
+        description: 'WhatsApp italic formatting',
+        preview: '_Hello World_',
+        convert: (text) => text
+    },
+    strikethrough: {
+        name: 'Strikethrough',
+        description: 'Slashed through text',
+        preview: '~Hello World~',
+        convert: (text) => text
+    },
+    mono: {
+        name: 'Monospace',
+        description: 'Code/monospace style',
+        preview: '```Hello World```',
+        convert: (text) => text
+    },
+    serif_bold: {
+        name: 'Serif Bold',
+        description: 'Bold serif unicode font',
+        preview: '𝐇𝐞𝐥𝐥𝐨 𝐖𝐨𝐫𝐥𝐝',
+        map: {
+            upper: 0x1D400 - 65,
+            lower: 0x1D41A - 97,
+            digits: 0x1D7CE - 48
+        }
+    },
+    serif_italic: {
+        name: 'Serif Italic',
+        description: 'Italic serif unicode font',
+        preview: '𝐻𝑒𝑙𝑙𝑜 𝑊𝑜𝑟𝑙𝑑',
+        map: {
+            upper: 0x1D434 - 65,
+            lower: 0x1D44E - 97
+        },
+        special_lower: { h: '\u{1D489}' }
+    },
+    serif_bold_italic: {
+        name: 'Serif Bold Italic',
+        description: 'Bold italic serif unicode font',
+        preview: '𝑯𝒆𝒍𝒍𝒐 𝑾𝒐𝒓𝒍𝒅',
+        map: {
+            upper: 0x1D468 - 65,
+            lower: 0x1D482 - 97
+        }
+    },
+    script: {
+        name: 'Script',
+        description: 'Handwriting/cursive style',
+        preview: '𝒽𝑒𝓁𝓁𝑜 𝒲𝑜𝓇𝓁𝒹',
+        map: {
+            upper: 0x1D49C - 65,
+            lower: 0x1D4B6 - 97
+        },
+        special_upper: { B: '\u212C', E: '\u2130', F: '\u2131', H: '\u210B', I: '\u2110', L: '\u2112', M: '\u2133', R: '\u211B' },
+        special_lower: { e: '\u212F', g: '\u210A', o: '\u2134' }
+    },
+    bold_script: {
+        name: 'Bold Script',
+        description: 'Bold cursive/handwriting style',
+        preview: '𝓗𝓮𝓵𝓵𝓸 𝓦𝓸𝓻𝓵𝓭',
+        map: {
+            upper: 0x1D4D0 - 65,
+            lower: 0x1D4EA - 97
+        }
+    },
+    fraktur: {
+        name: 'Fraktur',
+        description: 'Gothic/old German style',
+        preview: '𝔥𝔢𝔩𝔩𝔬 𝔚𝔬𝔯𝔩𝔡',
+        map: {
+            upper: 0x1D504 - 65,
+            lower: 0x1D51E - 97
+        },
+        special_upper: { C: '\u212D', H: '\u210C', I: '\u2111', R: '\u211C', Z: '\u2128' }
+    },
+    double_struck: {
+        name: 'Double Struck',
+        description: 'Mathematical hollow letters',
+        preview: '𝕙𝕖𝕝𝕝𝕠 𝕎𝕠𝕣𝕝𝕕',
+        map: {
+            upper: 0x1D538 - 65,
+            lower: 0x1D552 - 97,
+            digits: 0x1D7D8 - 48
+        },
+        special_upper: { C: '\u2102', H: '\u210D', N: '\u2115', P: '\u2119', Q: '\u211A', R: '\u211D', Z: '\u2124' }
+    },
+    sans: {
+        name: 'Sans Serif',
+        description: 'Clean sans-serif unicode font',
+        preview: '𝖧𝖾𝗅𝗅𝗈 𝖶𝗈𝗋𝗅𝖽',
+        map: {
+            upper: 0x1D5A0 - 65,
+            lower: 0x1D5BA - 97,
+            digits: 0x1D7E2 - 48
+        }
+    },
+    sans_bold: {
+        name: 'Sans Bold',
+        description: 'Bold sans-serif unicode font',
+        preview: '𝗛𝗲𝗹𝗹𝗼 𝗪𝗼𝗿𝗹𝗱',
+        map: {
+            upper: 0x1D5D4 - 65,
+            lower: 0x1D5EE - 97,
+            digits: 0x1D7EC - 48
+        }
+    },
+    sans_italic: {
+        name: 'Sans Italic',
+        description: 'Italic sans-serif unicode font',
+        preview: '𝘏𝘦𝘭𝘭𝘰 𝘞𝘰𝘳𝘭𝘥',
+        map: {
+            upper: 0x1D608 - 65,
+            lower: 0x1D622 - 97
+        }
+    },
+    sans_bold_italic: {
+        name: 'Sans Bold Italic',
+        description: 'Bold italic sans-serif unicode font',
+        preview: '𝙃𝙚𝙡𝙡𝙤 𝙒𝙤𝙧𝙡𝙙',
+        map: {
+            upper: 0x1D63C - 65,
+            lower: 0x1D656 - 97
+        }
+    },
+    monospace_uni: {
+        name: 'Monospace',
+        description: 'Unicode monospace font',
+        preview: '𝙷𝚎𝚕𝚕𝚘 𝚆𝚘𝚛𝚕𝚍',
+        map: {
+            upper: 0x1D670 - 65,
+            lower: 0x1D68A - 97,
+            digits: 0x1D7F6 - 48
+        }
+    },
+    fullwidth: {
+        name: 'Fullwidth',
+        description: 'Wide/fullwidth characters',
+        preview: 'Ｈｅｌｌｏ Ｗｏｒｌｄ',
+        map: {
+            upper: 0xFF21 - 65,
+            lower: 0xFF41 - 97,
+            digits: 0xFF10 - 48
+        }
+    }
+};
+
+// WhatsApp markdown wrappers (applied around line-by-line text blocks)
+const WA_WRAPPERS = {
+    bold:          { prefix: '*', suffix: '*' },
+    italic:        { prefix: '_', suffix: '_' },
+    strikethrough: { prefix: '~', suffix: '~' },
+    mono:          { prefix: '```', suffix: '```' }
+};
+
+function convertChar(char, style) {
+    const code = char.charCodeAt(0);
+    const isUpper = code >= 65 && code <= 90;
+    const isLower = code >= 97 && code <= 122;
+    const isDigit = code >= 48 && code <= 57;
+
+    // Check special character overrides first
+    if (isUpper && style.special_upper?.[char]) return style.special_upper[char];
+    if (isLower && style.special_lower?.[char]) return style.special_lower[char];
+
+    if (!style.map) return char;
+
+    if (isUpper && style.map.upper !== undefined) {
+        return String.fromCodePoint(code + style.map.upper);
+    }
+    if (isLower && style.map.lower !== undefined) {
+        return String.fromCodePoint(code + style.map.lower);
+    }
+    if (isDigit && style.map.digits !== undefined) {
+        return String.fromCodePoint(code + style.map.digits);
+    }
+    return char;
+}
+
+function applyUnicodeFont(text, styleName) {
+    const style = FONT_STYLES[styleName];
+    if (!style || !style.map) return text;
+    return [...text].map(char => convertChar(char, style)).join('');
+}
+
+function applyWAWrapper(text, styleName) {
+    const wrapper = WA_WRAPPERS[styleName];
+    if (!wrapper) return text;
+    // Apply line by line to preserve structure
+    const lines = text.split('\n');
+    return lines.map(line => {
+        const trimmed = line.trim();
+        if (!trimmed) return line;
+        // Don't double-wrap lines already wrapped in WA markdown
+        if (trimmed.startsWith(wrapper.prefix) && trimmed.endsWith(wrapper.suffix)) return line;
+        // Preserve leading whitespace
+        const leading = line.match(/^(\s*)/)?.[1] || '';
+        return `${leading}${wrapper.prefix}${trimmed}${wrapper.suffix}`;
+    }).join('\n');
+}
+
+function applyBotFont(text, styleName) {
+    if (!text || !styleName || styleName === 'none') return text;
+    // WhatsApp markdown wrappers
+    if (WA_WRAPPERS[styleName]) return applyWAWrapper(text, styleName);
+    // Unicode font substitution
+    if (FONT_STYLES[styleName]?.map) return applyUnicodeFont(text, styleName);
+    return text;
+}
+
+function getStyleList() {
+    return Object.entries(FONT_STYLES).map(([key, val]) => ({
+        key,
+        name: val.name,
+        description: val.description,
+        preview: val.preview || applyBotFont('Hello World', key)
+    }));
+}
+
+module.exports = { FONT_STYLES, applyBotFont, getStyleList };

package/davelib/greetings.js

@@ -0,0 +1,47 @@
+function getTimeGreeting() {
+    const hour = new Date().getHours();
+    
+    if (hour >= 5 && hour < 12) {
+        return { greeting: 'Good Morning', emoji: '🌅' };
+    } else if (hour >= 12 && hour < 17) {
+        return { greeting: 'Good Afternoon', emoji: '☀️' };
+    } else if (hour >= 17 && hour < 21) {
+        return { greeting: 'Good Evening', emoji: '🌆' };
+    } else {
+        return { greeting: 'Good Night', emoji: '🌙' };
+    }
+}
+
+function formatTime() {
+    const now = new Date();
+    return now.toLocaleTimeString('en-US', { 
+        hour: '2-digit', 
+        minute: '2-digit',
+        hour12: true 
+    });
+}
+
+function formatDate() {
+    const now = new Date();
+    return now.toLocaleDateString('en-US', {
+        weekday: 'long',
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric'
+    });
+}
+
+function getGreetingMessage(userName = 'User') {
+    const { greeting, emoji } = getTimeGreeting();
+    const time = formatTime();
+    const date = formatDate();
+    
+    return `${emoji} *${greeting}, ${userName}!*\n🕐 ${time}\n📅 ${date}`;
+}
+
+module.exports = {
+    getTimeGreeting,
+    formatTime,
+    formatDate,
+    getGreetingMessage
+};

package/davelib/id.js

@@ -0,0 +1,11 @@
+function makeid(num = 4) {
+    let result = "";
+    let characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    var characters9 = characters.length;
+    for (var i = 0; i < num; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters9));
+    }
+    return result;
+}
+
+module.exports = { makeid };