@designliquido/delegua 1.20.0 → 1.21.0

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

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.aleatorio = aleatorio;
-exports.aleatorio_entre = aleatorio_entre;
 exports.algum = algum;
-exports.arredondar = arredondar;
+exports.combinar = combinar;
+exports.contar = contar;
 exports.encontrar = encontrar;
 exports.encontrar_indice = encontrar_indice;
 exports.encontrar_ultimo = encontrar_ultimo;
@@ -12,22 +12,21 @@ exports.filtrar_por = filtrar_por;
 exports.incluido = incluido;
 exports.inteiro = inteiro;
 exports.intervalo = intervalo;
+exports.inverter = inverter;
 exports.enumerar = enumerar;
 exports.mapear = mapear;
 exports.maximo = maximo;
 exports.minimo = minimo;
-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.somar = somar;
 exports.tamanho = tamanho;
 exports.texto = texto;
 exports.todos = todos;
-exports.todos_em_condicao = todos_em_condicao;
 exports.tupla = tupla;
+exports.unico = unico;
 exports.vetor = vetor;
 const excecoes_1 = require("../../../excecoes");
 const objeto_delegua_classe_1 = require("../../../interpretador/estruturas/objeto-delegua-classe");
@@ -36,8 +35,9 @@ const descritor_tipo_classe_1 = require("../../../interpretador/estruturas/descr
 const estruturas_1 = require("../../../interpretador/estruturas");
 const construtos_1 = require("../../../construtos");
 const quebras_1 = require("../../../quebras");
+const iteravel_1 = require("../../../interpretador/estruturas/iteravel");
 /**
- * Compara dois valores (números ou vetores).
+ * Compara dois valores (números, textos, booleanos ou vetores).
  * Retorna:
  * > 0 se a > b
  * < 0 se a < b
@@ -48,6 +48,12 @@ function compararElementosRecursivamente(a, b) {
     if (typeof a === 'number' && typeof b === 'number') {
         return a - b;
     }
+    if (typeof a === 'string' && typeof b === 'string') {
+        return a.localeCompare(b);
+    }
+    if (typeof a === 'boolean' && typeof b === 'boolean') {
+        return (a === b) ? 0 : (a ? 1 : -1);
+    }
     if (Array.isArray(a) && Array.isArray(b)) {
         const tamanho = Math.min(a.length, b.length);
         for (let i = 0; i < tamanho; i++) {
@@ -57,879 +63,962 @@ function compararElementosRecursivamente(a, b) {
         }
         return a.length - b.length;
     }
-    // Tipos incompatíveis (ex: comparar número com vetor)
+    // Tipos incompatíveis
     throw new Error('Tipos incompatíveis para comparação.');
 }
-/**
- * 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, ...argumentos) {
-    const argumentosUsuario = argumentos.filter((arg) => !(arg && typeof arg === 'object' && 'lexema' in arg && 'linha' in arg));
-    if (argumentosUsuario.length <= 0) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+function validacao_comum_numeros(interpretador, valorParaConverter, nomeDaFuncao) {
+    const numeroConvertido = Number(valorParaConverter);
+    if (valorParaConverter === '' ||
+        valorParaConverter === null ||
+        valorParaConverter === undefined ||
+        typeof valorParaConverter === 'boolean' ||
+        Number.isNaN(numeroConvertido)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'A função recebe ao menos um parâmetro.'));
+        }, `Valor não parece estar estruturado como um número válido. Somente números ou textos com números podem ser convertidos na função ${nomeDaFuncao}().`);
     }
+}
+/**
+ * Retorna um número aleatório.
+ * - Sem argumentos: retorna um número real entre 0 (inclusivo) e 1 (exclusivo).
+ * - Com um argumento: retorna um número real entre 0 (inclusivo) e `maximo` (exclusivo).
+ * - Com dois argumentos: retorna um número real entre `minimo` (inclusivo) e `maximo` (exclusivo).
+ * @param {number} [minimo] O número mínimo (inclusivo), ou o máximo quando único argumento.
+ * @param {number} [maximo] O número máximo (exclusivo).
+ * @returns {Promise<number>} O número real aleatório gerado.
+ */
+async function aleatorio(interpretador, ...argumentos) {
+    const argumentosUsuario = argumentos.filter((arg) => !(arg &&
+        typeof arg === 'object' &&
+        'lexema' in arg &&
+        'linha' in arg));
+    if (argumentosUsuario.length === 0)
+        return Math.random();
     if (argumentosUsuario.length > 2) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'A quantidade de parâmetros máxima para esta função é 2.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'A função aceita no máximo 2 parâmetros.');
     }
     const minimo = interpretador.resolverValor(argumentosUsuario[0]);
-    if (argumentosUsuario.length === 1) {
-        if (typeof minimo !== '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 - minimo)) + minimo;
+    if (typeof minimo !== 'number') {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
+            linha: interpretador.linhaDeclaracaoAtual,
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'O primeiro parâmetro deve ser um número.');
     }
+    if (argumentosUsuario.length === 1)
+        return Math.random() * minimo;
     const maximo = interpretador.resolverValor(argumentosUsuario[1]);
-    if (typeof minimo !== 'number' || typeof maximo !== 'number') {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+    if (typeof maximo !== 'number') {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Os dois parâmetros devem ser do tipo número.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'O segundo parâmetro deve ser um número.');
     }
-    return Promise.resolve(Math.floor(Math.random() * (maximo - minimo)) + minimo);
+    return Math.random() * (maximo - minimo) + minimo;
 }
 /**
- * Verifica se algum dos elementos satisfaz à condição para por parâmetro.
+ * Verifica se algum dos elementos satisfaz a condição passada 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.
+ * @param {any} iteravel Um iterável.
+ * @param {any} funcaoPesquisa A função que ensina o método de pesquisa.
+ * @returns {Promise<boolean>} Verdadeiro se há algum elemento no iterável 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,
+async function algum(interpretador, iteravel, funcaoPesquisa) {
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
-    }
-    if (valorFuncaoPesquisa.constructor !== estruturas_1.DeleguaFuncao) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.');
+    }
+    const valorFuncao = interpretador.resolverValor(funcaoPesquisa);
+    if (!(valorFuncao instanceof estruturas_1.DeleguaFuncao) &&
+        !(valorFuncao instanceof funcao_padrao_1.FuncaoPadrao)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro deve ser uma função.');
     }
-    for (let indice = 0; indice < valorVetor.length; ++indice) {
-        if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
+    for (const item of itens) {
+        if (await valorFuncao.chamar(interpretador, item, {
+            linha: interpretador.linhaDeclaracaoAtual,
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        })) {
             return true;
         }
     }
     return false;
 }
-/**
- * Arredonda um número para uma quantidade específica de casas decimais.
- * @param {InterpretadorInterface} interpretador A instância do interpretador.
- * @param {any} numero O número a ser arredondado.
- * @param {any} casasDecimais A quantidade de casas decimais para o arredondamento.
- * @returns {Promise<number>} O número arredondado.
- */
-async function arredondar(interpretador, numero, casasDecimais) {
-    const valorNumero = interpretador.resolverValor(numero);
-    const valorCasas = interpretador.resolverValor(casasDecimais);
-    if (numero == undefined || numero == null) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(null, 'Erro: arredondar() deve receber um número.', interpretador.linhaDeclaracaoAtual));
-    }
-    if (typeof numero !== 'number') {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(null, `Erro de Tipo: arredondar() espera um número, mas recebeu '${typeof valorNumero}'.`, interpretador.linhaDeclaracaoAtual));
-    }
-    const fator = Math.pow(10, valorCasas);
-    const resultado = Math.round(valorNumero * fator) / fator;
-    return Promise.resolve(resultado);
+async function combinar(interpretador, primeiroIteravel, segundoIteravel) {
+    const resolverEValidar = (iteravel, nomeParametro) => {
+        const valor = interpretador.resolverValor(iteravel);
+        const itens = new iteravel_1.Iteravel(valor).elementos;
+        if (itens.length === 0 &&
+            valor !== '' &&
+            !(valor instanceof construtos_1.TuplaN) &&
+            !Array.isArray(valor)) {
+            throw new excecoes_1.ErroEmTempoDeExecucao({
+                linha: interpretador.linhaDeclaracaoAtual,
+                hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            }, `Parâmetro inválido. O ${nomeParametro} parâmetro deve ser um iterável.`);
+        }
+        return itens;
+    };
+    const itensPrimeiroIteravel = resolverEValidar(primeiroIteravel, 'primeiro');
+    const itensSegundoIteravel = resolverEValidar(segundoIteravel, 'segundo');
+    const resultado = [];
+    const tamanhoMinimo = Math.min(itensPrimeiroIteravel.length, itensSegundoIteravel.length);
+    for (let i = 0; i < tamanhoMinimo; i++) {
+        resultado.push(new construtos_1.TuplaN(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, [
+            new construtos_1.Literal(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, itensPrimeiroIteravel[i], typeof itensPrimeiroIteravel[i] === 'string' ? 'texto' : 'qualquer'),
+            new construtos_1.Literal(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, itensSegundoIteravel[i], typeof itensSegundoIteravel[i] === 'string' ? 'texto' : 'qualquer')
+        ]));
+    }
+    return resultado;
+}
+;
+async function contar(interpretador, iteravel, elemento) {
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0 &&
+        valorIteravel !== '' &&
+        !(valorIteravel instanceof construtos_1.TuplaN) &&
+        !Array.isArray(valorIteravel)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
+            linha: interpretador.linhaDeclaracaoAtual,
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.');
+    }
+    const elementoResolvido = interpretador.resolverValor(elemento);
+    return itens.filter(item => item === elementoResolvido).length;
 }
