@designliquido/delegua 0.57.1 → 0.58.0

package/umd/delegua.js

@@ -293,6 +293,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.primitivasConhecidas = {};
         this.pilhaEscopos = new pilha_escopos_1.PilhaEscopos();
         this.montaoTipos = new montao_tipos_1.MontaoTipos();
+        this.intuirTipoQualquerParaIdentificadores = false;
         (0, comum_1.registrarPrimitiva)(this.primitivasConhecidas, 'dicionário', primitivas_dicionario_1.default);
         (0, comum_1.registrarPrimitiva)(this.primitivasConhecidas, 'número', primitivas_numero_1.default);
         (0, comum_1.registrarPrimitiva)(this.primitivasConhecidas, 'texto', primitivas_texto_1.default);
@@ -443,6 +444,34 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             this.blocos -= 1;
         }
     }
+    /**
+     * Resolve uma lista de compreensão.
+     * @returns {ListaCompreensao} A lista de compreensão resolvida.
+     */
+    resolverCompreensaoDeLista(retornoExpressao) {
+        this.consumir(delegua_2.default.PARA, "Esperado instrução 'para' após identificado.");
+        this.consumir(delegua_2.default.CADA, "Esperado instrução 'cada' após 'para'.");
+        const simboloVariavelIteracao = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado identificador de variável após 'para cada'.");
+        if (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.DE, delegua_2.default.EM)) {
+            throw this.erro(this.simbolos[this.atual], "Esperado palavras reservadas 'em' ou 'de' após variável de iteração em instrução em lista de compreensão.");
+        }
+        const localizacaoVetor = this.simboloAnterior();
+        const vetor = this.ou();
+        this.consumir(delegua_2.default.SE, "Esperado condição 'se' após vetor.");
+        const condicao = this.expressao();
+        this.consumir(delegua_2.default.COLCHETE_DIREITO, 'Espero fechamento de colchetes após condição.');
+        const tipoVetor = vetor.tipo;
+        if (!tipoVetor.endsWith('[]') && !['qualquer', 'vetor'].includes(tipoVetor)) {
+            throw this.erro(localizacaoVetor, `Variável ou constante em 'para cada' não é iterável. Tipo resolvido: ${tipoVetor}.`);
+        }
+        const variavelIteracao = new construtos_1.Variavel(this.hashArquivo, simboloVariavelIteracao);
+        return new construtos_1.ListaCompreensao(Number(this.simbolos[this.atual]), this.hashArquivo, retornoExpressao, vetor, new construtos_1.ParaCadaComoConstruto(retornoExpressao.hashArquivo, retornoExpressao.linha, variavelIteracao, vetor, new declaracoes_1.Bloco(retornoExpressao.hashArquivo, retornoExpressao.linha, [
+            new declaracoes_1.Se(condicao, new declaracoes_1.Bloco(retornoExpressao.hashArquivo, retornoExpressao.linha, [
+                new declaracoes_1.Retorna(simboloVariavelIteracao, retornoExpressao),
+            ]), [], null),
+        ])), 'qualquer[]' // TODO: Talvez um dia inferir o tipo aqui.
+        );
+    }
     primario() {
         const simboloAtual = this.simbolos[this.atual];
         let valores = [];
@@ -458,6 +487,16 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO)) {
                     return this.construtoTupla();
                 }
