@designliquido/delegua 0.41.6 → 0.41.8

package/umd/delegua.js

@@ -288,6 +288,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             this.primitivasConhecidas[nomePrimitivaVetor] = 'vetor';
         }
         this.primitivasConhecidas['inteiro'] = 'inteiro';
+        this.primitivasConhecidas['numero'] = 'número';
+        this.primitivasConhecidas['número'] = 'número';
         this.primitivasConhecidas['texto'] = 'texto';
         this.pilhaEscopos = new pilha_escopos_1.PilhaEscopos();
     }
@@ -397,6 +399,22 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 }
                 const tipoVetor = (0, inferenciador_1.inferirTipoVariavel)(valores);
                 return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), valores, valores.length, tipoVetor);
+            case delegua_2.default.EXPRESSAO_REGULAR:
+                let valor = '';
+                let linhaAtual = this.simbolos[this.atual].linha;
+                let eParExpressaoRegular = this.simbolos.filter((l) => l.linha === linhaAtual && l.tipo === delegua_2.default.EXPRESSAO_REGULAR)
+                    .length %
+                    2 ===
+                    0;
+                if (eParExpressaoRegular) {
+                    this.avancarEDevolverAnterior();
+                    while (!this.verificarTipoSimboloAtual(delegua_2.default.EXPRESSAO_REGULAR)) {
+                        valor += this.simbolos[this.atual].lexema || '';
+                        this.avancarEDevolverAnterior();
+                    }
+                    this.avancarEDevolverAnterior();
+                    return new construtos_1.ExpressaoRegular(this.hashArquivo, simboloAtual, valor);
+                }
             case delegua_2.default.FALSO:
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), false, 'lógico');
@@ -434,6 +452,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), null, 'nulo');
             case delegua_2.default.NUMERO:
+            case delegua_2.default.NÚMERO:
             case delegua_2.default.TEXTO:
                 const simboloNumeroTexto = this.avancarEDevolverAnterior();
                 const tipoInferido = (0, inferenciador_1.inferirTipoVariavel)(simboloNumeroTexto.literal);
@@ -517,22 +536,6 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                     }
                 }
                 return new construtos_1.TipoDe(this.hashArquivo, simboloAtual, construto);
-            case delegua_2.default.EXPRESSAO_REGULAR:
-                let valor = '';
-                let linhaAtual = this.simbolos[this.atual].linha;
-                let eParExpressaoRegular = this.simbolos.filter((l) => l.linha === linhaAtual && l.tipo === delegua_2.default.EXPRESSAO_REGULAR)
-                    .length %
-                    2 ===
-                    0;
-                if (eParExpressaoRegular) {
-                    this.avancarEDevolverAnterior();
-                    while (!this.verificarTipoSimboloAtual(delegua_2.default.EXPRESSAO_REGULAR)) {
-                        valor += this.simbolos[this.atual].lexema || '';
-                        this.avancarEDevolverAnterior();
-                    }
-                    this.avancarEDevolverAnterior();
-                    return new construtos_1.ExpressaoRegular(this.hashArquivo, simboloAtual, valor);
-                }
         }
         throw this.erro(this.simbolos[this.atual], 'Esperado expressão.');
     }
@@ -1651,6 +1654,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.pilhaEscopos.definirTipoVariavel('filtrarPor', 'qualquer[]');
         this.pilhaEscopos.definirTipoVariavel('inteiro', 'inteiro');
         this.pilhaEscopos.definirTipoVariavel('mapear', 'qualquer[]');
+        this.pilhaEscopos.definirTipoVariavel('numero', 'número');
+        this.pilhaEscopos.definirTipoVariavel('número', 'número');
         this.pilhaEscopos.definirTipoVariavel('paraCada', 'qualquer[]');
         this.pilhaEscopos.definirTipoVariavel('primeiroEmCondicao', 'qualquer');
         this.pilhaEscopos.definirTipoVariavel('real', 'número');
@@ -2425,7 +2430,10 @@ class AvaliadorSintaticoPitugues {
             // Se tipo ainda não foi definido, infere.
             // tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(inicializadores[indice], tipo);
             // this.pilhaEscopos.definirTipoVariavel(identificador.lexema, tipo);
-            retorno.push(new declaracoes_1.Const(identificador, inicializadores[indice], tipo));
+            retorno.push(new declaracoes_1.Const(identificador, inicializadores[indice], tipo
+            // TODO: Discutir decoradores com comunidade.
+            // Array.from(this.pilhaDecoradores)
+            ));
         }
         // this.pilhaDecoradores = [];
         return retorno;
