@designliquido/delegua 1.18.2 → 1.18.4

package/umd/delegua.js

@@ -642,13 +642,47 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
     visitarChamadaPorVariavel(entidadeChamadaVariavel, argumentos) {
         const variavel = entidadeChamadaVariavel;
         const nomeFuncao = variavel.simbolo.lexema;
-        const funcoesNativas = ['inteiro', 'real', 'numero', 'número', 'texto', 'leia', 'escreva', 'tipo'];
+        const funcoesNativas = [
+            'aleatorio',
+            'aleatorioEntre',
+            'algum',
+            'arredondar',
+            'clonar',
+            'encontrar',
+            'encontrarIndice',
+            'encontrarUltimo',
+            'encontrarUltimoIndice',
+            'escreva',
+            'filtrarPor',
+            'incluido',
+            'inteiro',
+            'intervalo',
+            'leia',
+            'longo',
+            'mapear',
+            'maximo',
+            'minimo',
+            'numero',
+            'número',
+            'ordenar',
+            'paraCada',
+            'primeiroEmCondicao',
+            'real',
+            'reduzir',
+            'somar',
+            'tamanho',
+            'texto',
+            'tipo',
+            'todos',
+            'todosEmCondicao',
+            'tupla',
+            'vetor',
+        ];
         const pareceSerClasse = nomeFuncao[0] === nomeFuncao[0].toUpperCase();
         if (funcoesNativas.includes(nomeFuncao) || pareceSerClasse) {
             return Promise.resolve();
         }
-        const funcaoChamada = this.gerenciadorEscopos.buscar(nomeFuncao) ||
-            this.funcoes[nomeFuncao];
+        const funcaoChamada = this.gerenciadorEscopos.buscar(nomeFuncao) || this.funcoes[nomeFuncao];
         if (!funcaoChamada) {
             this.erro(entidadeChamadaVariavel.simbolo, `Chamada da função '${nomeFuncao}' não existe.`);
             return Promise.resolve();
@@ -819,11 +853,15 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         }
         return Promise.resolve();
     }