+;
 /**
- * Encontra o primeiro elemento de um vetor cuja função de pesquisa retorne
- * verdadeiro na avaliação de cada elemento.
+ * Retorna o primeiro elemento de um iterável que satisfaça a condição definida na função de pesquisa.
+ * A execução é interrompida assim que o elemento for encontrado.
  * @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.
+ * @param {any} iteravel O iterável a ser percorrido.
+ * @param {any} funcaoPesquisa A função que define a condição de busca.
+ * @returns {Promise<any>} O primeiro elemento encontrado, ou nulo caso nenhum elemento satisfaça a condição.
  */
-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,
+async function encontrar(interpretador, iteravel, funcaoPesquisa) {
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
-    }
-    if (valorFuncaoPesquisa.constructor !== estruturas_1.DeleguaFuncao) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.');
+    }
+    const valorFuncao = interpretador.resolverValor(funcaoPesquisa);
+    if (!(valorFuncao instanceof estruturas_1.DeleguaFuncao) &&
+        !(valorFuncao instanceof funcao_padrao_1.FuncaoPadrao)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro deve ser uma função.');
     }
-    for (let indice = 0; indice < valorVetor.length; ++indice) {
-        if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
-            return valorVetor[indice];
+    for (const item of itens) {
+        if (await valorFuncao.chamar(interpretador, item, {
+            linha: interpretador.linhaDeclaracaoAtual,
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        })) {
+            return item;
         }
     }
     return null;
 }
 /**
- * Encontra o índice do primeiro elemento de um vetor cuja função de pesquisa retorne
- * verdadeiro na avaliação de cada elemento.
+ * Retorna o índice do primeiro elemento de um iterável que satisfaça a condição definida na função de pesquisa.
+ * A execução é interrompida assim que o elemento for encontrado.
  * @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.
+ * @param {any} iteravel O iterável a ser percorrido.
+ * @param {any} funcaoPesquisa A função que define a condição de busca.
+ * @returns {Promise<number>} O índice do primeiro elemento encontrado, ou -1 caso nenhum elemento satisfaça a condição.
  */
-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,
+async function encontrar_indice(interpretador, iteravel, funcaoPesquisa) {
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
-    }
-    if (valorFuncaoPesquisa.constructor !== estruturas_1.DeleguaFuncao) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.');
+    }
+    const valorFuncao = interpretador.resolverValor(funcaoPesquisa);
+    if (!(valorFuncao instanceof estruturas_1.DeleguaFuncao) &&
+        !(valorFuncao instanceof funcao_padrao_1.FuncaoPadrao)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro deve ser uma função.');
     }
-    for (let indice = 0; indice < valorVetor.length; ++indice) {
-        if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
-            return indice;
+    for (let i = 0; i < itens.length; i++) {
+        if (await valorFuncao.chamar(interpretador, itens[i], {
+            linha: interpretador.linhaDeclaracaoAtual,
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        })) {
+            return i;
         }
     }
     return -1;
 }
 /**
- * Encontrar o último elemento de um vetor cuja função de pesquisa retorne
- * verdadeiro na avaliação de cada elemento.
+ * Retorna o último elemento de um iterável que satisfaça a condição definida na função de pesquisa.
+ * A execução é interrompida assim que o elemento for encontrado.
  * @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.
+ * @param {any} iteravel O iterável a ser percorrido.
+ * @param {any} funcaoPesquisa A função que define a condição de busca.
+ * @returns {Promise<any>} O último elemento encontrado, ou nulo caso nenhum elemento satisfaça a condição.
  */