@@ -3808,6 +3816,7 @@ exports.filtrarPor = filtrarPor;
 exports.incluido = incluido;
 exports.inteiro = inteiro;
 exports.mapear = mapear;
+exports.numero = numero;
 exports.ordenar = ordenar;
 exports.paraCada = paraCada;
 exports.primeiroEmCondicao = primeiroEmCondicao;
@@ -3838,7 +3847,6 @@ async function aleatorio(interpretador) {
  * @returns {Promise<number>} Um número real entre os valores máximo e mínimo especificados.
  */
 async function aleatorioEntre(interpretador, minimo, maximo) {
-    // eslint-disable-next-line prefer-rest-params
     if (arguments.length <= 0) {
         return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'A função recebe ao menos um parâmetro.'));
     }
@@ -4023,23 +4031,27 @@ async function incluido(interpretador, vetor, valor) {
     }
     return false;
 }
-/**
- *
- * @param {InterpretadorInterface} interpretador A instância do interpretador.
- * @param numero
- * @returns
- */
-async function inteiro(interpretador, numero) {
-    if (numero === null || numero === undefined)
-        return Promise.resolve(0);
-    const valor = numero.hasOwnProperty('valor') ? numero.valor : numero;
-    if (isNaN(valor)) {
+function validacaoComumNumeros(valorParaConverter) {
+    if (isNaN(valorParaConverter)) {
         return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Valor não parece ser um número. Somente números ou textos com números podem ser convertidos para inteiro.'));
     }
-    if (!/^(-)?\d+(\.\d+)?$/.test(valor)) {
+    if (!/^(-)?\d+(\.\d+)?$/.test(valorParaConverter)) {
         return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Valor não parece estar estruturado como um número (texto vazio, falso ou não definido). Somente números ou textos com números podem ser convertidos para inteiro.'));
     }
-    return Promise.resolve(parseInt(valor));
+    return null;
+}
+/**
+ * Converte um valor em um número inteiro.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} valorParaConverter O valor a ser convertido.
+ * @returns {Promise<any>} Uma Promise com o resultado da conversão.
+ */
+async function inteiro(interpretador, valorParaConverter) {
+    if (valorParaConverter === null || valorParaConverter === undefined)
+        return Promise.resolve(0);
+    const valor = valorParaConverter.hasOwnProperty('valor') ? valorParaConverter.valor : valorParaConverter;
+    const resultadoValidacao = validacaoComumNumeros(valor);
+    return resultadoValidacao || Promise.resolve(parseInt(valor));
 }
 /**
  *
@@ -4065,6 +4077,19 @@ async function mapear(interpretador, vetor, funcaoMapeamento) {
     }
     return resultados;
 }
+/**
+ * Converte um valor em um número, com parte decimal ou não.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} valorParaConverter O valor a ser convertido.
+ * @returns {Promise<any>} Uma Promise com o resultado da conversão.
+ */
+async function numero(interpretador, valorParaConverter) {
+    if (valorParaConverter === null || valorParaConverter === undefined)
+        return Promise.resolve(0);
+    const valor = valorParaConverter.hasOwnProperty('valor') ? valorParaConverter.valor : valorParaConverter;
+    const resultadoValidacao = validacaoComumNumeros(valor);
+    return resultadoValidacao || Promise.resolve(Number(valor));
+}
 /**
  *
  * @param vetor
@@ -4215,17 +4240,20 @@ async function tamanho(interpretador, objeto) {
  * Transforma o valor ou variável em texto.
  * @param {InterpretadorInterface} interpretador A instância do interpretador.
  * @param {VariavelInterface | any} valorOuVariavel O valor ou variável.
- * @returns {string} O valor resolvido em texto.
+ * @returns {Promise<string>} O valor resolvido em texto.
  */
 async function texto(interpretador, valorOuVariavel) {
     return Promise.resolve(`${valorOuVariavel.hasOwnProperty('valor') ? valorOuVariavel.valor : valorOuVariavel}`);
 }
 /**
- *
- * @param interpretador
- * @param vetor
- * @param funcaoCondicional
- * @returns
+ * Retorna verdadeiro se todos os elementos do primeiro parâmetro retornam verdadeiro ao
+ * serem aplicados como argumentos da função passada como segundo parâmetro.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} vetor O primeiro parâmetro, um vetor.
+ * @param {VariavelInterface | any} funcaoCondicional A função que será executada com cada
+ *                                  valor do vetor passado como primeiro parâmetro.
+ * @returns {Promise<boolean>} Verdadeiro, se todos os valores do vetor fazem a função passada
+ *                             por parâmetro devolver verdadeiro, ou falso em caso contrário.
  */
 async function todosEmCondicao(interpretador, vetor, funcaoCondicional) {
     if (vetor === null || vetor === undefined)
@@ -4291,13 +4319,13 @@ exports.default = {
         tipoRetorno: 'texto[]',
         implementacao: (interpretador, valor) => {
             return Promise.resolve(Object.keys(valor));
-        }
+        },
     },
     valores: {
         tipoRetorno: 'qualquer[]',
         implementacao: (interpretador, valor) => {
             return Promise.resolve(Object.values(valor));
-        }
+        },
     },
 };
 
@@ -4309,13 +4337,13 @@ exports.default = {
         tipoRetorno: 'número',
         implementacao: (interpretador, valor) => {
             return Promise.resolve(Math.floor(valor));
-        }
+        },
     },
     arredondarParaCima: {
         tipoRetorno: 'número',
         implementacao: (interpretador, valor) => {
             return Promise.resolve(Math.ceil(valor));
-        }
+        },
     },
 };
 
