@designliquido/delegua 1.18.3 → 1.18.5

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) {
@@ -998,6 +1086,9 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
     verificarVariavel(variavel) {
         const variavelEscopo = this.gerenciadorEscopos.buscar(variavel.simbolo.lexema);
         if (!variavelEscopo) {
+            if (this.funcoes[variavel.simbolo.lexema]) {
+                return Promise.resolve();
+            }
             this.erro(variavel.simbolo, `Variável '${variavel.simbolo.lexema}' ainda não foi declarada até este ponto.`);
             return Promise.resolve();
         }
@@ -1202,14 +1293,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 +1552,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 +1637,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 +1675,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 +2815,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) {
@@ -3036,10 +3176,29 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.NAO, delegua_2.default.NEGACAO, delegua_2.default.ADICAO, delegua_2.default.SUBTRACAO, delegua_2.default.BIT_NOT, delegua_2.default.INCREMENTAR, delegua_2.default.DECREMENTAR)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = await this.unario();
+            if (operador.tipo === delegua_2.default.NEGACAO ||
+                operador.tipo === delegua_2.default.NAO) {
+                this.verificarOperandoNegacao(operador, direito);
+            }
             return new construtos_1.Unario(this.hashArquivo, operador, direito, 'ANTES');
         }
         return await this.chamar();
     }