-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,
+async function encontrar_ultimo(interpretador, iteravel, funcaoPesquisa) {
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
-    }
-    if (valorFuncaoPesquisa.constructor !== estruturas_1.DeleguaFuncao) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.');
+    }
+    const valorFuncao = interpretador.resolverValor(funcaoPesquisa);
+    if (!(valorFuncao instanceof estruturas_1.DeleguaFuncao) &&
+        !(valorFuncao instanceof funcao_padrao_1.FuncaoPadrao)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro deve ser uma função.');
     }
-    for (let indice = valorVetor.length - 1; indice >= 0; --indice) {
-        if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
-            return valorVetor[indice];
+    for (let i = itens.length - 1; i >= 0; i--) {
+        if (await valorFuncao.chamar(interpretador, [itens[i]], {
+            linha: interpretador.linhaDeclaracaoAtual,
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        })) {
+            return itens[i];
         }
     }
     return null;
 }
 /**
- *
+ * Retorna o índice do último elemento de um iterável que satisfaça a condição definida na função de pesquisa.
+ * A execução é interrompida assim que o elemento for encontrado.
  * @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.
+ * @param {any} iteravel O iterável a ser percorrido.
+ * @param {any} funcaoPesquisa A função que define a condição de busca.
+ * @returns {Promise<number>} O índice do último elemento encontrado, ou -1 caso nenhum elemento satisfaça a condição.
  */
-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,
+async function encontrar_ultimo_indice(interpretador, iteravel, funcaoPesquisa) {
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
-    }
-    if (valorFuncaoPesquisa.constructor !== estruturas_1.DeleguaFuncao) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.');
+    }
+    const valorFuncao = interpretador.resolverValor(funcaoPesquisa);
+    if (!(valorFuncao instanceof estruturas_1.DeleguaFuncao) &&
+        !(valorFuncao instanceof funcao_padrao_1.FuncaoPadrao)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro deve ser uma função.');
     }
-    for (let indice = valorVetor.length - 1; indice >= 0; --indice) {
-        if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
-            return indice;
+    for (let i = itens.length - 1; i >= 0; i--) {
+        if (await valorFuncao.chamar(interpretador, itens[i], {
+            linha: interpretador.linhaDeclaracaoAtual,
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        })) {
+            return i;
         }
     }
-    return null;
+    return -1;
 }
 /**
- *
- * @param interpretador
- * @param vetor
- * @param funcaoFiltragem
- * @returns
+ * Retorna os elementos que satisfazem a condição definida na função de pesquisa.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {any} iteravel O iterável a ser percorrido.
+ * @param {any} funcaoPesquisa A função que define a condição de busca.
+ * @returns {Promise<any[]>} Os elementos que satisfazem a função de pesquisa.
  */
-async function filtrar_por(interpretador, vetor, funcaoFiltragem) {
-    if (vetor === null || vetor === undefined)
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+async function filtrar_por(interpretador, iteravel, funcaoPesquisa) {
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             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.'));
+        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.');
     }
-    if (valorFuncaoFiltragem.constructor !== estruturas_1.DeleguaFuncao) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+    const valorFuncao = interpretador.resolverValor(funcaoPesquisa);
+    if (!(valorFuncao instanceof estruturas_1.DeleguaFuncao) &&
+        !(valorFuncao instanceof funcao_padrao_1.FuncaoPadrao)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O segundo parâmetro da função filtrarPor() deve ser uma função.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro 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) {
+    for (const item of itens) {
+        const retornoFuncao = await valorFuncao.chamar(interpretador, item, {
+            linha: interpretador.linhaDeclaracaoAtual,
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        });
+        if (retornoFuncao === null || retornoFuncao === undefined)
             continue;
-        }
-        const deveRetornarValor = informacoesValor.valorRetornado.valor;
-        if (deveRetornarValor === false)
+        const passouPeloFiltro = retornoFuncao.valorRetornado.valor;
+        if (passouPeloFiltro === false)
             continue;
-        resultados.push(valorVetor[indice]);
+        resultados.push(item);
     }
     return resultados;
 }
 /**
- *
+ * Verifica se um valor específico está incluído dentro de um iterável.
  * @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
+ * @param {any} iteravel O iterável a ser percorrido.
+ * @param {any} valor O valor a ser buscado.
+ * @returns {Promise<boolean>} verdadeiro se o valor for encontrado, falso caso contrário.
  */
-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,
+async function incluido(interpretador, iteravel, valor) {
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.');
     }
-    for (let indice = 0; indice < valorVetor.length; ++indice) {
-        if (valorVetor[indice] == valorValor) {
+    const valorResolvido = interpretador.resolverValor(valor);
+    for (const item of itens) {
+        if (item == valorResolvido)
             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.
+ * @param {any} valor O valor a ser convertido.
+ * @returns {Promise<number>} 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));
+async function inteiro(interpretador, valor) {
+    const valorResolvido = interpretador.resolverValor(valor);
+    validacao_comum_numeros(interpretador, valorResolvido, 'inteiro');
+    return parseInt(String(valorResolvido), 10);
 }
 /**
  * Cria um vetor com números inteiros no intervalo especificado.
  * O valor inicial é inclusivo e o valor final é exclusivo.
  * @param {InterpretadorInterface} interpretador A instância do interpretador.
- * @param {VariavelInterface | number} valorInicial O valor inicial (inclusivo).
+ * @param {VariavelInterface | number} valorInicial O valor inicial (inclusivo) ou o limite final se for o único parâmetro.
  * @param {VariavelInterface | number} valorFinal O valor final (exclusivo).
  * @param {VariavelInterface | number} valorPasso O valor do passo.
  * @returns {Promise<number[]>} Um vetor com os números no intervalo.
  */
 async function intervalo(interpretador, valorInicial, valorFinal, valorPasso) {
-    const primeiroParam = interpretador.resolverValor(valorInicial);
-    const segundoParam = interpretador.resolverValor(valorFinal);
-    const terceiroParam = interpretador.resolverValor(valorPasso);
-    let inicioInteiro;
-    let fimInteiro;
-    let passoInteiro = 1;
-    // intervalo(parada) - apenas um parâmetro
-    if (segundoParam === undefined || segundoParam === null) {
-        if (typeof primeiroParam !== 'number' || isNaN(primeiroParam)) {
-            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-                hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+    const validarEConverter = (valorBruto, mensagemErro) => {
+        if (valorBruto === undefined || valorBruto === null)
+            return undefined;
+        const valorResolvido = interpretador.resolverValor(valorBruto);
+        if (typeof valorResolvido !== 'number' ||
+            Number.isNaN(valorResolvido)) {
+            throw new excecoes_1.ErroEmTempoDeExecucao({
                 linha: interpretador.linhaDeclaracaoAtual,
-            }, 'O parâmetro deve ser do tipo número ou inteiro.'));
-        }
-        inicioInteiro = 0;
-        fimInteiro = Math.floor(primeiroParam);
-    }
-    // intervalo(inicio, parada) ou intervalo(inicio, parada, passo)
-    else {
-        if (typeof primeiroParam !== 'number' ||
-            isNaN(primeiroParam) ||
-            typeof segundoParam !== 'number' ||
-            isNaN(segundoParam)) {
-            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
                 hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
-                linha: interpretador.linhaDeclaracaoAtual,
-            }, 'Os parâmetros de início e fim devem ser do tipo número ou inteiro.'));
-        }
-        inicioInteiro = Math.floor(primeiroParam);
-        fimInteiro = Math.floor(segundoParam);
-        // Se há um terceiro parâmetro (passo)
-        if (terceiroParam !== undefined && terceiroParam !== null) {
-            if (typeof terceiroParam !== 'number' || isNaN(terceiroParam)) {
-                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-                    hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
-                    linha: interpretador.linhaDeclaracaoAtual,
-                }, 'O parâmetro de passo deve ser do tipo número ou inteiro.'));
-            }
-            passoInteiro = Math.floor(terceiroParam);
-            if (passoInteiro === 0) {
-                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-                    hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
-                    linha: interpretador.linhaDeclaracaoAtual,
-                }, 'O passo não pode ser zero.'));
-            }
+            }, mensagemErro);
         }