@@ -4325,19 +4353,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     aparar: {
         tipoRetorno: 'texto',
-        implementacao: (interpretador, texto) => Promise.resolve(texto.trim())
+        implementacao: (interpretador, texto) => Promise.resolve(texto.trim()),
     },
     apararFim: {
         tipoRetorno: 'texto',
-        implementacao: (interpretador, texto) => Promise.resolve(texto.trimEnd())
+        implementacao: (interpretador, texto) => Promise.resolve(texto.trimEnd()),
     },
     apararInicio: {
         tipoRetorno: 'texto',
-        implementacao: (interpretador, texto) => Promise.resolve(texto.trimStart())
+        implementacao: (interpretador, texto) => Promise.resolve(texto.trimStart()),
     },
     concatenar: {
         tipoRetorno: 'texto',
-        implementacao: (interpretador, ...texto) => Promise.resolve(''.concat(...texto))
+        implementacao: (interpretador, ...texto) => Promise.resolve(''.concat(...texto)),
     },
     dividir: {
         tipoRetorno: 'texto[]',
@@ -4346,40 +4374,40 @@ exports.default = {
                 return Promise.resolve(texto.split(divisor, limite));
             }
             return Promise.resolve(texto.split(divisor));
-        }
+        },
     },
     fatiar: {
         tipoRetorno: 'texto',
-        implementacao: (interpretador, texto, inicio, fim) => Promise.resolve(texto.slice(inicio, fim))
+        implementacao: (interpretador, texto, inicio, fim) => Promise.resolve(texto.slice(inicio, fim)),
     },
     inclui: {
         tipoRetorno: 'texto',
-        implementacao: (interpretador, texto, elemento) => Promise.resolve(texto.includes(elemento))
+        implementacao: (interpretador, texto, elemento) => Promise.resolve(texto.includes(elemento)),
     },
     inverter: {
         tipoRetorno: 'texto',
-        implementacao: (interpretador, texto) => Promise.resolve(texto.split('').reduce((texto, caracter) => (texto = caracter + texto), ''))
+        implementacao: (interpretador, texto) => Promise.resolve(texto.split('').reduce((texto, caracter) => (texto = caracter + texto), '')),
     },
     maiusculo: {
         tipoRetorno: 'texto',
-        implementacao: (interpretador, texto) => Promise.resolve(texto.toUpperCase())
+        implementacao: (interpretador, texto) => Promise.resolve(texto.toUpperCase()),
     },
     minusculo: {
         tipoRetorno: 'texto',
-        implementacao: (interpretador, texto) => Promise.resolve(texto.toLowerCase())
+        implementacao: (interpretador, texto) => Promise.resolve(texto.toLowerCase()),
     },
     substituir: {
         tipoRetorno: 'texto',
-        implementacao: (interpretador, texto, elemento, substituto) => Promise.resolve(texto.replace(elemento, substituto))
+        implementacao: (interpretador, texto, elemento, substituto) => Promise.resolve(texto.replace(elemento, substituto)),
     },
     subtexto: {
         tipoRetorno: 'texto',
-        implementacao: (interpretador, texto, inicio, fim) => Promise.resolve(texto.slice(inicio, fim))
+        implementacao: (interpretador, texto, inicio, fim) => Promise.resolve(texto.slice(inicio, fim)),
     },
     tamanho: {
         tipoRetorno: 'número',
-        implementacao: (interpretador, texto) => Promise.resolve(texto.length)
-    }
+        implementacao: (interpretador, texto) => Promise.resolve(texto.length),
+    },
 };
 
 },{}],19:[function(require,module,exports){
@@ -4391,20 +4419,20 @@ exports.default = {
         implementacao: (interpretador, vetor, elemento) => {
             vetor.push(elemento);
             return Promise.resolve(vetor);
-        }
+        },
     },
     concatenar: {
         tipoRetorno: 'qualquer[]',
         implementacao: (interpretador, vetor, outroVetor) => {
             return Promise.resolve(vetor.concat(outroVetor));
-        }
+        },
     },
     empilhar: {
         tipoRetorno: 'qualquer[]',
         implementacao: (interpretador, vetor, elemento) => {
             vetor.push(elemento);
             return Promise.resolve(vetor);
-        }
+        },
     },
     encaixar: {
         tipoRetorno: 'qualquer[]',
@@ -4419,7 +4447,7 @@ exports.default = {
                 elementos = !items.length ? vetor.splice(inicio) : vetor.splice(inicio, ...items);
             }
             return Promise.resolve(elementos);
-        }
+        },
     },
     fatiar: {
         tipoRetorno: 'qualquer[]',
@@ -4438,19 +4466,19 @@ exports.default = {
                 }
             }
             return retorno;