-    visitarDeclaracaoEscolha(declaracao) {
+    async visitarDeclaracaoEscolha(declaracao) {
         const identificadorOuLiteral = declaracao.identificadorOuLiteral;
         const tipo = identificadorOuLiteral.tipo || 'qualquer';
         const tiposLiteraisCasos = [];
+        this.marcarVariaveisUsadasEmExpressao(identificadorOuLiteral);
         for (let caminho of declaracao.caminhos) {
+            for (const declaracao of caminho.declaracoes) {
+                await declaracao.aceitar(this);
+            }
             for (let condicao of caminho.condicoes) {
                 switch (condicao.constructor) {
                     case construtos_1.Literal:
@@ -831,7 +869,9 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                         const tiposNumericos = ['inteiro', 'número', 'real'];
                         const ambosSaoNumericos = tiposNumericos.includes(condicaoLiteral.tipo) &&
                             tiposNumericos.includes(tipo);
-                        if (condicaoLiteral.tipo !== tipo && !ambosSaoNumericos && tipo !== 'qualquer') {
+                        if (condicaoLiteral.tipo !== tipo &&
+                            !ambosSaoNumericos &&
+                            tipo !== 'qualquer') {
                             this.erro({
                                 lexema: condicaoLiteral.valor,
                                 tipo: condicaoLiteral.tipo,
@@ -852,23 +892,32 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                 }
             }
         }
-        if (tipo === 'qualquer' && tiposLiteraisCasos.length > 0 && identificadorOuLiteral instanceof construtos_1.Variavel) {
+        if (tipo === 'qualquer' &&
+            tiposLiteraisCasos.length > 0 &&
+            identificadorOuLiteral instanceof construtos_1.Variavel) {
             const tiposUnicos = [...new Set(tiposLiteraisCasos)];
             if (tiposUnicos.length === 1) {
                 const tipoInferido = tiposUnicos[0];
                 const variavelEscopo = this.gerenciadorEscopos.buscar(identificadorOuLiteral.simbolo.lexema);
                 if (variavelEscopo) {
-                    this.sugestao(identificadorOuLiteral.simbolo, `Um tipo melhor pode ser inferido para '${identificadorOuLiteral.simbolo.lexema}': '${tipoInferido}'`, [{
+                    this.sugestao(identificadorOuLiteral.simbolo, `Um tipo melhor pode ser inferido para '${identificadorOuLiteral.simbolo.lexema}': '${tipoInferido}'`, [
+                        {
                             titulo: `Alterar tipo de '${identificadorOuLiteral.simbolo.lexema}' para '${tipoInferido}'`,
                             textoOriginal: 'qualquer',
                             textoSubstituto: tipoInferido,
                             linha: variavelEscopo.linha,
                             colunaInicio: 0,
                             colunaFim: 0,
-                        }]);
+                        },
+                    ]);
                 }
             }
         }
+        if (declaracao.caminhoPadrao) {
+            for (const decl of declaracao.caminhoPadrao.declaracoes) {
+                await decl.aceitar(this);
+            }
+        }
         return Promise.resolve();
     }
     async visitarDeclaracaoEnquanto(declaracao) {
@@ -921,9 +970,48 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         }
         return Promise.resolve();
     }
-    visitarDeclaracaoParaCada(declaracao) {
-        // Marca o vetor/dicionário como usado
+    async visitarDeclaracaoParaCada(declaracao) {
         this.marcarVariaveisUsadasEmExpressao(declaracao.vetorOuDicionario);
+        this.gerenciadorEscopos.empilharEscopo();
+        try {
+            if (declaracao.variavelIteracao instanceof construtos_1.Variavel) {
+                const nome = declaracao.variavelIteracao.simbolo.lexema;
+                this.gerenciadorEscopos.declarar(nome, {
+                    nome,
+                    tipo: 'qualquer',
+                    imutavel: false,
+                    valor: null,
+                    inicializada: true,
+                    usada: false,
+                    hashArquivo: declaracao.hashArquivo,
+                    linha: declaracao.linha,
+                });
+            }
+            else if (declaracao.variavelIteracao instanceof construtos_1.Dupla) {
+                const dupla = declaracao.variavelIteracao;
+                for (const parte of [dupla.primeiro, dupla.segundo]) {
+                    if (parte instanceof construtos_1.Variavel) {
+                        const nome = parte.simbolo.lexema;
+                        this.gerenciadorEscopos.declarar(nome, {
+                            nome,
+                            tipo: 'qualquer',
+                            imutavel: false,
+                            valor: null,
+                            inicializada: true,
+                            usada: false,
+                            hashArquivo: declaracao.hashArquivo,
+                            linha: declaracao.linha,
+                        });
+                    }
+                }
+            }
+            if (declaracao.corpo) {
+                await declaracao.corpo.aceitar(this);
+            }
+        }
+        finally {
+            this.gerenciadorEscopos.desempilharEscopo();
+        }
         return Promise.resolve();
     }
     async visitarDeclaracaoSe(declaracao) {
@@ -1202,14 +1290,40 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                 const nomeFuncao = entidadeChamadaVariavel.simbolo.lexema;
                 // Lista de funções embutidas que não precisam ser declaradas
                 const funcoesEmbutidas = [
+                    'aleatorio',
+                    'aleatorioEntre',
+                    'algum',
+                    'arredondar',
+                    'clonar',
+                    'encontrar',
+                    'encontrarIndice',
+                    'encontrarUltimo',
+                    'encontrarUltimoIndice',
+                    'escreva',
+                    'filtrarPor',
+                    'incluido',
                     'inteiro',
-                    'real',
+                    'intervalo',
+                    'leia',
+                    'longo',
+                    'mapear',
+                    'maximo',
+                    'minimo',
                     'numero',
                     'número',
+                    'ordenar',
+                    'paraCada',
+                    'primeiroEmCondicao',
+                    'real',
+                    'reduzir',
+                    'somar',
+                    'tamanho',
                     'texto',
-                    'leia',
-                    'escreva',
                     'tipo',
+                    'todos',
+                    'todosEmCondicao',
+                    'tupla',
+                    'vetor',
                 ];
                 // Classes/construtores geralmente começam com letra maiúscula
                 const pareceSerClasse = nomeFuncao[0] === nomeFuncao[0].toUpperCase();
@@ -1435,6 +1549,9 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         return Promise.resolve();
     }
     visitarExpressaoRetornar(declaracao) {
+        if (declaracao.valor) {
+            this.marcarVariaveisUsadasEmExpressao(declaracao.valor);
+        }
         return Promise.resolve(undefined);
     }
     visitarExpressaoDeVariavel(expressao) {
@@ -1517,7 +1634,8 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
             if (nomeSuperclasse === declaracao.simbolo.lexema) {
                 this.erro(superClasseVariavel.simbolo, `A classe '${declaracao.simbolo.lexema}' não pode herdar de si mesma.`);
             }
-            else if (!this.classesDeclaradas.has(nomeSuperclasse) && !this.classesExternasConhecidas.has(nomeSuperclasse)) {
+            else if (!this.classesDeclaradas.has(nomeSuperclasse) &&
+                !this.classesExternasConhecidas.has(nomeSuperclasse)) {
                 this.erro(superClasseVariavel.simbolo, `Superclasse '${nomeSuperclasse}' não foi declarada.`);
             }
         }
@@ -1554,8 +1672,26 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                     metodo.funcao.corpo.length === 0) {
                     this.aviso(metodo.simbolo, `Método especifica tipo de retorno '${tipoRetornoMetodo}', mas não há qualquer retorno correspondente no corpo do método.`);
                 }
-                for (const stmt of metodo.funcao.corpo) {
-                    await stmt.aceitar(this);
+                this.gerenciadorEscopos.empilharEscopo();
+                try {
+                    for (const parametro of metodo.funcao.parametros) {
+                        this.gerenciadorEscopos.declarar(parametro.nome.lexema, {
+                            nome: parametro.nome.lexema,
+                            tipo: parametro.tipoDado || 'qualquer',
+                            imutavel: false,
+                            valor: undefined,
+                            inicializada: true,
+                            usada: true,
+                            hashArquivo: parametro.nome.hashArquivo,
+                            linha: parametro.nome.linha,
+                        });
+                    }
+                    for (const declaracao of metodo.funcao.corpo) {
+                        await declaracao.aceitar(this);
+                    }
+                }
+                finally {
+                    this.gerenciadorEscopos.desempilharEscopo();
                 }
             }
         }
@@ -2676,7 +2812,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                                 construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaVetorSelecionada.tipoRetorno);
                                 break;
                             default:
-                                if (construtoTipado.tipo && construtoTipado.tipo in this.tiposDefinidosEmCodigo) {
+                                if (construtoTipado.tipo &&
+                                    construtoTipado.tipo in this.tiposDefinidosEmCodigo) {
                                     const tipoCorrespondente = this.tiposDefinidosEmCodigo[construtoTipado.tipo];
                                     const possivelMetodo = tipoCorrespondente.metodos.filter((m) => m.simbolo.lexema === construtoTipado.simbolo.lexema);
                                     if (possivelMetodo.length > 0) {
@@ -3407,7 +3544,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                     this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
                     const declaracoes = [];
                     do {
-                        declaracoes.push(await this.resolverDeclaracao());
+                        declaracoes.push((await this.resolverDeclaracao()));
                     } while (!this.verificarTipoSimboloAtual(delegua_2.default.CASO) &&
                         !this.verificarTipoSimboloAtual(delegua_2.default.PADRAO) &&
                         !this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA));
@@ -3480,7 +3617,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         const simboloNao = new simbolo_1.Simbolo(delegua_2.default.NEGACAO, 'nao', null, Number(simboloAssercao.linha), simboloAssercao.hashArquivo, simboloAssercao.colunaInicio, simboloAssercao.colunaFim);
         const condicaoNegada = new construtos_1.Unario(simboloAssercao.hashArquivo, simboloNao, condicao, 'ANTES');
         const declaracaoFalhar = new declaracoes_1.Falhar(simboloAssercao, mensagemFalha);
-        const blocoFalha = new declaracoes_1.Bloco(simboloAssercao.hashArquivo, Number(simboloAssercao.linha), [declaracaoFalhar]);
+        const blocoFalha = new declaracoes_1.Bloco(simboloAssercao.hashArquivo, Number(simboloAssercao.linha), [
+            declaracaoFalhar,
+        ]);
         return new declaracoes_1.Se(condicaoNegada, blocoFalha);
     }
     async logicaComumFazer() {
@@ -3540,7 +3679,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 construtoCaminhoModulo = new construtos_1.Literal(identificadorModulo.hashArquivo, Number(identificadorModulo.linha), identificadorModulo.lexema);
                 break;
             default:
-                throw this.erro(this.simbolos[this.atual], "Esperado caminho do módulo como texto ou identificador em declaração de importação.");
+                throw this.erro(this.simbolos[this.atual], 'Esperado caminho do módulo como texto ou identificador em declaração de importação.');
         }
         const importar = new declaracoes_1.Importar(construtoCaminhoModulo);
         if (identificadorDeTudo !== null) {
@@ -3713,7 +3852,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         const caminhoEntao = (await this.resolverDeclaracao());
         let caminhoSenao = undefined;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.SENAO, delegua_2.default.SENÃO)) {
-            caminhoSenao = await this.resolverDeclaracao();
+            caminhoSenao = (await this.resolverDeclaracao());
         }
         return new declaracoes_1.Se(condicao, caminhoEntao, [], caminhoSenao);
     }
@@ -3848,11 +3987,11 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 const classeDefinida = this.tiposDefinidosEmCodigo[tipoObjeto];
                 if (classeDefinida instanceof declaracoes_1.Classe) {
                     const nomeMembro = entidadeChamada.simbolo.lexema;
-                    const metodo = classeDefinida.metodos?.find(m => m.simbolo.lexema === nomeMembro);
+                    const metodo = classeDefinida.metodos?.find((m) => m.simbolo.lexema === nomeMembro);
                     if (metodo) {
                         return metodo.tipo || 'qualquer';
                     }
-                    const propriedade = classeDefinida.propriedades?.find(p => p.nome.lexema === nomeMembro);
+                    const propriedade = classeDefinida.propriedades?.find((p) => p.nome.lexema === nomeMembro);
                     if (propriedade) {
                         return propriedade.tipo || 'qualquer';
                     }
@@ -3874,6 +4013,17 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             const propriedadeCorrespondente = tipoCorrespondente.propriedades[entidadeChamada.simbolo.lexema];
             return propriedadeCorrespondente.tipo;
         }
+        // Chamada via 'isto': verificar métodos da classe em análise antes de checar primitivas.
+        if (entidadeChamada.objeto instanceof construtos_1.Isto) {
+            if (this.metodosClasseAtualEmAnalise) {
+                const nomeMembro = entidadeChamada.simbolo.lexema;
+                const metodo = this.metodosClasseAtualEmAnalise.find((m) => m.simbolo.lexema === nomeMembro);
+                if (metodo) {
+                    return metodo.tipo || 'qualquer';
+                }
+            }
+            return 'qualquer';
+        }
         // Este caso ocorre quando a variável/constante é do tipo 'qualquer',
         // e a chamada normalmente é feita para uma primitiva.
         // A inferência, portanto, ocorre pelo uso da primitiva.
@@ -4016,7 +4166,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         for (let [indice, identificador] of identificadores.entries()) {
             const tipoOriginal = tipo; // Preserva o tipo antes da inferência
-            tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(inicializadores[indice], tipo) ?? tipo;
+            tipo =
+                this.logicaComumInferenciaTiposVariaveisEConstantes(inicializadores[indice], tipo) ?? tipo;
             if (tipo !== 'dicionário') {
                 this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, tipo));
             }
@@ -4084,7 +4235,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         let retorno = [];
         for (let [indice, identificador] of identificadores.entries()) {
             // Se tipo ainda não foi definido, infere.
-            tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(inicializadores[indice], tipo) ?? tipo;
+            tipo =
+                this.logicaComumInferenciaTiposVariaveisEConstantes(inicializadores[indice], tipo) ?? tipo;
             if (tipo !== 'dicionário') {
                 this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, tipo));
             }
@@ -4383,7 +4535,21 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                     }
                     this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros do operador.");
                     this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do corpo do operador.");