+        return Math.floor(valorResolvido);
+    };
+    let inicio = validarEConverter(valorInicial, 'O parâmetro de início deve ser do tipo número ou inteiro.');
+    let fim = validarEConverter(valorFinal, 'O parâmetro de fim deve ser do tipo número ou inteiro.');
+    const passo = validarEConverter(valorPasso, 'O parâmetro de passo deve ser do tipo número ou inteiro.') ?? 1;
+    if (passo === 0) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
+            linha: interpretador.linhaDeclaracaoAtual,
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'O passo não pode ser zero.');
+    }
+    if (fim === undefined) {
+        fim = inicio;
+        inicio = 0;
     }
     const resultado = [];
-    if (passoInteiro > 0) {
-        for (let i = inicioInteiro; i < fimInteiro; i += passoInteiro) {
+    if (passo > 0) {
+        for (let i = inicio; i < fim; i += passo) {
             resultado.push(i);
         }
     }
     else {
-        // Parâmetro passo sendo um número negativo
-        for (let i = inicioInteiro; i > fimInteiro; i += passoInteiro) {
+        // Passo negativo
+        for (let i = inicio; i > fim; i += passo) {
             resultado.push(i);
         }
     }
-    return Promise.resolve(resultado);
+    return resultado;
 }
+async function inverter(interpretador, iteravel) {
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0 &&
+        valorIteravel !== '' &&
+        !(valorIteravel instanceof construtos_1.TuplaN) &&
+        !Array.isArray(valorIteravel)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
+            linha: interpretador.linhaDeclaracaoAtual,
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.');
+    }
+    const itensInvertidos = [...itens].reverse();
+    if (iteravel instanceof construtos_1.TuplaN) {
+        return new construtos_1.TuplaN(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, itensInvertidos);
+    }
+    if (typeof valorIteravel === 'string') {
+        return itensInvertidos.join('');
+    }
+    return itensInvertidos;
+}
+;
 /**
  * Dado um vetor e, opcionalmente, um valor de início, retorna um vetor de dicionários,
  * onde cada dicionário contém o índice e o valor correspondente do vetor original.
  * @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 {number | undefined} inicio O valor de início (opcional).
+ * @param {any} iteravel Um iterável.
+ * @param {any} [inicio] O valor inicial do contador de índices (opcional, padrão 0).
  * @returns {Promise<any[]>} Um vetor de dicionários com índice e valor.
  */
-async function enumerar(interpretador, vetor, inicio) {
-    if (vetor === null || vetor === undefined) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+async function enumerar(interpretador, iteravel, inicio) {
+    if (iteravel === null || iteravel === undefined) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O primeiro parâmetro da função enumerar() não pode ser nulo.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função enumerar() não pode ser nulo.');
     }
-    if (inicio !== undefined && (typeof inicio !== 'number' || isNaN(inicio))) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+    const valorInicioResolvido = interpretador.resolverValor(inicio);
+    if (valorInicioResolvido !== undefined &&
+        (typeof valorInicioResolvido !== 'number' || Number.isNaN(valorInicioResolvido))) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
+            linha: interpretador.linhaDeclaracaoAtual,
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'O parâmetro de início deve ser do tipo número ou inteiro.');
+    }
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0 &&
+        valorIteravel !== '' &&
+        !Array.isArray(valorIteravel) &&
+        !(valorIteravel?.constructor === construtos_1.TuplaN)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'O parâmetro de início deve ser do tipo número ou inteiro.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.');
     }
-    const valorVetor = interpretador.resolverValor(vetor);
-    const inicioInteiro = typeof inicio === 'number' && !isNaN(inicio) ? Math.floor(inicio) : 0;
+    const inicioInteiro = typeof valorInicioResolvido === 'number'
+        ? Math.floor(valorInicioResolvido)
+        : 0;
     const resultados = [];
-    for (let i = inicioInteiro; i < valorVetor.length; ++i) {
-        resultados.push({ indice: i, valor: valorVetor[i] });
+    for (let i = 0; i < itens.length; i++) {
+        const valorResolvido = interpretador.resolverValor(itens[i]);
+        resultados.push({
+            indice: i + inicioInteiro,
+            valor: valorResolvido
+        });
     }
-    return Promise.resolve(resultados);
+    return resultados;
 }
 /**
- * Dado um vetor e uma função de mapeamento, executa a função de mapeamento
- * passando como argumento cada elemento do vetor.
+ * Dado um iterável e uma função de mapeamento, executa a função de mapeamento
+ * passando como argumento cada elemento do iterável.
  * @param interpretador A instância do interpretador.
- * @param vetor O vetor
+ * @param iteravel O iteravel a ser mapeado.
  * @param funcaoMapeamento A função de mapeamento.
- * @returns O resultado acumulado da execução da função de mapeamento.
+ * @returns {Promise<any[]>} O resultado acumulado em forma de vetor.
  */