-        }
+        },
     },
     inclui: {
         tipoRetorno: 'lógico',
-        implementacao: (interpretador, vetor, elemento) => Promise.resolve(vetor.includes(elemento))
+        implementacao: (interpretador, vetor, elemento) => Promise.resolve(vetor.includes(elemento)),
     },
     inverter: {
         tipoRetorno: 'qualquer[]',
-        implementacao: (interpretador, vetor) => Promise.resolve(vetor.reverse())
+        implementacao: (interpretador, vetor) => Promise.resolve(vetor.reverse()),
     },
     juntar: {
         tipoRetorno: 'texto',
-        implementacao: (interpretador, vetor, separador) => Promise.resolve(vetor.join(separador))
+        implementacao: (interpretador, vetor, separador) => Promise.resolve(vetor.join(separador)),
     },
     mapear: {
         tipoRetorno: 'qualquer[]',
@@ -4464,7 +4492,7 @@ exports.default = {
                 retorno.push(resultado);
             }
             return retorno;
-        }
+        },
     },
     ordenar: {
         tipoRetorno: 'qualquer[]',
@@ -4485,7 +4513,7 @@ exports.default = {
                 return vetor.sort();
             }
             return vetor.sort((a, b) => a - b);
-        }
+        },
     },
     remover: {
         tipoRetorno: 'qualquer[]',
@@ -4494,32 +4522,32 @@ exports.default = {
             if (index !== -1)
                 vetor.splice(index, 1);
             return Promise.resolve(vetor);
-        }
+        },
     },
     removerPrimeiro: {
         tipoRetorno: 'qualquer',
         implementacao: (interpretador, vetor) => {
             let elemento = vetor.shift();
             return Promise.resolve(elemento);
-        }
+        },
     },
     removerUltimo: {
         tipoRetorno: 'qualquer',
         implementacao: (interpretador, vetor) => {
             let elemento = vetor.pop();
             return Promise.resolve(elemento);
-        }
+        },
     },
     somar: {
         tipoRetorno: 'qualquer',
         implementacao: (interpretador, vetor) => {
             return Promise.resolve(vetor.reduce((acc, item) => acc + (typeof item === 'number' ? item : item.valor), 0));
-        }
+        },
     },
     tamanho: {
         tipoRetorno: 'número',
-        implementacao: (interpretador, vetor) => Promise.resolve(vetor.length)
-    }
+        implementacao: (interpretador, vetor) => Promise.resolve(vetor.length),
+    },
 };
 
 },{}],20:[function(require,module,exports){
@@ -4827,7 +4855,7 @@ class ComponenteLinguagem {
         this.valor = simbolo.lexema;
     }
     aceitar(visitante) {
-        throw new Error("Um componente de linguagem não tem método de visita.");
+        throw new Error('Um componente de linguagem não tem método de visita.');
     }
 }
 exports.ComponenteLinguagem = ComponenteLinguagem;
@@ -7527,6 +7555,8 @@ function carregarBibliotecasGlobais(pilhaEscoposExecucao) {
     pilhaEscoposExecucao.definirVariavel('incluido', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.incluido));
     pilhaEscoposExecucao.definirVariavel('inteiro', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.inteiro));
     pilhaEscoposExecucao.definirVariavel('mapear', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.mapear));