-                    const corpoOp = await this.blocoEscopo();
+                    const indiceAberturaCorpoOp = this.atual - 1;
+                    const quantidadeErrosAntesCorpoOp = this.erros.length;
+                    let corpoOp = [];
+                    try {
+                        corpoOp = await this.blocoEscopo();
+                    }
+                    catch (erro) {
+                        this.erros.push(erro);
+                    }
+                    if (this.erros.length > quantidadeErrosAntesCorpoOp) {
+                        this.atual =
+                            this.encontrarIndiceAposFechamentoDeBloco(indiceAberturaCorpoOp);
+                        corpoOp = [];
+                        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
+                    }
                     const corpoFuncaoOp = new construtos_1.FuncaoConstruto(this.hashArquivo, simboloNomeMetodo.linha, paramsOp, corpoOp);
                     const metodoOp = new declaracoes_1.FuncaoDeclaracao(simboloNomeMetodo, corpoFuncaoOp);
                     metodoOp.estatico = ehEstatico;
@@ -4418,7 +4584,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                         // Método de classe estrangeira não pode ter corpo.
                         if (ehEstrangeira &&
                             this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_ESQUERDA)) {
-                            throw this.erro(this.simbolos[this.atual], "Métodos de classe estrangeira não podem ter corpo.");
+                            throw this.erro(this.simbolos[this.atual], 'Métodos de classe estrangeira não podem ter corpo.');
                         }
                         // Método é abstrato quando: (a) está dentro de um bloco `abstrato {}`,
                         // ou (b) a classe é abstrata/estrangeira e o próximo token não é `{`.
@@ -4441,7 +4607,21 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                             // Método concreto: com corpo.
                             // Inferência de tipo de retorno igual a corpoDaFuncao().
                             this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do corpo do método.");
-                            const corpo = await this.blocoEscopo();
+                            const indiceAberturaCorpo = this.atual - 1;
+                            const quantidadeErrosAntesCorpo = this.erros.length;
+                            let corpo = [];
+                            try {
+                                corpo = await this.blocoEscopo();
+                            }
+                            catch (erro) {
+                                this.erros.push(erro);
+                            }
+                            if (this.erros.length > quantidadeErrosAntesCorpo) {
+                                this.atual =
+                                    this.encontrarIndiceAposFechamentoDeBloco(indiceAberturaCorpo);
+                                corpo = [];
+                                this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
+                            }
                             let expressoesRetorna = [];
                             for (const declaracao of corpo) {
                                 expressoesRetorna = expressoesRetorna.concat((0, comum_1.buscarRetornos)(declaracao));
@@ -4507,7 +4687,20 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                                         }
                                         this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros do acessor.");
                                         this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do corpo do acessor.");
-                                        const corpoAcessor = await this.blocoEscopo();
+                                        const indiceAberturaCorpoAcessor = this.atual - 1;
+                                        const quantidadeErrosAntesCorpoAcessor = this.erros.length;
+                                        let corpoAcessor = [];
+                                        try {
+                                            corpoAcessor = await this.blocoEscopo();
+                                        }
+                                        catch (erro) {
+                                            this.erros.push(erro);
+                                        }
+                                        if (this.erros.length > quantidadeErrosAntesCorpoAcessor) {
+                                            this.atual = this.encontrarIndiceAposFechamentoDeBloco(indiceAberturaCorpoAcessor);
+                                            corpoAcessor = [];
+                                            this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
+                                        }
                                         // Inferência de tipo de retorno
                                         let tipoAcessor = 'qualquer';
                                         let expressoesRetornaAcessor = [];
@@ -4572,6 +4765,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 }
             }
         };