-async function mapear(interpretador, vetor, funcaoMapeamento) {
-    if (vetor === null || vetor === undefined)
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+async function mapear(interpretador, iteravel, funcaoMapeamento) {
+    if (iteravel === null || iteravel === undefined) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
+            linha: interpretador.linhaDeclaracaoAtual,
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função mapear() não pode ser nulo.');
+    }
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0 &&
+        valorIteravel !== '' &&
+        !Array.isArray(valorIteravel) &&
+        !(valorIteravel?.constructor === construtos_1.TuplaN)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             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);
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.');
+    }
+    const valorFuncao = interpretador.resolverValor(funcaoMapeamento);
+    const ehUmaFuncao = valorFuncao instanceof estruturas_1.DeleguaFuncao ||
+        valorFuncao instanceof funcao_padrao_1.FuncaoPadrao;
+    if (!valorFuncao || !ehUmaFuncao) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
+            linha: interpretador.linhaDeclaracaoAtual,
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, '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;
+    for (const item of itens) {
+        const retornoFuncao = await valorFuncao.chamar(interpretador, [item], {
+            linha: interpretador.linhaDeclaracaoAtual,
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        });
+        if (retornoFuncao !== null && retornoFuncao !== undefined) {
+            if (retornoFuncao.hasOwnProperty('valorRetornado')) {
+                if (retornoFuncao.valorRetornado instanceof quebras_1.RetornoQuebra) {
+                    resultados.push(retornoFuncao.valorRetornado.valor);
+                }
+            }
+            else if (retornoFuncao instanceof quebras_1.RetornoQuebra) {
+                resultados.push(retornoFuncao.valor);
+            }
         }
-        resultados.push(informacoesRetorno.valorRetornado.valor);
     }
     return resultados;
 }
 /**
- * Encontra o maior número dentro de um vetor.
+ * Encontra o maior número dentro de um iterável.
  * @param {InterpretadorInterface} interpretador A instância do interpretador.
- * @param {VariavelInterface | any} vetor Uma variável de Pituguês ou um vetor nativo de JavaScript contendo números.
- * @returns {Promise<number>} O maior número encontrado no vetor.
+ * @param {any} iteravel O iterável a ser inspecionado.
+ * @returns {Promise<any>} O maior elemento encontrado.
  */
-async function maximo(interpretador, vetor) {
-    if (vetor === null || vetor === undefined) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+async function maximo(interpretador, iteravel) {
+    if (iteravel === null || iteravel === undefined) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O parâmetro da função maximo() não pode ser nulo.'));
-    }
-    const valorVetor = interpretador.resolverValor(vetor);
-    if (!Array.isArray(valorVetor)) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
-            linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O parâmetro da função maximo() deve ser um vetor.'));
+        }, 'Parâmetro inválido. O parâmetro da função maximo() não pode ser nulo.');
     }
-    if (vetor.length == 0) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0 &&
+        valorIteravel !== '' &&
+        !Array.isArray(valorIteravel) &&
+        !(valorIteravel?.constructor === construtos_1.TuplaN)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
+            linha: interpretador.linhaDeclaracaoAtual,
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. A função maximo() espera um iterável.');
+    }
+    if (itens.length === 0) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O vetor não pode estar vazio.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O iterável não pode estar vazio.');
     }
-    let maiorValor = valorVetor[0];
+    let maiorValor = interpretador.resolverValor(itens[0]);
     try {
-        for (let i = 1; i < valorVetor.length; i++) {
-            const elementoAtual = valorVetor[i];
-            if (compararElementosRecursivamente(elementoAtual, maiorValor) > 0) {
-                maiorValor = elementoAtual;
+        for (const item of itens) {
+            const itemResolvido = interpretador.resolverValor(item);
+            if (compararElementosRecursivamente(itemResolvido, maiorValor) > 0) {
+                maiorValor = itemResolvido;
             }
         }
     }
     catch (erro) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Não é possível comparar elementos de tipos diferentes dentro do vetor (ex: números com vetores).'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Não é possível comparar elementos de tipos incompatíveis dentro do iterável.');
     }
-    return Promise.resolve(maiorValor);
+    return maiorValor;
 }
 /**
- * Encontra o menor número dentro de um vetor.
+ * Encontra o menor número dentro de um iterável.
  * @param {InterpretadorInterface} interpretador A instância do interpretador.
- * @param {VariavelInterface | any} vetor Uma variável de Pituguês ou um vetor nativo de JavaScript contendo números.
- * @returns {Promise<number>} O menor número encontrado no vetor.
+ * @param {any} iteravel O iterável a ser inspecionado.
+ * @returns {Promise<any>} O menor elemento encontrado.
  */
-async function minimo(interpretador, vetor) {
-    if (vetor === null || vetor === undefined) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+async function minimo(interpretador, iteravel) {
+    if (iteravel === null || iteravel === undefined) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O parâmetro da função minimo() não pode ser nulo.'));
-    }
-    const valorVetor = interpretador.resolverValor(vetor);
-    if (!Array.isArray(valorVetor)) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
-            linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O parâmetro da função minimo() deve ser um vetor.'));
+        }, 'Parâmetro inválido. O parâmetro da função minimo() não pode ser nulo.');
     }
-    if (valorVetor.length == 0) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0 &&
+        valorIteravel !== '' &&
+        !Array.isArray(valorIteravel) &&
+        !(valorIteravel?.constructor === construtos_1.TuplaN)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
+            linha: interpretador.linhaDeclaracaoAtual,
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. A função minimo() espera um iterável.');
+    }
+    if (itens.length === 0) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O vetor não pode estar vazio.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O iterável não pode estar vazio.');
     }
-    let menorValor = valorVetor[0];
+    let menorValor = interpretador.resolverValor(itens[0]);
     try {
-        for (let i = 1; i < valorVetor.length; i++) {
-            const elementoAtual = valorVetor[i];
-            if (compararElementosRecursivamente(elementoAtual, menorValor) < 0) {
-                menorValor = elementoAtual;
+        for (const item of itens) {
+            const itemResolvido = interpretador.resolverValor(item);
+            if (compararElementosRecursivamente(itemResolvido, menorValor) < 0) {
+                menorValor = itemResolvido;
             }
         }
     }
     catch (erro) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Não é possível comparar elementos de tipos diferentes dentro do vetor (ex: números com vetores).'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Não é possível comparar elementos de tipos incompatíveis dentro do iterável.');
     }
-    return Promise.resolve(menorValor);
+    return menorValor;
 }
 /**
- * Converte um valor em um número, com parte decimal ou não.
+ * Ordena os elementos de um iterável
  * @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.
+ * @param {any} iteravel O iterável a ser ordenado.
+ * @returns {Promise<any[]>} Um novo vetor com os elementos ordenados.
  */