+    pilhaEscoposExecucao.definirVariavel('numero', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.numero));
+    pilhaEscoposExecucao.definirVariavel('número', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.numero));
     pilhaEscoposExecucao.definirVariavel('ordenar', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.ordenar));
     pilhaEscoposExecucao.definirVariavel('paraCada', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.paraCada));
     pilhaEscoposExecucao.definirVariavel('primeiroEmCondicao', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.primeiroEmCondicao));
@@ -7681,7 +7711,7 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
                     argumentos[i].valor = parametro['padrao'] ? parametro['padrao'].valor : null;
                 }
                 ambiente.valores[nome] = argumento && argumento.hasOwnProperty('valor') ? argumento.valor : argumento;
-                // Se o argumento é `DeleguaFuncao`, para habilitar o recurso de _currying_, 
+                // Se o argumento é `DeleguaFuncao`, para habilitar o recurso de _currying_,
                 // copiamos seu valor para o escopo atual. Nem sempre podemos contar com a tipagem explícita aqui.
                 if (argumento.valor && ['funcao', 'função'].includes(argumento.valor.tipo)) {
                     parametro.referencia = true;
@@ -8575,7 +8605,7 @@ class InterpretadorBase {
                 for (let i = 0; i < diferenca; i++) {
                     argumentos.push({
                         nome: null,
-                        valor: null
+                        valor: null,
                     });
                 }
             }
@@ -8888,7 +8918,9 @@ class InterpretadorBase {
                     }
                     else {
                         const literalErro = new construtos_1.Literal(declaracao.hashArquivo, Number(declaracao.linha), erro.mensagem);
-                        const chamadaPegue = new construtos_1.Chamada(declaracao.caminhoPegue.hashArquivo, declaracao.caminhoPegue, [literalErro]);
+                        const chamadaPegue = new construtos_1.Chamada(declaracao.caminhoPegue.hashArquivo, declaracao.caminhoPegue, [
+                            literalErro,
+                        ]);
                         valorRetorno = await chamadaPegue.aceitar(this);
                     }
                 }
@@ -9239,11 +9271,7 @@ class InterpretadorBase {
                 dicionario[chaveLogico] = promises[1];
                 continue;
             }
-            else if (typeof promises[1] === 'object') {
-                dicionario[promises[0]] = promises[1].valor;
-                continue;
-            }
-            dicionario[promises[0]] = promises[1];
+            dicionario[promises[0]] = promises[1].hasOwnProperty('valor') ? promises[1].valor : promises[1];
         }
         return dicionario;
     }
@@ -9347,16 +9375,9 @@ class InterpretadorBase {
      * @param mostrarResultado Se resultado deve ser mostrado ou não. Normalmente usado
      *                         pelo modo LAIR.
      */
-    async executar(declaracao, mostrarResultado = false) {
+    async executar(declaracao) {
         const resultado = await declaracao.aceitar(this);
         /* console.log("Resultado aceitar: " + resultado, this); */
-        // TODO: Mover a lógica abaixo para `delegua-node`.
-        if (mostrarResultado) {
-            this.funcaoDeRetorno(this.paraTexto(resultado));
-        }
-        if (resultado || typeof resultado === primitivos_1.default.BOOLEANO) {
-            this.resultadoInterpretador.push(this.paraTexto(resultado));
-        }
         return resultado;
     }
     /**
@@ -9426,7 +9447,8 @@ class InterpretadorBase {
                 this.erros.push(retornoOuErro);
             }
         }
-        catch (erro) { // TODO: Estudar remoção do `catch`.
+        catch (erro) {
+            // TODO: Estudar remoção do `catch`.
             throw new Error(`Não deveria estar caindo aqui. Há erros no interpretador que não estão tratados corretamente. Erro atual: ${JSON.stringify(erro)}.`);
         }
         finally {
@@ -10029,13 +10051,13 @@ const estruturas_1 = require("./estruturas");
 const interpretador_base_1 = require("./interpretador-base");
 const inferenciador_1 = require("../inferenciador");
 const excecoes_1 = require("../excecoes");
+const quebras_1 = require("../quebras");
 const primitivas_dicionario_1 = __importDefault(require("../bibliotecas/primitivas-dicionario"));
 const primitivas_numero_1 = __importDefault(require("../bibliotecas/primitivas-numero"));
 const primitivas_texto_1 = __importDefault(require("../bibliotecas/primitivas-texto"));
 const primitivas_vetor_1 = __importDefault(require("../bibliotecas/primitivas-vetor"));
 const primitivos_1 = __importDefault(require("../tipos-de-dados/primitivos"));
 const delegua_1 = __importDefault(require("../tipos-de-dados/delegua"));
-const quebras_1 = require("../quebras");
 /**
  * O interpretador de Delégua.
  */
@@ -10275,9 +10297,9 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                 const acessoPropriedade = valorTipoDe;
                 return acessoPropriedade.tipoRetornoPropriedade;
             case 'AcessoMetodoOuPropriedade':
-                // TODO: Deve ser removido mais futuramente. 
+                // TODO: Deve ser removido mais futuramente.
                 // Apenas `AcessoMetodo` e `AcessoPropriedade` devem funcionar aqui.
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, "Não deveria cair aqui.");
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, 'Não deveria cair aqui.');
             case 'Escreva':
                 return 'função<vazio>';
             case 'Leia':