+                // Ao resolver a expressão aqui, identificadores dentro da expressão de compreensão 
+                // de lista serão tratados como 'qualquer', para evitar erros de tipo.
+                this.intuirTipoQualquerParaIdentificadores = true;
+                const retornoExpressaoOuPrimeiroValor = this.seTernario();
+                this.intuirTipoQualquerParaIdentificadores = false;
+                if (this.simbolos[this.atual].tipo === delegua_2.default.PARA) {
+                    return this.resolverCompreensaoDeLista(retornoExpressaoOuPrimeiroValor);
+                }
+                // Aqui já sabemos que não é uma compreensão de lista.
+                valores.push(retornoExpressaoOuPrimeiroValor);
                 while (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.COLCHETE_DIREITO)) {
                     switch (this.simbolos[this.atual].tipo) {
                         case delegua_2.default.VIRGULA:
@@ -469,7 +508,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                             valores.push(new construtos_1.ComentarioComoConstruto(simboloComentario));
                             break;
                         default:
-                            const valor = this.atribuir();
+                            const valor = this.seTernario();
                             valores.push(valor);
                             break;
                     }
@@ -527,7 +566,14 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             case delegua_2.default.IDENTIFICADOR:
                 const simboloIdentificador = this.avancarEDevolverAnterior();
                 let tipoOperando;
-                if (simboloIdentificador.lexema in this.tiposDefinidosEmCodigo) {
+                if (this.intuirTipoQualquerParaIdentificadores) {
+                    // Esta indicação é utilizada para compreensões de lista, onde o 
+                    // tipo do identificador de iteração é 'qualquer' por definição.
+                    tipoOperando = 'qualquer';
+                    this.pilhaEscopos.definirInformacoesVariavel(simboloIdentificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(simboloIdentificador.lexema, 'qualquer') // TODO: Talvez um dia inferir o tipo aqui.
+                    );
+                }
+                else if (simboloIdentificador.lexema in this.tiposDefinidosEmCodigo) {
                     tipoOperando = simboloIdentificador.lexema;
                 }
                 else {
@@ -663,7 +709,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 const nome = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado nome de método ou propriedade após '.'.");
                 let tipoInferido = expressaoAnterior.tipo;
                 // Se não for um dicionário anônimo (ou seja, ser variável ou constante com nome)
-                if (expressaoAnterior.tipo === 'dicionário' && expressaoAnterior.constructor !== construtos_1.Dicionario) {
+                if (expressaoAnterior.tipo === 'dicionário' &&
+                    expressaoAnterior.constructor !== construtos_1.Dicionario) {
                     // TODO: Achar algum caso em que aqui não seja variável.
                     const nomeDicionario = expressaoAnterior.simbolo.lexema;
                     const elementoDicionarioPilha = this.pilhaEscopos.obterElementoMontaoTipos(nomeDicionario);
@@ -1082,7 +1129,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         const corpo = this.resolverDeclaracao();
         return {
             condicao,
-            corpo
+            corpo,
         };
     }
     declaracaoEnquanto() {
@@ -1187,7 +1234,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         const condicaoEnquanto = this.expressao();
         return {
             caminhoFazer,
-            condicaoEnquanto
+            condicaoEnquanto,
         };
     }
     declaracaoFazer(simboloFazer) {
@@ -1218,7 +1265,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             case delegua_2.default.CHAVE_ESQUERDA:
                 this.avancarEDevolverAnterior();
                 do {
-                    const identificadorImportacao = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado identificador de elemento a ser importado.");
+                    const identificadorImportacao = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado identificador de elemento a ser importado.');
                     elementosImportacao.push(identificadorImportacao);
                 } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
                 this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' após lista de elementos a serem importados.");
@@ -1285,7 +1332,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             nomeVariavelChave,
             nomeVariavelValor,
             dicionario,
-            corpo
+            corpo,
         };
     }
     declaracaoParaCadaDicionario(simboloPara) {
@@ -1309,7 +1356,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             }
         }
         const tipoVetor = vetor.tipo;
-        if (!tipoVetor.endsWith('[]') && !['dicionário', 'qualquer', 'texto', 'vetor'].includes(tipoVetor)) {
+        if (!tipoVetor.endsWith('[]') &&
+            !['dicionário', 'qualquer', 'texto', 'vetor'].includes(tipoVetor)) {
             throw this.erro(simboloPara, `Variável ou constante em 'para cada' não é iterável. Tipo resolvido: ${tipoVetor}.`);
         }
         let tipoVariavelIteracao = 'qualquer';
@@ -1322,7 +1370,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         return {
             variavelIteracao,
             vetor,
-            corpo
+            corpo,
         };
     }
     declaracaoParaCadaVetor(simboloPara) {
@@ -1373,7 +1421,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             inicializador,
             condicao,
             incrementar,
-            corpo
+            corpo,
         };
     }
     declaracaoParaTradicional(simboloPara) {
@@ -1642,11 +1690,14 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                             if (!tipoCorrespondente) {
                                 throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamadaAcessoMetodoOuPropriedade.simbolo, `Tipo '${entidadeChamadaAcessoMetodoOuPropriedade.objeto.tipo}' não foi encontrado entre os tipos definidos por bibliotecas.`);
                             }
-                            if (!(entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema in tipoCorrespondente.metodos) &&
-                                !(entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema in tipoCorrespondente.propriedades)) {
+                            if (!(entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema in
+                                tipoCorrespondente.metodos) &&
+                                !(entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema in
+                                    tipoCorrespondente.propriedades)) {
                                 throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamadaAcessoMetodoOuPropriedade.simbolo, `Membro '${entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema}' não existe no tipo '${entidadeChamadaAcessoMetodoOuPropriedade.objeto.tipo}'.`);
                             }
-                            if (entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema in tipoCorrespondente.metodos) {
+                            if (entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema in
+                                tipoCorrespondente.metodos) {
                                 return tipoCorrespondente.metodos[entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema].tipo;
                             }
                             return tipoCorrespondente.propriedades[entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema].tipo;
@@ -1713,7 +1764,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             for (var i = 0; i < construto.valores.length; i++) {
                 const chaveCorrespondente = this.resolverValorConstruto(construto.chaves[i]);
                 const valorCorrespondente = construto.valores[i];
-                subElementos[chaveCorrespondente] = this.resolverInformacaoElementoSintaticoDeDicionario(valorCorrespondente);
+                subElementos[chaveCorrespondente] =
+                    this.resolverInformacaoElementoSintaticoDeDicionario(valorCorrespondente);
             }
             retorno.subElementos = subElementos;
             const endereco = this.montaoTipos.adicionarReferencia(retorno);
@@ -2066,6 +2118,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoPesquisa', 'função'),
         ]));