-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)
+async function ordenar(interpretador, iteravel) {
+    if (iteravel === null || iteravel === 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,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função ordenar() não pode ser nulo.');
+    }
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0 &&
+        valorIteravel !== '' &&
+        !Array.isArray(valorIteravel) &&
+        !(valorIteravel?.constructor === construtos_1.TuplaN)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Valor inválido. Objeto inserido não é um vetor.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. A função ordenar() espera um iterável.');
     }
-    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;
+    const itensParaOrdenar = [...itens];
+    try {
+        itensParaOrdenar.sort((a, b) => {
+            const valorA = interpretador.resolverValor(a);
+            const valorB = interpretador.resolverValor(b);
+            if (typeof valorA === 'string' && typeof valorB === 'string') {
+                return valorA.localeCompare(valorB);
             }
-        }
-    } 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,
+            return compararElementosRecursivamente(valorA, valorB);
+        });
+    }
+    catch (erro) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O primeiro parâmetro da função paraCada() não pode ser nulo.'));
-    const valorVetor = interpretador.resolverValor(vetor);
-    const valorFuncaoFiltragem = interpretador.resolverValor(funcaoFiltragem);
-    for (let indice = 0; indice < valorVetor.length; ++indice) {
-        await valorFuncaoFiltragem.chamar(interpretador, [valorVetor[indice]]);
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Não é possível ordenar um iterável que contenha elementos de tipos incompatíveis.');
     }
+    return itensParaOrdenar;
 }
 /**
- *
- * @param interpretador
- * @param vetor
- * @param funcaoFiltragem
- * @returns
+ * Executa uma função para cada elemento do iterável.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {any} iteravel O iterável a ser percorrido.
+ * @param {any} funcaoExecucao A função que será chamada para cada elemento.
+ * @returns {Promise<void>}
  */
-async function primeiro_em_condicao(interpretador, vetor, funcaoFiltragem) {
-    if (vetor === null || vetor === undefined)
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+async function para_cada(interpretador, iteravel, funcaoExecucao) {
+    if (iteravel === null || iteravel === undefined) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O primeiro parâmetro da função primeiroEmCondicao() não pode ser nulo.'));
-    const valorVetor = interpretador.resolverValor(vetor);
-    const valorFuncaoFiltragem = interpretador.resolverValor(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.'));
+        }, 'Parâmetro inválido. O primeiro parâmetro da função para_cada() não pode ser nulo.');
     }
-    if (valorFuncaoFiltragem.constructor.name !== 'DeleguaFuncao') {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0 &&
+        valorIteravel !== '' &&
+        !Array.isArray(valorIteravel) &&
+        !(valorIteravel?.constructor === construtos_1.TuplaN)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
+            linha: interpretador.linhaDeclaracaoAtual,
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.');
+    }
+    const valorFuncao = interpretador.resolverValor(funcaoExecucao);
+    const ehUmaFuncao = valorFuncao instanceof estruturas_1.DeleguaFuncao ||
+        valorFuncao instanceof funcao_padrao_1.FuncaoPadrao;
+    if (!valorFuncao || !ehUmaFuncao) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O segundo parâmetro da função primeiroEmCondicao() deve ser uma função.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro da função para_cada() 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;
-        }
+    for (const item of itens) {
+        await valorFuncao.chamar(interpretador, [item], {
+            linha: interpretador.linhaDeclaracaoAtual,
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        });
     }
-    return undefined;
 }
 /**
- *
- * @param interpretador
- * @param numero
- * @returns
+ * Converte um valor em um número real (ponto flutuante).
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {any} valor O valor a ser convertido.
+ * @returns {Promise<number>} O resultado da conversão.
  */
-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));
+async function real(interpretador, valor) {
+    const valorResolvido = interpretador.resolverValor(valor);
+    validacao_comum_numeros(interpretador, valorResolvido, 'real');
+    return parseFloat(String(valorResolvido));
 }
 /**
- *
- * @param interpretador
- * @param vetor
- * @param funcaoReducao
- * @param valorInicial
- * @returns
+ * Reduz um iterável a um único valor, executando uma função acumuladora em cada elemento.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {any} iteravel O iterável a ser reduzido.
+ * @param {any} funcaoReducao A função que será chamada (acumulador, valorAtual).
+ * @param {any} [valorInicial=null] O valor inicial do acumulador.
+ * @returns {Promise<any>} O resultado acumulado.
  */
-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 && valorInicial.hasOwnProperty && valorInicial.hasOwnProperty('valor')
-        ? valorInicial.valor
-        : valorInicial;
-    if (!Array.isArray(valorVetor)) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+async function reduzir(interpretador, iteravel, funcaoReducao, valorInicial = null) {
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const valorFuncaoReducao = interpretador.resolverValor(funcaoReducao);
+    const valorPadrao = interpretador.resolverValor(valorInicial);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0 &&
+        valorIteravel !== '' &&
+        !Array.isArray(valorIteravel) &&
+        !(valorIteravel?.constructor === construtos_1.TuplaN)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             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,
+        }, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um iterável.');
+    }
+    const ehUmaFuncao = valorFuncaoReducao instanceof estruturas_1.DeleguaFuncao ||
+        valorFuncaoReducao instanceof funcao_padrao_1.FuncaoPadrao ||
+        typeof valorFuncaoReducao?.chamar === 'function';
+    if (!valorFuncaoReducao || !ehUmaFuncao) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.');
     }
-    // Se não houver valor inicial e vetor vazio, não é possível reduzir
     if ((valorPadrao === null || valorPadrao === undefined) &&
-        (!Array.isArray(valorVetor) || valorVetor.length === 0)) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        itens.length === 0) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Não é possível reduzir um vetor vazio sem valor inicial.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Não é possível reduzir um iterável vazio sem valor inicial.');
     }
     let resultado = valorPadrao;
     let inicio = 0;
     if (resultado === null || resultado === undefined) {
-        resultado = valorVetor[0];
+        resultado = interpretador.resolverValor(itens[0]);
         inicio = 1;
     }
-    for (let index = inicio; index < valorVetor.length; ++index) {
-        resultado = await valorFuncaoReducao.chamar(interpretador, [resultado, valorVetor[index]]);
+    for (let i = inicio; i < itens.length; i++) {
+        const elementoAtual = interpretador.resolverValor(itens[i]);
+        const resultadoFuncao = await valorFuncaoReducao.chamar(interpretador, [resultado, elementoAtual], {
+            linha: interpretador.linhaDeclaracaoAtual,
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        });
+        resultado = interpretador.resolverValor(resultadoFuncao);
     }
     return resultado;
 }
 /**
- * Realiza a soma de todos os números dentro de um vetor.
+ * Realiza a soma de todos os números dentro de um iterável.
  * @param {InterpretadorInterface} interpretador A instância do interpretador.
- * @param {VariavelInterface | any} vetor Uma variável de Pituguês ou um vetor nativo de JavaScript contendo números.
- * @returns {Promise<number>} A soma de todos os elementos do vetor.
+ * @param {any} iteravel O iterável contendo os números.
+ * @returns {Promise<number>} A soma de todos os elementos.
  */