@@ -10445,9 +10467,9 @@ class PilhaEscoposExecucao {
                 if (variavel.imutavel) {
                     throw new excecoes_1.ErroEmTempoDeExecucao(simbolo, `Constante '${simbolo.lexema}' não pode receber novos valores.`);
                 }
-                const tipoInferido = variavel && variavel.hasOwnProperty('tipo') && variavel.tipo ?
-                    variavel.tipo :
-                    (0, inferenciador_1.inferirTipoVariavel)(valor);
+                const tipoInferido = variavel && variavel.hasOwnProperty('tipo') && variavel.tipo
+                    ? variavel.tipo
+                    : (0, inferenciador_1.inferirTipoVariavel)(valor);
                 const tipo = tipoInferido.toLowerCase();
                 const valorResolvido = this.converterValor(tipo, valor);
                 if (indice !== undefined && indice !== null) {
@@ -12828,6 +12850,7 @@ exports.default = {
     NEGACAO: 'NEGACAO',
     NULO: 'NULO',
     NUMERO: 'NUMERO',
+    NÚMERO: 'NÚMERO',
     OU: 'OU',
     PADRAO: 'PADRAO',
     PADRÃO: 'PADRÃO',
@@ -26034,7 +26057,8 @@ class TradutorAssemblyScript {
                 case 'Retorna':
                     const declaracaoRetorna = declaracao;
                     resultado +=
-                        'return ' + this.dicionarioConstrutos[declaracaoRetorna.valor.constructor.name](declaracaoRetorna.valor);
+                        'return ' +
+                            this.dicionarioConstrutos[declaracaoRetorna.valor.constructor.name](declaracaoRetorna.valor);
                     break;
                 default:
                     resultado += this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao) + '\n';
@@ -26349,7 +26373,7 @@ class TradutorJavaScript {
             const argumentoResolvido = this.dicionarioConstrutos[argumento.constructor.name](argumento);
             argumentosResolvidos.push(argumentoResolvido);
         }
-        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => atual += proximo + ', ', "");
+        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => (atual += proximo + ', '), '');
         textoArgumentos = textoArgumentos.slice(0, -2);
         switch (nomeMetodo) {
             case 'adicionar':
@@ -26449,7 +26473,7 @@ class TradutorJavaScript {
         let resultado = '{';
         for (let i = 0; i < dicionario.chaves.length; i++) {
             resultado += this.dicionarioConstrutos[dicionario.chaves[i].constructor.name](dicionario.chaves[i]);
-            resultado += ":";
+            resultado += ':';
             resultado += this.dicionarioConstrutos[dicionario.valores[i].constructor.name](dicionario.valores[i]) + ',';
         }
         resultado += '}';
@@ -26460,10 +26484,14 @@ class TradutorJavaScript {
             const possuiInterpolacao = /\$\{(verdadeiro|falso|nulo)\}/.test(literal.valor);
             const valor = literal.valor.replace(/\$\{(verdadeiro|falso|nulo)\}/g, (_, match) => {
                 switch (match) {
-                    case 'verdadeiro': return '${true}';
-                    case 'falso': return '${false}';
-                    case 'nulo': return '${null}';
-                    default: return match;
+                    case 'verdadeiro':
+                        return '${true}';
+                    case 'falso':
+                        return '${false}';
+                    case 'nulo':
+                        return '${null}';
+                    default:
+                        return match;
                 }
             });
             return possuiInterpolacao ? `\`${valor}\`` : `'${literal.valor}'`;
@@ -26477,13 +26505,13 @@ class TradutorJavaScript {
             const argumentoResolvido = this.dicionarioConstrutos[argumento.constructor.name](argumento);
             argumentosResolvidos.push(argumentoResolvido);
         }
-        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => atual += proximo + ', ', "");
+        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => (atual += proximo + ', '), '');
         textoArgumentos = textoArgumentos.slice(0, -2);
         switch (variavel.simbolo.lexema) {
             case 'texto':
                 return `String(${textoArgumentos})`;
             default:
-                const buscaClasseCorrespondente = this.declaracoesDeClasses.filter(d => d.simbolo.lexema === variavel.simbolo.lexema);
+                const buscaClasseCorrespondente = this.declaracoesDeClasses.filter((d) => d.simbolo.lexema === variavel.simbolo.lexema);
                 if (buscaClasseCorrespondente.length === 0 && argumentosValidados.length === 0) {
                     return `${variavel.simbolo.lexema}`;
                 }
@@ -26571,7 +26599,8 @@ class TradutorJavaScript {
                 case 'Retorna':
                     const declaracaoRetorna = declaracao;
                     resultado +=
-                        'return ' + this.dicionarioConstrutos[declaracaoRetorna.valor.constructor.name](declaracaoRetorna.valor);
+                        'return ' +
+                            this.dicionarioConstrutos[declaracaoRetorna.valor.constructor.name](declaracaoRetorna.valor);
                     break;
                 default:
                     resultado += this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao) + '\n';
@@ -26766,7 +26795,7 @@ class TradutorJavaScript {
     }
     // TODO: Talvez terminar (ou remover, sei lá).
     traduzirFuncaoAnonimaParaLambda(argumento) {
-        return "";
+        return '';
     }
     traduzirAcessoMetodoVetor(objeto, nomeMetodo, argumentos) {
         const objetoResolvido = this.dicionarioConstrutos[objeto.constructor.name](objeto);
@@ -26778,7 +26807,7 @@ class TradutorJavaScript {
         switch (nomeMetodo) {
             case 'adicionar':
             case 'empilhar':
-                let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => atual += proximo + ', ', "");
+                let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => (atual += proximo + ', '), '');
                 textoArgumentos = textoArgumentos.slice(0, -2);
                 return `${objetoResolvido}.push(${textoArgumentos})`;
             case 'fatiar':
@@ -26879,7 +26908,7 @@ class TradutorJavaScript {
             const argumentoResolvido = this.dicionarioConstrutos[argumento.constructor.name](argumento);
             argumentosResolvidos.push(argumentoResolvido);
         }
-        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => atual += proximo + ', ', "");
+        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => (atual += proximo + ', '), '');
         textoArgumentos = textoArgumentos.slice(0, -2);
         return `${argumentoReferenciaFuncao.simboloFuncao.lexema}(${textoArgumentos})`;
     }
@@ -26889,7 +26918,7 @@ class TradutorJavaScript {
             const argumentoResolvido = this.dicionarioConstrutos[argumento.constructor.name](argumento);
             argumentosResolvidos.push(argumentoResolvido);
         }
-        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => atual += proximo + ', ', "");
+        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => (atual += proximo + ', '), '');
         textoArgumentos = textoArgumentos.slice(0, -2);
         return `${referenciaFuncao.simboloFuncao.lexema}(${textoArgumentos})`;
     }
