@designliquido/delegua 0.57.2 → 0.59.0

package/bibliotecas/dialetos/pitugues/biblioteca-global.js

@@ -0,0 +1,686 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aleatorio = aleatorio;
+exports.aleatorio_entre = aleatorio_entre;
+exports.algum = algum;
+exports.encontrar = encontrar;
+exports.encontrar_indice = encontrar_indice;
+exports.encontrar_ultimo = encontrar_ultimo;
+exports.encontrar_ultimo_indice = encontrar_ultimo_indice;
+exports.filtrar_por = filtrar_por;
+exports.incluido = incluido;
+exports.inteiro = inteiro;
+exports.mapear = mapear;
+exports.numero = numero;
+exports.ordenar = ordenar;
+exports.para_cada = para_cada;
+exports.primeiro_em_condicao = primeiro_em_condicao;
+exports.real = real;
+exports.reduzir = reduzir;
+exports.tamanho = tamanho;
+exports.texto = texto;
+exports.todos_em_condicao = todos_em_condicao;
+exports.tupla = tupla;
+const excecoes_1 = require("../../../excecoes");
+const objeto_delegua_classe_1 = require("../../../interpretador/estruturas/objeto-delegua-classe");
+const funcao_padrao_1 = require("../../../interpretador/estruturas/funcao-padrao");
+const descritor_tipo_classe_1 = require("../../../interpretador/estruturas/descritor-tipo-classe");
+const estruturas_1 = require("../../../interpretador/estruturas");
+const construtos_1 = require("../../../construtos");
+const quebras_1 = require("../../../quebras");
+/**
+ * Retorna um número aleatório entre 0 e 1.
+ * @returns {Promise<number>} Número real.
+ */
+async function aleatorio(interpretador) {
+    return Promise.resolve(Math.random());
+}
+/**
+ * Retorna um número aleatório de acordo com o parâmetro passado.
+ * Mínimo(inclusivo) - Máximo(exclusivo).
+ * @param {number} minimo O número mínimo.
+ * @param {number} maximo O número máximo.
+ * @returns {Promise<number>} Um número real entre os valores máximo e mínimo especificados.
+ */
+async function aleatorio_entre(interpretador, minimo, maximo) {
+    if (arguments.length <= 0) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'A função recebe ao menos um parâmetro.'));
+    }
+    const valorMinimo = minimo.hasOwnProperty('valor')
+        ? minimo.valor
+        : minimo;
+    if (arguments.length === 2) {
+        if (typeof valorMinimo !== 'number') {
+            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+                hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+                linha: interpretador.linhaDeclaracaoAtual,
+            }, 'O parâmetro deve ser um número.'));
+        }
+        return Math.floor(Math.random() * (0 - valorMinimo)) + valorMinimo;
+    }
+    if (arguments.length > 3) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'A quantidade de parâmetros máxima para esta função é 2.'));
+    }
+    const valorMaximo = maximo.hasOwnProperty('valor')
+        ? maximo.valor
+        : maximo;
+    if (typeof valorMinimo !== 'number' || typeof valorMaximo !== 'number') {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Os dois parâmetros devem ser do tipo número.'));
+    }
+    return Promise.resolve(Math.floor(Math.random() * (valorMaximo - valorMinimo)) + valorMinimo);
+}
+/**
+ * Verifica se algum dos elementos satisfaz à condição para por parâmetro.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
+ * @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.
+ * @returns {Promise<boolean>} Verdadeiro se há algum elemento no vetor com a condição. Falso caso contrário.
+ */
+async function algum(interpretador, vetor, funcaoPesquisa) {
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor')
+        ? funcaoPesquisa.valor
+        : funcaoPesquisa;
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
+    }
+    if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
+    }
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Encontra o primeiro elemento de um vetor cuja função de pesquisa retorne
+ * verdadeiro na avaliação de cada elemento.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
+ * @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.
+ * @returns {Promise<any>} Um elemento, caso o elemento seja encontraro, ou nulo em caso contrário.
+ */
+async function encontrar(interpretador, vetor, funcaoPesquisa) {
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor')
+        ? funcaoPesquisa.valor
+        : funcaoPesquisa;
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
+    }
+    if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
+    }
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
+            return valorVetor[indice];
+        }
+    }
+    return null;
+}
+/**
+ * Encontra o índice do primeiro elemento de um vetor cuja função de pesquisa retorne
+ * verdadeiro na avaliação de cada elemento.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
+ * @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.
+ * @returns {Promise<number>} O número correspondente ao índice se o elemento for encontrado, ou nulo em caso contrário.
+ */
+async function encontrar_indice(interpretador, vetor, funcaoPesquisa) {
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor')
+        ? funcaoPesquisa.valor
+        : funcaoPesquisa;
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
+    }
+    if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
+    }
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
+            return indice;
+        }
+    }
+    return -1;
+}
+/**
+ * Encontrar o último elemento de um vetor cuja função de pesquisa retorne
+ * verdadeiro na avaliação de cada elemento.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
+ * @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.
+ * @returns {Promise<any>} O número correspondente ao índice se o elemento for encontrado, ou nulo em caso contrário.
+ */
+async function encontrar_ultimo(interpretador, vetor, funcaoPesquisa) {
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor')
+        ? funcaoPesquisa.valor
+        : funcaoPesquisa;
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
+    }
+    if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
+    }
+    for (let indice = valorVetor.length - 1; indice >= 0; --indice) {
+        if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
+            return valorVetor[indice];
+        }
+    }
+    return null;
+}
+/**
+ *
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
+ * @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.
+ * @returns {Promise<number>} O número correspondente ao índice se o elemento for encontrado, ou nulo em caso contrário.
+ */
+async function encontrar_ultimo_indice(interpretador, vetor, funcaoPesquisa) {
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor')
+        ? funcaoPesquisa.valor
+        : funcaoPesquisa;
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
+    }
+    if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
+    }
+    for (let indice = valorVetor.length - 1; indice >= 0; --indice) {
+        if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
+            return indice;
+        }
+    }
+    return null;
+}
+/**
+ *
+ * @param interpretador
+ * @param vetor
+ * @param funcaoFiltragem
+ * @returns
+ */
+async function filtrar_por(interpretador, vetor, funcaoFiltragem) {
+    if (vetor === null || vetor === undefined)
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função filtrarPor() não pode ser nulo.'));
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor')
+        ? funcaoFiltragem.valor
+        : funcaoFiltragem;
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função filtrarPor() deve ser um vetor.'));
+    }
+    const construtorResolvido = valorFuncaoFiltragem.constructor.name.replaceAll('_', '');
+    if (construtorResolvido !== 'DeleguaFuncao') {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro da função filtrarPor() deve ser uma função.'));
+    }
+    const resultados = [];
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        const informacoesValor = await valorFuncaoFiltragem.chamar(interpretador, [
+            valorVetor[indice],
+        ]);
+        if (informacoesValor === null || informacoesValor === undefined) {
+            continue;
+        }
+        const deveRetornarValor = informacoesValor.valorRetornado.valor;
+        if (deveRetornarValor === false)
+            continue;
+        resultados.push(valorVetor[indice]);
+    }
+    return resultados;
+}
+/**
+ *
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
+ * @param valor
+ * @returns
+ */
+async function incluido(interpretador, vetor, valor) {
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorValor = valor.hasOwnProperty('valor') ? valor.valor : valor;
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
+    }
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        if (valorVetor[indice] == valorValor) {
+            return true;
+        }
+    }
+    return false;
+}
+function validacao_comum_numeros(interpretador, valorParaConverter) {
+    if (isNaN(valorParaConverter)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, '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(valorParaConverter)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, '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 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 = validacao_comum_numeros(interpretador, valor);
+    return resultadoValidacao || Promise.resolve(parseInt(valor));
+}
+/**
+ * Dado um vetor e uma função de mapeamento, executa a função de mapeamento
+ * passando como argumento cada elemento do vetor.
+ * @param interpretador A instância do interpretador.
+ * @param vetor O vetor
+ * @param funcaoMapeamento A função de mapeamento.
+ * @returns O resultado acumulado da execução da função de mapeamento.
+ */
+async function mapear(interpretador, vetor, funcaoMapeamento) {
+    if (vetor === null || vetor === undefined)
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função mapear() não pode ser nulo.'));
+    const valorVetor = interpretador.resolverValor(vetor);
+    const valorFuncaoMapeamento = interpretador.resolverValor(funcaoMapeamento);
+    // TODO: As lógicas de validação abaixo deixam de fazer sentido com a validação de argumentos feita
+    // na avaliação sintática. Estudar remoção.
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função mapear() deve ser um vetor.'));
+    }
+    const nomeConstrutorFuncaoMapeamento = valorFuncaoMapeamento.constructor.name.replaceAll('_', '');
+    if (nomeConstrutorFuncaoMapeamento !== 'DeleguaFuncao') {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro da função mapear() deve ser uma função.'));
+    }
+    const resultados = [];
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        const informacoesRetorno = await valorFuncaoMapeamento.chamar(interpretador, [
+            valorVetor[indice],
+        ]);
+        if (!informacoesRetorno.hasOwnProperty('valorRetornado')) {
+            console.warn(`Retorno inconsistente em mapear(): ${JSON.stringify(informacoesRetorno)}.`);
+            continue;
+        }
+        if (!(informacoesRetorno.valorRetornado instanceof quebras_1.RetornoQuebra)) {
+            console.warn(`mapear() finalizado com valor retornado diferente do esperado: ${JSON.stringify(informacoesRetorno)}.`);
+            continue;
+        }
+        resultados.push(informacoesRetorno.valorRetornado.valor);
+    }
+    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 = validacao_comum_numeros(interpretador, valor);
+    return resultadoValidacao || Promise.resolve(Number(valor));
+}
+/**
+ *
+ * @param vetor
+ * @returns
+ */
+async function ordenar(interpretador, vetor) {
+    if (vetor === null || vetor === undefined)
+        throw new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função ordenar() não pode ser nulo.');
+    const objeto = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    if (!Array.isArray(objeto)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Valor inválido. Objeto inserido não é um vetor.'));
+    }
+    let trocado;
+    const tamanho = objeto.length;
+    do {
+        trocado = false;
+        for (let i = 0; i < tamanho - 1; i++) {
+            if (objeto[i] > objeto[i + 1]) {
+                [objeto[i], objeto[i + 1]] = [objeto[i + 1], objeto[i]];
+                trocado = true;
+            }
+        }
+    } while (trocado);
+    return Promise.resolve(objeto);
+}
+/**
+ *
+ * @param interpretador
+ * @param vetor
+ * @param funcaoFiltragem
+ * @returns
+ */
+async function para_cada(interpretador, vetor, funcaoFiltragem) {
+    if (vetor === null || vetor === undefined)
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função paraCada() não pode ser nulo.'));
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor')
+        ? funcaoFiltragem.valor
+        : funcaoFiltragem;
+    // TODO: As lógicas de validação abaixo deixam de fazer sentido com a validação de argumentos feita
+    // na avaliação sintática. Estudar remoção.
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função paraCada() deve ser um vetor.'));
+    }
+    if (valorFuncaoFiltragem.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro da função paraCada() deve ser uma função.'));
+    }
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        await valorFuncaoFiltragem.chamar(interpretador, [valorVetor[indice]]);
+    }
+}
+/**
+ *
+ * @param interpretador
+ * @param vetor
+ * @param funcaoFiltragem
+ * @returns
+ */
+async function primeiro_em_condicao(interpretador, vetor, funcaoFiltragem) {
+    if (vetor === null || vetor === undefined)
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função primeiroEmCondicao() não pode ser nulo.'));
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor')
+        ? funcaoFiltragem.valor
+        : funcaoFiltragem;
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função primeiroEmCondicao() deve ser um vetor.'));
+    }
+    if (valorFuncaoFiltragem.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro da função primeiroEmCondicao() deve ser uma função.'));
+    }
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        const valorResolvido = await valorFuncaoFiltragem.chamar(interpretador, [
+            valorVetor[indice],
+        ]);
+        if (valorResolvido !== null) {
+            return valorResolvido;
+        }
+    }
+    return undefined;
+}
+/**
+ *
+ * @param interpretador
+ * @param numero
+ * @returns
+ */
+async function real(interpretador, numero) {
+    if (numero === null || numero === undefined)
+        return Promise.resolve(parseFloat('0'));
+    const valor = numero.hasOwnProperty('valor') ? numero.valor : numero;
+    if (!/^(-)?\d+(\.\d+)?$/.test(valor)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Valor não parece estar estruturado como um número (texto/valor vazio, falso ou não definido). Somente números ou textos com números podem ser convertidos para real.'));
+    }
+    return Promise.resolve(parseFloat(valor));
+}
+/**
+ *
+ * @param interpretador
+ * @param vetor
+ * @param funcaoReducao
+ * @param valorInicial
+ * @returns
+ */
+async function reduzir(interpretador, vetor, funcaoReducao, valorInicial = null) {
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorFuncaoReducao = funcaoReducao.hasOwnProperty('valor')
+        ? funcaoReducao.valor
+        : funcaoReducao;
+    const valorPadrao = valorInicial.hasOwnProperty('valor') ? valorInicial.valor : valorInicial;
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
+    }
+    if (valorFuncaoReducao.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
+    }
+    let resultado = valorPadrao;
+    let inicio = 0;
+    if (!resultado) {
+        resultado = vetor[0];
+        inicio = 1;
+    }
+    for (let index = inicio; index < vetor.length; ++index) {
+        resultado = await valorFuncaoReducao.chamar(interpretador, [resultado, vetor[index]]);
+    }
+    return resultado;
+}
+/**
+ *
+ * @param objeto
+ * @returns
+ */
+async function tamanho(interpretador, objeto) {
+    const valorObjeto = objeto.hasOwnProperty('valor') ? objeto.valor : objeto;
+    if (typeof valorObjeto === 'number') {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Função global tamanho() não funciona com números.'));
+    }
+    if (valorObjeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Função global tamanho não funciona com objetos complexos.'));
+    }
+    if (valorObjeto instanceof estruturas_1.DeleguaFuncao) {
+        return Promise.resolve(valorObjeto.declaracao.parametros.length);
+    }
+    if (valorObjeto instanceof funcao_padrao_1.FuncaoPadrao) {
+        return Promise.resolve(valorObjeto.valorAridade);
+    }
+    if (valorObjeto instanceof descritor_tipo_classe_1.DescritorTipoClasse) {
+        const metodos = valorObjeto.metodos;
+        let tamanho = 0;
+        if (metodos.inicializacao && metodos.inicializacao.eInicializador) {
+            tamanho = metodos.inicializacao.declaracao.parametros.length;
+        }
+        return Promise.resolve(tamanho);
+    }
+    return Promise.resolve(valorObjeto.length);
+}
+/**
+ * Transforma o valor ou variável em texto.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} valorParaConverter O valor ou variável.
+ * @returns {Promise<string>} O valor resolvido em texto.
+ */
+async function texto(interpretador, valorParaConverter) {
+    return Promise.resolve(`${valorParaConverter.hasOwnProperty('valor') ? valorParaConverter.valor : valorParaConverter}`);
+}
+/**
+ * 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 todos_em_condicao(interpretador, vetor, funcaoCondicional) {
+    if (vetor === null || vetor === undefined)
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função todosEmCondicao() não pode ser nulo.'));
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorFuncaoCondicional = funcaoCondicional.hasOwnProperty('valor')
+        ? funcaoCondicional.valor
+        : funcaoCondicional;
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função todosEmCondicao() deve ser um vetor.'));
+    }
+    if (valorFuncaoCondicional.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro da função todosEmCondicao() deve ser uma função.'));
+    }
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        if (!(await valorFuncaoCondicional.chamar(interpretador, [valorVetor[indice]])))
+            return false;
+    }
+    return true;
+}
+/**
+ * Transforma um vetor de elementos em uma tupla de N elementos, sendo N a
+ * largura do vetor.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any[]} vetor O vetor.
+ * @returns A tupla resolvida.
+ */
+async function tupla(interpretador, vetor) {
+    const valorVetor = !Array.isArray(vetor) && vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    // TODO: As lógicas de validação abaixo deixam de fazer sentido com a validação de argumentos feita
+    // na avaliação sintática. Estudar remoção.
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Argumento de função nativa `tupla` não parece ser um vetor.'));
+    }
+    switch (valorVetor.length) {
+        case 2:
+            return Promise.resolve(new construtos_1.Dupla(valorVetor[0], valorVetor[1]));
+        case 3:
+            return Promise.resolve(new construtos_1.Trio(valorVetor[0], valorVetor[1], valorVetor[2]));
+        case 4:
+            return Promise.resolve(new construtos_1.Quarteto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3]));
+        case 5:
+            return Promise.resolve(new construtos_1.Quinteto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4]));
+        case 6:
+            return Promise.resolve(new construtos_1.Sexteto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5]));
+        case 7:
+            return Promise.resolve(new construtos_1.Septeto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6]));
+        case 8:
+            return Promise.resolve(new construtos_1.Octeto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6], valorVetor[7]));
+        case 9:
+            return Promise.resolve(new construtos_1.Noneto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6], valorVetor[7], valorVetor[8]));
+        case 10:
+            return Promise.resolve(new construtos_1.Deceto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6], valorVetor[7], valorVetor[8], valorVetor[9]));
+        case 1:
+        default:
+            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+                hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+                linha: interpretador.linhaDeclaracaoAtual,
+            }, 'Para ser transformado em uma tupla, vetor precisa ter de 2 a 10 elementos.'));
+    }
+}
+//# sourceMappingURL=biblioteca-global.js.map