+        this.metodosClasseAtualEmAnalise = metodos;
         await compreenderMembros('publico', false);
         this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
         // Verificação em tempo de análise: classe deve implementar todos os contratos das interfaces.
@@ -4630,6 +4824,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasses, metodos, propriedades, pilhaDecoradoresClasse, ehAbstrata, ehEstrangeira, ehEstatica, implementaInterfaces, mesclas);
         this.tiposDefinidosEmCodigo[definicaoClasse.simbolo.lexema] = definicaoClasse;
         this.superclasseAtual = undefined;
+        this.metodosClasseAtualEmAnalise = undefined;
         return definicaoClasse;
     }
     /**
@@ -4777,6 +4972,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
      * @returns Sempre retorna `void`.
      */
     sincronizar() {
+        if (this.estaNoFinal()) {
+            return;
+        }
         this.avancarEDevolverAnterior(); // avança além do token com erro
         while (!this.estaNoFinal()) {
             // Um ponto-e-vírgula já consumido indica fronteira limpa entre declarações.
@@ -4800,6 +4998,21 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             this.avancarEDevolverAnterior();
         }
     }
+    encontrarIndiceAposFechamentoDeBloco(indiceAbertura) {
+        let aberturasPendentes = 1;
+        for (let indice = indiceAbertura + 1; indice < this.simbolos.length; indice++) {
+            if (this.simbolos[indice].tipo === delegua_2.default.CHAVE_ESQUERDA) {
+                aberturasPendentes++;
+            }
+            else if (this.simbolos[indice].tipo === delegua_2.default.CHAVE_DIREITA) {
+                aberturasPendentes--;
+                if (aberturasPendentes === 0) {
+                    return indice + 1;
+                }
+            }
+        }
+        return this.simbolos.length;
+    }
     /**
      * Todas as resoluções triviais da linguagem, ou seja, todas as
      * resoluções que podem ocorrer dentro ou fora de um bloco.
@@ -6329,9 +6542,7 @@ class AvaliadorSintaticoPitugues {
             }
             // Modo formatação: {expressao:formato}
             if (mioloLimpo.includes(':')) {
-                const [variavel, formato] = mioloLimpo
-                    .split(':')
-                    .map(s => s.trim());
+                const [variavel, formato] = mioloLimpo.split(':').map((s) => s.trim());
                 if (variavel) {
                     return `" + "{:${formato}}".formatar(${variavel}) + "`;
                 }
@@ -6455,8 +6666,7 @@ class AvaliadorSintaticoPitugues {
             case pitugues_2.default.INTERPOLACAO:
                 const simboloInterpolacao = this.avancarEDevolverAnterior();
                 const conteudoOriginal = simboloInterpolacao.literal;
-                const codigoTransformado = this
-                    .transformarInterpolacaoEmFormatacao(conteudoOriginal);
+                const codigoTransformado = this.transformarInterpolacaoEmFormatacao(conteudoOriginal);
                 const microLexador = new micro_lexador_pitugues_1.MicroLexadorPitugues();
                 const retornoMicroLexador = microLexador.mapear(codigoTransformado);
                 const microAvaliadorSintatico = new micro_avaliador_sintatico_pitugues_1.MicroAvaliadorSintaticoPitugues();
@@ -6669,7 +6879,7 @@ class AvaliadorSintaticoPitugues {
             while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.SE)) {
                 const operador = this.simbolos[this.atual - 1];
                 const expressaoOuCondicao = await this.seTernario();
-                this.consumir(pitugues_2.default.SENAO, `Esperado 'senão' ou 'senao' após caminho positivo em se ternário. Atual:
+                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 = await this.seTernario();
                 expressaoEntao = new construtos_1.SeTernario(this.hashArquivo, expressaoOuCondicao, expressaoEntao, operador, expressaoSenao);
@@ -7981,7 +8191,10 @@ class AvaliadorSintaticoPortugolIpt extends avaliador_sintatico_base_1.Avaliador
             else if (this.verificarSeSimboloAtualEIgualA(portugol_ipt_1.default.DEFEITO)) {
                 this.consumir(portugol_ipt_1.default.DOIS_PONTOS, "Esperado ':' após 'defeito'.");
                 this.consumirQuebrasLinha();
-                const bloco = await this.resolverBloco([portugol_ipt_1.default.FIMESCOLHE, portugol_ipt_1.default.FIM]);
+                const bloco = await this.resolverBloco([
+                    portugol_ipt_1.default.FIMESCOLHE,
+                    portugol_ipt_1.default.FIM,
+                ]);
                 caminhoPadrao = { condicoes: [], declaracoes: bloco.declaracoes };
             }
             else {
@@ -8710,11 +8923,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         const simboloTente = this.simboloAnterior();
         const blocoTente = [];
         while (!this.estaNoFinal() &&
-            ![
-                prisma_1.default.PEGUE,
-                prisma_1.default.FINALMENTE,
-                prisma_1.default.FIM,
-            ].includes(this.simbolos[this.atual].tipo)) {
+            ![prisma_1.default.PEGUE, prisma_1.default.FINALMENTE, prisma_1.default.FIM].includes(this.simbolos[this.atual].tipo)) {
             blocoTente.push(await this.resolverDeclaracaoForaDeBloco());
         }
         let blocoPegue = null;
@@ -8982,7 +9191,8 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
         this.consumir(prisma_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do corpo do método.");
         const declaracoesCorpo = [];
-        while (!this.estaNoFinal() && !this.verificarTipoSimboloAtual(prisma_1.default.CHAVE_DIREITA)) {
+        while (!this.estaNoFinal() &&
+            !this.verificarTipoSimboloAtual(prisma_1.default.CHAVE_DIREITA)) {
             declaracoesCorpo.push(await this.resolverDeclaracaoForaDeBloco());
         }
         this.consumir(prisma_1.default.CHAVE_DIREITA, "Esperado '}' após o corpo do método.");
@@ -19332,7 +19542,7 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
         this.eInicializador = eInicializador;
     }
     aridade() {
-        return this.declaracao?.parametros?.filter(p => p.abrangencia !== 'multiplo').length || 0;
+        return this.declaracao?.parametros?.filter((p) => p.abrangencia !== 'multiplo').length || 0;
     }
     /**
      * Método utilizado por Delégua para representar esta função quando impressa.
@@ -20752,7 +20962,8 @@ class InterpretadorBase {
         ];
         const valores = [];
         for (let propriedade of propriedadesValidas) {
-            if (expressao.hasOwnProperty(propriedade) && expressao[propriedade] !== undefined) {
+            if (expressao.hasOwnProperty(propriedade) &&
+                expressao[propriedade] !== undefined) {
                 const valor = await this.avaliar(expressao[propriedade]);
                 valores.push(valor);
             }
@@ -21101,7 +21312,9 @@ class InterpretadorBase {
                         valor: valorDireito,
                         imutavel: false,
                     };
-                return await metodoASerChamado.chamar(this, [{ nome: null, valor: argumentoOperador }]);
+                return await metodoASerChamado.chamar(this, [
+                    { nome: null, valor: argumentoOperador },
+                ]);
             }
         }
         const tipoEsquerdo = esquerda?.hasOwnProperty('tipo')
@@ -21115,7 +21328,8 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    return this.converterParaBigInt(valorEsquerdo) ** this.converterParaBigInt(valorDireito);
+                    return (this.converterParaBigInt(valorEsquerdo) **
+                        this.converterParaBigInt(valorDireito));
                 }
                 const resultadoExponenciacao = Math.pow(valorEsquerdo, valorDireito);
                 return resultadoExponenciacao;
@@ -21142,7 +21356,8 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    return this.converterParaBigInt(valorEsquerdo) - this.converterParaBigInt(valorDireito);
+                    return (this.converterParaBigInt(valorEsquerdo) -
+                        this.converterParaBigInt(valorDireito));
                 }
                 return Number(valorEsquerdo) - Number(valorDireito);
             case delegua_1.default.ADICAO:
@@ -21177,8 +21392,10 @@ class InterpretadorBase {
                 }
                 // TODO: Se tipo for 'qualquer', seria uma boa confiar nos operadores
                 // tradicionais do JavaScript?
-                if (tipoEsquerdo === 'qualquer' || tipoDireito === 'qualquer' ||
-                    tipoEsquerdo === 'nulo' || tipoDireito === 'nulo') {
+                if (tipoEsquerdo === 'qualquer' ||
+                    tipoDireito === 'qualquer' ||
+                    tipoEsquerdo === 'nulo' ||
+                    tipoDireito === 'nulo') {
                     return valorEsquerdo + valorDireito;
                 }
                 return this.paraTexto(valorEsquerdo) + this.paraTexto(valorDireito);
@@ -21267,7 +21484,8 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    return this.converterParaBigInt(valorEsquerdo) & this.converterParaBigInt(valorDireito);
+                    return (this.converterParaBigInt(valorEsquerdo) &
+                        this.converterParaBigInt(valorDireito));
                 }
                 return Number(valorEsquerdo) & Number(valorDireito);
             case delegua_1.default.CIRCUMFLEXO:
@@ -21277,7 +21495,8 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    return this.converterParaBigInt(valorEsquerdo) ^ this.converterParaBigInt(valorDireito);
+                    return (this.converterParaBigInt(valorEsquerdo) ^
+                        this.converterParaBigInt(valorDireito));
                 }
                 return Number(valorEsquerdo) ^ Number(valorDireito);
             case delegua_1.default.BIT_OR:
@@ -21287,21 +21506,28 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    return this.converterParaBigInt(valorEsquerdo) | this.converterParaBigInt(valorDireito);
+                    return (this.converterParaBigInt(valorEsquerdo) |
+                        this.converterParaBigInt(valorDireito));
                 }
                 return Number(valorEsquerdo) | Number(valorDireito);
             case delegua_1.default.MENOR_MENOR:
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt (interno para longo) se qualquer operando for BigInt ou se deslocamento >= 32
-                if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint' || Number(valorDireito) >= 32) {
-                    return this.converterParaBigInt(valorEsquerdo) << this.converterParaBigInt(valorDireito);
+                if (typeof valorEsquerdo === 'bigint' ||
+                    typeof valorDireito === 'bigint' ||
+                    Number(valorDireito) >= 32) {
+                    return (this.converterParaBigInt(valorEsquerdo) <<
+                        this.converterParaBigInt(valorDireito));
                 }
                 return Number(valorEsquerdo) << Number(valorDireito);
             case delegua_1.default.MAIOR_MAIOR:
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt (interno para longo) se qualquer operando for BigInt ou se deslocamento >= 32
-                if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint' || Number(valorDireito) >= 32) {
-                    return this.converterParaBigInt(valorEsquerdo) >> this.converterParaBigInt(valorDireito);
+                if (typeof valorEsquerdo === 'bigint' ||
+                    typeof valorDireito === 'bigint' ||
+                    Number(valorDireito) >= 32) {
+                    return (this.converterParaBigInt(valorEsquerdo) >>
+                        this.converterParaBigInt(valorDireito));
                 }
                 return Number(valorEsquerdo) >> Number(valorDireito);
             case delegua_1.default.DIFERENTE:
@@ -23448,7 +23674,8 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         // Objeto simples do JavaScript, ou dicionário de Delégua.
         if (objeto.constructor === Object) {
             if (expressao.nomeMetodo in primitivas_dicionario_1.default) {
-                const metodoDePrimitivaDicionario = primitivas_dicionario_1.default[expressao.nomeMetodo].implementacao;
+                const metodoDePrimitivaDicionario = primitivas_dicionario_1.default[expressao.nomeMetodo]
+                    .implementacao;
                 return new estruturas_1.MetodoPrimitiva(nomeObjeto, objeto, metodoDePrimitivaDicionario, expressao.nomeMetodo, 'dicionário');
             }
             return objeto[expressao.nomeMetodo] || null;
@@ -23487,7 +23714,8 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
             case delegua_1.default.NUMERO:
             case delegua_1.default.NÚMERO:
                 if (expressao.nomeMetodo in primitivas_numero_1.default) {
-                    const metodoDePrimitivaNumero = primitivas_numero_1.default[expressao.nomeMetodo].implementacao;
+                    const metodoDePrimitivaNumero = primitivas_numero_1.default[expressao.nomeMetodo]
+                        .implementacao;
                     if (metodoDePrimitivaNumero) {
                         return new estruturas_1.MetodoPrimitiva(nomeObjeto, objeto, metodoDePrimitivaNumero, expressao.nomeMetodo, tipoObjeto);
                     }
@@ -23500,7 +23728,8 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                 break;
             case delegua_1.default.TEXTO:
                 if (expressao.nomeMetodo in primitivas_texto_1.default) {
-                    const metodoDePrimitivaTexto = primitivas_texto_1.default[expressao.nomeMetodo].implementacao;
+                    const metodoDePrimitivaTexto = primitivas_texto_1.default[expressao.nomeMetodo]
+                        .implementacao;
                     if (metodoDePrimitivaTexto) {
                         return new estruturas_1.MetodoPrimitiva(nomeObjeto, objeto, metodoDePrimitivaTexto, expressao.nomeMetodo, 'texto');
                     }
@@ -23520,7 +23749,8 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
             case delegua_1.default.VETOR_QUALQUER:
             case delegua_1.default.VETOR_TEXTO:
                 if (expressao.nomeMetodo in primitivas_vetor_1.default) {
-                    const metodoDePrimitivaVetor = primitivas_vetor_1.default[expressao.nomeMetodo].implementacao;
+                    const metodoDePrimitivaVetor = primitivas_vetor_1.default[expressao.nomeMetodo]
+                        .implementacao;
                     if (metodoDePrimitivaVetor) {
                         return new estruturas_1.MetodoPrimitiva(nomeObjeto, objeto, metodoDePrimitivaVetor, expressao.nomeMetodo, tipoObjeto);
                     }
@@ -23621,7 +23851,8 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         // Objeto simples do JavaScript, ou dicionário de Delégua.
         if (objeto.constructor === Object) {
             if (expressao.simbolo.lexema in primitivas_dicionario_1.default) {
-                const metodoDePrimitivaDicionario = primitivas_dicionario_1.default[expressao.simbolo.lexema].implementacao;
+                const metodoDePrimitivaDicionario = primitivas_dicionario_1.default[expressao.simbolo.lexema]
+                    .implementacao;
                 return new estruturas_1.MetodoPrimitiva(nomeObjeto, objeto, metodoDePrimitivaDicionario, expressao.simbolo.lexema, 'dicionário');
             }
             return objeto[expressao.simbolo.lexema];
@@ -23634,7 +23865,8 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                     return funcaoExt.funcaoPorExtensao(objeto);
                 throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, `Método de primitiva '${expressao.simbolo.lexema}' não existe para o tipo texto.`);
             }
-            const metodoDePrimitivaTexto = primitivas_texto_1.default[expressao.simbolo.lexema].implementacao;
+            const metodoDePrimitivaTexto = primitivas_texto_1.default[expressao.simbolo.lexema]
+                .implementacao;
             return new estruturas_1.MetodoPrimitiva(nomeObjeto, objeto, metodoDePrimitivaTexto, expressao.simbolo.lexema, 'texto');
         }
         // A partir daqui, presume-se que o objeto é uma das estruturas
@@ -23659,7 +23891,8 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                         return funcaoExt.funcaoPorExtensao(objeto);
                     throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, `Método de primitiva '${expressao.simbolo.lexema}' não existe para o tipo ${tipoObjeto}.`);
                 }
-                const metodoDePrimitivaNumero = primitivas_numero_1.default[expressao.simbolo.lexema].implementacao;
+                const metodoDePrimitivaNumero = primitivas_numero_1.default[expressao.simbolo.lexema]
+                    .implementacao;
                 if (metodoDePrimitivaNumero) {
                     return new estruturas_1.MetodoPrimitiva(nomeObjeto, objeto, metodoDePrimitivaNumero, expressao.simbolo.lexema, 'número');
                 }
@@ -23672,7 +23905,8 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                         return funcaoExt.funcaoPorExtensao(objeto);
                     throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, `Método de primitiva '${expressao.simbolo.lexema}' não existe para o tipo ${tipoObjeto}.`);
                 }
-                const metodoDePrimitivaTexto = primitivas_texto_1.default[expressao.simbolo.lexema].implementacao;
+                const metodoDePrimitivaTexto = primitivas_texto_1.default[expressao.simbolo.lexema]
+                    .implementacao;
                 if (metodoDePrimitivaTexto) {
                     return new estruturas_1.MetodoPrimitiva(nomeObjeto, objeto, metodoDePrimitivaTexto, expressao.simbolo.lexema, 'texto');
                 }
@@ -23692,7 +23926,8 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                         return funcaoExt.funcaoPorExtensao(objeto);
                     throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, `Método de primitiva '${expressao.simbolo.lexema}' não existe para o tipo ${tipoObjeto}.`);
                 }
-                const metodoDePrimitivaVetor = primitivas_vetor_1.default[expressao.simbolo.lexema].implementacao;
+                const metodoDePrimitivaVetor = primitivas_vetor_1.default[expressao.simbolo.lexema]
+                    .implementacao;
                 if (metodoDePrimitivaVetor) {
                     return new estruturas_1.MetodoPrimitiva(nomeObjeto, objeto, metodoDePrimitivaVetor, expressao.simbolo.lexema, tipoObjeto);
                 }
@@ -23740,7 +23975,8 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         // Objeto simples do JavaScript, ou dicionário de Delégua.
         if (objeto.constructor === Object) {
             if (expressao.nomePropriedade in primitivas_dicionario_1.default) {
-                const metodoDePrimitivaDicionario = primitivas_dicionario_1.default[expressao.nomePropriedade].implementacao;
+                const metodoDePrimitivaDicionario = primitivas_dicionario_1.default[expressao.nomePropriedade]
+                    .implementacao;
                 return new estruturas_1.MetodoPrimitiva(nomeObjeto, objeto, metodoDePrimitivaDicionario, expressao.nomePropriedade, 'dicionário');
             }
             return objeto[expressao.nomePropriedade] || null;
@@ -24416,9 +24652,9 @@ class PilhaEscoposExecucao {
         }
         espacoMemoriaAncestral.valores[simbolo.lexema] = {
             valor,
-            tipo: (variavel.tipo === 'nulo' && !variavel.tipoExplicito)
+            tipo: variavel.tipo === 'nulo' && !variavel.tipoExplicito
                 ? (0, inferenciador_1.inferirTipoVariavel)(valor)
-                : (variavel.tipo || (0, inferenciador_1.inferirTipoVariavel)(valor)),
+                : variavel.tipo || (0, inferenciador_1.inferirTipoVariavel)(valor),
             imutavel: false,
             tipoExplicito: variavel.tipoExplicito,
         };
@@ -24439,9 +24675,7 @@ class PilhaEscoposExecucao {
                 }
                 const tipoAtual = variavel && variavel.hasOwnProperty('tipo') ? variavel.tipo : null;
                 const deveLiberarTipo = tipoAtual === 'nulo' && !variavel.tipoExplicito;
-                const tipoInferido = tipoAtual && !deveLiberarTipo
-                    ? tipoAtual
-                    : (0, inferenciador_1.inferirTipoVariavel)(valor);
+                const tipoInferido = tipoAtual && !deveLiberarTipo ? tipoAtual : (0, inferenciador_1.inferirTipoVariavel)(valor);
                 const tipo = (tipoInferido || 'objeto').toLowerCase();
                 const valorResolvido = this.converterValor(tipo, valor);
                 if (indice !== undefined && indice !== null) {
@@ -24713,7 +24947,9 @@ class LexadorCalango {
         const linhaPrimeiroCaracter = this.linha;
         // Restringe leitura à linha atual (como analisarNumero), evitando
         // que avancar() mude this.linha e corrompa o cálculo do substring.
-        while (this.simboloAtual() !== "'" && this.linha === linhaPrimeiroCaracter && !this.eFinalDoCodigo()) {
+        while (this.simboloAtual() !== "'" &&
+            this.linha === linhaPrimeiroCaracter &&
+            !this.eFinalDoCodigo()) {
             this.avancar();
         }
         if (this.linha !== linhaPrimeiroCaracter || this.eFinalDoCodigo()) {
@@ -27789,10 +28025,12 @@ class Lexador {
                                 break;
                             }
                         }
-                        valor += hex.length === 2 ? String.fromCharCode(parseInt(hex, 16)) : '\\x' + hex;
+                        valor +=
+                            hex.length === 2 ? String.fromCharCode(parseInt(hex, 16)) : '\\x' + hex;
                         break;
                     }
-                    case '\0': break; // barra invertida no fim de linha: ignora e continua na próxima linha
+                    case '\0':
+                        break; // barra invertida no fim de linha: ignora e continua na próxima linha
                     default:
                         valor += '\\' + proximoCaractere;
                         break;
@@ -45904,13 +46142,19 @@ class TradutorElixir {
     }
     mapearTipoParaTypespec(tipo) {
         switch (tipo) {
-            case 'texto': return 'String.t()';
+            case 'texto':
+                return 'String.t()';
             case 'numero':
-            case 'inteiro': return 'integer()';
-            case 'real': return 'float()';
-            case 'logico': return 'boolean()';
-            case 'vazio': return 'no_return()';
-            default: return 'term()';
+            case 'inteiro':
+                return 'integer()';
+            case 'real':
+                return 'float()';
+            case 'logico':
+                return 'boolean()';
+            case 'vazio':
+                return 'no_return()';
+            default:
+                return 'term()';
         }
     }
     /**
@@ -45999,11 +46243,15 @@ class TradutorElixir {
         this.moduloAtual = nomeModulo;
         if (declaracao.estrangeira) {
             // Classe estrangeira: emitir @callback para cada método, definindo a interface esperada do módulo.
-            resultado += this.adicionarIndentacao() + `@moduledoc "Classe estrangeira — implementação externa."\n`;
+            resultado +=
+                this.adicionarIndentacao() +
+                    `@moduledoc "Classe estrangeira — implementação externa."\n`;
             for (const metodo of declaracao.metodos) {
                 const params = metodo.funcao.parametros.map(() => 'term()').join(', ');
                 const retorno = this.mapearTipoParaTypespec(metodo.funcao.tipo);
-                resultado += this.adicionarIndentacao() + `@callback ${metodo.simbolo.lexema}(${params}) :: ${retorno}\n`;
+                resultado +=
+                    this.adicionarIndentacao() +
+                        `@callback ${metodo.simbolo.lexema}(${params}) :: ${retorno}\n`;
             }
         }
         else {
@@ -48480,22 +48728,38 @@ class TradutorPortugolIpt {
     // ── Operadores ───────────────────────────────────────────────────────────────
     traduzirOperador(tipo) {
         switch (tipo) {
-            case portugol_ipt_1.default.ADICAO: return '+';
-            case portugol_ipt_1.default.SUBTRACAO: return '-';
-            case portugol_ipt_1.default.MULTIPLICACAO: return '*';
-            case portugol_ipt_1.default.DIVISAO: return '/';
-            case portugol_ipt_1.default.MODULO: return '%';
-            case portugol_ipt_1.default.EXPONENCIACAO: return '**';
-            case portugol_ipt_1.default.IGUAL: return '==';
-            case portugol_ipt_1.default.DIFERENTE: return '!=';
-            case portugol_ipt_1.default.MAIOR: return '>';
-            case portugol_ipt_1.default.MAIOR_IGUAL: return '>=';
-            case portugol_ipt_1.default.MENOR: return '<';
-            case portugol_ipt_1.default.MENOR_IGUAL: return '<=';
-            case portugol_ipt_1.default.E: return '&&';
-            case portugol_ipt_1.default.OU: return '||';
-            case portugol_ipt_1.default.XOU: return '^^';
-            default: return tipo;
+            case portugol_ipt_1.default.ADICAO:
+                return '+';
+            case portugol_ipt_1.default.SUBTRACAO:
+                return '-';
+            case portugol_ipt_1.default.MULTIPLICACAO:
+                return '*';
+            case portugol_ipt_1.default.DIVISAO:
+                return '/';
+            case portugol_ipt_1.default.MODULO:
+                return '%';
+            case portugol_ipt_1.default.EXPONENCIACAO:
+                return '**';
+            case portugol_ipt_1.default.IGUAL:
+                return '==';
+            case portugol_ipt_1.default.DIFERENTE:
+                return '!=';
+            case portugol_ipt_1.default.MAIOR:
+                return '>';
+            case portugol_ipt_1.default.MAIOR_IGUAL:
+                return '>=';
+            case portugol_ipt_1.default.MENOR:
+                return '<';
+            case portugol_ipt_1.default.MENOR_IGUAL:
+                return '<=';
+            case portugol_ipt_1.default.E:
+                return '&&';
+            case portugol_ipt_1.default.OU:
+                return '||';
+            case portugol_ipt_1.default.XOU:
+                return '^^';
+            default:
+                return tipo;
         }
     }
     // ── Construtos ───────────────────────────────────────────────────────────────
@@ -48537,10 +48801,13 @@ class TradutorPortugolIpt {
     traduzirConstrutoUnario(unario) {
         const operando = this.traduzirConstruto(unario.operando);
         switch (unario.operador.tipo) {
-            case portugol_ipt_1.default.SUBTRACAO: return `-${operando}`;
+            case portugol_ipt_1.default.SUBTRACAO:
+                return `-${operando}`;
             case portugol_ipt_1.default.NEGACAO:
-            case portugol_ipt_1.default.NAO: return `!(${operando})`;
-            default: return `!(${operando})`;
+            case portugol_ipt_1.default.NAO:
+                return `!(${operando})`;
+            default:
+                return `!(${operando})`;
         }
     }
     traduzirConstrutoAtribuir(atribuir) {
@@ -48585,24 +48852,36 @@ class TradutorPortugolIpt {
     }
     tipoParaDelégua(tipo) {
         switch (tipo) {
-            case 'inteiro': return 'inteiro';
-            case 'texto': return 'texto';
-            case 'real': return 'real';
+            case 'inteiro':
+                return 'inteiro';
+            case 'texto':
+                return 'texto';
+            case 'real':
+                return 'real';
             case 'lógico':
-            case 'logico': return 'logico';
-            case 'caracter': return 'caracter';
-            default: return tipo;
+            case 'logico':
+                return 'logico';
+            case 'caracter':
+                return 'caracter';
+            default:
+                return tipo;
         }
     }
     valorPadraoPorTipo(tipo) {
         switch (tipo) {
-            case 'inteiro': return '0';
-            case 'texto': return "''";
-            case 'real': return '0.0';
+            case 'inteiro':
+                return '0';
+            case 'texto':
+                return "''";
+            case 'real':
+                return '0.0';
             case 'lógico':
-            case 'logico': return 'falso';
-            case 'caracter': return "' '";
-            default: return 'nulo';
+            case 'logico':
+                return 'falso';
+            case 'caracter':
+                return "' '";
+            default:
+                return 'nulo';
         }
     }
     traduzirDeclaracaoVar(declaracaoVar) {
@@ -48695,9 +48974,7 @@ class TradutorPortugolIpt {
                 init = this.traduzirDeclaracao(ini);
             }
         }
-        const cond = declaracaoPara.condicao
-            ? this.traduzirConstruto(declaracaoPara.condicao)
-            : '';
+        const cond = declaracaoPara.condicao ? this.traduzirConstruto(declaracaoPara.condicao) : '';
         const incr = declaracaoPara.incrementar
             ? this.traduzirConstruto(declaracaoPara.incrementar)
             : '';
@@ -48717,7 +48994,8 @@ class TradutorPortugolIpt {
         this.indentacao += 4;
         if (caminho.condicoes && caminho.condicoes.length > 0) {
             for (const cond of caminho.condicoes) {
-                resultado += ' '.repeat(this.indentacao) + `caso ${this.traduzirConstruto(cond)}:\n`;
+                resultado +=
+                    ' '.repeat(this.indentacao) + `caso ${this.traduzirConstruto(cond)}:\n`;
             }
         }
         else {
@@ -49731,7 +50009,9 @@ class TradutorReversoCalango {
             .map((parametro) => this.traduzirParametro(parametro))
             .filter((p) => p)
             .join(', ');
-        const tipoRetorno = declaracaoFuncao.tipo && declaracaoFuncao.tipo !== 'qualquer' && declaracaoFuncao.tipo !== 'vazio'
+        const tipoRetorno = declaracaoFuncao.tipo &&
+            declaracaoFuncao.tipo !== 'qualquer' &&
+            declaracaoFuncao.tipo !== 'vazio'
             ? `: ${declaracaoFuncao.tipo}`
             : '';
         let resultado = `funcao ${declaracaoFuncao.simbolo.lexema}(${parametros})${tipoRetorno} `;
@@ -50259,10 +50539,16 @@ class TradutorReversoPython extends AbstractParseTreeVisitor_1.AbstractParseTree
         return node.text;
     }
     visitFile_input(ctx) {
-        return ctx.stmt().map((s) => this.visit(s)).join('\n');
+        return ctx
+            .stmt()
+            .map((s) => this.visit(s))
+            .join('\n');
     }
     visitSimple_stmt(ctx) {
-        return ctx.small_stmt().map((s) => this.visit(s)).join('; ');
+        return ctx
+            .small_stmt()
+            .map((s) => this.visit(s))
+            .join('; ');
     }
     visitExpr_stmt(ctx) {
         const lhs = this.visit(ctx.testlist_star_expr());
@@ -50277,11 +50563,7 @@ class TradutorReversoPython extends AbstractParseTreeVisitor_1.AbstractParseTree
             const op = this.visitAugassign(ctx.augassign());
             const testlist = ctx.testlist();
             const yieldExpr = ctx.yield_expr();
-            const rhs = testlist
-                ? this.visit(testlist)
-                : yieldExpr
-                    ? this.visit(yieldExpr)
-                    : '';
+            const rhs = testlist ? this.visit(testlist) : yieldExpr ? this.visit(yieldExpr) : '';
             return `${lhs} ${op} ${rhs}`;
         }
         return lhs;
@@ -50318,10 +50600,16 @@ class TradutorReversoPython extends AbstractParseTreeVisitor_1.AbstractParseTree
         return ctx.text;
     }
     visitTestlist_star_expr(ctx) {
-        return ctx.test().map((t) => this.visit(t)).join(', ');
+        return ctx
+            .test()
+            .map((t) => this.visit(t))
+            .join(', ');
     }
     visitTestlist(ctx) {
-        return ctx.test().map((t) => this.visit(t)).join(', ');
+        return ctx
+            .test()
+            .map((t) => this.visit(t))
+            .join(', ');
     }
     visitTest(ctx) {
         const orTests = ctx.or_test();
@@ -50334,10 +50622,16 @@ class TradutorReversoPython extends AbstractParseTreeVisitor_1.AbstractParseTree
         return this.visitChildren(ctx);
     }
     visitOr_test(ctx) {
-        return ctx.and_test().map((t) => this.visit(t)).join(' ou ');
+        return ctx
+            .and_test()
+            .map((t) => this.visit(t))
+            .join(' ou ');
     }
     visitAnd_test(ctx) {
-        return ctx.not_test().map((t) => this.visit(t)).join(' e ');
+        return ctx
+            .not_test()
+            .map((t) => this.visit(t))
+            .join(' e ');
     }
     visitNot_test(ctx) {
         if (ctx.NOT()) {
@@ -50523,7 +50817,10 @@ class TradutorReversoPython extends AbstractParseTreeVisitor_1.AbstractParseTree
         return ctx.text;
     }
     visitArglist(ctx) {
-        return ctx.argument().map((a) => this.visit(a)).join(', ');
+        return ctx
+            .argument()
+            .map((a) => this.visit(a))
+            .join(', ');
     }
     visitArgument(ctx) {
         const testes = ctx.test();
@@ -50541,7 +50838,10 @@ class TradutorReversoPython extends AbstractParseTreeVisitor_1.AbstractParseTree
         if (compFor) {
             return this.traduzirCompreensao(ctx.test(0), compFor);
         }
-        return ctx.test().map((t) => this.visit(t)).join(', ');
+        return ctx
+            .test()
+            .map((t) => this.visit(t))
+            .join(', ');
     }
     traduzirCompreensao(exprCtx, compFor) {
         const variavel = this.visit(compFor.exprlist());
@@ -50598,7 +50898,10 @@ class TradutorReversoPython extends AbstractParseTreeVisitor_1.AbstractParseTree
         return tests.map((t) => this.visit(t)).join(', ');
     }
     visitSubscriptlist(ctx) {
-        return ctx.subscript().map((s) => this.visitSubscript(s)).join(', ');
+        return ctx
+            .subscript()
+            .map((s) => this.visitSubscript(s))
+            .join(', ');
     }
     visitSubscript(ctx) {
         const tests = ctx.test();