+        this.pilhaEscopos.definirInformacoesVariavel('clonar', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('clonar', 'qualquer', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valor', 'qualquer'),
+        ]));
         this.pilhaEscopos.definirInformacoesVariavel('encontrar', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('encontrar', 'qualquer', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoPesquisa', 'função'),
@@ -3182,7 +3237,6 @@ const primitivas_dicionario_1 = __importDefault(require("../../bibliotecas/primi
 const primitivas_numero_1 = __importDefault(require("../../bibliotecas/primitivas-numero"));
 const primitivas_texto_1 = __importDefault(require("../../bibliotecas/primitivas-texto"));
 const primitivas_vetor_1 = __importDefault(require("../../bibliotecas/primitivas-vetor"));
-const lista_compreensao_1 = require("../../construtos/lista-compreensao");
 /**
  * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
  * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
@@ -3409,8 +3463,9 @@ class AvaliadorSintaticoPitugues {
                 if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.COLCHETE_DIREITO)) {
                     return new construtos_1.Vetor(this.hashArquivo, simboloAtual.linha, [], 0, 'qualquer[]');
                 }
-                if (this.simbolos[this.atual].tipo == 'IDENTIFICADOR' && !this.verificarTipoProximoSimbolo(pitugues_2.default.VIRGULA)) {
-                    return this.resolverListaDeCompreensao();
+                if (this.simbolos[this.atual].tipo == 'IDENTIFICADOR' &&
+                    !this.verificarTipoProximoSimbolo(pitugues_2.default.VIRGULA)) {
+                    return this.resolverCompreensaoDeLista();
                 }
                 while (!this.verificarSeSimboloAtualEIgualA(pitugues_2.default.COLCHETE_DIREITO)) {
                     const valor = this.atribuir();
@@ -3617,8 +3672,22 @@ class AvaliadorSintaticoPitugues {
         }
         return expressao;
     }
+    seTernario() {
+        let expressaoEntao = this.ou();
+        if (this.simbolos[this.atual] && this.simbolos[this.atual].tipo === pitugues_2.default.SE && expressaoEntao.linha === this.simbolos[this.atual].linha) {
+            while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.SE)) {
+                const operador = this.simbolos[this.atual - 1];
+                const expressaoOuCondicao = this.seTernario();
+                this.consumir(pitugues_2.default.SENAO, `Esperado 'senão' ou 'senao' após caminho positivo em se ternário. Atual:
+                    ${this.simbolos[this.atual].lexema}.`);
+                const expressaoSenao = this.seTernario();
+                expressaoEntao = new construtos_1.SeTernario(this.hashArquivo, expressaoOuCondicao, expressaoEntao, operador, expressaoSenao);
+            }
+        }
+        return expressaoEntao;
+    }
     atribuir() {
-        const expressao = this.ou();
+        const expressao = this.seTernario();
         if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.IGUAL) ||
             this.verificarSeSimboloAtualEIgualA(pitugues_2.default.MAIS_IGUAL)) {
             const igual = this.simboloAnterior();
@@ -3981,7 +4050,7 @@ class AvaliadorSintaticoPitugues {
      * Resolve uma lista de compreensão.
      * @returns {ListaCompreensao} A lista de compreensão resolvida.
      */
-    resolverListaDeCompreensao() {
+    resolverCompreensaoDeLista() {
         // TODO: Se expressão não começar com um identificador, por exemplo `3 * x`, como faríamos para
         // aceitar o `x` na avaliação da expressão?
         if (this.simbolos[this.atual].tipo === pitugues_2.default.IDENTIFICADOR) {
@@ -3990,7 +4059,8 @@ class AvaliadorSintaticoPitugues {
             this.pilhaEscopos.definirInformacoesVariavel(simboloVariavelIteracao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(simboloVariavelIteracao.lexema, 'qualquer') // TODO: Talvez um dia inferir o tipo aqui.
             );
         }
-        const retornoExpressao = this.expressao();
+        // TODO: Reavaliar a precedência do se ternário.
+        const retornoExpressao = this.ou();
         this.consumir(pitugues_2.default.PARA, "Esperado instrução 'para' após identificado.");
         this.consumir(pitugues_2.default.CADA, "Esperado instrução 'cada' após 'para'.");
         const simboloVariavelIteracao = this.consumir(pitugues_2.default.IDENTIFICADOR, "Esperado identificador de variável após 'para cada'.");
@@ -4005,7 +4075,8 @@ class AvaliadorSintaticoPitugues {
             throw this.erro(this.simbolos[this.atual], "Esperado palavras reservadas 'em' ou 'de' após variável de iteração em instrução em lista de compreensão.");
         }
         const localizacaoVetor = this.simboloAnterior();
-        const vetor = this.expressao();
+        // TODO: Reavaliar a precedência do se ternário.
+        const vetor = this.ou();
         this.consumir(pitugues_2.default.SE, "Esperado condição 'se' após vetor.");
         const condicao = this.expressao();
         this.consumir(pitugues_2.default.COLCHETE_DIREITO, 'Espero fechamento de colchetes após condição.');
@@ -4014,10 +4085,10 @@ class AvaliadorSintaticoPitugues {
             throw this.erro(localizacaoVetor, `Variável ou constante em 'para cada' não é iterável. Tipo resolvido: ${tipoVetor}.`);
         }
         const variavelIteracao = new construtos_1.Variavel(this.hashArquivo, simboloVariavelIteracao);
-        return new lista_compreensao_1.ListaCompreensao(Number(this.simbolos[this.atual]), this.hashArquivo, retornoExpressao, vetor, new construtos_1.ParaCadaComoConstruto(retornoExpressao.hashArquivo, retornoExpressao.linha, variavelIteracao, vetor, new declaracoes_1.Bloco(retornoExpressao.hashArquivo, retornoExpressao.linha, [
+        return new construtos_1.ListaCompreensao(Number(this.simbolos[this.atual]), this.hashArquivo, retornoExpressao, vetor, new construtos_1.ParaCadaComoConstruto(retornoExpressao.hashArquivo, retornoExpressao.linha, variavelIteracao, vetor, new declaracoes_1.Bloco(retornoExpressao.hashArquivo, retornoExpressao.linha, [
             new declaracoes_1.Se(condicao, new declaracoes_1.Bloco(retornoExpressao.hashArquivo, retornoExpressao.linha, [
-                new declaracoes_1.Retorna(simboloVariavelIteracao, retornoExpressao)
-            ]), [], null)
+                new declaracoes_1.Retorna(simboloVariavelIteracao, retornoExpressao),
+            ]), [], null),
         ])), 'qualquer[]' // TODO: Talvez um dia inferir o tipo aqui.
         );
     }
@@ -4241,7 +4312,7 @@ class AvaliadorSintaticoPitugues {
 }
 exports.AvaliadorSintaticoPitugues = AvaliadorSintaticoPitugues;
 
-},{"../../bibliotecas/primitivas-dicionario":21,"../../bibliotecas/primitivas-numero":22,"../../bibliotecas/primitivas-texto":23,"../../bibliotecas/primitivas-vetor":24,"../../construtos":52,"../../construtos/lista-compreensao":55,"../../declaracoes":97,"../../inferenciador":116,"../../informacao-elemento-sintatico":117,"../../lexador":174,"../../tipos-de-dados/dialetos/pitugues":183,"../../tipos-de-simbolos/pitugues":191,"../comum":3,"../erro-avaliador-sintatico":11,"../informacao-escopo":13,"../pilha-escopos":17,"browser-process-hrtime":367}],7:[function(require,module,exports){
+},{"../../bibliotecas/primitivas-dicionario":21,"../../bibliotecas/primitivas-numero":22,"../../bibliotecas/primitivas-texto":23,"../../bibliotecas/primitivas-vetor":24,"../../construtos":52,"../../declaracoes":97,"../../inferenciador":116,"../../informacao-elemento-sintatico":117,"../../lexador":174,"../../tipos-de-dados/dialetos/pitugues":183,"../../tipos-de-simbolos/pitugues":191,"../comum":3,"../erro-avaliador-sintatico":11,"../informacao-escopo":13,"../pilha-escopos":17,"browser-process-hrtime":367}],7:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -5977,6 +6048,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.aleatorio = aleatorio;
 exports.aleatorioEntre = aleatorioEntre;
 exports.algum = algum;
+exports.clonar = clonar;
 exports.encontrar = encontrar;
 exports.encontrarIndice = encontrarIndice;
 exports.encontrarUltimo = encontrarUltimo;
@@ -6083,6 +6155,211 @@ async function algum(interpretador, vetor, funcaoPesquisa) {
     }
     return false;
 }
+/**
+ * Clona profundamente uma variável ou constante em Delégua.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} valor O valor a ser clonado.
+ * @returns {Promise<any>} Uma cópia profunda do valor fornecido.
+ */
+async function clonar(interpretador, valor) {
+    // Resolver o valor caso seja uma VariavelInterface
+    // Verificar se é null/undefined antes de usar hasOwnProperty
+    let valorResolvido;
+    if (valor === null || valor === undefined) {
+        valorResolvido = valor;
+    }
+    else if (typeof valor === 'object' && valor.hasOwnProperty('valor')) {
+        valorResolvido = valor.valor;
+    }
+    else {
+        valorResolvido = valor;
+    }
+    // Map para evitar referências circulares
+    const visitados = new WeakMap();
+    function clonarProfundo(valorAtual) {
+        var _a;
+        // Valores primitivos (null, undefined, number, string, boolean)
+        if (valorAtual === null || valorAtual === undefined) {
+            return valorAtual;
+        }
+        if (typeof valorAtual !== 'object') {
+            return valorAtual;
+        }
+        // Verificar se já visitamos este objeto (evitar referências circulares)
+        if (visitados.has(valorAtual)) {
+            return visitados.get(valorAtual);
+        }
+        // Arrays
+        if (Array.isArray(valorAtual)) {
+            const arrayClonado = [];
+            visitados.set(valorAtual, arrayClonado);
+            for (let i = 0; i < valorAtual.length; i++) {
+                arrayClonado[i] = clonarProfundo(valorAtual[i]);
+            }
+            return arrayClonado;
+        }
+        // Objetos de Delégua - ObjetoDeleguaClasse
+        if (valorAtual instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse) {
+            // Clonar propriedades do objeto
+            const propriedadesClonadas = {};
+            visitados.set(valorAtual, propriedadesClonadas);
+            for (const chave in valorAtual.propriedades) {
+                if (valorAtual.propriedades.hasOwnProperty(chave)) {
+                    propriedadesClonadas[chave] = clonarProfundo(valorAtual.propriedades[chave]);
+                }
+            }
+            // Criar novo objeto com as propriedades clonadas
+            // Nota: A classe em si não é clonada, apenas suas propriedades
+            const objetoClonado = new objeto_delegua_classe_1.ObjetoDeleguaClasse(valorAtual.classe);
+            objetoClonado.propriedades = propriedadesClonadas;
+            return objetoClonado;
+        }
+        // Tuplas
+        const nomeClasseTupla = (_a = valorAtual.constructor) === null || _a === void 0 ? void 0 : _a.name;
+        if (nomeClasseTupla &&
+            /^(Dupla|Trio|Quarteto|Quinteto|Sexteto|Septeto|Octeto|Noneto|Deceto)$/.test(nomeClasseTupla)) {
+            const valoresClonados = [];
+            visitados.set(valorAtual, valoresClonados);
+            // Extrair valores da tupla baseado no tipo
+            let valores = [];
+            switch (nomeClasseTupla) {
+                case 'Dupla':
+                    valores = [valorAtual.primeiro, valorAtual.segundo];
+                    break;
+                case 'Trio':
+                    valores = [valorAtual.primeiro, valorAtual.segundo, valorAtual.terceiro];
+                    break;
+                case 'Quarteto':
+                    valores = [
+                        valorAtual.primeiro,
+                        valorAtual.segundo,
+                        valorAtual.terceiro,
+                        valorAtual.quarto,
+                    ];
+                    break;
+                case 'Quinteto':
+                    valores = [
+                        valorAtual.primeiro,
+                        valorAtual.segundo,
+                        valorAtual.terceiro,
+                        valorAtual.quarto,
+                        valorAtual.quinto,
+                    ];
+                    break;
+                case 'Sexteto':
+                    valores = [
+                        valorAtual.primeiro,
+                        valorAtual.segundo,
+                        valorAtual.terceiro,
+                        valorAtual.quarto,
+                        valorAtual.quinto,
+                        valorAtual.sexto,
+                    ];
+                    break;
+                case 'Septeto':
+                    valores = [
+                        valorAtual.primeiro,
+                        valorAtual.segundo,
+                        valorAtual.terceiro,
+                        valorAtual.quarto,
+                        valorAtual.quinto,
+                        valorAtual.sexto,
+                        valorAtual.setimo,
+                    ];
+                    break;
+                case 'Octeto':
+                    valores = [
+                        valorAtual.primeiro,
+                        valorAtual.segundo,
+                        valorAtual.terceiro,
+                        valorAtual.quarto,
+                        valorAtual.quinto,
+                        valorAtual.sexto,
+                        valorAtual.setimo,
+                        valorAtual.oitavo,
+                    ];
+                    break;
+                case 'Noneto':
+                    valores = [
+                        valorAtual.primeiro,
+                        valorAtual.segundo,
+                        valorAtual.terceiro,
+                        valorAtual.quarto,
+                        valorAtual.quinto,
+                        valorAtual.sexto,
+                        valorAtual.setimo,
+                        valorAtual.oitavo,
+                        valorAtual.nono,
+                    ];
+                    break;
+                case 'Deceto':
+                    valores = [
+                        valorAtual.primeiro,
+                        valorAtual.segundo,
+                        valorAtual.terceiro,
+                        valorAtual.quarto,
+                        valorAtual.quinto,
+                        valorAtual.sexto,
+                        valorAtual.setimo,
+                        valorAtual.oitavo,
+                        valorAtual.nono,
+                        valorAtual.decimo,
+                    ];
+                    break;
+                default:
+                    // Se não conseguir identificar, tentar extrair valores diretamente
+                    if (valorAtual.valor) {
+                        valores = Array.isArray(valorAtual.valor)
+                            ? valorAtual.valor
+                            : [valorAtual.valor];
+                    }
+            }
+            // Clonar valores
+            for (let i = 0; i < valores.length; i++) {
+                valoresClonados.push(clonarProfundo(valores[i]));
+            }
+            // Recriar a tupla com valores clonados
+            switch (nomeClasseTupla) {
+                case 'Dupla':
+                    return new construtos_1.Dupla(valoresClonados[0], valoresClonados[1]);
+                case 'Trio':
+                    return new construtos_1.Trio(valoresClonados[0], valoresClonados[1], valoresClonados[2]);
+                case 'Quarteto':
+                    return new construtos_1.Quarteto(valoresClonados[0], valoresClonados[1], valoresClonados[2], valoresClonados[3]);
+                case 'Quinteto':
+                    return new construtos_1.Quinteto(valoresClonados[0], valoresClonados[1], valoresClonados[2], valoresClonados[3], valoresClonados[4]);
+                case 'Sexteto':
+                    return new construtos_1.Sexteto(valoresClonados[0], valoresClonados[1], valoresClonados[2], valoresClonados[3], valoresClonados[4], valoresClonados[5]);
+                case 'Septeto':
+                    return new construtos_1.Septeto(valoresClonados[0], valoresClonados[1], valoresClonados[2], valoresClonados[3], valoresClonados[4], valoresClonados[5], valoresClonados[6]);
+                case 'Octeto':
+                    return new construtos_1.Octeto(valoresClonados[0], valoresClonados[1], valoresClonados[2], valoresClonados[3], valoresClonados[4], valoresClonados[5], valoresClonados[6], valoresClonados[7]);
+                case 'Noneto':
+                    return new construtos_1.Noneto(valoresClonados[0], valoresClonados[1], valoresClonados[2], valoresClonados[3], valoresClonados[4], valoresClonados[5], valoresClonados[6], valoresClonados[7], valoresClonados[8]);
+                case 'Deceto':
+                    return new construtos_1.Deceto(valoresClonados[0], valoresClonados[1], valoresClonados[2], valoresClonados[3], valoresClonados[4], valoresClonados[5], valoresClonados[6], valoresClonados[7], valoresClonados[8], valoresClonados[9]);
+                default:
+                    // Se não conseguir recriar, retornar os valores clonados como array
+                    return valoresClonados;
+            }
+        }
+        // DeleguaFuncao e FuncaoPadrao - funções não são clonadas profundamente
+        // Elas mantêm referência à mesma definição, mas isso é comportamento esperado
+        if (valorAtual instanceof estruturas_1.DeleguaFuncao || valorAtual instanceof funcao_padrao_1.FuncaoPadrao) {
+            return valorAtual;
+        }
+        // Objetos simples (plain objects)
+        const objetoClonado = {};
+        visitados.set(valorAtual, objetoClonado);
+        for (const chave in valorAtual) {
+            if (valorAtual.hasOwnProperty(chave)) {
+                objetoClonado[chave] = clonarProfundo(valorAtual[chave]);
+            }
+        }
+        return objetoClonado;
+    }
+    return Promise.resolve(clonarProfundo(valorResolvido));
+}
 /**
  * Encontra o primeiro elemento de um vetor cuja função de pesquisa retorne
  * verdadeiro na avaliação de cada elemento.
@@ -7067,7 +7344,7 @@ exports.default = {
         ],
         implementacao: (interpretador, nomePrimitiva, vetor, elemento) => {
             vetor.push(elemento);
-            // TODO: Será que apenas isso é suficiente aqui? 
+            // TODO: Será que apenas isso é suficiente aqui?
             if (nomePrimitiva !== '') {
                 interpretador.pilhaEscoposExecucao.atribuirVariavel({ lexema: nomePrimitiva }, vetor);
             }
@@ -7127,18 +7404,47 @@ exports.default = {
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('excluirQuantidade', 'número'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('itens', 'qualquer[]'),
         ],
-        implementacao: (interpretador, nomePrimitiva, vetor, inicio, excluirQuantidade, ...itens) => {
+        implementacao: (interpretador, nomePrimitiva, vetor, posicaoInicial, quantidadeExclusao, ...itens) => {
             let elementos = [];
-            if (excluirQuantidade || excluirQuantidade === 0) {
+            if (quantidadeExclusao || quantidadeExclusao === 0) {
                 elementos = !itens.length
-                    ? vetor.splice(inicio, excluirQuantidade)
-                    : vetor.splice(inicio, excluirQuantidade, ...itens);
+                    ? vetor.splice(posicaoInicial, quantidadeExclusao)
+                    : vetor.splice(posicaoInicial, quantidadeExclusao, ...itens);
+                if (nomePrimitiva !== '') {
+                    interpretador.pilhaEscoposExecucao.atribuirVariavel({ lexema: nomePrimitiva }, vetor);
+                }
+                return Promise.resolve(elementos);
             }
             else {
-                elementos = !itens.length ? vetor.splice(inicio) : vetor.splice(inicio, ...itens);
+                elementos = !itens.length
+                    ? vetor.splice(posicaoInicial)
+                    : vetor.splice(posicaoInicial, ...itens);
+                if (nomePrimitiva !== '') {
+                    interpretador.pilhaEscoposExecucao.atribuirVariavel({ lexema: nomePrimitiva }, elementos);
+                }
+                return Promise.resolve(vetor);
             }
-            return Promise.resolve(elementos);
         },
+        assinaturaFormato: 'vetor.encaixar(posicaoInicial?: número, quantidadeExclusao?: número, itens?: qualquer[])',
+        documentacao: '# `vetor.encaixar(posicaoInicial, quantidadeExclusao, itens)` \n \n' +
+            'Encaixa um vetor em outro, dadas posições de início e quantidade de ítens a serem excluídos do vetor original. \n' +
+            '\n\n ## Exemplo de Código\n' +
+            '\n\n```delegua\nvar v = [1, 2, 3, 4, 5]\n' +
+            'escreva(v.encaixar()) // "[1, 2, 3, 4, 5]", ou seja, não faz coisa alguma.\n' +
+            `var v1 = v.encaixar(2)\n` +
+            'escreva(v) // "[3, 4, 5]", ou seja, a posição 2, onde fica o 3, passa a ser a nova posição inicial do vetor.\n' +
+            'escreva(v1) // "[1, 2]", ou seja, o retorno de `encaixar()` são as posições removidas do vetor original.\n' +
+            'var v2 = [1, 2, 3, 4, 5]\n' +
+            'escreva(v2.encaixar(2, 1)) // "[3]"\n' +
+            'escreva(v2) // "[1, 2, 4, 5]"\n```' +
+            'var v3 = [1, 2, 3, 4, 5]\n' +
+            'escreva(v3.encaixar(2, 1, "teste")) // "[3]"\n' +
+            'escreva(v3) // "[1, 2, "teste", 4, 5]"\n```' +
+            '\n\n ### Formas de uso \n' +
+            '`encaixar` suporta sobrecarga do método.\n\n',
+        exemploCodigo: 'vetor.encaixar(<nova posição inicial>)\n' +
+            'vetor.encaixar(<a partir desta posição>, <exclua esta quantidade de elementos>)\n' +
+            'vetor.encaixar(<a partir desta posição>, <exclua esta quantidade de elementos>, <adicione estes elementos>)',
     },
     fatiar: {
         tipoRetorno: 'qualquer[]',
@@ -7154,7 +7460,7 @@ exports.default = {
             '\n\n```delegua\nvar v = [1, 2, 3, 4, 5]\n' +
             'escreva(v.fatiar()) // "[1, 2, 3, 4, 5]", ou seja, não faz coisa alguma.\n' +
             'escreva(v.fatiar(2, 4)) // "[3, 4]"\n' +
-            'escreva(v.fatiar(2)) // "[3, 4, 5]", ou seja, seleciona tudo da posição 3 até o final do vetor.\n```' +
+            'escreva(v.fatiar(2)) // "[3, 4, 5]", ou seja, extrai trecho da 3ª posição até o final do vetor.\n```' +
             '\n\n ### Formas de uso \n' +
             'Fatiar suporta sobrecarga do método.\n\n',
         exemploCodigo: 'vetor.fatiar(<a partir desta posição>)\n' +
@@ -7181,8 +7487,7 @@ exports.default = {
         },
         assinaturaFormato: 'vetor.filtrarPor(funcao: função)',
         documentacao: '# `vetor.filtrarPor(funcao)` \n \n' +
-            'Dada uma função passada como parâmetro, executa essa função para cada elemento do vetor. \n' +
-            'Elementos cujo retorno da função é `falso` são excluídos. \n' +
+            'Devolve todos os elementos de um vetor cujo resultado da execução de uma função, passada por parâmetro, seja verdadeiro.\n' +
             '\n\n ### Exemplo de Código\n' +
             '\n\n```delegua\nvar v = [1, 2, 3, 4, 5]\n' +
             'var funcaoNumerosImpares = funcao (n) { retorna n % 2 > 0 }\n' +
@@ -7226,13 +7531,13 @@ exports.default = {
         ],
         implementacao: (interpretador, nomePrimitiva, vetor, separador) => Promise.resolve(vetor.join(separador)),
         assinaturaFormato: 'vetor.juntar(separador: texto)',
-        documentacao: '# `vetor.juntar(separador)` \n \n' +
+        documentacao: '# `vetor.juntar(separador = ",")` \n \n' +
             'Junta todos os elementos de um vetor em um texto, separando cada elemento pelo separador passado como parâmetro.\n' +
             '\n\n ## Exemplo de Código\n' +
             '\n\n```delegua\nvar v = [1, 2, 3]\n' +
             'escreva(v.juntar(":")) // "1:2:3"\n```' +
             '\n\n ### Formas de uso \n',
-        exemploCodigo: 'vetor.juntar()',
+        exemploCodigo: 'vetor.juntar()\n' + 'vetor.juntar(<separador>)',
     },
     mapear: {
         tipoRetorno: 'qualquer[]',
@@ -7251,7 +7556,7 @@ exports.default = {
             return retorno;
         },
         assinaturaFormato: 'vetor.mapear(funcao: função)',
-        documentacao: '# `vetor.mapear(funcao)` \n \n' +
+        documentacao: '# `vetor.mapear(funcao)`\n\n' +
             'Dada uma função passada como parâmetro, executa essa função para cada elemento do vetor. \n' +
             'Cada elemento retornado por esta função é adicionado ao vetor resultante. \n' +
             '\n\n ## Exemplo de Código\n' +
@@ -11025,6 +11330,7 @@ function carregarBibliotecasGlobais(pilhaEscoposExecucao) {
     pilhaEscoposExecucao.definirVariavel('aleatorio', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.aleatorio));
     pilhaEscoposExecucao.definirVariavel('aleatorioEntre', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.aleatorioEntre));
     pilhaEscoposExecucao.definirVariavel('algum', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.algum));
+    pilhaEscoposExecucao.definirVariavel('clonar', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.clonar));
     pilhaEscoposExecucao.definirVariavel('encontrar', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.encontrar));
     pilhaEscoposExecucao.definirVariavel('encontrarIndice', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.encontrarIndice));
     pilhaEscoposExecucao.definirVariavel('encontrarUltimo', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.encontrarUltimo));
@@ -11674,7 +11980,6 @@ const metodo_primitiva_1 = require("./estruturas/metodo-primitiva");
 const lexador_1 = require("../lexador");
 const avaliador_sintatico_1 = require("../avaliador-sintatico");
 const espaco_memoria_1 = require("./espaco-memoria");
-const comum_1 = require("./comum");
 const excecoes_1 = require("../excecoes");
 const primitivas_dicionario_1 = __importDefault(require("../bibliotecas/primitivas-dicionario"));
 const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
@@ -11730,7 +12035,6 @@ class InterpretadorBase {
             emLacoRepeticao: false,
         };
         this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-        (0, comum_1.carregarBibliotecasGlobais)(this.pilhaEscoposExecucao);
     }
     visitarExpressaoSeparador(expressao) {
         throw new Error('Método não implementado.');
@@ -12406,8 +12710,7 @@ class InterpretadorBase {
         // para vetor de duplas.
         // TODO: Converter elementos para `Construto` se necessário.
         if (declaracao.vetorOuDicionario.tipo === 'dicionário') {
-            valorVetorResolvido = Object.entries(valorVetorResolvido)
-                .map(v => new construtos_1.Dupla(v[0], v[1]));
+            valorVetorResolvido = Object.entries(valorVetorResolvido).map((v) => new construtos_1.Dupla(v[0], v[1]));
         }
         if (!Array.isArray(valorVetorResolvido)) {
             return Promise.reject("Variável ou literal provida em instrução 'para cada' não é um vetor.");
@@ -12837,7 +13140,7 @@ class InterpretadorBase {
         const funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, funcao);
         return Promise.resolve({
-            declaracao: funcao
+            declaracao: funcao,
         });
     }
     /**
@@ -13189,7 +13492,7 @@ class InterpretadorBase {
 exports.InterpretadorBase = InterpretadorBase;
 
 }).call(this)}).call(this,require('_process'))
-},{"../avaliador-sintatico":12,"../bibliotecas/primitivas-dicionario":21,"../construtos":52,"../excecoes":110,"../inferenciador":116,"../lexador":174,"../quebras":181,"../tipos-de-dados/delegua":182,"../tipos-de-dados/primitivos":184,"../tipos-de-simbolos/delegua":187,"./comum":142,"./espaco-memoria":143,"./estruturas":150,"./estruturas/metodo-primitiva":151,"./pilha-escopos-execucao":160,"_process":421,"browser-process-hrtime":367}],158:[function(require,module,exports){
+},{"../avaliador-sintatico":12,"../bibliotecas/primitivas-dicionario":21,"../construtos":52,"../excecoes":110,"../inferenciador":116,"../lexador":174,"../quebras":181,"../tipos-de-dados/delegua":182,"../tipos-de-dados/primitivos":184,"../tipos-de-simbolos/delegua":187,"./espaco-memoria":143,"./estruturas":150,"./estruturas/metodo-primitiva":151,"./pilha-escopos-execucao":160,"_process":421,"browser-process-hrtime":367}],158:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -13204,6 +13507,7 @@ const excecoes_1 = require("../excecoes");
 const declaracoes_1 = require("../declaracoes");
 const quebras_1 = require("../quebras");
 const montao_1 = require("./montao");
+const comum_1 = require("./comum");
 const primitivas_dicionario_1 = __importDefault(require("../bibliotecas/primitivas-dicionario"));
 const primitivas_numero_1 = __importDefault(require("../bibliotecas/primitivas-numero"));
 const primitivas_texto_1 = __importDefault(require("../bibliotecas/primitivas-texto"));
@@ -13217,6 +13521,14 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
     constructor(diretorioBase, performance = false, funcaoDeRetorno = null, funcaoDeRetornoMesmaLinha = null) {
         super(diretorioBase, performance, funcaoDeRetorno, funcaoDeRetornoMesmaLinha);
         this.montao = new montao_1.Montao();
+        this.pontoInicializacaoBibliotecasGlobais();
+    }
+    /**
+     * Cada dialeto que deriva deste interpretador conhece este ponto de inicialização.
+     * A partir daqui, cada dialeto pode carregar as bibliotecas globais específicas do seu dialeto.
+     */
+    pontoInicializacaoBibliotecasGlobais() {
+        (0, comum_1.carregarBibliotecasGlobais)(this.pilhaEscoposExecucao);
     }
     resolverReferenciaMontao(referenciaMontao) {
         const valorMontao = this.montao.obterReferencia(this.hashArquivoDeclaracaoAtual, this.linhaDeclaracaoAtual, referenciaMontao.endereco);
@@ -13267,8 +13579,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         }
         if (objeto.valor instanceof estruturas_1.ObjetoPadrao)
             return objeto.valor.paraTexto();
-        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
-            objeto instanceof estruturas_1.DeleguaFuncao)
+        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse || objeto instanceof estruturas_1.DeleguaFuncao)
             return objeto.paraTexto();
         if (objeto instanceof quebras_1.RetornoQuebra) {
             if (typeof objeto.valor === 'boolean')
@@ -13306,7 +13617,8 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                 if (typeof valor === primitivos_1.default.BOOLEANO) {
                     valor = valor ? 'verdadeiro' : 'falso';
                 }
-                if (valor instanceof estruturas_1.ReferenciaMontao || ((valor === null || valor === void 0 ? void 0 : valor.hasOwnProperty) && (valor === null || valor === void 0 ? void 0 : valor.hasOwnProperty('tipo')))) {
+                if (valor instanceof estruturas_1.ReferenciaMontao ||
+                    ((valor === null || valor === void 0 ? void 0 : valor.hasOwnProperty) && (valor === null || valor === void 0 ? void 0 : valor.hasOwnProperty('tipo')))) {
                     valor = this.resolverValor(valor);
                 }
                 objetoEscrita[propriedade] = valor;
@@ -13345,13 +13657,14 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         return Promise.resolve({
             tipo: `função<${funcao.declaracao.tipo || 'qualquer'}>`,
             tipoExplicito: funcao.declaracao.tipoExplicito,
-            declaracao: funcao
+            declaracao: funcao,
         });
     }
     async logicaComumExecucaoEnquanto(enquanto, acumularRetornos) {
         let retornoExecucao;
         const retornos = [];
-        while ((acumularRetornos || !(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra)) &&
+        while ((acumularRetornos ||
+            !(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra)) &&
             this.eVerdadeiro(await this.avaliar(enquanto.condicao))) {
             try {
                 retornoExecucao = await this.executar(enquanto.corpo);
@@ -13359,7 +13672,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                     if (acumularRetornos) {
                         return {
                             valorRetornado: retornos,
-                            tipo: 'vetor'
+                            tipo: 'vetor',
                         };
                     }
                     return null;
@@ -13383,7 +13696,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         if (acumularRetornos) {
             return {
                 valorRetornado: retornos,
-                tipo: 'vetor'
+                tipo: 'vetor',
             };
         }
         return retornoExecucao;
@@ -13401,7 +13714,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                     if (acumularRetornos) {
                         return {
                             valorRetornado: retornos,
-                            tipo: 'vetor'
+                            tipo: 'vetor',
                         };
                     }
                     return null;
@@ -13421,12 +13734,13 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                 });
                 return Promise.reject(erro);
             }
-        } while ((acumularRetornos || !(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra)) &&
+        } while ((acumularRetornos ||
+            !(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra)) &&
             this.eVerdadeiro(await this.avaliar(fazer.condicaoEnquanto)));
         if (acumularRetornos) {
             return {
                 valorRetornado: retornos,
-                tipo: 'vetor'
+                tipo: 'vetor',
             };
         }
     }
@@ -13442,9 +13756,9 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         }
         let retornoExecucao;
         const retornos = [];
-        while (acumularRetornos || !(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra)) {
-            if (para.condicao !== null &&
-                !this.eVerdadeiro(await this.avaliar(para.condicao))) {
+        while (acumularRetornos ||
+            !(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra)) {
+            if (para.condicao !== null && !this.eVerdadeiro(await this.avaliar(para.condicao))) {
                 break;
             }
             retornoExecucao = await this.executar(para.corpo);
@@ -13452,7 +13766,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                 if (acumularRetornos) {
                     return {
                         valorRetornado: retornos,
-                        tipo: 'vetor'
+                        tipo: 'vetor',
                     };
                 }
                 return null;
@@ -13470,7 +13784,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         if (acumularRetornos) {
             return {
                 valorRetornado: retornos,
-                tipo: 'vetor'
+                tipo: 'vetor',
             };
         }
         return retornoExecucao;
@@ -13491,14 +13805,16 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         if (paraCada.vetorOuDicionario.tipo === 'dicionário') {
             valorVetorOuDicionarioResolvido = Object.entries(valorVetorOuDicionarioResolvido).map((v) => new construtos_1.Dupla(v[0], v[1]));
         }
-        if (paraCada.vetorOuDicionario.tipo === 'texto' || typeof valorVetorOuDicionarioResolvido === 'string') {
+        if (paraCada.vetorOuDicionario.tipo === 'texto' ||
+            typeof valorVetorOuDicionarioResolvido === 'string') {
             valorVetorOuDicionarioResolvido = valorVetorOuDicionarioResolvido.split('');
         }
         if (!Array.isArray(valorVetorOuDicionarioResolvido)) {
             return Promise.reject("Variável ou literal provida em instrução 'para cada' não é um vetor.");
         }
         const retornos = [];
-        while ((acumularRetornos || !(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra)) &&
+        while ((acumularRetornos ||
+            !(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra)) &&
             paraCada.posicaoAtual < valorVetorOuDicionarioResolvido.length) {
             try {
                 if (paraCada.variavelIteracao instanceof construtos_1.Variavel) {
@@ -13514,7 +13830,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                     if (acumularRetornos) {
                         return {
                             valorRetornado: retornos,
-                            tipo: 'vetor'
+                            tipo: 'vetor',
                         };
                     }
                     return null;
@@ -13539,7 +13855,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         if (acumularRetornos) {
             return {
                 valorRetornado: retornos,
-                tipo: 'vetor'
+                tipo: 'vetor',
             };
         }
         return retornoExecucao;
@@ -13997,7 +14313,9 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
             return Promise.reject("Variável ou literal provida em instrução 'para cada' não é um vetor.");
         }
         const resultadoCompreensao = await this.avaliar(listaCompreensao.paraCada);
-        const resultadoCompreensaoResolvido = resultadoCompreensao.valorRetornado.filter(r => r !== null).map(r => this.resolverValor(r));
+        const resultadoCompreensaoResolvido = resultadoCompreensao.valorRetornado
+            .filter((r) => r !== null)
+            .map((r) => this.resolverValor(r));
         return resultadoCompreensaoResolvido;
     }
     visitarExpressaoPara(expressao) {
@@ -14132,7 +14450,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                 escopoAnterior.espacoMemoria.valores = Object.assign(escopoAnterior.espacoMemoria.valores, ultimoEscopo.espacoMemoria.valores);
                 escopoAnterior.espacoMemoria.enderecosMontao = new Set([
                     ...escopoAnterior.espacoMemoria.enderecosMontao,
-                    ...ultimoEscopo.espacoMemoria.enderecosMontao
+                    ...ultimoEscopo.espacoMemoria.enderecosMontao,
                 ]);
             }
             else {
@@ -14152,7 +14470,9 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         const resultados = await super.interpretar(declaracoes, manterAmbiente);
         if (resultados.resultado.length > 0) {
             const ultimoResultado = resultados.resultado[resultados.resultado.length - 1];
-            if (ultimoResultado && ultimoResultado.valorRetornado instanceof quebras_1.RetornoQuebra && ultimoResultado.valorRetornado.valor instanceof estruturas_1.ReferenciaMontao) {
+            if (ultimoResultado &&
+                ultimoResultado.valorRetornado instanceof quebras_1.RetornoQuebra &&
+                ultimoResultado.valorRetornado.valor instanceof estruturas_1.ReferenciaMontao) {
                 const ultimaDeclaracao = declaracoes[declaracoes.length - 1];
                 ultimoResultado.valorRetornado.valor = this.montao.obterReferencia(ultimaDeclaracao.hashArquivo, ultimaDeclaracao.linha, ultimoResultado.valorRetornado.valor.endereco);
             }
@@ -14162,7 +14482,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
 }
 exports.Interpretador = Interpretador;
 
-},{"../bibliotecas/primitivas-dicionario":21,"../bibliotecas/primitivas-numero":22,"../bibliotecas/primitivas-texto":23,"../bibliotecas/primitivas-vetor":24,"../construtos":52,"../declaracoes":97,"../excecoes":110,"../inferenciador":116,"../quebras":181,"../tipos-de-dados/delegua":182,"../tipos-de-dados/primitivos":184,"./estruturas":150,"./interpretador-base":157,"./montao":159}],159:[function(require,module,exports){
+},{"../bibliotecas/primitivas-dicionario":21,"../bibliotecas/primitivas-numero":22,"../bibliotecas/primitivas-texto":23,"../bibliotecas/primitivas-vetor":24,"../construtos":52,"../declaracoes":97,"../excecoes":110,"../inferenciador":116,"../quebras":181,"../tipos-de-dados/delegua":182,"../tipos-de-dados/primitivos":184,"./comum":142,"./estruturas":150,"./interpretador-base":157,"./montao":159}],159:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Montao = void 0;
@@ -16342,13 +16662,14 @@ exports.palavrasReservadas = {
     nulo: pitugues_1.default.NULO,
     ou: pitugues_1.default.OU,
     padrao: pitugues_1.default.PADRAO,
+    padrão: pitugues_1.default.PADRAO,
     para: pitugues_1.default.PARA,
     pegue: pitugues_1.default.PEGUE,
     quebrar: pitugues_1.default.QUEBRAR,
     retorna: pitugues_1.default.RETORNA,
     se: pitugues_1.default.SE,
     senao: pitugues_1.default.SENAO,
-    senão: pitugues_1.default.SENÃO,
+    senão: pitugues_1.default.SENAO,
     super: pitugues_1.default.SUPER,
     sustar: pitugues_1.default.SUSTAR,
     tendo: pitugues_1.default.TENDO,