-async function somar(interpretador, vetor) {
-    if (vetor === null || vetor === undefined) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+async function somar(interpretador, iteravel) {
+    if (iteravel === null || iteravel === undefined) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O parâmetro da função somar() não pode ser nulo.'));
-    }
-    const valorVetor = interpretador.resolverValor(vetor);
-    if (!Array.isArray(valorVetor)) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O parâmetro da função somar() não pode ser nulo.');
+    }
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0 &&
+        valorIteravel !== '' &&
+        !Array.isArray(valorIteravel) &&
+        !(valorIteravel instanceof construtos_1.TuplaN)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O parâmetro da função somar() deve ser um vetor.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O parâmetro da função somar() deve ser um iterável.');
     }
-    if (valorVetor.length === 0)
-        return Promise.resolve(0);
+    if (itens.length === 0)
+        return 0;
     let somaDosElementos = 0;
-    for (let elemento of valorVetor) {
-        if (typeof elemento !== 'number' || isNaN(elemento)) {
-            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-                hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+    for (const item of itens) {
+        const itemResolvido = interpretador.resolverValor(item);
+        if (typeof itemResolvido !== 'number' || Number.isNaN(itemResolvido)) {
+            throw new excecoes_1.ErroEmTempoDeExecucao({
                 linha: interpretador.linhaDeclaracaoAtual,
-            }, 'A função somar() aceita apenas vetores contendo números.'));
+                hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            }, 'A função somar() aceita apenas iteráveis contendo números.');
         }
-        somaDosElementos += elemento;
+        somaDosElementos += itemResolvido;
     }
-    return Promise.resolve(somaDosElementos);
+    return somaDosElementos;
 }
 /**
- *
- * @param objeto
- * @returns
+ * Retorna o tamanho do objeto, vetor, texto ou número de parâmetros de uma função/classe.
+ * * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {any} valor O valor a ser inspecionado.
+ * @returns {Promise<number>} O tamanho.
  */
-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,
+async function tamanho(interpretador, valor) {
+    const valorResolvido = interpretador.resolverValor(valor);
+    if (valorResolvido === null || valorResolvido === undefined) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Função global tamanho() não funciona com números.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Não é possível obter o tamanho de um valor nulo ou não definido.');
     }
-    if (valorObjeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+    if (typeof valorResolvido === 'number' ||
+        typeof valorResolvido === 'boolean') {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
+            linha: interpretador.linhaDeclaracaoAtual,
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, `A função global tamanho() não funciona com ${typeof valorResolvido === 'number' ? 'números' : 'booleanos'}.`);
+    }
+    if (valorResolvido instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Função global tamanho não funciona com objetos complexos.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'A função global tamanho() não funciona com objetos complexos instanciados.');
     }