+    verificarOperandoNegacao(operador, operando) {
+        if (operando instanceof construtos_1.Literal) {
+            if (operando.tipo !== 'lógico') {
+                this.erros.push(this.erro(operador, `Operador '!' só pode ser usado com valores lógicos. Tipo recebido: ${operando.tipo}.`));
+            }
+            return;
+        }
+        if (operando instanceof construtos_1.Unario) {
+            const tipoOp = operando.operador.tipo;
+            if (tipoOp === delegua_2.default.NEGACAO || tipoOp === delegua_2.default.NAO) {
+                return;
+            }
+            this.verificarOperandoNegacao(operador, operando.operando);
+        }
+    }
     /**
      * A exponenciacão é uma exceção na ordem de avaliação (resolve primeiro à direita).
      * Por isso `direito` chama `exponenciacao()`, e não `unario()`.
@@ -3407,7 +3566,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 +3639,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 +3701,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 +3874,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 +4009,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';
                     }
@@ -3878,7 +4039,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         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);
+                const metodo = this.metodosClasseAtualEmAnalise.find((m) => m.simbolo.lexema === nomeMembro);
                 if (metodo) {
                     return metodo.tipo || 'qualquer';
                 }
@@ -4027,7 +4188,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));
             }
@@ -4095,7 +4257,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));
             }
@@ -4404,7 +4567,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                         this.erros.push(erro);
                     }
                     if (this.erros.length > quantidadeErrosAntesCorpoOp) {
-                        this.atual = this.encontrarIndiceAposFechamentoDeBloco(indiceAberturaCorpoOp);
+                        this.atual =
+                            this.encontrarIndiceAposFechamentoDeBloco(indiceAberturaCorpoOp);
                         corpoOp = [];
                         this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
                     }
@@ -4442,7 +4606,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 é `{`.
@@ -4475,7 +4639,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                                 this.erros.push(erro);
                             }
                             if (this.erros.length > quantidadeErrosAntesCorpo) {
-                                this.atual = this.encontrarIndiceAposFechamentoDeBloco(indiceAberturaCorpo);
+                                this.atual =
+                                    this.encontrarIndiceAposFechamentoDeBloco(indiceAberturaCorpo);
                                 corpo = [];
                                 this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
                             }
@@ -4553,8 +4718,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                                         catch (erro) {
                                             this.erros.push(erro);
                                         }
-                                        if (this.erros.length >
-                                            quantidadeErrosAntesCorpoAcessor) {
+                                        if (this.erros.length > quantidadeErrosAntesCorpoAcessor) {
                                             this.atual = this.encontrarIndiceAposFechamentoDeBloco(indiceAberturaCorpoAcessor);
                                             corpoAcessor = [];
                                             this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
@@ -6400,9 +6564,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}) + "`;
                 }
@@ -6526,8 +6688,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();
@@ -7329,24 +7490,37 @@ class AvaliadorSintaticoPitugues {
         this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' antes do escopo da classe.");
         const possivelDocumentacao = this.declaracaoTextoDeDocumentacao();
         const metodos = [];
-        const propriedades = [];
-        const indentacaoLinha = this.localizacoes[this.simboloAtual().linha].espacosIndentacao;
+        const propriedadesDeClasse = [];
+        const indentacaoLinha = this
+            .localizacoes[this.simboloAtual().linha]
+            .espacosIndentacao;
         while (!this.estaNoFinal() &&
             this.localizacoes[this.simboloAtual().linha].espacosIndentacao === indentacaoLinha &&
             this.verificarSeSimboloAtualEIgualA(pitugues_2.default.CONSTRUTOR, pitugues_2.default.FUNCAO, pitugues_2.default.FUNÇÃO, pitugues_2.default.IDENTIFICADOR)) {
             const simboloAnterior = this.simbolos[this.atual - 1];
             if (simboloAnterior.tipo === pitugues_2.default.IDENTIFICADOR) {
-                this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' antes do escopo da classe.");
-                const tipoPropriedade = this.consumir(pitugues_2.default.IDENTIFICADOR, 'Esperado tipo de propriedade após dois-pontos, em declaração de classe.');
-                const propriedade = new declaracoes_1.PropriedadeClasse(simboloAnterior, tipoPropriedade.lexema, []);
-                propriedades.push(propriedade);
+                if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DOIS_PONTOS)) {
+                    const simboloTipo = this.consumir(pitugues_2.default.IDENTIFICADOR, 'Esperado tipo da propriedade após os dois pontos.');
+                    const propriedade = new declaracoes_1.PropriedadeClasse(simboloAnterior, simboloTipo.lexema, [], 'publico', false, undefined);
+                    propriedadesDeClasse.push(propriedade);
+                }
+                else if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.IGUAL)) {
+                    const valorPropriedade = await this.expressao();
+                    const propriedade = new declaracoes_1.PropriedadeClasse(simboloAnterior, undefined, [], 'publico', true, valorPropriedade);
+                    propriedadesDeClasse.push(propriedade);
+                }
+                else {
+                    throw this.erro(this.simboloAtual(), "Esperado ':' (para tipo) ou '=' (para valor) após o nome da propriedade.");
+                }
             }
             else {
-                metodos.push(await this.funcao('método', this.simbolos[this.atual - 1].tipo === pitugues_2.default.CONSTRUTOR));
+                const ehConstrutor = simboloAnterior.tipo === pitugues_2.default.CONSTRUTOR;
+                const metodoResolvido = await this.funcao('método', ehConstrutor);
+                metodos.push(metodoResolvido);
             }
         }
         this.superclasseAtual = undefined;
-        const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasse ? [superClasse] : [], metodos, propriedades);
+        const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasse ? [superClasse] : [], metodos, propriedadesDeClasse);
         if (possivelDocumentacao) {
             definicaoClasse.documentacao = possivelDocumentacao;
         }
@@ -8052,7 +8226,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 {
@@ -8781,11 +8958,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;
@@ -9053,7 +9226,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.");
@@ -10768,10 +10942,28 @@ class MicroAvaliadorSintatico extends micro_avaliador_sintatico_base_1.MicroAval
         }
         return expressao;
     }
+    verificarOperandoNegacao(operador, operando) {
+        if (operando instanceof construtos_1.Literal) {
+            if (operando.tipo !== 'lógico') {
+                this.erro(operador, `Operador '!' só pode ser usado com valores lógicos. Tipo recebido: ${operando.tipo}.`);
+            }
+            return;
+        }
+        if (operando instanceof construtos_1.Unario) {
+            const tipoOp = operando.operador.tipo;
+            if (tipoOp === delegua_1.default.NEGACAO) {
+                return;
+            }
+            this.verificarOperandoNegacao(operador, operando.operando);
+        }
+    }
     unario() {
         if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.NEGACAO, delegua_1.default.SUBTRACAO, delegua_1.default.BIT_NOT, delegua_1.default.INCREMENTAR, delegua_1.default.DECREMENTAR)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.unario();
+            if (operador.tipo === delegua_1.default.NEGACAO) {
+                this.verificarOperandoNegacao(operador, direito);
+            }
             return new construtos_1.Unario(-1, operador, direito, 'ANTES');
         }
         return this.chamar();
@@ -15615,7 +15807,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PropriedadeClasse = void 0;
 const declaracao_1 = require("./declaracao");
 class PropriedadeClasse extends declaracao_1.Declaracao {
-    constructor(nome, tipo, decoradores = [], acesso = 'publico', estatico = false) {
+    constructor(nome, tipo, decoradores = [], acesso = 'publico', estatico = false, valorInicial) {
         super(Number(nome.linha), nome.hashArquivo);
         this.nome = nome;
         this.tipo = tipo;
@@ -15624,6 +15816,7 @@ class PropriedadeClasse extends declaracao_1.Declaracao {
         this.estatico = estatico;
         this.autoObter = false;
         this.autoDefinir = false;
+        this.valorInicial = valorInicial;
     }
     async aceitar(visitante) {
         return Promise.reject(new Error('Não utilizado por enquanto.'));
@@ -19403,7 +19596,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.
@@ -19622,6 +19815,7 @@ class DescritorTipoClasse extends chamavel_1.Chamavel {
     constructor(simboloOriginal, superClasses, metodos, propriedades) {
         super();
         this.dialetoRequerExpansaoPropriedadesEspacoMemoria = false;
+        this.sombrearPropriedadesDeClasse = false;
         this.simboloOriginal = simboloOriginal;
         if (Array.isArray(superClasses)) {
             this.superClasses = superClasses;
@@ -20427,7 +20621,13 @@ class ObjetoDeleguaClasse {
             throw new excecoes_1.ErroEmTempoDeExecucao(simbolo, `Propriedade '${simbolo.lexema}' é somente-leitura.`);
         }
         if (Object.prototype.hasOwnProperty.call(this.classe.membrosEstaticos, simbolo.lexema)) {
-            await this.classe.definirEstatico(simbolo.lexema, valor, visitante);
+            if (this.classe.sombrearPropriedadesDeClasse) {
+                this.verificarAcessoLeitura(simbolo.lexema, simbolo, visitante);
+                this.propriedades[simbolo.lexema] = valor;
+            }
+            else {
+                await this.classe.definirEstatico(simbolo.lexema, valor, visitante);
+            }
             return;
         }
         // Verificar acesso antes da atribuição.
@@ -20823,7 +21023,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);
             }
@@ -21172,7 +21373,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')
@@ -21186,7 +21389,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;
@@ -21213,7 +21417,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:
@@ -21248,8 +21453,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);
@@ -21338,7 +21545,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:
@@ -21348,7 +21556,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:
@@ -21358,21 +21567,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:
@@ -22395,6 +22611,9 @@ class InterpretadorBase {
         if (tipoResolvido.startsWith('função<')) {
             tipoResolvido = tipoResolvido.replace('função<', '').replace('>', '');
         }
+        if (!declaracao.tipoExplicito && tipoResolvido === delegua_2.default.QUALQUER && valorFinal instanceof Array) {
+            tipoResolvido = (0, inferenciador_1.inferirTipoVariavel)(valorFinal);
+        }
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valorFinal, tipoResolvido, declaracao.tipoExplicito && declaracao.tipoOriginal !== 'qualquer');
         // TODO: É relevante registrar uma declaração de variável no
         // resultado do interpretador?
@@ -23519,7 +23738,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;
@@ -23558,7 +23778,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);
                     }
@@ -23571,7 +23792,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');
                     }
@@ -23591,7 +23813,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);
                     }
@@ -23692,7 +23915,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];
@@ -23705,7 +23929,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
@@ -23730,7 +23955,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');
                 }
@@ -23743,7 +23969,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');
                 }
@@ -23763,7 +23990,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);
                 }
@@ -23811,7 +24039,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;
@@ -24487,9 +24716,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,
         };
@@ -24510,9 +24739,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) {
@@ -24784,7 +25011,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()) {
@@ -27860,10 +28089,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;
@@ -42580,10 +42811,10 @@ class TradutorAssemblyARM {
         // Para android: ainda é um binário standalone, mas com rótulo Delegua_main
         // para deixar claro que não é o _start do CRT padrão.
         const entryLabel = this.alvo === 'android' ? 'Delegua_main' : '_start';
-        this.text = `
-.text
-.global ${entryLabel}
-
+        this.text = `
+.text
+.global ${entryLabel}
+
 ${entryLabel}:`;
     }
     gerarDigitoAleatorio() {
@@ -42624,11 +42855,11 @@ ${entryLabel}:`;
         }
         const indice = this.dicionarioConstrutos[construto.indice.constructor.name](construto.indice);
         const reg = this.obterRegistrador();
-        this.text += `
-    ldr ${reg}, =${nomeVar}
-    ldr r0, =${indice}
-    lsl r0, r0, #2          @ multiply index by 4 (word size)
-    add ${reg}, ${reg}, r0
+        this.text += `
+    ldr ${reg}, =${nomeVar}
+    ldr r0, =${indice}
+    lsl r0, r0, #2          @ multiply index by 4 (word size)
+    add ${reg}, ${reg}, r0
     ldr r0, [${reg}]`;
         this.liberarRegistrador(reg);
         return 'r0';
@@ -42651,12 +42882,12 @@ ${entryLabel}:`;
         const indice = this.dicionarioConstrutos[construto.indice.constructor.name](construto.indice);
         const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
         const reg = this.obterRegistrador();
-        this.text += `
-    ldr ${reg}, =${nomeVar}
-    ldr r1, =${indice}
-    lsl r1, r1, #2          @ multiply by 4
-    add ${reg}, ${reg}, r1
-    ldr r1, =${valor}
+        this.text += `
+    ldr ${reg}, =${nomeVar}
+    ldr r1, =${indice}
+    lsl r1, r1, #2          @ multiply by 4
+    add ${reg}, ${reg}, r1
+    ldr r1, =${valor}
     str r1, [${reg}]`;
         this.liberarRegistrador(reg);
     }
@@ -42674,9 +42905,9 @@ ${entryLabel}:`;
             this.bss += `    ${varLabel}: .space 4\n`;
             this.variaveis.set(nomeVar, varLabel);
         }
-        this.text += `
-    ldr r0, =${valor}
-    ldr r1, =${this.variaveis.get(nomeVar)}
+        this.text += `
+    ldr r0, =${valor}
+    ldr r1, =${this.variaveis.get(nomeVar)}
     str r0, [r1]`;
     }
     traduzirConstrutoBinario(construto) {
@@ -42686,75 +42917,75 @@ ${entryLabel}:`;
         const reg = this.obterRegistrador();
         // Load left operand into r0
         if (esquerda !== 'r0') {
-            this.text += `
+            this.text += `
     ldr r0, =${esquerda}`;
         }
         // Load right operand into reg
-        this.text += `
+        this.text += `
     ldr ${reg}, =${direita}`;
         switch (operador) {
             case '+':
-                this.text += `
+                this.text += `
     add r0, r0, ${reg}`;
                 break;
             case '-':
-                this.text += `
+                this.text += `
     sub r0, r0, ${reg}`;
                 break;
             case '*':
-                this.text += `
+                this.text += `
     mul r0, r0, ${reg}`;
                 break;
             case '/':
-                this.text += `
+                this.text += `
     sdiv r0, r0, ${reg}`;
                 break;
             case '%':
-                this.text += `
-    sdiv r1, r0, ${reg}
-    mul r1, r1, ${reg}
+                this.text += `
+    sdiv r1, r0, ${reg}
+    mul r1, r1, ${reg}
     sub r0, r0, r1          @ r0 = r0 - (r0/reg)*reg`;
                 break;
             case '<':
-                this.text += `
-    cmp r0, ${reg}
-    movlt r0, #1
+                this.text += `
+    cmp r0, ${reg}
+    movlt r0, #1
     movge r0, #0`;
                 break;
             case '>':
-                this.text += `
-    cmp r0, ${reg}
-    movgt r0, #1
+                this.text += `
+    cmp r0, ${reg}
+    movgt r0, #1
     movle r0, #0`;
                 break;
             case '<=':
-                this.text += `
-    cmp r0, ${reg}
-    movle r0, #1
+                this.text += `
+    cmp r0, ${reg}
+    movle r0, #1
     movgt r0, #0`;
                 break;
             case '>=':
-                this.text += `
-    cmp r0, ${reg}
-    movge r0, #1
+                this.text += `
+    cmp r0, ${reg}
+    movge r0, #1
     movlt r0, #0`;
                 break;
             case '==':
             case '===':
-                this.text += `
-    cmp r0, ${reg}
-    moveq r0, #1
+                this.text += `
+    cmp r0, ${reg}
+    moveq r0, #1
     movne r0, #0`;
                 break;
             case '!=':
             case '!==':
-                this.text += `
-    cmp r0, ${reg}
-    movne r0, #1
+                this.text += `
+    cmp r0, ${reg}
+    movne r0, #1
     moveq r0, #0`;
                 break;
             default:
-                this.text += `
+                this.text += `
     @ Operador ${operador} não implementado`;
         }
         this.liberarRegistrador(reg);
@@ -42771,35 +43002,35 @@ ${entryLabel}:`;
             if (index < registrosArgs.length) {
                 const valorArg = this.dicionarioConstrutos[arg.constructor.name](arg);
                 if (valorArg !== registrosArgs[index]) {
-                    this.text += `
+                    this.text += `
     ldr ${registrosArgs[index]}, =${valorArg}`;
                 }
             }
             else {
                 // Push extra args on stack
                 const valorArg = this.dicionarioConstrutos[arg.constructor.name](arg);
-                this.text += `
-    ldr r0, =${valorArg}
+                this.text += `
+    ldr r0, =${valorArg}
     push {r0}`;
             }
         });
-        this.text += `
+        this.text += `
     bl ${nomeFuncao}`;
     }
     traduzirConstrutoDefinirValor(construto) {
         const objeto = this.dicionarioConstrutos[construto.objeto.constructor.name](construto.objeto);
         const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
-        this.text += `
-    ldr r0, =${valor}
-    ldr r1, =${objeto}
+        this.text += `
+    ldr r0, =${valor}
+    ldr r1, =${objeto}
     str r0, [r1]`;
     }
     traduzirFuncaoConstruto(construto) {
         const labelFuncao = `func_${this.gerarDigitoAleatorio()}`;
-        this.text += `
-
-${labelFuncao}:
-    push {fp, lr}
+        this.text += `
+
+${labelFuncao}:
+    push {fp, lr}
     mov fp, sp`;
         // Traduzir corpo da função
         if (construto.corpo && Array.isArray(construto.corpo)) {
@@ -42809,8 +43040,8 @@ ${labelFuncao}:
                 }
             });
         }
-        this.text += `
-    mov sp, fp
+        this.text += `
+    mov sp, fp
     pop {fp, pc}`;
     }
     traduzirConstrutoLiteral(construto) {
@@ -42825,29 +43056,29 @@ ${labelFuncao}:
         const operador = construto.operador.lexema;
         const labelVerdadeiro = this.gerarLabel();
         const labelFim = this.gerarLabel();
-        this.text += `
-    ldr r0, =${esquerda}
+        this.text += `
+    ldr r0, =${esquerda}
     cmp r0, #0`;
         if (operador === 'e' || operador === '&&') {
-            this.text += `
-    beq ${labelFim}
-    ldr r0, =${direita}
-    cmp r0, #0
-    beq ${labelFim}
-${labelVerdadeiro}:
-    mov r0, #1
+            this.text += `
+    beq ${labelFim}
+    ldr r0, =${direita}
+    cmp r0, #0
+    beq ${labelFim}
+${labelVerdadeiro}:
+    mov r0, #1
 ${labelFim}:`;
         }
         else if (operador === 'ou' || operador === '||') {
-            this.text += `
-    bne ${labelVerdadeiro}
-    ldr r0, =${direita}
-    cmp r0, #0
-    bne ${labelVerdadeiro}
-    mov r0, #0
-    b ${labelFim}
-${labelVerdadeiro}:
-    mov r0, #1
+            this.text += `
+    bne ${labelVerdadeiro}
+    ldr r0, =${direita}
+    cmp r0, #0
+    bne ${labelVerdadeiro}
+    mov r0, #0
+    b ${labelFim}
+${labelVerdadeiro}:
+    mov r0, #1
 ${labelFim}:`;
         }
         return 'r0';
@@ -42859,16 +43090,16 @@ ${labelFim}:`;
     traduzirConstrutoUnario(construto) {
         const operando = this.dicionarioConstrutos[construto.operando.constructor.name](construto.operando);
         const operador = construto.operador.lexema;
-        this.text += `
+        this.text += `
     ldr r0, =${operando}`;
         if (operador === '-') {
-            this.text += `
+            this.text += `
     neg r0, r0`;
         }
         else if (operador === '!' || operador === 'nao') {
-            this.text += `
-    cmp r0, #0
-    moveq r0, #1
+            this.text += `
+    cmp r0, #0
+    moveq r0, #1
     movne r0, #0`;
         }
         return 'r0';
@@ -42877,8 +43108,8 @@ ${labelFim}:`;
         const nomeVar = construto.simbolo?.lexema;
         if (nomeVar && this.variaveis.has(nomeVar)) {
             const varLabel = this.variaveis.get(nomeVar);
-            this.text += `
-    ldr r0, =${varLabel}
+            this.text += `
+    ldr r0, =${varLabel}
     ldr r0, [r0]`;
             return 'r0';
         }
@@ -42892,9 +43123,9 @@ ${labelFim}:`;
             construto.valores.forEach((valor, index) => {
                 if (this.dicionarioConstrutos[valor.constructor.name]) {
                     const valorTraduzido = this.dicionarioConstrutos[valor.constructor.name](valor);
-                    this.text += `
-    ldr r0, =${valorTraduzido}
-    ldr r1, =${labelVetor}
+                    this.text += `
+    ldr r0, =${valorTraduzido}
+    ldr r1, =${labelVetor}
     str r0, [r1, #${index * 4}]`;
                 }
             });
@@ -42914,17 +43145,17 @@ ${labelFim}:`;
     traduzirDeclaracaoEnquanto(declaracao) {
         const labelInicio = this.gerarLabel();
         const labelFim = this.gerarLabel();
-        this.text += `
+        this.text += `
 ${labelInicio}:`;
         const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
-        this.text += `
-    cmp ${condicao}, #0
+        this.text += `
+    cmp ${condicao}, #0
     beq ${labelFim}`;
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
         }
-        this.text += `
-    b ${labelInicio}
+        this.text += `
+    b ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoEscolha(declaracao) {
@@ -42935,10 +43166,10 @@ ${labelFim}:`;
                 const labelProximo = this.gerarLabel();
                 if (caminho.condicoes && caminho.condicoes[0]) {
                     const valorCaso = this.dicionarioConstrutos[caminho.condicoes[0].constructor.name](caminho.condicoes[0]);
-                    this.text += `
-    ldr r0, =${valorEscolha}
-    ldr r1, =${valorCaso}
-    cmp r0, r1
+                    this.text += `
+    ldr r0, =${valorEscolha}
+    ldr r1, =${valorCaso}
+    cmp r0, r1
     bne ${labelProximo}`;
                     if (caminho.declaracoes && Array.isArray(caminho.declaracoes)) {
                         caminho.declaracoes.forEach((decl) => {
@@ -42947,13 +43178,13 @@ ${labelFim}:`;
                             }
                         });
                     }
-                    this.text += `
-    b ${labelFim}
+                    this.text += `
+    b ${labelFim}
 ${labelProximo}:`;
                 }
             });
         }
-        this.text += `
+        this.text += `
 ${labelFim}:`;
     }
     traduzirDeclaracaoExpressao(declaracao) {
@@ -42964,7 +43195,7 @@ ${labelFim}:`;
     }
     traduzirDeclaracaoFazer(declaracao) {
         const labelInicio = this.gerarLabel();
-        this.text += `
+        this.text += `
 ${labelInicio}:`;
         if (declaracao.caminhoFazer && declaracao.caminhoFazer.declaracoes) {
             declaracao.caminhoFazer.declaracoes.forEach((decl) => {
@@ -42975,8 +43206,8 @@ ${labelInicio}:`;
         }
         if (declaracao.condicaoEnquanto) {
             const condicao = this.dicionarioConstrutos[declaracao.condicaoEnquanto.constructor.name](declaracao.condicaoEnquanto);
-            this.text += `
-    cmp ${condicao}, #0
+            this.text += `
+    cmp ${condicao}, #0
     bne ${labelInicio}`;
         }
     }
@@ -42990,18 +43221,18 @@ ${labelInicio}:`;
                 mensagem = this.dicionarioConstrutos[explicacao.constructor.name](explicacao);
             }
         }
-        this.text += `
-    @ Falhar com mensagem: ${mensagem}
-    mov r0, #1
-    mov r7, #1              @ sys_exit
+        this.text += `
+    @ Falhar com mensagem: ${mensagem}
+    mov r0, #1
+    mov r7, #1              @ sys_exit
     swi 0`;
     }
     traduzirDeclaracaoFuncao(declaracao) {
         const nomeFuncao = declaracao.simbolo?.lexema || 'funcao';
-        this.text += `
-
-${nomeFuncao}:
-    push {fp, lr}
+        this.text += `
+
+${nomeFuncao}:
+    push {fp, lr}
     mov fp, sp`;
         if (declaracao.funcao &&
             declaracao.funcao.corpo &&
@@ -43012,12 +43243,12 @@ ${nomeFuncao}:
                 }
             });
         }
-        this.text += `
-    mov sp, fp
+        this.text += `
+    mov sp, fp
     pop {fp, pc}`;
     }
     traduzirDeclaracaoImportar(declaracao) {
-        this.text += `
+        this.text += `
     @ Importar: ${declaracao.caminho || 'unknown'}`;
     }
     traduzirDeclaracaoLeia(declaracao) {
@@ -43034,11 +43265,11 @@ ${nomeFuncao}:
             this.bss += `    ${varLabel}: .space 256\n`;
             this.variaveis.set(nomeVar, varLabel);
         }
-        this.text += `
-    ldr r1, =${this.variaveis.get(nomeVar)}
-    mov r2, #256
-    mov r0, #0              @ stdin
-    mov r7, #3              @ sys_read
+        this.text += `
+    ldr r1, =${this.variaveis.get(nomeVar)}
+    mov r2, #256
+    mov r0, #0              @ stdin
+    mov r7, #3              @ sys_read
     swi 0`;
     }
     traduzirDeclaracaoPara(declaracao) {
@@ -43053,12 +43284,12 @@ ${nomeFuncao}:
                 this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
             }
         }
-        this.text += `
+        this.text += `
 ${labelInicio}:`;
         if (declaracao.condicao) {
             const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
-            this.text += `
-    cmp ${condicao}, #0
+            this.text += `
+    cmp ${condicao}, #0
     beq ${labelFim}`;
         }
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
@@ -43069,8 +43300,8 @@ ${labelInicio}:`;
                 this.dicionarioConstrutos[declaracao.incrementar.constructor.name](declaracao.incrementar);
             }
         }
-        this.text += `
-    b ${labelInicio}
+        this.text += `
+    b ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoParaCada(declaracao) {
@@ -43085,55 +43316,55 @@ ${labelFim}:`;
         if (vetor instanceof construtos_1.Vetor) {
             tamanhoVetor = vetor.tamanho || 0;
         }
-        this.text += `
-    mov r4, #0              @ counter
-${labelInicio}:
-    cmp r4, #${tamanhoVetor}
+        this.text += `
+    mov r4, #0              @ counter
+${labelInicio}:
+    cmp r4, #${tamanhoVetor}
     bge ${labelFim}`;
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
         }
-        this.text += `
-    add r4, r4, #1
-    b ${labelInicio}
+        this.text += `
+    add r4, r4, #1
+    b ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoRetorna(declaracao) {
         if (declaracao.valor) {
             const valor = this.dicionarioConstrutos[declaracao.valor.constructor.name](declaracao.valor);
-            this.text += `
+            this.text += `
     ldr r0, =${valor}`;
         }
-        this.text += `
-    mov sp, fp
+        this.text += `
+    mov sp, fp
     pop {fp, pc}`;
     }
     traduzirDeclaracaoSe(declaracao) {
         const labelSenao = this.gerarLabel();
         const labelFim = this.gerarLabel();
         const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
-        this.text += `
-    cmp ${condicao}, #0
+        this.text += `
+    cmp ${condicao}, #0
     beq ${labelSenao}`;
         if (this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name](declaracao.caminhoEntao);
         }
-        this.text += `
-    b ${labelFim}
+        this.text += `
+    b ${labelFim}
 ${labelSenao}:`;
         if (declaracao.caminhoSenao &&
             this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name](declaracao.caminhoSenao);
         }
-        this.text += `
+        this.text += `
 ${labelFim}:`;
     }
     traduzirDeclaracaoClasse(declaracao) {
-        this.text += `
+        this.text += `
     @ Classe: ${declaracao.simbolo?.lexema || 'unknown'}`;
     }
     traduzirDeclaracaoTente(declaracao) {
-        this.text += `
+        this.text += `
     @ Tente-pegue`;
         if (declaracao.caminhoTente && Array.isArray(declaracao.caminhoTente)) {
             declaracao.caminhoTente.forEach((decl) => {
@@ -43170,9 +43401,9 @@ ${labelFim}:`;
             }
             else if (this.dicionarioConstrutos[tipoInicializador]) {
                 const valor = this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
-                this.text += `
-    ldr r0, =${valor}
-    ldr r1, =${varLabel}
+                this.text += `
+    ldr r0, =${valor}
+    ldr r1, =${varLabel}
     str r0, [r1]`;
             }
         }
@@ -43199,20 +43430,20 @@ ${labelFim}:`;
         // Para ambos linux-arm e android, continuamos usando a convenção
         // de syscall Linux ARM (write). Em Android típico, esse binário
         // seria executado via adb/Termux, onde essa convenção ainda é válida.
-        this.text += `
-    ldr r1, =${nome_string_literal}
-    mov r2, #${tam_string_literal}
-    mov r0, #1              @ fd stdout
-    mov r7, #4              @ sys_write
+        this.text += `
+    ldr r1, =${nome_string_literal}
+    mov r2, #${tam_string_literal}
+    mov r0, #1              @ fd stdout
+    mov r7, #4              @ sys_write
     swi 0`;
     }
     saidaSistema() {
         // Mesmo comentário da função Escreva: usamos sys_exit Linux.
         // Em um futuro modo Android "NDK/JNI", esta função deveria
         // apenas retornar ao chamador em vez de fazer syscall direta.
-        this.text += `
-    mov r0, #1              @ exit status
-    mov r7, #1              @ sys_exit
+        this.text += `
+    mov r0, #1              @ exit status
+    mov r7, #1              @ sys_exit
     swi 0`;
     }
     traduzir(declaracoes) {
@@ -43288,10 +43519,10 @@ class TradutorAssemblyRISCV {
             Var: this.traduzirDeclaracaoVar.bind(this),
         };
         this.indentacao = 0;
-        this.text = `
-.text
-.global _start
-
+        this.text = `
+.text
+.global _start
+
 _start:`;
     }
     gerarDigitoAleatorio() {
@@ -43357,9 +43588,9 @@ _start:`;
         const reg = this.obterRegistrador();
         this.text += `\n    la ${reg}, ${nomeVar}`;
         this.emitirCarga('a0', indice);
-        this.text += `
-    slli a0, a0, 3          # multiplicar índice por 8 (palavra de 64 bits)
-    add ${reg}, ${reg}, a0
+        this.text += `
+    slli a0, a0, 3          # multiplicar índice por 8 (palavra de 64 bits)
+    add ${reg}, ${reg}, a0
     ld a0, 0(${reg})`;
         this.liberarRegistrador(reg);
         return 'a0';
@@ -43383,8 +43614,8 @@ _start:`;
         const reg = this.obterRegistrador();
         this.text += `\n    la ${reg}, ${nomeVar}`;
         this.emitirCarga('a1', indice);
-        this.text += `
-    slli a1, a1, 3          # multiplicar índice por 8
+        this.text += `
+    slli a1, a1, 3          # multiplicar índice por 8
     add ${reg}, ${reg}, a1`;
         this.emitirCarga('a1', valor);
         this.text += `\n    sd a1, 0(${reg})`;
@@ -43404,8 +43635,8 @@ _start:`;
             this.variaveis.set(nomeVar, varLabel);
         }
         this.emitirCarga('a0', valor);
-        this.text += `
-    la a1, ${this.variaveis.get(nomeVar)}
+        this.text += `
+    la a1, ${this.variaveis.get(nomeVar)}
     sd a0, 0(a1)`;
     }
     traduzirConstrutoBinario(construto) {
@@ -43489,18 +43720,18 @@ _start:`;
         const objeto = this.dicionarioConstrutos[construto.objeto.constructor.name](construto.objeto);
         const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
         this.emitirCarga('a0', valor);
-        this.text += `
-    la a1, ${objeto}
+        this.text += `
+    la a1, ${objeto}
     sd a0, 0(a1)`;
     }
     traduzirFuncaoConstruto(construto) {
         const labelFuncao = `func_${this.gerarDigitoAleatorio()}`;
-        this.text += `
-
-${labelFuncao}:
-    addi sp, sp, -16
-    sd   ra, 8(sp)
-    sd   s0, 0(sp)
+        this.text += `
+
+${labelFuncao}:
+    addi sp, sp, -16
+    sd   ra, 8(sp)
+    sd   s0, 0(sp)
     addi s0, sp, 16`;
         if (construto.corpo && Array.isArray(construto.corpo)) {
             construto.corpo.forEach((declaracao) => {
@@ -43509,10 +43740,10 @@ ${labelFuncao}:
                 }
             });
         }
-        this.text += `
-    ld   ra, 8(sp)
-    ld   s0, 0(sp)
-    addi sp, sp, 16
+        this.text += `
+    ld   ra, 8(sp)
+    ld   s0, 0(sp)
+    addi sp, sp, 16
     ret`;
     }
     traduzirConstrutoLiteral(construto) {
@@ -43536,21 +43767,21 @@ ${labelFuncao}:
         if (operador === 'e' || operador === '&&') {
             this.text += `\n    beqz a0, ${labelFim}`;
             this.emitirCarga('a0', direita);
-            this.text += `
-    beqz a0, ${labelFim}
-${labelVerdadeiro}:
-    li a0, 1
+            this.text += `
+    beqz a0, ${labelFim}
+${labelVerdadeiro}:
+    li a0, 1
 ${labelFim}:`;
         }
         else if (operador === 'ou' || operador === '||') {
             this.text += `\n    bnez a0, ${labelVerdadeiro}`;
             this.emitirCarga('a0', direita);
-            this.text += `
-    bnez a0, ${labelVerdadeiro}
-    li a0, 0
-    j ${labelFim}
-${labelVerdadeiro}:
-    li a0, 1
+            this.text += `
+    bnez a0, ${labelVerdadeiro}
+    li a0, 0
+    j ${labelFim}
+${labelVerdadeiro}:
+    li a0, 1
 ${labelFim}:`;
         }
         return 'a0';
@@ -43575,8 +43806,8 @@ ${labelFim}:`;
         const nomeVar = construto.simbolo?.lexema;
         if (nomeVar && this.variaveis.has(nomeVar)) {
             const varLabel = this.variaveis.get(nomeVar);
-            this.text += `
-    la a0, ${varLabel}
+            this.text += `
+    la a0, ${varLabel}
     ld a0, 0(a0)`;
             return 'a0';
         }
@@ -43592,8 +43823,8 @@ ${labelFim}:`;
             if (this.dicionarioConstrutos[valor.constructor.name]) {
                 const valorTraduzido = this.dicionarioConstrutos[valor.constructor.name](valor);
                 this.emitirCarga('a0', valorTraduzido);
-                this.text += `
-    la a1, ${labelVetor}
+                this.text += `
+    la a1, ${labelVetor}
     sd a0, ${index * 8}(a1)`;
             }
         });
@@ -43621,8 +43852,8 @@ ${labelFim}:`;
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
         }
-        this.text += `
-    j ${labelInicio}
+        this.text += `
+    j ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoEscolha(declaracao) {
@@ -43643,8 +43874,8 @@ ${labelFim}:`;
                             }
                         });
                     }
-                    this.text += `
-    j ${labelFim}
+                    this.text += `
+    j ${labelFim}
 ${labelProximo}:`;
                 }
             });
@@ -43688,20 +43919,20 @@ ${labelProximo}:`;
                 mensagem = this.dicionarioConstrutos[explicacao.constructor.name](explicacao);
             }
         }
-        this.text += `
-    # Falhar com mensagem: ${mensagem}
-    li a0, 1
-    li a7, 93               # sys_exit
+        this.text += `
+    # Falhar com mensagem: ${mensagem}
+    li a0, 1
+    li a7, 93               # sys_exit
     ecall`;
     }
     traduzirDeclaracaoFuncao(declaracao) {
         const nomeFuncao = declaracao.simbolo?.lexema || 'funcao';
-        this.text += `
-
-${nomeFuncao}:
-    addi sp, sp, -16
-    sd   ra, 8(sp)
-    sd   s0, 0(sp)
+        this.text += `
+
+${nomeFuncao}:
+    addi sp, sp, -16
+    sd   ra, 8(sp)
+    sd   s0, 0(sp)
     addi s0, sp, 16`;
         if (declaracao.funcao &&
             declaracao.funcao.corpo &&
@@ -43712,10 +43943,10 @@ ${nomeFuncao}:
                 }
             });
         }
-        this.text += `
-    ld   ra, 8(sp)
-    ld   s0, 0(sp)
-    addi sp, sp, 16
+        this.text += `
+    ld   ra, 8(sp)
+    ld   s0, 0(sp)
+    addi sp, sp, 16
     ret`;
     }
     traduzirDeclaracaoImportar(declaracao) {
@@ -43735,11 +43966,11 @@ ${nomeFuncao}:
             this.bss += `    ${varLabel}: .space 256\n`;
             this.variaveis.set(nomeVar, varLabel);
         }
-        this.text += `
-    li a0, 0                # fd stdin
-    la a1, ${this.variaveis.get(nomeVar)}
-    li a2, 256
-    li a7, 63               # sys_read
+        this.text += `
+    li a0, 0                # fd stdin
+    la a1, ${this.variaveis.get(nomeVar)}
+    li a2, 256
+    li a7, 63               # sys_read
     ecall`;
     }
     traduzirDeclaracaoPara(declaracao) {
@@ -43770,8 +44001,8 @@ ${nomeFuncao}:
                 this.dicionarioConstrutos[declaracao.incrementar.constructor.name](declaracao.incrementar);
             }
         }
-        this.text += `
-    j ${labelInicio}
+        this.text += `
+    j ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoParaCada(declaracao) {
@@ -43783,17 +44014,17 @@ ${labelFim}:`;
             tamanhoVetor = vetor.tamanho || 0;
         }
         // t0: contador; t1: limite (caller-saved, seguros aqui)
-        this.text += `
-    li t0, 0                # contador
-    li t1, ${tamanhoVetor}
-${labelInicio}:
+        this.text += `
+    li t0, 0                # contador
+    li t1, ${tamanhoVetor}
+${labelInicio}:
     bge t0, t1, ${labelFim}`;
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
         }
-        this.text += `
-    addi t0, t0, 1
-    j ${labelInicio}
+        this.text += `
+    addi t0, t0, 1
+    j ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoRetorna(declaracao) {
@@ -43801,10 +44032,10 @@ ${labelFim}:`;
             const valor = this.dicionarioConstrutos[declaracao.valor.constructor.name](declaracao.valor);
             this.emitirCarga('a0', valor);
         }
-        this.text += `
-    ld   ra, 8(sp)
-    ld   s0, 0(sp)
-    addi sp, sp, 16
+        this.text += `
+    ld   ra, 8(sp)
+    ld   s0, 0(sp)
+    addi sp, sp, 16
     ret`;
     }
     traduzirDeclaracaoSe(declaracao) {
@@ -43818,8 +44049,8 @@ ${labelFim}:`;
         if (this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name](declaracao.caminhoEntao);
         }
-        this.text += `
-    j ${labelFim}
+        this.text += `
+    j ${labelFim}
 ${labelSenao}:`;
         if (declaracao.caminhoSenao &&
             this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name]) {
@@ -43865,8 +44096,8 @@ ${labelSenao}:`;
             else if (this.dicionarioConstrutos[tipoInicializador]) {
                 const valor = this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
                 this.emitirCarga('a0', valor);
-                this.text += `
-    la a1, ${varLabel}
+                this.text += `
+    la a1, ${varLabel}
     sd a0, 0(a1)`;
             }
         }
@@ -43893,17 +44124,17 @@ ${labelSenao}:`;
             tamanhoString = String(stringValue.length);
         }
         // sys_write(fd=1, buf, count): a7=64, a0=fd, a1=buf, a2=count
-        this.text += `
-    la a1, ${nomeStringLiteral}
-    li a2, ${tamanhoString}
-    li a0, 1                # fd stdout
-    li a7, 64               # sys_write
+        this.text += `
+    la a1, ${nomeStringLiteral}
+    li a2, ${tamanhoString}
+    li a0, 1                # fd stdout
+    li a7, 64               # sys_write
     ecall`;
     }
     saidaSistema() {
-        this.text += `
-    li a0, 0                # código de saída
-    li a7, 93               # sys_exit
+        this.text += `
+    li a0, 0                # código de saída
+    li a7, 93               # sys_exit
     ecall`;
     }
     traduzir(declaracoes) {
@@ -43979,14 +44210,14 @@ class TradutorAssemblyX64 {
             Escreva: this.traduzirDeclaracaoEscreva.bind(this),
         };
         this.indentacao = 0;
-        this.textoSaida = `
-section .text
-    ${this.alvo === 'linux' ? 'global _start' : 'global main'}
+        this.textoSaida = `
+section .text
+    ${this.alvo === 'linux' ? 'global _start' : 'global main'}
 ${this.alvo === 'linux' ? '_start:' : 'main:'}`;
         if (this.alvo === 'windows') {
             this.textoSaida =
-                `
-extern printf
+                `
+extern printf
 ` + this.textoSaida;
         }
     }
@@ -44046,8 +44277,8 @@ extern printf
         }
         const indice = this.dicionarioConstrutos[construto.indice.constructor.name](construto.indice);
         const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
-        this.textoSaida += `
-    mov rax, ${valor}
+        this.textoSaida += `
+    mov rax, ${valor}
     mov [${nomeVar} + ${indice} * 8], rax`;
     }
     traduzirConstrutoAtribuir(construto) {
@@ -44065,8 +44296,8 @@ extern printf
             this.bss += `    ${varLabel} resq 1\n`;
             this.variaveis.set(nomeVar, varLabel);
         }
-        this.textoSaida += `
-    mov rax, ${valor}
+        this.textoSaida += `
+    mov rax, ${valor}
     mov [${this.variaveis.get(nomeVar)}], rax`;
     }
     traduzirConstrutoBinario(construto) {
@@ -44074,71 +44305,71 @@ extern printf
         const direita = this.dicionarioConstrutos[construto.direita.constructor.name](construto.direita);
         const operador = construto.operador.lexema;
         const registrador = this.obterRegistrador();
-        this.textoSaida += `
-    mov rax, ${esquerda}
+        this.textoSaida += `
+    mov rax, ${esquerda}
     mov ${registrador}, ${direita}`;
         switch (operador) {
             case '+':
-                this.textoSaida += `
+                this.textoSaida += `
     add rax, ${registrador}`;
                 break;
             case '-':
-                this.textoSaida += `
+                this.textoSaida += `
     sub rax, ${registrador}`;
                 break;
             case '*':
-                this.textoSaida += `
+                this.textoSaida += `
     imul rax, ${registrador}`;
                 break;
             case '/':
-                this.textoSaida += `
-    xor rdx, rdx
+                this.textoSaida += `
+    xor rdx, rdx
     idiv ${registrador}`;
                 break;
             case '%':
-                this.textoSaida += `
-    xor rdx, rdx
-    idiv ${registrador}
+                this.textoSaida += `
+    xor rdx, rdx
+    idiv ${registrador}
     mov rax, rdx`;
                 break;
             case '<':
-                this.textoSaida += `
-    cmp rax, ${registrador}
-    setl al
+                this.textoSaida += `
+    cmp rax, ${registrador}
+    setl al
     movzx rax, al`;
                 break;
             case '>':
-                this.textoSaida += `
-    cmp rax, ${registrador}
-    setg al
+                this.textoSaida += `
+    cmp rax, ${registrador}
+    setg al
     movzx rax, al`;
                 break;
             case '<=':
-                this.textoSaida += `
-    cmp rax, ${registrador}
-    setle al
+                this.textoSaida += `
+    cmp rax, ${registrador}
+    setle al
     movzx rax, al`;
                 break;
             case '>=':
-                this.textoSaida += `
-    cmp rax, ${registrador}
-    setge al
+                this.textoSaida += `
+    cmp rax, ${registrador}
+    setge al
     movzx rax, al`;
                 break;
             case '==':
-                this.textoSaida += `
-    cmp rax, ${registrador}
-    sete al
+                this.textoSaida += `
+    cmp rax, ${registrador}
+    sete al
     movzx rax, al`;
                 break;
             case '!=':
-                this.textoSaida += `
-    cmp rax, ${registrador}
-    setne al
+                this.textoSaida += `
+    cmp rax, ${registrador}
+    setne al
     movzx rax, al`;
                 break;
             default:
-                this.textoSaida += `
+                this.textoSaida += `
     ; Operador ${operador} não implementado`;
         }
         this.liberarRegistrador(registrador);
@@ -44156,28 +44387,28 @@ extern printf
         construto.argumentos.forEach((arg, index) => {
             if (index < registrosArgs.length) {
                 const valorArg = this.dicionarioConstrutos[arg.constructor.name](arg);
-                this.textoSaida += `
+                this.textoSaida += `
     mov ${registrosArgs[index]}, ${valorArg}`;
             }
             else {
                 // TODO: push extra args on stack according to target ABI
             }
         });
-        this.textoSaida += `
+        this.textoSaida += `
     call ${nomeFuncao}`;
     }
     traduzirConstrutoDefinirValor(construto) {
         const objeto = this.dicionarioConstrutos[construto.objeto.constructor.name](construto.objeto);
         const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
-        this.textoSaida += `
-    mov rax, ${valor}
+        this.textoSaida += `
+    mov rax, ${valor}
     mov [${objeto}], rax`;
     }
     traduzirFuncaoConstruto(construto) {
         const labelFuncao = `func_${this.gerarDigitoAleatorio()}`;
-        this.textoSaida += `
-${labelFuncao}:
-    push rbp
+        this.textoSaida += `
+${labelFuncao}:
+    push rbp
     mov rbp, rsp`;
         // Traduzir corpo da função
         if (construto.corpo && Array.isArray(construto.corpo)) {
@@ -44187,8 +44418,8 @@ ${labelFuncao}:
                 }
             });
         }
-        this.textoSaida += `
-    pop rbp
+        this.textoSaida += `
+    pop rbp
     ret`;
     }
     traduzirConstrutoLiteral(construto) {
@@ -44203,29 +44434,29 @@ ${labelFuncao}:
         const operador = construto.operador.lexema;
         const labelVerdadeiro = this.gerarLabel();
         const labelFim = this.gerarLabel();
-        this.textoSaida += `
-    mov rax, ${esquerda}
+        this.textoSaida += `
+    mov rax, ${esquerda}
     cmp rax, 0`;
         if (operador === 'e' || operador === '&&') {
-            this.textoSaida += `
-    je ${labelFim}
-    mov rax, ${direita}
-    cmp rax, 0
-    je ${labelFim}
-${labelVerdadeiro}:
-    mov rax, 1
+            this.textoSaida += `
+    je ${labelFim}
+    mov rax, ${direita}
+    cmp rax, 0
+    je ${labelFim}
+${labelVerdadeiro}:
+    mov rax, 1
 ${labelFim}:`;
         }
         else if (operador === 'ou' || operador === '||') {
-            this.textoSaida += `
-    jne ${labelVerdadeiro}
-    mov rax, ${direita}
-    cmp rax, 0
-    jne ${labelVerdadeiro}
-    mov rax, 0
-    jmp ${labelFim}
-${labelVerdadeiro}:
-    mov rax, 1
+            this.textoSaida += `
+    jne ${labelVerdadeiro}
+    mov rax, ${direita}
+    cmp rax, 0
+    jne ${labelVerdadeiro}
+    mov rax, 0
+    jmp ${labelFim}
+${labelVerdadeiro}:
+    mov rax, 1
 ${labelFim}:`;
         }
         return 'rax';
@@ -44238,26 +44469,26 @@ ${labelFim}:`;
     traduzirConstrutoUnario(construto) {
         const operando = this.dicionarioConstrutos[construto.operando.constructor.name](construto.operando);
         const operador = construto.operador.lexema;
-        this.textoSaida += `
+        this.textoSaida += `
     mov rax, ${operando}`;
         if (operador === '-') {
-            this.textoSaida += `
+            this.textoSaida += `
     neg rax`;
         }
         else if (operador === '!' || operador === 'nao') {
-            this.textoSaida += `
-    cmp rax, 0
-    sete al
+            this.textoSaida += `
+    cmp rax, 0
+    sete al
     movzx rax, al`;
         }
         else if (operador === '++') {
-            this.textoSaida += `
-    inc rax
+            this.textoSaida += `
+    inc rax
     mov ${operando}, rax`;
         }
         else if (operador === '--') {
-            this.textoSaida += `
-    dec rax
+            this.textoSaida += `
+    dec rax
     mov ${operando}, rax`;
         }
         return 'rax';
@@ -44277,8 +44508,8 @@ ${labelFim}:`;
             construto.valores.forEach((valor, index) => {
                 if (this.dicionarioConstrutos[valor.constructor.name]) {
                     const valorTraduzido = this.dicionarioConstrutos[valor.constructor.name](valor);
-                    this.textoSaida += `
-    mov rax, ${valorTraduzido}
+                    this.textoSaida += `
+    mov rax, ${valorTraduzido}
     mov [${rotuloVetor} + ${index * 8}], rax`;
                 }
             });
@@ -44298,17 +44529,17 @@ ${labelFim}:`;
     traduzirDeclaracaoEnquanto(declaracao) {
         const labelInicio = this.gerarLabel();
         const labelFim = this.gerarLabel();
-        this.textoSaida += `
+        this.textoSaida += `
 ${labelInicio}:`;
         const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
-        this.textoSaida += `
-    cmp ${condicao}, 0
+        this.textoSaida += `
+    cmp ${condicao}, 0
     je ${labelFim}`;
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
         }
-        this.textoSaida += `
-    jmp ${labelInicio}
+        this.textoSaida += `
+    jmp ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoEscolha(declaracao) {
@@ -44319,9 +44550,9 @@ ${labelFim}:`;
                 const labelProximo = this.gerarLabel();
                 if (caminho.condicoes && caminho.condicoes[0]) {
                     const valorCaso = this.dicionarioConstrutos[caminho.condicoes[0].constructor.name](caminho.condicoes[0]);
-                    this.textoSaida += `
-    mov rax, ${valorEscolha}
-    cmp rax, ${valorCaso}
+                    this.textoSaida += `
+    mov rax, ${valorEscolha}
+    cmp rax, ${valorCaso}
     jne ${labelProximo}`;
                     if (caminho.declaracoes && Array.isArray(caminho.declaracoes)) {
                         caminho.declaracoes.forEach((declaracao) => {
@@ -44330,13 +44561,13 @@ ${labelFim}:`;
                             }
                         });
                     }
-                    this.textoSaida += `
-    jmp ${labelFim}
+                    this.textoSaida += `
+    jmp ${labelFim}
 ${labelProximo}:`;
                 }
             });
         }
-        this.textoSaida += `
+        this.textoSaida += `
 ${labelFim}:`;
     }
     traduzirDeclaracaoExpressao(declaracao) {
@@ -44347,7 +44578,7 @@ ${labelFim}:`;
     }
     traduzirDeclaracaoFazer(declaracao) {
         const labelInicio = this.gerarLabel();
-        this.textoSaida += `
+        this.textoSaida += `
 ${labelInicio}:`;
         // Em Delégua, fazer-enquanto tem caminhoFazer que é um Bloco
         if (declaracao.caminhoFazer && declaracao.caminhoFazer.declaracoes) {
@@ -44359,8 +44590,8 @@ ${labelInicio}:`;
         }
         if (declaracao.condicaoEnquanto) {
             const condicao = this.dicionarioConstrutos[declaracao.condicaoEnquanto.constructor.name](declaracao.condicaoEnquanto);
-            this.textoSaida += `
-    cmp ${condicao}, 0
+            this.textoSaida += `
+    cmp ${condicao}, 0
     jne ${labelInicio}`;
         }
     }
@@ -44375,24 +44606,24 @@ ${labelInicio}:`;
             }
         }
         if (this.alvo === 'linux') {
-            this.textoSaida += `
-        ; Falhar com mensagem: ${mensagem}
-        mov eax, 1
-        mov ebx, 1
+            this.textoSaida += `
+        ; Falhar com mensagem: ${mensagem}
+        mov eax, 1
+        mov ebx, 1
         int 0x80`;
         }
         else {
-            this.textoSaida += `
-        ; Falhar com mensagem: ${mensagem}
-        mov eax, 1
+            this.textoSaida += `
+        ; Falhar com mensagem: ${mensagem}
+        mov eax, 1
         ret`;
         }
     }
     traduzirDeclaracaoFuncao(declaracao) {
         const nomeFuncao = declaracao.simbolo?.lexema || 'funcao';
-        this.textoSaida += `
-${nomeFuncao}:
-    push rbp
+        this.textoSaida += `
+${nomeFuncao}:
+    push rbp
     mov rbp, rsp`;
         if (declaracao.funcao &&
             declaracao.funcao.corpo &&
@@ -44403,13 +44634,13 @@ ${nomeFuncao}:
                 }
             });
         }
-        this.textoSaida += `
-    pop rbp
+        this.textoSaida += `
+    pop rbp
     ret`;
     }
     traduzirDeclaracaoImportar(declaracao) {
         // Importação é tratada em tempo de linkagem
-        this.textoSaida += `
+        this.textoSaida += `
     ; Importar: ${declaracao.caminho || 'unknown'}`;
     }
     traduzirDeclaracaoLeia(declaracao) {
@@ -44426,11 +44657,11 @@ ${nomeFuncao}:
             this.bss += `    ${varLabel} resb 256\n`;
             this.variaveis.set(nomeVar, varLabel);
         }
-        this.textoSaida += `
-    mov eax, 3
-    mov ebx, 0
-    mov ecx, ${this.variaveis.get(nomeVar)}
-    mov edx, 256
+        this.textoSaida += `
+    mov eax, 3
+    mov ebx, 0
+    mov ecx, ${this.variaveis.get(nomeVar)}
+    mov edx, 256
     int 0x80`;
     }
     traduzirDeclaracaoPara(declaracao) {
@@ -44456,12 +44687,12 @@ ${nomeFuncao}:
                 }
             }
         }
-        this.textoSaida += `
+        this.textoSaida += `
 ${labelInicio}:`;
         if (declaracao.condicao) {
             const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
-            this.textoSaida += `
-    cmp ${condicao}, 0
+            this.textoSaida += `
+    cmp ${condicao}, 0
     je ${labelFim}`;
         }
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
@@ -44472,8 +44703,8 @@ ${labelInicio}:`;
                 this.dicionarioConstrutos[declaracao.incrementar.constructor.name](declaracao.incrementar);
             }
         }
-        this.textoSaida += `
-    jmp ${labelInicio}
+        this.textoSaida += `
+    jmp ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoParaCada(declaracao) {
@@ -44488,57 +44719,57 @@ ${labelFim}:`;
         if (vetor instanceof construtos_1.Vetor) {
             tamanhoVetor = vetor.tamanho || 0;
         }
-        this.textoSaida += `
-    xor rcx, rcx
-${rotuloInicio}:
-    cmp rcx, ${tamanhoVetor}
+        this.textoSaida += `
+    xor rcx, rcx
+${rotuloInicio}:
+    cmp rcx, ${tamanhoVetor}
     jge ${rotuloFim}`;
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
         }
-        this.textoSaida += `
-    inc rcx
-    jmp ${rotuloInicio}
+        this.textoSaida += `
+    inc rcx
+    jmp ${rotuloInicio}
 ${rotuloFim}:`;
     }
     traduzirDeclaracaoRetorna(declaracao) {
         if (declaracao.valor) {
             const valor = this.dicionarioConstrutos[declaracao.valor.constructor.name](declaracao.valor);
-            this.textoSaida += `
+            this.textoSaida += `
     mov rax, ${valor}`;
         }
-        this.textoSaida += `
-    pop rbp
+        this.textoSaida += `
+    pop rbp
     ret`;
     }
     traduzirDeclaracaoSe(declaracao) {
         const rotuloSenao = this.gerarLabel();
         const rotuloFim = this.gerarLabel();
         const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
-        this.textoSaida += `
-    cmp ${condicao}, 0
+        this.textoSaida += `
+    cmp ${condicao}, 0
     je ${rotuloSenao}`;
         if (this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name](declaracao.caminhoEntao);
         }
-        this.textoSaida += `
-    jmp ${rotuloFim}
+        this.textoSaida += `
+    jmp ${rotuloFim}
 ${rotuloSenao}:`;
         if (declaracao.caminhoSenao &&
             this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name](declaracao.caminhoSenao);
         }
-        this.textoSaida += `
+        this.textoSaida += `
 ${rotuloFim}:`;
     }
     traduzirDeclaracaoClasse(declaracao) {
         // Classes em assembly são complexas - implementação básica
-        this.textoSaida += `
+        this.textoSaida += `
     ; Classe: ${declaracao.simbolo?.lexema || 'unknown'}`;
     }
     traduzirDeclaracaoTente(declaracao) {
         // Try-catch em assembly requer handler complexo
-        this.textoSaida += `
+        this.textoSaida += `
     ; Tente-pegue`;
         if (declaracao.caminhoTente && Array.isArray(declaracao.caminhoTente)) {
             declaracao.caminhoTente.forEach((declaracao) => {
@@ -44575,8 +44806,8 @@ ${rotuloFim}:`;
             }
             else if (this.dicionarioConstrutos[tipoInicializador]) {
                 const valor = this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
-                this.textoSaida += `
-    mov rax, ${valor}
+                this.textoSaida += `
+    mov rax, ${valor}
     mov [${varLabel}], rax`;
             }
         }
@@ -44596,33 +44827,33 @@ ${rotuloFim}:`;
             return;
         this.helperPrintIntEmitido = true;
         this.bss += `    __print_buf resb 24\n`;
-        this.helpers += `
-__delegua_print_int:
-    push rbx
-    push rcx
-    push rdx
-    push rsi
-    mov rcx, 10
-    lea rsi, [__print_buf + 22]
-    mov byte [rsi], 10
-.print_digitloop:
-    xor rdx, rdx
-    div rcx
-    add dl, '0'
-    dec rsi
-    mov [rsi], dl
-    test rax, rax
-    jnz .print_digitloop
-    lea rdx, [__print_buf + 23]
-    sub rdx, rsi
-    mov ecx, esi
-    mov ebx, 1
-    mov eax, 4
-    int 0x80
-    pop rsi
-    pop rdx
-    pop rcx
-    pop rbx
+        this.helpers += `
+__delegua_print_int:
+    push rbx
+    push rcx
+    push rdx
+    push rsi
+    mov rcx, 10
+    lea rsi, [__print_buf + 22]
+    mov byte [rsi], 10
+.print_digitloop:
+    xor rdx, rdx
+    div rcx
+    add dl, '0'
+    dec rsi
+    mov [rsi], dl
+    test rax, rax
+    jnz .print_digitloop
+    lea rdx, [__print_buf + 23]
+    sub rdx, rsi
+    mov ecx, esi
+    mov ebx, 1
+    mov eax, 4
+    int 0x80
+    pop rsi
+    pop rdx
+    pop rcx
+    pop rbx
     ret`;
     }
     traduzirDeclaracaoEscreva(declaracaoEscreva) {
@@ -44631,16 +44862,16 @@ __delegua_print_int:
             const nome_string_literal = this.criaStringLiteral(arg);
             const tam_string_literal = this.criaTamanhoNaMemoriaReferenteAVar(nome_string_literal);
             if (this.alvo === 'linux') {
-                this.textoSaida += `
-    mov edx, ${tam_string_literal}
-    mov ecx, ${nome_string_literal}
-    mov ebx, 1        ; fd stdout
-    mov eax, 4        ; sys_write
+                this.textoSaida += `
+    mov edx, ${tam_string_literal}
+    mov ecx, ${nome_string_literal}
+    mov ebx, 1        ; fd stdout
+    mov eax, 4        ; sys_write
     int 0x80`;
             }
             else {
-                this.textoSaida += `
-    lea rcx, [rel ${nome_string_literal}]
+                this.textoSaida += `
+    lea rcx, [rel ${nome_string_literal}]
     call printf`;
             }
         }
@@ -44648,8 +44879,8 @@ __delegua_print_int:
             const valor = this.dicionarioConstrutos[arg.constructor.name](arg);
             if (this.alvo === 'linux') {
                 this.emitirHelperPrintInt();
-                this.textoSaida += `
-    mov rax, ${valor}
+                this.textoSaida += `
+    mov rax, ${valor}
     call __delegua_print_int`;
             }
             else {
@@ -44657,24 +44888,24 @@ __delegua_print_int:
                     this.data += `    __fmt_int db '%d', 10, 0\n`;
                     this.fmtIntWindowsEmitido = true;
                 }
-                this.textoSaida += `
-    mov rdx, ${valor}
-    lea rcx, [rel __fmt_int]
+                this.textoSaida += `
+    mov rdx, ${valor}
+    lea rcx, [rel __fmt_int]
     call printf`;
             }
         }
     }
     saidaSistema() {
         if (this.alvo === 'linux') {
-            this.textoSaida += `
-        mov eax, 1        ; sys_exit
-        xor ebx, ebx      ; status 0
+            this.textoSaida += `
+        mov eax, 1        ; sys_exit
+        xor ebx, ebx      ; status 0
         int 0x80`;
         }
         else {
             // Windows: return from main with 0 in EAX
-            this.textoSaida += `
-        xor eax, eax
+            this.textoSaida += `
+        xor eax, eax
         ret`;
         }
     }
@@ -45975,13 +46206,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()';
         }
     }
     /**
@@ -46070,11 +46307,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 {
@@ -48551,22 +48792,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 ───────────────────────────────────────────────────────────────
@@ -48608,10 +48865,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) {
@@ -48656,24 +48916,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) {
@@ -48766,9 +49038,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)
             : '';
@@ -48788,7 +49058,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 {
@@ -49802,7 +50073,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} `;
@@ -50330,10 +50603,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());
@@ -50348,11 +50627,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;
@@ -50389,10 +50664,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();
@@ -50405,10 +50686,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()) {
@@ -50594,7 +50881,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();
@@ -50612,7 +50902,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());
@@ -50669,7 +50962,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();
@@ -53021,35 +53317,35 @@ class TradutorWebAssembly {
      * Fornece os imports necessários (`delegua.escreva_texto`, `delegua.escreva_inteiro`).
      */
     gerarArquivoHost() {
-        return `// Gerado por Delégua -> WebAssembly
-// Uso: node delegua-host.mjs <arquivo.wasm>
-import { readFileSync } from 'fs';
-
-const args = process.argv.slice(2);
-const wasmPath = args[0] ?? 'saida.wasm';
-
-let memoryExport;
-
-const importObject = {
-    delegua: {
-        /** Imprime texto a partir de um ponteiro e comprimento na memória linear. */
-        escreva_texto(ptr, len) {
-            const bytes = new Uint8Array(memoryExport.buffer, ptr, len);
-            process.stdout.write(new TextDecoder('utf-8').decode(bytes));
-        },
-        /** Imprime um inteiro de 64 bits (recebido como BigInt no JS). */
-        escreva_inteiro(valor) {
-            process.stdout.write(String(valor));
-        },
-    }
-};
-
-const wasmBuffer = readFileSync(wasmPath);
-const { instance } = await WebAssembly.instantiate(wasmBuffer, importObject);
-memoryExport = instance.exports.memory;
-
-const codigoSaida = Number(instance.exports.principal());
-process.exit(codigoSaida);
+        return `// Gerado por Delégua -> WebAssembly
+// Uso: node delegua-host.mjs <arquivo.wasm>
+import { readFileSync } from 'fs';
+
+const args = process.argv.slice(2);
+const wasmPath = args[0] ?? 'saida.wasm';
+
+let memoryExport;
+
+const importObject = {
+    delegua: {
+        /** Imprime texto a partir de um ponteiro e comprimento na memória linear. */
+        escreva_texto(ptr, len) {
+            const bytes = new Uint8Array(memoryExport.buffer, ptr, len);
+            process.stdout.write(new TextDecoder('utf-8').decode(bytes));
+        },
+        /** Imprime um inteiro de 64 bits (recebido como BigInt no JS). */
+        escreva_inteiro(valor) {
+            process.stdout.write(String(valor));
+        },
+    }
+};
+
+const wasmBuffer = readFileSync(wasmPath);
+const { instance } = await WebAssembly.instantiate(wasmBuffer, importObject);
+memoryExport = instance.exports.memory;
+
+const codigoSaida = Number(instance.exports.principal());
+process.exit(codigoSaida);
 `;
     }
 }