@@ -27011,7 +27040,7 @@ class TradutorMermaidJs {
             Literal: this.traduzirConstrutoLiteral.bind(this),
             Unario: this.traduzirConstrutoUnario.bind(this),
             Variavel: this.traduzirConstrutoVariavel.bind(this),
-            Vetor: this.traduzirConstrutoVetor.bind(this)
+            Vetor: this.traduzirConstrutoVetor.bind(this),
         };
         this.dicionarioDeclaracoes = {
             Bloco: this.traduzirDeclaracaoBloco.bind(this),
@@ -27024,7 +27053,7 @@ class TradutorMermaidJs {
             Para: this.traduzirDeclaracaoPara.bind(this),
             ParaCada: this.traduzirDeclaracaoParaCada.bind(this),
             Se: this.traduzirDeclaracaoSe.bind(this),
-            Var: this.traduzirDeclaracaoVar.bind(this)
+            Var: this.traduzirDeclaracaoVar.bind(this),
         };
     }
     traduzirConstrutoAcessoIndiceVariavel(acessoIndiceVariavel) {
@@ -27057,7 +27086,7 @@ class TradutorMermaidJs {
             case delegua_1.default.MENOR:
                 return `${operandoEsquerdo} for menor que ${operandoDireito}`;
         }
-        return "";
+        return '';
     }
     traduzirConstrutoChamada(chamada) {
         const textoEntidadeChamada = this.dicionarioConstrutos[chamada.entidadeChamada.constructor.name](chamada.entidadeChamada);
@@ -27097,7 +27126,7 @@ class TradutorMermaidJs {
         return `função`;
     }
     traduzirConstrutoLeia(leia) {
-        let texto = "leia da entrada";
+        let texto = 'leia da entrada';
         if (leia.argumentos && leia.argumentos.length > 0) {
             const textoArgumento = this.dicionarioConstrutos[leia.argumentos[0].constructor.name](leia.argumentos[0]);
             texto += `, imprimindo antes: \\'${textoArgumento}\\'`;
@@ -27116,7 +27145,7 @@ class TradutorMermaidJs {
     }
     traduzirConstrutoUnario(unario) {
         const textoOperando = this.dicionarioConstrutos[unario.operando.constructor.name](unario.operando);
-        let textoOperador = "";
+        let textoOperador = '';
         switch (unario.operador.tipo) {
             case delegua_1.default.INCREMENTAR:
                 textoOperador = `incrementar ${textoOperando} em 1`;
@@ -27126,9 +27155,9 @@ class TradutorMermaidJs {
                 break;
         }
         switch (unario.incidenciaOperador) {
-            case "ANTES":
+            case 'ANTES':
                 return `${textoOperador}, devolver valor de ${textoOperando}`;
-            case "DEPOIS":
+            case 'DEPOIS':
                 return `devolver valor de ${textoOperando}, ${textoOperador}`;
         }
     }
@@ -27216,7 +27245,7 @@ class TradutorMermaidJs {
         this.anteriores.pop();
         return {
             caminho: arestaCondicaoCaminho,
-            declaracoesCaminho: verticesResolvidos
+            declaracoesCaminho: verticesResolvidos,
         };
     }
     traduzirDeclaracaoEscolha(declaracaoEscolha) {
@@ -27570,7 +27599,7 @@ class TradutorPython {
             const argumentoResolvido = this.dicionarioConstrutos[argumento.constructor.name](argumento);
             argumentosResolvidos.push(argumentoResolvido);
         }
-        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => atual += proximo + ', ', "");
+        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => (atual += proximo + ', '), '');
         textoArgumentos = textoArgumentos.slice(0, -2);
         switch (nomeMetodo) {
             case 'adicionar':
@@ -27632,7 +27661,7 @@ class TradutorPython {
     }
     // TODO: Talvez terminar (ou remover, sei lá).
     traduzirFuncaoAnonimaParaLambda(argumento) {
-        return "";
+        return '';
     }
     traduzirAcessoMetodoVetor(objeto, nomeMetodo, argumentos) {
         const objetoResolvido = this.dicionarioConstrutos[objeto.constructor.name](objeto);
@@ -27644,7 +27673,7 @@ class TradutorPython {
         switch (nomeMetodo) {
             case 'adicionar':
             case 'empilhar':
-                let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => atual += proximo + ', ', "");
+                let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => (atual += proximo + ', '), '');
                 textoArgumentos = textoArgumentos.slice(0, -2);
                 return `${objetoResolvido}.append(${textoArgumentos})`;
             case 'fatiar':
@@ -27709,7 +27738,7 @@ class TradutorPython {
             const argumentoResolvido = this.dicionarioConstrutos[argumento.constructor.name](argumento);
             argumentosResolvidos.push(argumentoResolvido);
         }
-        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => atual += proximo + ', ', "");
+        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => (atual += proximo + ', '), '');
         textoArgumentos = textoArgumentos.slice(0, -2);
         return `${argumentoReferenciaFuncao.simboloFuncao.lexema}(${textoArgumentos})`;
     }
@@ -27814,7 +27843,7 @@ class TradutorPython {
             const argumentoResolvido = this.dicionarioConstrutos[argumento.constructor.name](argumento);
             argumentosResolvidos.push(argumentoResolvido);
         }
-        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => atual += proximo + ', ', "");
+        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => (atual += proximo + ', '), '');
         textoArgumentos = textoArgumentos.slice(0, -2);
         return `${referenciaFuncao.simboloFuncao.lexema}(${textoArgumentos})`;
     }
@@ -27835,7 +27864,7 @@ class TradutorPython {
             const argumentoResolvido = this.dicionarioConstrutos[argumento.constructor.name](argumento);
             argumentosResolvidos.push(argumentoResolvido);
         }
-        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => atual += proximo + ', ', "");
+        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => (atual += proximo + ', '), '');
         textoArgumentos = textoArgumentos.slice(0, -2);
         switch (variavel.simbolo.lexema) {
             case 'texto':