-    if (valorObjeto instanceof estruturas_1.DeleguaFuncao) {
-        return Promise.resolve(valorObjeto.declaracao.parametros.length);
+    if (valorResolvido instanceof estruturas_1.DeleguaFuncao) {
+        return valorResolvido.declaracao.parametros.length;
     }
-    if (valorObjeto instanceof funcao_padrao_1.FuncaoPadrao) {
-        return Promise.resolve(valorObjeto.valorAridade);
+    if (valorResolvido instanceof funcao_padrao_1.FuncaoPadrao) {
+        return valorResolvido.valorAridade;
     }
-    if (valorObjeto instanceof descritor_tipo_classe_1.DescritorTipoClasse) {
-        const metodos = valorObjeto.metodos;
-        let tamanho = 0;
+    if (valorResolvido instanceof descritor_tipo_classe_1.DescritorTipoClasse) {
+        const metodos = valorResolvido.metodos;
         const metodoInicializacao = metodos.inicializacao;
+        let tamanho = 0;
         if (metodoInicializacao &&
             !Array.isArray(metodoInicializacao) &&
             metodoInicializacao.eInicializador) {
             tamanho = metodoInicializacao.declaracao.parametros.length;
         }
-        return Promise.resolve(tamanho);
+        return tamanho;
     }
-    return Promise.resolve(valorObjeto.length);
+    if (valorResolvido.length === undefined &&
+        typeof valorResolvido === 'object') {
+        if (valorResolvido.hasOwnProperty('elementos')) {
+            return valorResolvido.elementos.length;
+        }
+        return Object.keys(valorResolvido).length;
+    }
+    return valorResolvido.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.
+ * @param {any} valor O valor ou variável a ser convertido em texto.
  * @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 iterável forem truly.
- * @param {InterpretadorInterface} interpretador A instância do interpretador.
- * @param {VariavelInterface | any} iteravel O primeiro parâmetro, qualquer dado que seja iterável (vetores, tuplas, dicionários etc.).
- * @returns {Promise<boolean>} Verdadeiro, se todos os valores do iterável forem Truly.
- */
-async function todos(interpretador, iteravel) {
-    const valorIteravel = interpretador.resolverValor(iteravel);
-    const ehObjetoOuDicionario = valorIteravel && typeof valorIteravel === 'object' && !Array.isArray(valorIteravel);
-    const ehIteravelNativo = valorIteravel && typeof valorIteravel[Symbol.iterator] === 'function';
-    if (!ehIteravelNativo && !ehObjetoOuDicionario) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
-            linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.'));
+async function texto(interpretador, valor) {
+    const valorResolvido = interpretador.resolverValor(valor);
+    if (valorResolvido === null || valorResolvido === undefined) {
+        return 'nulo';
     }
-    const itens = ehIteravelNativo ? valorIteravel : Object.values(valorIteravel);
-    for (const valor of itens) {
-        const valorResolvido = interpretador.resolverValor(valor);
-        if (!interpretador.eVerdadeiro(valorResolvido))
-            return false;
+    if (typeof valorResolvido === 'boolean') {
+        return valorResolvido ? 'verdadeiro' : 'falso';
     }
-    return true;
+    return String(valorResolvido);
 }
 /**
- * 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.
+ * Retorna verdadeiro se todos os elementos do iterável forem verdadeiros (truthy). Caso seja passado uma função como segundo parâmetro, cada elemento do iterável será passado para ela.
  * @param {InterpretadorInterface} interpretador A instância do interpretador.
- * @param {VariavelInterface | any} iteravel O primeiro parâmetro, qualquer dado que seja iterável (vetores, tuplas, dicionários etc.).
- * @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 iterável fazem a função passada
- *                             por parâmetro devolver verdadeiro, ou falso em caso contrário.
+ * @param {any} iteravel Qualquer dado que seja iterável
+ * @param {any} funcaoCondicional A função que será executada com cada valor.
+ * @returns {Promise<boolean>} Verdadeiro, se todos os valores do iterável forem verdadeiros ou se satisfazerem a função condicional.
  */
-async function todos_em_condicao(interpretador, iteravel, funcaoCondicional) {
-    const simboloChamada = {
-        linha: interpretador.linhaDeclaracaoAtual,
-        hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
-    };
-    const valorIteravel = interpretador.resolverValor(iteravel);
-    const ehObjetoOuDicionario = valorIteravel && typeof valorIteravel === 'object' && !Array.isArray(valorIteravel);
-    const ehIteravelNativo = valorIteravel && typeof valorIteravel[Symbol.iterator] === 'function';
-    if (!ehIteravelNativo && !ehObjetoOuDicionario) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+async function todos(interpretador, iteravel, funcaoCondicional) {
+    if (iteravel === null || iteravel === undefined) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
+            linha: interpretador.linhaDeclaracaoAtual,
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O parâmetro da função todos() não pode ser nulo.');
+    }
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0 &&
+        valorIteravel !== '' &&
+        !Array.isArray(valorIteravel) &&
+        !(valorIteravel?.constructor === construtos_1.TuplaN)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.'));
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.');
     }
     const valorFuncao = interpretador.resolverValor(funcaoCondicional);
-    const naoEhUmaFuncao = !(valorFuncao instanceof estruturas_1.DeleguaFuncao || valorFuncao instanceof funcao_padrao_1.FuncaoPadrao);
-    if (!valorFuncao || naoEhUmaFuncao) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
-            linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O segundo parâmetro deve ser uma função.'));
+    if (valorFuncao) {
+        const ehUmaFuncao = valorFuncao instanceof estruturas_1.DeleguaFuncao ||
+            valorFuncao instanceof funcao_padrao_1.FuncaoPadrao;
+        if (!valorFuncao || !ehUmaFuncao) {
+            throw new excecoes_1.ErroEmTempoDeExecucao({
+                linha: interpretador.linhaDeclaracaoAtual,
+                hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            }, 'Parâmetro inválido. O segundo parâmetro deve ser uma função.');
+        }
     }
-    const itens = ehIteravelNativo ? valorIteravel : Object.values(valorIteravel);
-    for (const valor of itens) {
-        const resultadoChamada = await valorFuncao.chamar(interpretador, [valor], simboloChamada);
-        const resultadoResolvido = interpretador.resolverValor(resultadoChamada);
+    for (const item of itens) {
+        let resultado;
+        if (valorFuncao) {
+            const resultadoChamada = await valorFuncao.chamar(interpretador, [item], {
+                linha: interpretador.linhaDeclaracaoAtual,
+                hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            });
+            if (resultadoChamada !== null && resultadoChamada !== undefined) {
+                if (resultadoChamada.hasOwnProperty('valorRetornado')) {
+                    resultado = resultadoChamada.valorRetornado instanceof quebras_1.RetornoQuebra
+                        ? resultadoChamada.valorRetornado.valor
+                        : resultadoChamada.valorRetornado;
+                }
+                else if (resultadoChamada instanceof quebras_1.RetornoQuebra) {
+                    resultado = resultadoChamada.valor;
+                }
+                else {
+                    resultado = resultadoChamada;
+                }
+            }
+        }
+        else {
+            resultado = item;
+        }
+        const resultadoResolvido = interpretador.resolverValor(resultado);
         if (!interpretador.eVerdadeiro(resultadoResolvido))
             return false;
     }
     return true;
 }
 /**
- * Transforma um vetor de elementos em uma tupla de N elementos, sendo N a
- * largura do vetor.
+ * Transforma um iteravel em uma tupla.
  * @param {InterpretadorInterface} interpretador A instância do interpretador.
- * @param {VariavelInterface | any[]} vetor O vetor.
+ * @param {any} iteravel O iterável a ser convertido.
  * @returns A tupla resolvida.
  */
-async function tupla(interpretador, vetor) {
-    const valorVetor = interpretador.resolverValor(vetor);
-    if (!Array.isArray(valorVetor)) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+async function tupla(interpretador, iteravel) {
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0 &&
+        valorIteravel !== '' &&
+        !(valorIteravel instanceof construtos_1.Vetor) &&
+        !Array.isArray(valorIteravel)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Argumento de função nativa `tupla` não parece ser um vetor.'));
+        }, 'O argumento passado para a função `tupla()` deve ser iterável.');
     }
-    const elementos = valorVetor.map((item) => {
+    const itensDaTupla = itens.map(item => {
         const valorResolvido = interpretador.resolverValor(item);
         const literal = new construtos_1.Literal(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, valorResolvido);
         if (typeof valorResolvido === 'string') {
@@ -937,17 +1026,41 @@ async function tupla(interpretador, vetor) {
         }
         return literal;
     });
-    return new construtos_1.TuplaN(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, elementos);
+    return new construtos_1.TuplaN(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, itensDaTupla);
+}
+async function unico(interpretador, iteravel) {
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0 &&
+        valorIteravel !== '' &&
+        !(valorIteravel?.constructor === construtos_1.TuplaN) &&
+        !Array.isArray(valorIteravel)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'O argumento passado para a função `unico()` deve ser iterável.');
+    }
+    return [...new Set(itens)];
 }
-async function vetor(interpretador, tupla) {
-    const objetoTupla = interpretador.resolverValor(tupla);
-    if (!(objetoTupla instanceof construtos_1.TuplaN)) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+;
+/**
+ * Transforma um iteravel em um vetor.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {any} iteravel O iterável a ser convertido.
+ * @returns O vetor resolvido.
+ */
+async function vetor(interpretador, iteravel) {
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const itens = new iteravel_1.Iteravel(valorIteravel).elementos;
+    if (itens.length === 0 &&
+        valorIteravel !== '' &&
+        !(valorIteravel?.constructor === construtos_1.TuplaN) &&
+        !Array.isArray(valorIteravel)) {
+        throw new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Argumento de função nativa `vetor` não parece ser uma tupla.'));
+        }, 'O argumento passado para a função `vetor()` deve ser iterável.');
     }
-    const resultado = objetoTupla.elementos.map((elemento) => interpretador.resolverValor(elemento));
-    return Promise.resolve(resultado);
+    return itens.map(elemento => interpretador.resolverValor(elemento));
 }
 //# sourceMappingURL=biblioteca-global.js.map