@diegofemello/bitbot-types 1.3.21 → 1.3.22

package/dist/utils/utils.js

@@ -0,0 +1,2110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timestampToDate = exports.stopWords = exports.pornWords = exports.makeText = exports.getRandomName = void 0;
+exports.getRandomFrasesVitoria = getRandomFrasesVitoria;
+exports.normalizeString = normalizeString;
+exports.checkGuessWithOptions = checkGuessWithOptions;
+exports.normalizeStringAndRemoveStopWords = normalizeStringAndRemoveStopWords;
+exports.formatWords = formatWords;
+exports.randomIntFromInterval = randomIntFromInterval;
+exports.levenshteinDistance = levenshteinDistance;
+exports.extractNumbersFromString = extractNumbersFromString;
+exports.getRandomNumber = getRandomNumber;
+exports.mapearParaIntervalo = mapearParaIntervalo;
+exports.calcularValorOriginal = calcularValorOriginal;
+exports.interpolateColor = interpolateColor;
+exports.getWeightedRandomCard = getWeightedRandomCard;
+exports.compareCardOrder = compareCardOrder;
+exports.obterNivelTreinador = obterNivelTreinador;
+exports.obterLimiteBuddy = obterLimiteBuddy;
+exports.getValorPatrimonioPoke = getValorPatrimonioPoke;
+exports.getPossePatrimonioPoke = getPossePatrimonioPoke;
+exports.getValorPokemon = getValorPokemon;
+exports.comparePokemonIds = comparePokemonIds;
+exports.premiarPresente = premiarPresente;
+exports.premiarMisteryBox = premiarMisteryBox;
+exports.formatPokemonName = formatPokemonName;
+exports.getValueApostaBicho = getValueApostaBicho;
+exports.calcPremioBicho = calcPremioBicho;
+exports.checkIsShiny = checkIsShiny;
+exports.checkIsDark = checkIsDark;
+exports.checkIsTera = checkIsTera;
+exports.checkIsShinyOrDark = checkIsShinyOrDark;
+exports.checkIsMega = checkIsMega;
+exports.checkIsGmax = checkIsGmax;
+exports.checkIsAlternative = checkIsAlternative;
+exports.checkHasPokemon = checkHasPokemon;
+exports.checkHasCard = checkHasCard;
+exports.getDayId = getDayId;
+exports.compareIds = compareIds;
+exports.isOwner = isOwner;
+exports.checkIsVip = checkIsVip;
+exports.obterQuantoFaltaParaProximoNivel = obterQuantoFaltaParaProximoNivel;
+exports.streamToBuffer = streamToBuffer;
+exports.extractContactNumber = extractContactNumber;
+exports.isBoolean = isBoolean;
+exports.calcSlotValue = calcSlotValue;
+exports.getRandomFromArray = getRandomFromArray;
+exports.calcStars = calcStars;
+exports.formatStars = formatStars;
+exports.calcXpByStars = calcXpByStars;
+exports.cleanObject = cleanObject;
+exports.getErrorMessage = getErrorMessage;
+exports.assignPosition = assignPosition;
+exports.timeout = timeout;
+exports.getActualMonth = getActualMonth;
+exports.checkGuess = checkGuess;
+exports.getRandomErroMessage = getRandomErroMessage;
+exports.timeoutPromise = timeoutPromise;
+exports.convertTime = convertTime;
+exports.getLinkRegex = getLinkRegex;
+exports.getCensuredText = getCensuredText;
+exports.isOwnerGroup = isOwnerGroup;
+exports.extrairIdsMencionados = extrairIdsMencionados;
+exports.generateCode = generateCode;
+exports.drawHangman = drawHangman;
+exports.clearObject = clearObject;
+exports.getMonthId = getMonthId;
+exports.isShiny = isShiny;
+exports.compareCardsOrder = compareCardsOrder;
+exports.privateNumber = privateNumber;
+exports.limitDescription = limitDescription;
+exports.convertToCurrency = convertToCurrency;
+exports.getDateFormat = getDateFormat;
+exports.getBlobFromPath = getBlobFromPath;
+exports.base64ToBlob = base64ToBlob;
+exports.loadImage = loadImage;
+exports.blobToBase64 = blobToBase64;
+exports.formatTime = formatTime;
+exports.raidComparator = raidComparator;
+exports.toISOStringWithOffset = toISOStringWithOffset;
+const frasesVitoria = [
+    `AEEEE CARAI!!!`,
+    `🤩`,
+    `😱`,
+    `PARABÉNS!!!`,
+    `OLHA SÓ!!!`,
+    `QUE SORTE!!!`,
+    `OLOQUINHO MEU!`,
+    `CARAI BICHÃO!!`,
+    `Me dá um pouco dessa sorte ai!?`,
+];
+function getRandomFrasesVitoria() {
+    return frasesVitoria[getRandomNumber(0, frasesVitoria.length - 1)];
+}
+const normalizedStopWords = [
+    'de',
+    'que',
+    'do',
+    'da',
+    'e',
+    'para',
+    'co',
+    'no',
+    'se',
+    'na',
+    'po',
+    'mai',
+    'do',
+    'como',
+    'ma',
+    'foi',
+    'ao',
+    'ele',
+    'da',
+    'te',
+    'seu',
+    'sua',
+    'ou',
+    'se',
+    'quando',
+    'muito',
+    'ha',
+    'no',
+    'ja',
+    'esta',
+    'eu',
+    'tambe',
+    'so',
+    'pelo',
+    'pela',
+    'ate',
+    'isso',
+    'ela',
+    'entre',
+    'era',
+    'depoi',
+    'mesmo',
+    'ao',
+    'te',
+    'seu',
+    'que',
+    'na',
+    'me',
+    'esse',
+    'ele',
+    'estao',
+    'voce',
+    'vc',
+    'tinha',
+    'fora',
+    'essa',
+    'nu',
+    'ne',
+    'sua',
+    'meu',
+    'minha',
+    'te',
+    'numa',
+    'pelo',
+    'ela',
+    'havia',
+    'seja',
+    'qual',
+    'sera',
+    'no',
+    'tenho',
+    'nao',
+    'nao',
+    'lhe',
+    'dele',
+    'essa',
+    'esse',
+    'pela',
+    'este',
+    'fosse',
+    'dele',
+    'tu',
+    'te',
+    'voce',
+    'vo',
+    'lhe',
+    'meu',
+    'minha',
+    'teu',
+    'tua',
+    'teu',
+    'tua',
+    'nosso',
+    'nossa',
+    'nosso',
+    'nossa',
+    'dela',
+    'dela',
+    'esta',
+    'este',
+    'esta',
+    'aquele',
+    'aquela',
+    'aquele',
+    'aquela',
+    'isto',
+    'aquilo',
+    'estou',
+    'esta',
+    'estamo',
+    'estao',
+    'estive',
+    'esteve',
+    'estivemo',
+    'estivera',
+    'estava',
+    'estavamo',
+    'estava',
+    'estivera',
+    'estiveramo',
+    'esteja',
+    'estejamo',
+    'esteja',
+    'estivesse',
+    'estivessemo',
+    'estivesse',
+    'estive',
+    'estivermo',
+    'estivere',
+    'hei',
+    'ha',
+    'havemo',
+    'hao',
+    'houve',
+    'houvemo',
+    'houvera',
+    'houvera',
+    'houveramo',
+    'haja',
+    'hajamo',
+    'haja',
+    'houvesse',
+    'houvessemo',
+    'houvesse',
+    'houve',
+    'houvermo',
+    'houvere',
+    'houverei',
+    'houvera',
+    'houveremo',
+    'houverao',
+    'houveria',
+    'houveriamo',
+    'houveria',
+    'sou',
+    'somo',
+    'sao',
+    'era',
+    'eramo',
+    'era',
+    'fui',
+    'foi',
+    'fomo',
+    'fora',
+    'fora',
+    'foramo',
+    'seja',
+    'sejamo',
+    'seja',
+    'fosse',
+    'fossemo',
+    'fosse',
+    'formo',
+    'fore',
+    'serei',
+    'sera',
+    'seremo',
+    'serao',
+    'seria',
+    'seriamo',
+    'seria',
+    'temo',
+    'te',
+    'tinhamo',
+    'tinha',
+    'tive',
+    'teve',
+    'tivemo',
+    'tivera',
+    'tivera',
+    'tiveramo',
+    'tenha',
+    'tenhamo',
+    'tenha',
+    'tivesse',
+    'tivessemo',
+    'tivesse',
+    'tive',
+    'tivermo',
+    'tivere',
+    'terei',
+    'tera',
+    'teremo',
+    'terao',
+    'teria',
+    'teriamo',
+    'teria',
+    'vc',
+    'tb',
+    'q',
+    'cmg',
+    'p',
+    'eh',
+    'mt',
+    'td',
+    'pra',
+    'pro',
+    'the',
+    'the',
+    'i',
+    'me',
+    'my',
+    'myself',
+    'we',
+    'ou',
+    'ou',
+    'ourselve',
+    'you',
+    'you',
+    'you',
+    'yourself',
+    'yourselve',
+    'he',
+    'hi',
+    'hi',
+    'himself',
+    'she',
+    'he',
+    'he',
+    'herself',
+    'it',
+    'it',
+    'itself',
+    'they',
+    'the',
+    'thei',
+    'thei',
+    'themselve',
+    'what',
+    'which',
+    'who',
+    'who',
+    'thi',
+    'that',
+    'these',
+    'those',
+    'are',
+    'wa',
+    'were',
+    'be',
+    'bee',
+    'being',
+    'have',
+    'ha',
+    'had',
+    'having',
+    'do',
+    'dao',
+    'did',
+    'doing',
+    'the',
+    'but',
+    'if',
+    'because',
+    'until',
+    'while',
+    'by',
+    'with',
+    'about',
+    'against',
+    'betwee',
+    'into',
+    'through',
+    'during',
+    'before',
+    'afte',
+    'above',
+    'below',
+    'fro',
+    'up',
+    'dow',
+    'out',
+    'off',
+    'ove',
+    'unde',
+    'agai',
+    'furthe',
+    'the',
+    'once',
+    'here',
+    'there',
+    'whe',
+    'where',
+    'why',
+    'how',
+    'all',
+    'any',
+    'both',
+    'each',
+    'few',
+    'more',
+    'most',
+    'othe',
+    'some',
+    'such',
+    'no',
+    'no',
+    'not',
+    'only',
+    'ow',
+    'same',
+    'so',
+    'tha',
+    'too',
+    'very',
+    'ca',
+    'wa',
+    'wo',
+];
+function normalizeString(input, isCommand = false, removeResultLen = 0, lower = true) {
+    if (!input || typeof input !== 'string')
+        return '';
+    let result = '';
+    if (lower) {
+        result = `${input}`
+            .toLowerCase()
+            .replace(/[']/g, '')
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .replace(/[áàãâä]/g, 'a')
+            .replace(/[éèêë]/g, 'e')
+            .replace(/[íìîï]/g, 'i')
+            .replace(/[óòõôö]/g, 'o')
+            .replace(/[úùûü]/g, 'u')
+            .replace(/[ç]/g, 'c')
+            .replace(isCommand ? /[^a-z0-9@ -]+/g : /[^a-z0-9@ ]+/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+    else {
+        result = `${input}`
+            .replace(/[']/g, '')
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .replace(/[áàãâä]/g, 'a')
+            .replace(/[éèêë]/g, 'e')
+            .replace(/[íìîï]/g, 'i')
+            .replace(/[óòõôö]/g, 'o')
+            .replace(/[úùûü]/g, 'u')
+            .replace(/[ÁÀÃÂÄ]/g, 'A')
+            .replace(/[ÉÈÊË]/g, 'E')
+            .replace(/[ÍÌÎÏ]/g, 'I')
+            .replace(/[ÓÒÕÔÖ]/g, 'O')
+            .replace(/[ÚÙÛÜ]/g, 'U')
+            .replace(/[Ç]/g, 'C')
+            .replace(/[ç]/g, 'c')
+            .replace(isCommand ? /[^a-zA-Z0-9@ -]+/g : /[^a-zA-Z0-9@ ]+/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+    if (removeResultLen > 0) {
+        return result.slice(0, removeResultLen);
+    }
+    return result;
+}
+function checkGuessWithOptions(input, options, limite = 2) {
+    const normalizedInput = normalizeStringAndRemoveStopWords(input);
+    limite = input.length <= 4 && limite >= 2 ? limite - 1 : limite;
+    for (const option of options) {
+        const normalizedOption = normalizeStringAndRemoveStopWords(option);
+        console.log(normalizedInput, normalizedOption);
+        const distance = levenshteinDistance(normalizedInput, normalizedOption);
+        if (distance <= limite) {
+            return option;
+        }
+    }
+    return '';
+}
+function normalizeStringAndRemoveStopWords(input, join = '', wordsToRemove = [], minLetters = 1, wordsToInclude = []) {
+    if (!input || typeof input !== 'string')
+        return '';
+    const resultWords = normalizeString(input)
+        .replace(/-/g, ' ')
+        .replace(/\b(a|o|as|os|e|um|um|uma|of|and|or|for|to|in|at)\b/g, '')
+        .replace(/oes\b/g, 'ao')
+        .replace(/s\b/g, '')
+        .replace(/r\b/g, '')
+        .replace(/m\b/g, '')
+        .replace(/n\b/g, '')
+        .replace(/s\b/g, '')
+        .trim()
+        .split(' ')
+        .filter((word) => word &&
+        word.length > minLetters &&
+        ((!normalizedStopWords.includes(word) &&
+            !wordsToRemove.includes(word)) ||
+            wordsToInclude.includes(word)));
+    const result = [...new Set(resultWords)].join(join).trim() ?? '';
+    if (join === '') {
+        return result.replace(/\s+/g, '');
+    }
+    return result;
+}
+function formatWords(palavra, qtdShow, qtdShowInLast = 0, lettersToShow = []) {
+    const palavraArray = [...(palavra?.toUpperCase() || '')];
+    const newLettersToShow = lettersToShow.map((letter) => letter.toUpperCase());
+    const translated = palavraArray.map((char, i) => {
+        if (char === ' ' ||
+            char === '-' ||
+            char === "'" ||
+            char === '"' ||
+            char === '.' ||
+            char === ',' ||
+            char === '!' ||
+            char === '?' ||
+            char === ':' ||
+            i < qtdShow ||
+            i >= palavraArray.length - qtdShowInLast ||
+            (newLettersToShow?.length &&
+                newLettersToShow.includes(normalizeString(char)?.toUpperCase()))) {
+            return char;
+        }
+        else {
+            return '_';
+        }
+    });
+    return translated.join(' ').toUpperCase();
+}
+function randomIntFromInterval(min, max) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+}
+function levenshteinDistance(a, b) {
+    const dp = [];
+    for (let i = 0; i <= a.length; i++) {
+        dp[i] = [i];
+    }
+    for (let j = 1; j <= b.length; j++) {
+        dp[0][j] = j;
+    }
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        }
+    }
+    return dp[a.length][b.length];
+}
+function extractNumbersFromString(str) {
+    if (!str)
+        return '';
+    return str.replace(/\D/g, '');
+}
+function getRandomNumber(min, max, notIn = []) {
+    const randomNumber = Math.floor(Math.random() * (max - min + 1)) + min;
+    if (notIn.includes(randomNumber)) {
+        return getRandomNumber(min, max, notIn);
+    }
+    return randomNumber;
+}
+function mapearParaIntervalo(valorOriginal, minOriginal, maxOriginal, minMapeado, maxMapeado) {
+    const percentagem = (valorOriginal - minOriginal) / (maxOriginal - minOriginal);
+    const valorMapeado = minMapeado + percentagem * (maxMapeado - minMapeado);
+    return valorMapeado;
+}
+function calcularValorOriginal(valorMapeado, minOriginal, maxOriginal, minMapeado, maxMapeado) {
+    const percentagem = (valorMapeado - minMapeado) / (maxMapeado - minMapeado);
+    const valorOriginal = minOriginal + percentagem * (maxOriginal - minOriginal);
+    return valorOriginal;
+}
+function interpolateColor(color1, color2, factor, start = 0, end = 1) {
+    const normalizedFactor = mapearParaIntervalo(factor, start, end, 0, 1);
+    const hexToRGB = (hex) => ({
+        r: parseInt(hex.substring(1, 3), 16),
+        g: parseInt(hex.substring(3, 5), 16),
+        b: parseInt(hex.substring(5, 7), 16),
+    });
+    const RGBToHex = (r, g, b) => `#${((1 << 24) | (r << 16) | (g << 8) | b).toString(16).slice(1)}`;
+    const startRGB = hexToRGB(color1);
+    const endRGB = hexToRGB(color2);
+    const r = Math.round(startRGB.r + normalizedFactor * (endRGB.r - startRGB.r));
+    const g = Math.round(startRGB.g + normalizedFactor * (endRGB.g - startRGB.g));
+    const b = Math.round(startRGB.b + normalizedFactor * (endRGB.b - startRGB.b));
+    const result = RGBToHex(r, g, b);
+    return result;
+}
+const getRandomName = (ext) => {
+    const extension = ext ? '.' + ext : '';
+    return `${Math.floor(Math.random() * 10000)}${extension}`;
+};
+exports.getRandomName = getRandomName;
+const makeText = (texto, ...params) => {
+    for (let i = 0; i < params.length; i++) {
+        const regex = new RegExp(`{p${i + 1}}`, 'g');
+        texto = texto.replace(regex, params[i]);
+    }
+    return texto.replace('@c.us', '').replace('@g.us', '');
+};
+exports.makeText = makeText;
+function getWeightedRandomCard(cards, rarity = 8) {
+    const weightedIndices = [];
+    cards.forEach((card, index) => {
+        const weight = rarity - card.rarity;
+        for (let i = 0; i < weight; i++) {
+            weightedIndices.push(index);
+        }
+    });
+    const randomIndex = getRandomNumber(0, weightedIndices.length - 1);
+    return cards[weightedIndices[randomIndex]];
+}
+function compareCardOrder(a, b) {
+    const orderLetters = [
+        'M',
+        'W',
+        'P',
+        'X',
+        'R',
+        'Y',
+        'V',
+        'G',
+        'N',
+        'H',
+        'K',
+        'T',
+        'S',
+        'D',
+        'B',
+        'E',
+    ];
+    const aOrder = orderLetters.indexOf(a.id[0]);
+    const bOrder = orderLetters.indexOf(b.id[0]);
+    if (aOrder !== bOrder) {
+        return aOrder - bOrder;
+    }
+    const aNumber = parseInt(a.id.slice(1), 10);
+    const bNumber = parseInt(b.id.slice(1), 10);
+    return aNumber - bNumber;
+}
+function obterNivelTreinador(pontos) {
+    if (!pontos)
+        return 0;
+    let nivel = 0;
+    let pontosRestantes = pontos;
+    while (pontosRestantes >= calcularXPNecessarioParaProximoNivel(nivel)) {
+        pontosRestantes -= calcularXPNecessarioParaProximoNivel(nivel);
+        nivel++;
+    }
+    return nivel;
+}
+function obterLimiteBuddy(level = 0) {
+    if (level >= 25)
+        return 6;
+    if (level >= 20)
+        return 5;
+    if (level >= 15)
+        return 4;
+    if (level >= 10)
+        return 3;
+    if (level >= 5)
+        return 2;
+    return 1;
+}
+function getValorPatrimonioPoke(pokemon, isShiny = false) {
+    if (!pokemon)
+        return 0;
+    if (checkIsShinyOrDark(pokemon.number)) {
+        isShiny = true;
+    }
+    return Math.floor(((isShiny ? pokemon.valor_patrimonio_shiny : pokemon.valor_patrimonio) ||
+        200) * 0.9);
+}
+function getPossePatrimonioPoke(pokemon, isShiny = false) {
+    if (!pokemon)
+        return 0;
+    if (checkIsShinyOrDark(pokemon.number)) {
+        isShiny = true;
+    }
+    return (isShiny ? pokemon.valor_posse_shiny : pokemon.valor_posse) || 200;
+}
+function getValorPokemon(pokemon) {
+    if (!pokemon)
+        return 9999;
+    let valor = pokemon?.real_price || 1500;
+    const isShiny = checkIsShiny(pokemon.number);
+    const isDark = checkIsDark(pokemon.number);
+    if (isShiny) {
+        valor += 20;
+    }
+    if (isDark) {
+        valor += 24;
+    }
+    return isShiny ? valor * 1.9 : isDark ? valor * 2.5 : valor;
+}
+function comparePokemonIds(a, b) {
+    if (!a || !b)
+        return 0;
+    if (!a)
+        return -1;
+    if (!b)
+        return 1;
+    const getNumericPrefix = (str) => {
+        const match = str.match(/^\d+/);
+        return match ? Number(match[0]) : 0;
+    };
+    const hasS = (str) => /[sd]/.test(str);
+    const hasF = (str) => /[fgm]/.test(str);
+    const getFNumber = (str) => {
+        const match = str.match(/[fgm](\d+)/);
+        return match ? Number(match[1]) : null;
+    };
+    const aNum = getNumericPrefix(a);
+    const bNum = getNumericPrefix(b);
+    if (aNum !== bNum) {
+        return aNum - bNum;
+    }
+    const aHasS = hasS(a);
+    const bHasS = hasS(b);
+    const aHasF = hasF(a);
+    const bHasF = hasF(b);
+    if (!aHasS && !aHasF && !bHasS && !bHasF) {
+        return 0;
+    }
+    if (!aHasS && !aHasF)
+        return -1;
+    if (!bHasS && !bHasF)
+        return 1;
+    if (aHasS && !aHasF && bHasS && !bHasF) {
+        return 0;
+    }
+    if (aHasS && !aHasF)
+        return -1;
+    if (bHasS && !bHasF)
+        return 1;
+    if (aHasF && bHasF) {
+        const aFNum = getFNumber(a) || 0;
+        const bFNum = getFNumber(b) || 0;
+        if (aFNum !== bFNum) {
+            return aFNum - bFNum;
+        }
+        else {
+            return aHasS ? 1 : -1;
+        }
+    }
+    if (aHasF && !bHasF)
+        return 1;
+    if (!aHasF && bHasF)
+        return -1;
+    return aHasS ? 1 : -1;
+}
+function premiarPresente(buffed, hasLuck) {
+    const rand = Math.random();
+    if (rand <= 0.03 && !buffed && !hasLuck) {
+        return -3;
+    }
+    else if (rand > 0.985) {
+        return -4;
+    }
+    else if (rand > 0.96) {
+        return -2;
+    }
+    else if (rand > (buffed && hasLuck ? 0.58 : buffed ? 0.69 : hasLuck ? 0.84 : 0.89)) {
+        return -1;
+    }
+    else {
+        if (rand > 0.45 || buffed) {
+            return getRandomNumber(75, 150);
+        }
+        else {
+            return getRandomNumber(40, 95);
+        }
+    }
+}
+function premiarMisteryBox(box, ganhouAnteriormente = false, nerf = false) {
+    if (!box)
+        return 0;
+    const min = (nerf ? Math.round(box.startMoney / 1.5) : box.startMoney) || 100;
+    const max = nerf ? Math.round(box.endMoney / 1.25) : box.endMoney;
+    if (!ganhouAnteriormente) {
+        const percentCard = nerf ? box.percentCard - 0.1 : box.percentCard;
+        if (percentCard >= Math.random()) {
+            return -1;
+        }
+        if (box.pokes?.length > 0 && Math.random() > 0.89) {
+            return -2;
+        }
+    }
+    return getRandomNumber(min, max);
+}
+function formatPokemonName(pokemon, includeId = false) {
+    if (!pokemon?.name)
+        return `${includeId ? `[${pokemon?.number ?? '???'}] ` : ''}Desconhecido`;
+    return `${includeId ? `[${pokemon.number}] ` : ''}${pokemon.name}${pokemon.form_name ? ` (${pokemon.form_name})` : ''}${checkIsShiny(pokemon.number ?? '') ? ' ✨' : checkIsDark(pokemon.number ?? '') ? ' 🩸' : ''}`;
+}
+function getValueApostaBicho(isMega) {
+    return isMega ? 300 : 75;
+}
+function calcPremioBicho(jogoBicho, isMega) {
+    const lenApostas = jogoBicho.apostadores?.length ?? 0;
+    const aposta = getValueApostaBicho(isMega);
+    const valorAcumulado = lenApostas * aposta;
+    if ((lenApostas < 12 && !isMega) || lenApostas < 5) {
+        return valorAcumulado;
+    }
+    const participantsDistinct = jogoBicho.apostadores
+        .map((apostador) => apostador.user_id)
+        .filter((value, index, self) => self.indexOf(value) === index) ?? [];
+    const qtdApostadores = participantsDistinct.length;
+    let valorAdicional = isMega ? 5000 : 800;
+    const qtdToDivide = isMega ? 100 : 16;
+    const q = qtdApostadores / 10;
+    if (q > 1) {
+        valorAdicional += (valorAdicional / 10) * q;
+    }
+    if (qtdApostadores <= qtdToDivide) {
+        const qtdToAdd = Math.floor(valorAdicional / qtdToDivide);
+        valorAdicional = qtdToAdd * qtdApostadores;
+    }
+    return valorAcumulado + valorAdicional;
+}
+function checkIsShiny(id) {
+    return /[s]$/i.test(id);
+}
+function checkIsDark(id) {
+    return /[d]$/i.test(id);
+}
+function checkIsTera(id) {
+    return /[t]$/i.test(id);
+}
+function checkIsShinyOrDark(id) {
+    return /[sd]$/i.test(id);
+}
+function checkIsMega(id) {
+    return /[m]/i.test(id);
+}
+function checkIsGmax(id) {
+    return /[g]/i.test(id);
+}
+function checkIsAlternative(id) {
+    return /[fgm]/i.test(id);
+}
+function checkHasPokemon(pokemons, pokemonId, min = 1) {
+    const pokemon = (pokemons ?? [])?.find((c) => (c.id ?? '').toLowerCase() === pokemonId.toLowerCase() &&
+        (c.quantidade >= min || !min));
+    if (!pokemon)
+        return null;
+    return pokemon;
+}
+function checkHasCard(cards, cardsIds, exactly = false, min = 1) {
+    if (!cards?.length)
+        return null;
+    return cards?.find((c) => cardsIds.some((cardId) => (exactly
+        ? c.id === cardId
+        : c.id.match(new RegExp(`^${cardId}`, 'i'))) && c.quantidade >= min));
+}
+function getDayId(date = new Date(), adjust = true) {
+    if (adjust) {
+        date.setHours(date.getHours() - 3);
+    }
+    const year = date.getFullYear();
+    let month = (date.getMonth() + 1).toString();
+    let day = date.getDate().toString();
+    if (month.length === 1)
+        month = `0${month}`;
+    if (day.length === 1)
+        day = `0${day}`;
+    return Number(`${year}${month}${day}`);
+}
+const getNumericPrefix = (str) => {
+    const extracted = str?.split(/s|d|f|g|m/)[0];
+    const match = extracted?.match(/^\d+/);
+    return match ? Number(match[0]) : 999999;
+};
+const getNumberInfo = (id) => {
+    const numberAfterForm = id.split(/s|d/)?.[0]?.split(/f|g|m/)?.[1] || '0';
+    let formIndex = 0;
+    if (checkIsAlternative(id)) {
+        formIndex++;
+    }
+    if (checkIsMega(id)) {
+        formIndex++;
+    }
+    if (checkIsGmax(id)) {
+        formIndex += 2;
+    }
+    if (checkIsShiny(id)) {
+        formIndex += 0.5;
+    }
+    if (checkIsDark(id)) {
+        formIndex += 0.25;
+    }
+    return {
+        numberAfterForm: Number(numberAfterForm),
+        formIndex,
+    };
+};
+function compareIds(a, b) {
+    if (a == 'BATTLE')
+        return -1;
+    if (b == 'BATTLE')
+        return 1;
+    if (!a || !b)
+        return 0;
+    if (!a)
+        return -1;
+    if (!b)
+        return 1;
+    const numA = getNumericPrefix(a);
+    const numB = getNumericPrefix(b);
+    if (numA !== numB) {
+        return numA - numB;
+    }
+    const numberInfoA = getNumberInfo(a);
+    const numberInfoB = getNumberInfo(b);
+    if (numberInfoA.numberAfterForm !== numberInfoB.numberAfterForm) {
+        return numberInfoA.numberAfterForm - numberInfoB.numberAfterForm;
+    }
+    if (numberInfoA.formIndex !== numberInfoB.formIndex) {
+        return numberInfoA.formIndex - numberInfoB.formIndex;
+    }
+    return 0;
+}
+function isOwner(contactId) {
+    return ['5521975525315@c.us', '5521992287892@c.us'].includes(contactId);
+}
+function checkIsVip(vip) {
+    return vip && vip.until && new Date(vip.until) > new Date();
+}
+// export function shuffle(array: any[]) {
+//   if (!array || !array.length) return array;
+//   for (let i = array.length - 1; i > 0; i--) {
+//     const j = Math.floor(Math.random() * (i + 1));
+//     [array[i], array[j]] = [array[j], array[i]];
+//   }
+//   return array;
+// }
+function calcularXPNecessarioParaProximoNivel(nivel) {
+    return nivel === 0
+        ? 185
+        : nivel >= 10
+            ? (nivel + 1) * 235
+            : (nivel + 1) * 135 + 50;
+}
+function obterQuantoFaltaParaProximoNivel(pontos) {
+    if (!pontos)
+        return 0;
+    let nivel = 0;
+    let pontosRestantes = pontos;
+    while (pontosRestantes >= calcularXPNecessarioParaProximoNivel(nivel)) {
+        pontosRestantes -= calcularXPNecessarioParaProximoNivel(nivel);
+        nivel++;
+    }
+    return calcularXPNecessarioParaProximoNivel(nivel) - pontosRestantes;
+}
+function streamToBuffer(readableStream) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        readableStream.on('data', (data) => {
+            chunks.push(data instanceof Buffer ? data : Buffer.from(data));
+        });
+        readableStream.on('end', () => {
+            resolve(Buffer.concat(chunks));
+        });
+        readableStream.on('error', reject);
+    });
+}
+function extractContactNumber(contactId) {
+    if (!contactId)
+        return '';
+    return contactId.split('@')[0];
+}
+function isBoolean(value) {
+    return (value === 'true' ||
+        value === '1' ||
+        value === true ||
+        value === 'True' ||
+        value === 'TRUE' ||
+        value === 'T' ||
+        Number(value) >= 1);
+}
+function calcSlotValue(slots) {
+    const calcValue = slots * 18;
+    let valor = calcValue > 999 ? 999 : calcValue;
+    if (slots > 90) {
+        const qtd = slots - 90;
+        valor += qtd * 25;
+    }
+    return valor;
+}
+function getRandomFromArray(array) {
+    if (!array?.length) {
+        return null;
+    }
+    else if (array.length === 1) {
+        return array[0];
+    }
+    else {
+        return array[Math.floor(Math.random() * array.length)];
+    }
+}
+function calcStars(finalMultiplier) {
+    let qtdEstrelas = Math.floor(finalMultiplier);
+    qtdEstrelas = qtdEstrelas < 1 ? 1 : qtdEstrelas;
+    return qtdEstrelas >= 6 ? 6 : qtdEstrelas < 1 ? 1 : qtdEstrelas;
+}
+function formatStars(qtdEstrelas) {
+    qtdEstrelas = Math.floor(qtdEstrelas);
+    if (qtdEstrelas < 1)
+        qtdEstrelas = 1;
+    if (qtdEstrelas > 6)
+        qtdEstrelas = 6;
+    let starEmoji = '⭐';
+    if (qtdEstrelas > 5) {
+        starEmoji = '🌟';
+    }
+    let stars = '';
+    for (let i = 0; i < qtdEstrelas; i++) {
+        stars += starEmoji;
+    }
+    return stars;
+}
+function calcXpByStars(stars, xp) {
+    const level = obterNivelTreinador(xp);
+    const mapXp = {
+        0: 15,
+        1: 30,
+        2: 40,
+        3: 60,
+        4: 80,
+        5: 110,
+        6: 150,
+    };
+    let result = mapXp[stars] ?? 50;
+    result += Math.round((result * level) / 100);
+    return Math.round(result);
+}
+function cleanObject(obj, options) {
+    const { removeFalse = false, removeEmptyArrays = true, removeEmptyObjects = true, removeZero = false, removeLowerThanZero = false, } = options || {};
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+        const shouldRemove = value === undefined ||
+            value === null ||
+            value === '' ||
+            (removeFalse && value === false) ||
+            (removeZero && value === 0) ||
+            (removeLowerThanZero && value < 0) ||
+            (removeEmptyArrays && Array.isArray(value) && value.length === 0) ||
+            (removeEmptyObjects &&
+                typeof value === 'object' &&
+                !Array.isArray(value) &&
+                value !== null &&
+                Object.keys(value).length === 0);
+        if (!shouldRemove) {
+            if (typeof value === 'object' &&
+                value !== null &&
+                !Array.isArray(value)) {
+                acc[key] = cleanObject(value, options);
+            }
+            else {
+                acc[key] = value;
+            }
+        }
+        return acc;
+    }, {});
+}
+function getErrorMessage(error, logMessage) {
+    let errorMessage = 'Erro desconhecido';
+    if (typeof error === 'string') {
+        errorMessage = error;
+    }
+    else if (error instanceof Error) {
+        errorMessage = error.message;
+    }
+    else if (typeof error === 'object' && error !== null) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const anyError = error;
+        // NestJS HttpException ou errors do tipo { message: string | string[] }
+        if (anyError.message) {
+            if (Array.isArray(anyError.message)) {
+                errorMessage = anyError.message.join(', ');
+            }
+            else {
+                errorMessage = String(anyError.message);
+            }
+        }
+        // AxiosError com response.data.message
+        else if (anyError.response?.data?.message) {
+            errorMessage = Array.isArray(anyError.response.data.message)
+                ? anyError.response.data.message.join(', ')
+                : String(anyError.response.data.message);
+        }
+        // AxiosError com response.data.error
+        else if (anyError.response?.data?.error) {
+            errorMessage = String(anyError.response.data.error);
+        }
+        // Errors do tipo { error: '...' }
+        else if (anyError.error) {
+            errorMessage = String(anyError.error);
+        }
+        // Fallback: tenta stringify o objeto
+        else {
+            errorMessage = JSON.stringify(anyError);
+        }
+    }
+    if (logMessage) {
+        if (typeof logMessage === 'string') {
+            console.error(logMessage, errorMessage, error);
+        }
+        else {
+            console.error(errorMessage, error?.stack);
+        }
+    }
+    return errorMessage;
+}
+function assignPosition(array, key, positionKey) {
+    array
+        .sort((a, b) => Number(b[key]) - Number(a[key]))
+        .forEach((e, i) => {
+        e[positionKey] = (i + 1);
+    });
+}
+async function timeout(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+exports.pornWords = [
+    'anus',
+    'arrombado',
+    'boceta',
+    'boiola',
+    'bokete',
+    'bolagato',
+    'bolcat',
+    'boquete',
+    'bosseta',
+    'branquelo',
+    'brecha',
+    'brexa',
+    'brioco',
+    'bronha',
+    'buceta',
+    'bugre',
+    'bunda',
+    'bunduda',
+    'busseta',
+    'bárbaro',
+    'caceta',
+    'cacete',
+    'caipira',
+    'canalha',
+    'canceroso',
+    'caralho',
+    'casseta',
+    'cassete',
+    'checheca',
+    'chereca',
+    'chibumba',
+    'chochota',
+    'chota',
+    'chupada',
+    'chupado',
+    'clitoris',
+    'clitóris',
+    'culhao',
+    'culhão',
+    'curalho',
+    'cuzao',
+    'cuzão',
+    'cuzuda',
+    'escrota',
+    'escroto',
+    'esporrada',
+    'esporrado',
+    'esporro',
+    'fodida',
+    'fodido',
+    'fornica',
+    'fornicação',
+    'fornição',
+    'fudendo',
+    'fudeção',
+    'fudida',
+    'fudido',
+    'furada',
+    'furado',
+    'furnica',
+    'furnicar',
+    'gonorrea',
+    'gonorreia',
+    'gonorreia',
+    'grelinho',
+    'grelo',
+    'leprosa',
+    'leproso',
+    'masturba',
+    'merda',
+    'mija',
+    'mijada',
+    'mijado',
+    'mijo',
+    'nhaca',
+    'nojeira',
+    'gore',
+    'pau',
+    'pelado',
+    'pelada',
+    'nua',
+    'pemba',
+    'pentelha',
+    'pentelho',
+    'perereca',
+    'perneta',
+    'peru',
+    'peão',
+    'pica',
+    'picao',
+    'picão',
+    'pilantra',
+    'pinel',
+    'pintudo',
+    'pintão',
+    'piroca',
+    'piroco',
+    'piru',
+    'prega',
+    'prequito',
+    'priquito',
+    'prostibulo',
+    'prostituta',
+    'prostituto',
+    'punheta',
+    'punhetao',
+    'punhetão',
+    'pustula',
+    'puta',
+    'piroca',
+    'penis',
+    'porno',
+    'prolapse',
+    'prostituta',
+    'rabao',
+    'rabão',
+    'rabo',
+    'rabuda',
+    'rabudao',
+    'rabudão',
+    'rabudo',
+    'rabudona',
+    'rachada',
+    'rola',
+    'rolinha',
+    'sacana',
+    'safada',
+    'safado',
+    'sapatao',
+    'sapatão',
+    'sifilis',
+    'sífilis',
+    'siririca',
+    'tarada',
+    'tarado',
+    'testuda',
+    'transa',
+    'tesuda',
+    'tesudo',
+    'tesão',
+    'tezao',
+    'tezuda',
+    'tezudo',
+    'traveco',
+    'vadia',
+    'vagina',
+    'xana',
+    'xaninha',
+    'xavasca',
+    'xerereca',
+    'xexeca',
+    'xibiu',
+    'xibumba',
+    'xiíta',
+    'xochota',
+    'xota',
+    'xoxota',
+    'sexo',
+    'pornhub',
+    'xvideos',
+    'redtube',
+    'xxx',
+    'cumshot',
+    'dildo',
+    'anal',
+    'porn',
+    'mature',
+    'sex',
+    'xx',
+    'bbw',
+    'slut',
+    'whore',
+    'tits',
+    'titty',
+    'titties',
+    'pussy',
+    'sperm',
+    'cheat',
+    'booty',
+    'ebony',
+    'asian',
+    'brazilian',
+    'fuck',
+    'cock',
+    'cunt',
+    'lesbian',
+    'shemale',
+    'boob',
+    'boobies',
+    'boobs',
+    'naughty',
+    'fatty',
+    'bitch',
+    'granny',
+    'jizz',
+    'faggot',
+    'horny',
+    'bukakke',
+    'bdsm',
+    'vagina',
+    'smut',
+    'x-rated',
+    'lusty',
+    'erotic',
+    'cunnilingus',
+    'blowjob',
+    'panty',
+    'hentai',
+    'latex',
+    'fetisch',
+    'fetish',
+    'erotik',
+    'erotic',
+    'bondage',
+    'naked',
+    'strip',
+    'mature',
+    'stocking',
+    'coitus',
+    'depraved',
+    'tube',
+    'perverse',
+    'rectal',
+    'prolapse',
+    'hentai',
+    'calcinha',
+    'calc',
+    'cow',
+    'dick',
+    'moaning',
+    'orgy',
+    'threesome',
+];
+exports.stopWords = [
+    'de',
+    'a',
+    'o',
+    'que',
+    'e',
+    'do',
+    'da',
+    'em',
+    'um',
+    'para',
+    'é',
+    'com',
+    'uma',
+    'os',
+    'no',
+    'se',
+    'na',
+    'por',
+    'mais',
+    'as',
+    'dos',
+    'como',
+    'mas',
+    'foi',
+    'ao',
+    'ele',
+    'das',
+    'tem',
+    'à',
+    'seu',
+    'sua',
+    'ou',
+    'ser',
+    'quando',
+    'muito',
+    'há',
+    'nos',
+    'já',
+    'está',
+    'eu',
+    'também',
+    'só',
+    'pelo',
+    'pela',
+    'até',
+    'isso',
+    'ela',
+    'entre',
+    'era',
+    'depois',
+    'mesmo',
+    'aos',
+    'ter',
+    'seus',
+    'quem',
+    'nas',
+    'me',
+    'esse',
+    'eles',
+    'estão',
+    'você',
+    'vc',
+    'tinha',
+    'foram',
+    'essa',
+    'num',
+    'nem',
+    'suas',
+    'meu',
+    'às',
+    'minha',
+    'têm',
+    'numa',
+    'pelos',
+    'elas',
+    'havia',
+    'seja',
+    'qual',
+    'será',
+    'nós',
+    'tenho',
+    'não',
+    'nao',
+    'lhe',
+    'deles',
+    'essas',
+    'esses',
+    'pelas',
+    'este',
+    'fosse',
+    'dele',
+    'tu',
+    'te',
+    'vocês',
+    'vos',
+    'lhes',
+    'meus',
+    'minhas',
+    'teu',
+    'tua',
+    'teus',
+    'tuas',
+    'nosso',
+    'nossa',
+    'nossos',
+    'nossas',
+    'dela',
+    'delas',
+    'esta',
+    'estes',
+    'estas',
+    'aquele',
+    'aquela',
+    'aqueles',
+    'aquelas',
+    'isto',
+    'aquilo',
+    'estou',
+    'está',
+    'estamos',
+    'estão',
+    'estive',
+    'esteve',
+    'estivemos',
+    'estiveram',
+    'estava',
+    'estávamos',
+    'estavam',
+    'estivera',
+    'estivéramos',
+    'esteja',
+    'estejamos',
+    'estejam',
+    'estivesse',
+    'estivéssemos',
+    'estivessem',
+    'estiver',
+    'estivermos',
+    'estiverem',
+    'hei',
+    'há',
+    'havemos',
+    'hão',
+    'houve',
+    'houvemos',
+    'houveram',
+    'houvera',
+    'houvéramos',
+    'haja',
+    'hajamos',
+    'hajam',
+    'houvesse',
+    'houvéssemos',
+    'houvessem',
+    'houver',
+    'houvermos',
+    'houverem',
+    'houverei',
+    'houverá',
+    'houveremos',
+    'houverão',
+    'houveria',
+    'houveríamos',
+    'houveriam',
+    'sou',
+    'somos',
+    'são',
+    'era',
+    'éramos',
+    'eram',
+    'fui',
+    'foi',
+    'fomos',
+    'foram',
+    'fora',
+    'fôramos',
+    'seja',
+    'sejamos',
+    'sejam',
+    'fosse',
+    'fôssemos',
+    'fossem',
+    'for',
+    'formos',
+    'forem',
+    'serei',
+    'será',
+    'seremos',
+    'serão',
+    'seria',
+    'seríamos',
+    'seriam',
+    'temos',
+    'tém',
+    'tínhamos',
+    'tinham',
+    'tive',
+    'teve',
+    'tivemos',
+    'tiveram',
+    'tivera',
+    'tivéramos',
+    'tenha',
+    'tenhamos',
+    'tenham',
+    'tivesse',
+    'tivéssemos',
+    'tivessem',
+    'tiver',
+    'tivermos',
+    'tiverem',
+    'terei',
+    'terá',
+    'teremos',
+    'terão',
+    'teria',
+    'teríamos',
+    'teriam',
+    'vc',
+    'tb',
+    'q',
+    'n',
+    'cmg',
+    'p',
+    'eh',
+    'mt',
+    'td',
+    'pra',
+    'pro',
+    'the',
+    'of',
+    'and',
+    'or',
+    'for',
+    'to',
+    'in',
+    'at',
+    'the',
+    'i',
+    'me',
+    'my',
+    'myself',
+    'we',
+    'our',
+    'ours',
+    'ourselves',
+    'you',
+    'your',
+    'yours',
+    'yourself',
+    'yourselves',
+    'he',
+    'him',
+    'his',
+    'himself',
+    'she',
+    'her',
+    'hers',
+    'herself',
+    'it',
+    'its',
+    'itself',
+    'they',
+    'them',
+    'their',
+    'theirs',
+    'themselves',
+    'what',
+    'which',
+    'who',
+    'whom',
+    'this',
+    'that',
+    'these',
+    'those',
+    'am',
+    'is',
+    'are',
+    'was',
+    'were',
+    'be',
+    'been',
+    'being',
+    'have',
+    'has',
+    'had',
+    'having',
+    'do',
+    'does',
+    'did',
+    'doing',
+    'a',
+    'an',
+    'the',
+    'and',
+    'but',
+    'if',
+    'or',
+    'because',
+    'as',
+    'until',
+    'while',
+    'of',
+    'at',
+    'by',
+    'for',
+    'with',
+    'about',
+    'against',
+    'between',
+    'into',
+    'through',
+    'during',
+    'before',
+    'after',
+    'above',
+    'below',
+    'to',
+    'from',
+    'up',
+    'down',
+    'in',
+    'out',
+    'on',
+    'off',
+    'over',
+    'under',
+    'again',
+    'further',
+    'then',
+    'once',
+    'here',
+    'there',
+    'when',
+    'where',
+    'why',
+    'how',
+    'all',
+    'any',
+    'both',
+    'each',
+    'few',
+    'more',
+    'most',
+    'other',
+    'some',
+    'such',
+    'no',
+    'nor',
+    'not',
+    'only',
+    'own',
+    'same',
+    'so',
+    'than',
+    'too',
+    'very',
+    'wa',
+    'wo',
+];
+function getActualMonth(desloc = 0) {
+    const currentDate = new Date();
+    const currentMonth = currentDate.getMonth();
+    if (desloc) {
+        return (currentMonth - desloc + 12) % 12;
+    }
+    return currentMonth;
+}
+function checkGuess(input, real, limite = 2) {
+    const normalizedInput = normalizeStringAndRemoveStopWords(input);
+    const normalizedMovieName = normalizeStringAndRemoveStopWords(real);
+    limite = input.length <= 5 && limite >= 2 ? limite - 1 : limite;
+    const distance = levenshteinDistance(normalizedInput, normalizedMovieName);
+    return distance <= limite;
+}
+const messagesErro = [
+    '[❗] Putz, deu ruim aí, erro no comando.\nTenta de novo mais tarde, quem sabe cola, né?',
+    '[❗] Pô, que zica! Deu um bug no comando, mané.\nMelhor tentar outra hora.',
+    '[❗] Ih rapaz, alguma coisa deu tilt aí.\nComando foi pro beleléu.\nDá um tempo ai e tenta de novo.',
+    '[❗] Ah, não! Deu uma falha aí, comando foi pro espaço.\nDá um tempo e tenta de novo, talvez role.',
+    '[❗] Opa, que vacilo! Parece que o comando pirou.\nDá um refresco e tenta outra hora.',
+    '[❗] Eita, deu um crash aí! Comando se perdeu.\nDescansa e tenta dar uma chance depois.',
+    '[❗] Xii, deu zebra! Comando não foi na onda.\nRelaxa e tenta mais tarde, pode colar.',
+    '[❗] Caramba, erro aí no comando, mané! Bateu um bug.\nDescansa e tenta refazer mais tarde.',
+    '[❗] Oxi, que coisa! Comando se embolou.\nTenta dar um tempo e refazer mais tarde.',
+    '[❗] Ah, que bad! Deu tilt no comando, não foi na moral.\nRelaxa e tenta de novo depois.',
+    '[❗] Putz, o comando deu ruim.\nDescansa e tenta dar uma chance depois.',
+    '[❗] Vish, que sinistro! Comando fez o role errado.\nDá um tempo aí e tenta de novo.',
+    '[❗] Eita, deu ruim! Comando deu mole.\nRelaxa e tenta refazer mais tarde.',
+    '[❗] Ih, o bagulho deu uma bugada! Comando não foi na manha.\nDá um descanso e tenta mais tarde.',
+    '[❗] Puts, deu tilt no comando.\nTenta recarregar depois, quem sabe dá certo.',
+    '[❗] Ah, que zica! Comando deu uma pane.\nRelaxa e tenta dar um replay mais tarde.',
+    '[❗] Caramba, erro aí no comando, brother! Deu uma bugada.\nDá um tempo e tenta de novo.',
+    '[❗] Ih, rapaz! Comando deu uns rolinhos.\nDescansa e tenta refazer mais tarde.',
+    '[❗] Xiii, deu uma zebra aí! Comando não foi na onda.\nRelaxa e tenta dar um replay depois.',
+    '[❗] Pô, que vacilo! Comando deu um tilt.\nDescansa e tenta de novo mais tarde.',
+];
+function getRandomErroMessage() {
+    return messagesErro[Math.floor(Math.random() * messagesErro.length)];
+}
+async function timeoutPromise(timeoutNumber, timeoutMessage = 'Timeout') {
+    setTimeout(() => {
+        throw new Error(timeoutMessage);
+    }, timeoutNumber);
+}
+const timestampToDate = (timestampMsg) => {
+    const date = new Date(timestampMsg);
+    const dateFormatted = date.toLocaleString('pt-BR', {
+        timeZone: 'America/Sao_Paulo',
+        hour12: false,
+        day: '2-digit',
+        month: '2-digit',
+        year: 'numeric',
+    });
+    return dateFormatted;
+};
+exports.timestampToDate = timestampToDate;
+function convertTime(hms) {
+    if (hms.length < 3) {
+        return hms;
+    }
+    else if (hms.length < 6) {
+        const a = hms.split(':');
+        return (hms = +a[0] * 60 + +a[1]);
+    }
+    else {
+        const a = hms.split(':');
+        return (hms = +a[0] * 60 * 60 + +a[1] * 60 + +a[2]);
+    }
+}
+function getLinkRegex(filter) {
+    const regexMap = {
+        youtube: /http(?::\/\/(?:www\.youtube\.com\/|youtu\.be)|s:\/\/(?:www\.youtube\.com|youtu\.be))/gi,
+        whatsapp: /(?:https?:\/\/(?:chat\.whatsapp\.com|wa\.me)|chat\.whatsapp\.com|wa\.me)\//gi,
+        twitter: /(?:https?:\/\/)?(?:www\.)?twitter\.com\/(?:(?:\w)*#!\/)?(?:pages\/)?(?:[\w\-]*\/)*([\w\-]*)/gi,
+        facebook: /(?:https?:\/\/)?(?:www\.)?(mbasic.facebook|m\.facebook|facebook|fb)\.(com|me)\/(?:(?:\w\.)*#!\/)?(?:pages\/)?(?:[\w\-\.]*\/)*([\w\-\.]*)/gi,
+        instagram: /(?:https?:\/\/)?(?:www\.)?(?:instagram\.com|instagr\.am)\/(?:(?:\w\.)*#!\/)?(?:pages\/)?(?:[\w\-\.]*\/)*([\w\-\.]*)/gi,
+        tiktok: /(?:https?:\/\/)?(?:www\.)?(?:tiktok\.com)\/(?:(?:\w\.)*#!\/)?(?:pages\/)?(?:[\w\-\.]*\/)*([\w\-\.]*)/gi,
+        twitch: /(?:https?:\/\/)?(?:www\.)?(?:twitch\.tv)\/(?:(?:\w\.)*#!\/)?(?:pages\/)?(?:[\w\-\.]*\/)*([\w\-\.]*)/gi,
+        discord: /(?:https?:\/\/)?(?:www\.)?(?:discord\.gg)\/(?:(?:\w\.)*#!\/)?(?:pages\/)?(?:[\w\-\.]*\/)*([\w\-\.]*)/gi,
+        spotify: /(?:https?:\/\/)?(?:www\.)?(?:open\.spotify\.com)\/(?:(?:\w\.)*#!\/)?(?:pages\/)?(?:[\w\-\.]*\/)*([\w\-\.]*)/gi,
+        netflix: /(?:https?:\/\/)?(?:www\.)?(?:netflix\.com)\/(?:(?:\w\.)*#!\/)?(?:pages\/)?(?:[\w\-\.]*\/)*([\w\-\.]*)/gi,
+    };
+    return regexMap[filter] || / /;
+}
+function getCensuredText(text = '') {
+    const pornWordsRegex = new RegExp(exports.pornWords.join('|'), 'gi');
+    return text.replace(pornWordsRegex, '').trim();
+}
+function isOwnerGroup(chatId) {
+    return (chatId === process.env.GRUPO_CHAT || chatId === process.env.GRUPO_FIGURINHAS);
+}
+function extrairIdsMencionados(texto) {
+    if (!texto)
+        return [];
+    const regex = /<@(\d+)>/g;
+    const ids = [];
+    let match;
+    while ((match = regex.exec(texto)) !== null) {
+        ids.push(match[1]);
+    }
+    return ids;
+}
+function generateCode(length = 6) {
+    const characters = 'ABCDEFGHIJKLMNPQRSTUVWXYZ123456789';
+    let code = '';
+    for (let i = 0; i < length; i++) {
+        const randomIndex = Math.floor(Math.random() * characters.length);
+        code += characters[randomIndex];
+    }
+    return code;
+}
+function drawHangman(erros, hidden, dica, letrasErradas = '') {
+    hidden = hidden.toUpperCase(); /*?.replaceAll('_', '█');*/
+    letrasErradas = letrasErradas.toUpperCase();
+    switch (erros) {
+        case 0:
+            return (`ʢ_____          ${letrasErradas}` +
+                `\n |     |` +
+                '\n |' +
+                '\n |' +
+                '\n |' +
+                '\n |' +
+                `\n |    ${hidden}` +
+                `\n\nDica: *${dica}*`);
+        case 1:
+            return (`ʢ_____          ${letrasErradas}` +
+                `\n |     |` +
+                '\n |     O' +
+                '\n |' +
+                '\n |' +
+                '\n |' +
+                `\n |    ${hidden}` +
+                `\n\nDica: *${dica}*`);
+        case 2:
+            return (`ʢ_____          ${letrasErradas}` +
+                `\n |     |` +
+                '\n |     O' +
+                '\n |     |' +
+                '\n |' +
+                '\n |' +
+                `\n |    ${hidden}` +
+                `\n\nDica: *${dica}*`);
+        case 3:
+            return (`ʢ_____          ${letrasErradas}` +
+                `\n |     |` +
+                '\n |     O' +
+                '\n |    /|' +
+                '\n |' +
+                '\n |' +
+                `\n |    ${hidden}` +
+                `\n\nDica: *${dica}*`);
+        case 4:
+            return (`ʢ_____          ${letrasErradas}` +
+                `\n |     |` +
+                '\n |     O' +
+                '\n |    /|\\' +
+                '\n |' +
+                '\n |' +
+                `\n |    ${hidden}` +
+                `\n\nDica: *${dica}*`);
+        case 5:
+            return (`ʢ_____          ${letrasErradas}` +
+                `\n |     |` +
+                '\n |     O' +
+                '\n |    /|\\' +
+                '\n |    /' +
+                '\n |' +
+                `\n |    ${hidden}` +
+                `\n\nDica: *${dica}*`);
+        case 6:
+            return (` _____          ${letrasErradas}` +
+                `\n |     |` +
+                '\n |     O' +
+                '\n |    /|\\' +
+                '\n |    / \\' +
+                '\n |' +
+                `\n |    ${hidden}` +
+                `\nVocê perdeu!`);
+        default:
+            console.log('erros', erros);
+            return 'Erro';
+    }
+}
+function clearObject(item, originalItem) {
+    if (originalItem) {
+        item = {
+            ...originalItem,
+            ...item,
+        };
+    }
+    Object.keys(item).forEach((keyT) => {
+        const key = keyT;
+        if (!item[key] || (item[key] instanceof Array && item[key].length === 0)) {
+            delete item[key];
+        }
+        if (Array.isArray(item[key])) {
+            item[key].forEach((element) => {
+                if (Array.isArray(element)) {
+                    element.forEach((el) => {
+                        Object.keys(el).forEach((attr) => {
+                            if (!el[attr] || el[attr]?.length === 0) {
+                                delete el[attr];
+                            }
+                        });
+                    });
+                }
+                else if (typeof element === 'object') {
+                    Object.keys(element).forEach((attr) => {
+                        if (!element[attr] || element[attr]?.length === 0) {
+                            delete element[attr];
+                        }
+                    });
+                }
+            });
+        }
+    });
+    return item;
+}
+function getMonthId(offset) {
+    const currentDate = new Date();
+    const year = currentDate.getFullYear();
+    const month = currentDate.getMonth();
+    const totalMonths = year * 12 + month + offset;
+    const newYear = Math.floor(totalMonths / 12);
+    const newMonth = totalMonths % 12;
+    return newYear.toString() + (newMonth + 1).toString().padStart(2, '0');
+}
+function isShiny(id) {
+    return !!id?.toUpperCase().endsWith('S');
+}
+function compareCardsOrder(a, b, inverse = false) {
+    const orderLetters = [
+        'M',
+        'W',
+        'P',
+        'X',
+        'Y',
+        'R',
+        'G',
+        'V',
+        'N',
+        'B',
+        'H',
+        'K',
+        'T',
+        'S',
+        'D',
+    ];
+    let idA = (a?.id?.toUpperCase() || a?.type?.toUpperCase()) ?? 'D00';
+    let idB = (b?.id?.toUpperCase() || b?.type?.toUpperCase()) ?? 'D00';
+    let aOrder = orderLetters.indexOf(idA[0]);
+    let bOrder = orderLetters.indexOf(idB[0]);
+    if (a.isNewCard) {
+        aOrder += 10000;
+    }
+    if (b.isNewCard) {
+        bOrder += 10000;
+    }
+    if (aOrder !== bOrder) {
+        if (inverse) {
+            return bOrder - aOrder;
+        }
+        return aOrder - bOrder;
+    }
+    const aNumber = parseInt(idA.slice(1), 10);
+    const bNumber = parseInt(idB.slice(1), 10);
+    return aNumber - bNumber;
+}
+function privateNumber(contactId) {
+    const number = contactId?.replace('@c.us', '') ?? '';
+    return number.replace(/(\d{4})(\d{5,7})(\d{3})/, '$1*****$3');
+}
+function limitDescription(description, limit = 50) {
+    if (description.length > limit) {
+        return description.substring(0, limit) + '...';
+    }
+    else {
+        return description;
+    }
+}
+function convertToCurrency(value) {
+    return value?.toLocaleString('pt-BR', {
+        style: 'currency',
+        currency: 'BRL',
+    });
+}
+function getDateFormat(date) {
+    const dateObj = new Date(date);
+    return dateObj.toLocaleDateString('pt-BR', {
+        timeZone: 'America/Sao_Paulo',
+        hour12: false,
+        day: '2-digit',
+        month: '2-digit',
+        year: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+}
+async function getBlobFromPath(imagePath) {
+    let blob = null;
+    if (imagePath.startsWith('data:image')) {
+        const byteString = atob(imagePath.split(',')[1]);
+        const mimeString = imagePath.split(',')[0].split(':')[1].split(';')[0];
+        const ab = new ArrayBuffer(byteString.length);
+        const ia = new Uint8Array(ab);
+        for (let i = 0; i < byteString.length; i++) {
+            ia[i] = byteString.charCodeAt(i);
+        }
+        blob = new Blob([ab], { type: mimeString });
+    }
+    else {
+        const result = await fetch(imagePath);
+        if (!result.ok) {
+            console.error('Erro ao baixar a imagem.', result);
+            throw new Error('Erro ao baixar a imagem.');
+        }
+        blob = await result.blob();
+    }
+    return blob;
+}
+function base64ToBlob(base64) {
+    const byteString = atob(base64.split(',')[1]);
+    const mimeString = base64.split(',')[0].split(':')[1].split(';')[0];
+    const ab = new ArrayBuffer(byteString.length);
+    const ia = new Uint8Array(ab);
+    for (let i = 0; i < byteString.length; i++) {
+        ia[i] = byteString.charCodeAt(i);
+    }
+    return new Blob([ab], { type: mimeString });
+}
+async function loadImage(base64Str) {
+    const img = new Image();
+    img.src = base64Str;
+    await new Promise((resolve) => (img.onload = resolve));
+    return img;
+}
+async function blobToBase64(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            resolve(reader.result);
+        };
+        reader.onerror = reject;
+        reader.readAsDataURL(blob);
+    });
+}
+function formatTime(time) {
+    let hours = Math.floor((time % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
+    const minutes = Math.floor((time % (1000 * 60 * 60)) / (1000 * 60));
+    const seconds = Math.floor((time % (1000 * 60)) / 1000);
+    const days = Math.floor(time / (1000 * 60 * 60 * 24));
+    return `${days}d ${hours}h ${minutes}m ${seconds}s`;
+}
+function raidComparator(a, b) {
+    const now = Date.now();
+    const weight = (r) => {
+        if (r.finishedAt)
+            return 2;
+        return new Date(r.startTime).getTime() > now ? 1 : 0;
+    };
+    const wDiff = weight(a) - weight(b);
+    if (wDiff !== 0)
+        return wDiff;
+    return new Date(a.startTime).getTime() - new Date(b.startTime).getTime();
+}
+function toISOStringWithOffset(date) {
+    const pad = (n) => String(n).padStart(2, '0');
+    const offsetMin = date.getTimezoneOffset();
+    const sign = offsetMin > 0 ? '-' : '+';
+    const absMin = Math.abs(offsetMin);
+    const hoursOffset = pad(Math.floor(absMin / 60));
+    const minsOffset = pad(absMin % 60);
+    return (date.getFullYear() +
+        '-' +
+        pad(date.getMonth() + 1) +
+        '-' +
+        pad(date.getDate()) +
+        'T' +
+        pad(date.getHours()) +
+        ':' +
+        pad(date.getMinutes()) +
+        ':' +
+        pad(date.getSeconds()) +
+        sign +
+        hoursOffset +
+        ':' +
+        minsOffset);
+}