@designliquido/delegua 1.10.0 → 1.11.1

package/umd/delegua.js

@@ -12,7 +12,7 @@ const interfaces_1 = require("../interfaces");
  */
 class AnalisadorSemanticoBase {
     diagnosticoJaExiste(simbolo, mensagem) {
-        return this.diagnosticos.some(d => d.linha === simbolo.linha &&
+        return this.diagnosticos.some((d) => d.linha === simbolo.linha &&
             d.mensagem === mensagem &&
             d.simbolo.lexema === simbolo.lexema);
     }
@@ -63,7 +63,7 @@ class AnalisadorSemanticoBase {
         for (let [indice, parametro] of parametros.entries()) {
             const argumento = argumentos[indice];
             if (argumento) {
-                // Usando `obterTipoExpressao` para resolver adequadamente o tipo do argumento, 
+                // Usando `obterTipoExpressao` para resolver adequadamente o tipo do argumento,
                 // independentemente de ser um `Literal` (tipo já resolvido), `Variavel` (tipo inferido do
                 // escopo), `Binario`, `Agrupamento`, ou qualquer outro construto (retorna `null` quando
                 // o tipo não pode ser determinado em tempo de compilação).
@@ -119,7 +119,14 @@ class AnalisadorSemanticoBase {
      */
     inferirTipoBinario(binario) {
         const operadoresMatematicos = ['ADICAO', 'SUBTRACAO', 'MULTIPLICACAO', 'DIVISAO', 'MODULO'];
-        const operadoresComparacao = ['MAIOR', 'MAIOR_IGUAL', 'MENOR', 'MENOR_IGUAL', 'IGUAL', 'DIFERENTE'];
+        const operadoresComparacao = [
+            'MAIOR',
+            'MAIOR_IGUAL',
+            'MENOR',
+            'MENOR_IGUAL',
+            'IGUAL',
+            'DIFERENTE',
+        ];
         // Operadores de comparação sempre retornam lógico
         if (operadoresComparacao.includes(binario.operador.tipo)) {
             return 'lógico';
@@ -146,8 +153,8 @@ class AnalisadorSemanticoBase {
         return 'qualquer';
     }
     /**
-    * Marca as variáveis usadas em uma expressão.
-    */
+     * Marca as variáveis usadas em uma expressão.
+     */
     marcarVariaveisUsadasEmExpressao(expressao) {
         if (expressao instanceof construtos_1.Variavel) {
             this.gerenciadorEscopos.marcarComoUsada(expressao.simbolo.lexema);
@@ -233,7 +240,8 @@ class AnalisadorSemanticoBase {
         if (!caminhoSenaoResolvido || ((_a = caminhoSenaoResolvido.declaracoes) === null || _a === void 0 ? void 0 : _a.length) === 0) {
             return false;
         }
-        if (caminhoSenaoResolvido instanceof declaracoes_1.Se && ((_b = caminhoSenaoResolvido.caminhoEntao.declaracoes) === null || _b === void 0 ? void 0 : _b.length) === 1) {
+        if (caminhoSenaoResolvido instanceof declaracoes_1.Se &&
+            ((_b = caminhoSenaoResolvido.caminhoEntao.declaracoes) === null || _b === void 0 ? void 0 : _b.length) === 1) {
             const senaoSeRetorna = this.verificarSeRetorna(caminhoSenaoResolvido);
             return entaoRetorna && senaoSeRetorna;
         }
@@ -592,7 +600,8 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
     }
     visitarChamadaPorVariavel(entidadeChamadaVariavel, argumentos) {
         const variavel = entidadeChamadaVariavel;
-        const funcaoChamada = this.gerenciadorEscopos.buscar(variavel.simbolo.lexema) || this.funcoes[variavel.simbolo.lexema];
+        const funcaoChamada = this.gerenciadorEscopos.buscar(variavel.simbolo.lexema) ||
+            this.funcoes[variavel.simbolo.lexema];
         if (!funcaoChamada) {
             this.erro(entidadeChamadaVariavel.simbolo, `Chamada da função '${entidadeChamadaVariavel.simbolo.lexema}' não existe.`);
             return Promise.resolve();
@@ -889,15 +898,18 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                 // Verifica se a expressão problemática é um Leia ou uma variável inicializada com Leia
                 let mensagemAdicional = '';
                 if (expressaoProblematica instanceof construtos_1.Leia) {
-                    mensagemAdicional = " Função 'leia()' retorna texto. Use 'inteiro(leia(...))' ou 'real(leia(...))' para converter.";
+                    mensagemAdicional =
+                        " Função 'leia()' retorna texto. Use 'inteiro(leia(...))' ou 'real(leia(...))' para converter.";
                 }
                 else if (expressaoProblematica instanceof construtos_1.Variavel) {
                     const variavel = this.gerenciadorEscopos.buscar(expressaoProblematica.simbolo.lexema);
                     if (variavel && variavel.valor instanceof construtos_1.Leia) {
-                        mensagemAdicional = " A variável foi inicializada com 'leia()' que retorna texto. Use 'inteiro(leia(...))' ou 'real(leia(...))' para converter.";
+                        mensagemAdicional =
+                            " A variável foi inicializada com 'leia()' que retorna texto. Use 'inteiro(leia(...))' ou 'real(leia(...))' para converter.";
                     }
                     else {
-                        mensagemAdicional = " Use 'inteiro(...)' ou 'real(...)' para converter texto em número.";
+                        mensagemAdicional =
+                            " Use 'inteiro(...)' ou 'real(...)' para converter texto em número.";
                     }
                 }
                 this.erro(binario.operador, `Operação aritmética com tipo incompatível: operando ${ladoProblematico} é do tipo 'texto', mas a operação requer número.${mensagemAdicional}`);
@@ -906,8 +918,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         }
         if (tipoEsquerda && tipoDireita && tipoEsquerda !== tipoDireita) {
             // Verificar se são tipos numéricos compatíveis
-            const ambosNumericos = tiposNumericos.includes(tipoEsquerda) &&
-                tiposNumericos.includes(tipoDireita);
+            const ambosNumericos = tiposNumericos.includes(tipoEsquerda) && tiposNumericos.includes(tipoDireita);
             if (!ambosNumericos) {
                 this.aviso(binario.operador, `Operação entre tipos diferentes: tipo esquerdo '${tipoEsquerda}' e tipo direito '${tipoDireita}'. O resultado será resolvido implicitamente.`);
             }
@@ -1015,7 +1026,15 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                 let entidadeChamadaVariavel = chamada.entidadeChamada;
                 const nomeFuncao = entidadeChamadaVariavel.simbolo.lexema;
                 // Lista de funções built-in que não precisam ser declaradas
-                const funcoesBuiltIn = ['inteiro', 'real', 'número', 'texto', 'leia', 'escreva', 'tipo'];
+                const funcoesBuiltIn = [
+                    'inteiro',
+                    'real',
+                    'número',
+                    'texto',
+                    'leia',
+                    'escreva',
+                    'tipo',
+                ];
                 // Classes/construtores geralmente começam com letra maiúscula
                 const pareceSerClasse = nomeFuncao[0] === nomeFuncao[0].toUpperCase();
                 // Só verifica se a função existe se não for built-in e não parecer ser classe
@@ -1070,7 +1089,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                     tipo: 'IDENTIFICADOR',
                     linha: literal.linha,
                     hashArquivo: literal.hashArquivo,
-                    literal: null
+                    literal: null,
                 }, `Variável ou função '${nomeVariavel}' usada em interpolação não existe.`);
             }
             else if (variavel) {
@@ -1083,7 +1102,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                         tipo: 'IDENTIFICADOR',
                         linha: literal.linha,
                         hashArquivo: literal.hashArquivo,
-                        literal: null
+                        literal: null,
                     }, `Variável '${nomeVariavel}' usada em interpolação pode não ter sido inicializada.`);
                 }
             }
@@ -1146,7 +1165,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
             inicializada: true,
             usada: false,
             hashArquivo: declaracao.simbolo.hashArquivo,
-            linha: declaracao.simbolo.linha
+            linha: declaracao.simbolo.linha,
         });
         // TODO: Verificar inicializador.
         return Promise.resolve();
@@ -1178,7 +1197,8 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                                     if (tipoValor === 'string' && tipoRetornoFuncao !== 'texto') {
                                         this.erro(declaracao.simbolo, `Esperado retorno do tipo '${tipoRetornoFuncao}' dentro da função.`);
                                     }
-                                    if (tipoValor === 'number' && !['inteiro', 'real', 'número'].includes(tipoRetornoFuncao)) {
+                                    if (tipoValor === 'number' &&
+                                        !['inteiro', 'real', 'número'].includes(tipoRetornoFuncao)) {
                                         this.erro(declaracao.simbolo, `Esperado retorno do tipo '${tipoRetornoFuncao}' dentro da função.`);
                                     }
                                 }
@@ -1203,17 +1223,21 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
             tipoInferido = this.obterTipoExpressao(declaracao.inicializador);
         }
         // Sugestão de tipo melhor quando 'qualquer' é usado explicitamente
-        if (declaracao.tipoExplicito && declaracao.tipoOriginal === 'qualquer' && declaracao.inicializador) {
+        if (declaracao.tipoExplicito &&
+            declaracao.tipoOriginal === 'qualquer' &&
+            declaracao.inicializador) {
             const tipoMelhor = this.obterTipoExpressao(declaracao.inicializador);
             if (tipoMelhor && tipoMelhor !== 'qualquer') {
-                this.sugestao(declaracao.simbolo, 'Um tipo melhor pode ser inferido.', [{
+                this.sugestao(declaracao.simbolo, 'Um tipo melhor pode ser inferido.', [
+                    {
                         titulo: `Alterar tipo para '${tipoMelhor}'`,
                         textoOriginal: 'qualquer',
                         textoSubstituto: tipoMelhor,
                         linha: declaracao.simbolo.linha,
                         colunaInicio: declaracao.simbolo.colunaInicio,
                         colunaFim: declaracao.simbolo.colunaFim,
-                    }]);
+                    },
+                ]);
             }
         }
         const variavel = {
@@ -1224,7 +1248,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
             inicializada: declaracao.inicializador !== null && declaracao.inicializador !== undefined,
             usada: false,
             hashArquivo: declaracao.simbolo.hashArquivo,
-            linha: declaracao.simbolo.linha
+            linha: declaracao.simbolo.linha,
         };
         const declaradaComSucesso = this.gerenciadorEscopos.declarar(declaracao.simbolo.lexema, variavel);
         if (!declaradaComSucesso) {
@@ -1282,13 +1306,22 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
     }
     estaEmClasseOuSubclasse(nomeClasse) {
         var _a;
-        let atual = this.classeAtualEmAnalise;
-        while (atual !== null) {
+        const visitados = new Set();
+        const pilha = [this.classeAtualEmAnalise];
+        while (pilha.length > 0) {
+            const atual = pilha.pop();
+            if (!atual)
+                continue;
+            if (visitados.has(atual.simbolo.lexema))
+                continue;
+            visitados.add(atual.simbolo.lexema);
             if (atual.simbolo.lexema === nomeClasse)
                 return true;
-            if (!atual.superClasse)
-                break;
-            atual = (_a = this.classesRegistradas.get(atual.superClasse.simbolo.lexema)) !== null && _a !== void 0 ? _a : null;
+            for (const sc of atual.superClasses) {
+                const pai = (_a = this.classesRegistradas.get(sc.simbolo.lexema)) !== null && _a !== void 0 ? _a : null;
+                if (pai)
+                    pilha.push(pai);
+            }
         }
         return false;
     }
@@ -1316,13 +1349,13 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         }
     }
     async visitarDeclaracaoClasse(declaracao) {
-        if (declaracao.superClasse) {
-            const nomeSuperclasse = declaracao.superClasse.simbolo.lexema;
+        for (const superClasseVariavel of declaracao.superClasses) {
+            const nomeSuperclasse = superClasseVariavel.simbolo.lexema;
             if (nomeSuperclasse === declaracao.simbolo.lexema) {
-                this.erro(declaracao.superClasse.simbolo, `A classe '${declaracao.simbolo.lexema}' não pode herdar de si mesma.`);
+                this.erro(superClasseVariavel.simbolo, `A classe '${declaracao.simbolo.lexema}' não pode herdar de si mesma.`);
             }
             else if (!this.classesDeclararadas.has(nomeSuperclasse)) {
-                this.erro(declaracao.superClasse.simbolo, `Superclasse '${nomeSuperclasse}' não foi declarada.`);
+                this.erro(superClasseVariavel.simbolo, `Superclasse '${nomeSuperclasse}' não foi declarada.`);
             }
         }
         this.classesDeclararadas.add(declaracao.simbolo.lexema);
@@ -1360,7 +1393,9 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                 retorno.tipo === 'qualquer');
             // Se a função é 'vazio' e há retornos com tipo indeterminado,
             // tenta inferir o tipo e fornece mensagem útil ao desenvolvedor
-            if (tipoRetornoFuncao === 'vazio' && declaracao.funcao.tipoExplicito && retornosComTipoIndeterminado.length > 0) {
+            if (tipoRetornoFuncao === 'vazio' &&
+                declaracao.funcao.tipoExplicito &&
+                retornosComTipoIndeterminado.length > 0) {
                 const retornoComValor = retornosComTipoIndeterminado[0];
                 const tipoInferido = this.obterTipoExpressao(retornoComValor.valor);
                 if (tipoInferido && tipoInferido !== 'qualquer') {
@@ -1379,7 +1414,8 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                         if (tipoValor === 'string' && tipoRetornoFuncao !== 'texto') {
                             this.erro(declaracao.simbolo, `Esperado retorno do tipo '${tipoRetornoFuncao}' dentro da função.`);
                         }
-                        if (tipoValor === 'number' && !['inteiro', 'real', 'número'].includes(tipoRetornoFuncao)) {
+                        if (tipoValor === 'number' &&
+                            !['inteiro', 'real', 'número'].includes(tipoRetornoFuncao)) {
                             this.erro(declaracao.simbolo, `Esperado retorno do tipo '${tipoRetornoFuncao}' dentro da função.`);
                         }
                     }
@@ -1395,7 +1431,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         const naoUsadas = this.gerenciadorEscopos.obterVariaveisNaoUsadas();
         for (let variavel of naoUsadas) {
             // Verifica se já existe um erro associado à variável.
-            const temErro = this.diagnosticos.some(d => d.severidade === erros_1.DiagnosticoSeveridade.ERRO &&
+            const temErro = this.diagnosticos.some((d) => d.severidade === erros_1.DiagnosticoSeveridade.ERRO &&
                 d.simbolo.lexema === variavel.nome);
             // Se a variável já tem um erro associado, não emitir aviso de não usada.
             if (temErro) {
@@ -1405,7 +1441,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                 lexema: variavel.nome,
                 linha: variavel.linha,
                 tipo: variavel.tipo,
-                hashArquivo: variavel.hashArquivo
+                hashArquivo: variavel.hashArquivo,
             }, `Variável '${variavel.nome}' foi declarada mas nunca usada.`);
         }
     }
@@ -1914,6 +1950,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         if (this.simbolos[this.atual].lexema in this.tiposDefinidosEmCodigo) {
             return this.simbolos[this.atual].lexema;
         }
+        if (this.simbolos[this.atual].lexema in this.interfacesDeclaradas) {
+            return this.simbolos[this.atual].lexema;
+        }
         const lexemaElementar = this.simbolos[this.atual].lexema.toLowerCase();
         const tipoElementarResolvido = tipos.find((tipo) => tipo === lexemaElementar);
         if (!tipoElementarResolvido) {
@@ -1940,7 +1979,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
     }
     async construtoAjuda() {
         const simboloAjuda = this.avancarEDevolverAnterior();
-        if (this.estaNoFinal() || this.simbolos[this.atual].tipo !== delegua_2.default.PARENTESE_ESQUERDO) {
+        if (this.estaNoFinal() ||
+            this.simbolos[this.atual].tipo !== delegua_2.default.PARENTESE_ESQUERDO) {
             return new construtos_1.AjudaComoConstruto(simboloAjuda.hashArquivo, simboloAjuda.linha, undefined, false);
         }
         this.avancarEDevolverAnterior(); // parêntese esquerdo
@@ -2367,7 +2407,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             // o analisador semântico emitir o diagnóstico quando apropriado.
             tipoIdentificadorCorrespondente = 'qualquer';
         }
-        if (!tipoIdentificadorCorrespondente.endsWith('[]') && !['dicionário', 'qualquer', 'texto', 'tupla', 'vetor'].includes(tipoIdentificadorCorrespondente)) {
+        if (!tipoIdentificadorCorrespondente.endsWith('[]') &&
+            !['dicionário', 'qualquer', 'texto', 'tupla', 'vetor'].includes(tipoIdentificadorCorrespondente)) {
             throw this.erro(this.simbolos[this.atual], `Tipo ${tipoIdentificadorCorrespondente} não suporta acesso por índice.`);
         }
         let tipoAcesso = 'qualquer';
@@ -2441,8 +2482,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 if (expressaoAnterior.tipo === 'dicionário' &&
                     expressaoAnterior.constructor !== construtos_1.Dicionario) {
                     const elementoMontaoTipos = this.resolverElementoMontao(expressaoAnterior);
-                    if (elementoMontaoTipos &&
-                        nome.lexema in elementoMontaoTipos.subElementos) {
+                    if (elementoMontaoTipos && nome.lexema in elementoMontaoTipos.subElementos) {
                         tipoInferido = elementoMontaoTipos.subElementos[nome.lexema].tipo;
                     }
                 }
@@ -2699,7 +2739,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         if (construto instanceof construtos_1.Unario) {
             const operando = construto.operando;
             // Verifica se o operando é um vetor
-            if (operando instanceof construtos_1.Vetor || operando.tipo === 'vetor' || operando.tipo.endsWith('[]')) {
+            if (operando instanceof construtos_1.Vetor ||
+                operando.tipo === 'vetor' ||
+                operando.tipo.endsWith('[]')) {
                 return true;
             }
             // Verifica recursivamente para casos como !![]
@@ -3310,7 +3352,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
     }
     async declaracaoSe() {
         const condicao = await this.expressao();
-        const caminhoEntao = await this.resolverDeclaracao();
+        const caminhoEntao = (await this.resolverDeclaracao());
         let caminhoSenao = null;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.SENAO, delegua_2.default.SENÃO)) {
             caminhoSenao = await this.resolverDeclaracao();
@@ -3441,20 +3483,16 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         // Uma delas é a variável/constante ser uma classe padrão.
         // Isso ocorre quando a importação é feita de uma biblioteca Node.js.
         // Nesse caso, o tipo de `entidadeChamada.objeto` começa com uma letra maiúscula.
-        if (entidadeChamada.objeto.tipo &&
-            entidadeChamada.objeto.tipo.match(/^[A-Z]/)) {
+        if (entidadeChamada.objeto.tipo && entidadeChamada.objeto.tipo.match(/^[A-Z]/)) {
             const tipoCorrespondente = this.tiposDefinidosPorBibliotecas[entidadeChamada.objeto.tipo];
             if (!tipoCorrespondente) {
                 throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamada.simbolo, `Tipo '${entidadeChamada.objeto.tipo}' não foi encontrado entre os tipos definidos por bibliotecas.`);
             }
-            if (!(entidadeChamada.simbolo.lexema in
-                tipoCorrespondente.metodos) &&
-                !(entidadeChamada.simbolo.lexema in
-                    tipoCorrespondente.propriedades)) {
+            if (!(entidadeChamada.simbolo.lexema in tipoCorrespondente.metodos) &&
+                !(entidadeChamada.simbolo.lexema in tipoCorrespondente.propriedades)) {
                 throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamada.simbolo, `Membro '${entidadeChamada.simbolo.lexema}' não existe no tipo '${entidadeChamada.objeto.tipo}'.`);
             }
-            if (entidadeChamada.simbolo.lexema in
-                tipoCorrespondente.metodos) {
+            if (entidadeChamada.simbolo.lexema in tipoCorrespondente.metodos) {
                 const metodoCorrespondente = tipoCorrespondente.metodos[entidadeChamada.simbolo.lexema];
                 return metodoCorrespondente.tipoRetorno || 'qualquer';
             }
@@ -3807,7 +3845,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do corpo da interface.");
         const metodos = [];
         const propriedades = [];
-        while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
+        while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) &&
+            !this.estaNoFinal()) {
             this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
             if (this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA))
                 break;
@@ -3858,13 +3897,19 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         const simbolo = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da classe.');
         // Pré-registro para permitir auto-referência no corpo da própria classe,
         // como em `MinhaClasse.propriedadeEstatica` dentro de métodos.
-        this.tiposDefinidosEmCodigo[simbolo.lexema] = (_a = this.tiposDefinidosEmCodigo[simbolo.lexema]) !== null && _a !== void 0 ? _a : {};
+        this.tiposDefinidosEmCodigo[simbolo.lexema] =
+            (_a = this.tiposDefinidosEmCodigo[simbolo.lexema]) !== null && _a !== void 0 ? _a : {};
         const pilhaDecoradoresClasse = Array.from(this.pilhaDecoradores);
-        let superClasse = null;
+        // Verificar `herda SuperclasseA, SuperclasseB`
+        const superClasses = [];
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.HERDA)) {
-            const simboloSuperclasse = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da Superclasse.');
-            this.superclasseAtual = simboloSuperclasse.lexema;
-            superClasse = new construtos_1.Variavel(this.hashArquivo, this.simbolos[this.atual - 1], simboloSuperclasse.lexema);
+            do {
+                const simboloSuperclasse = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da Superclasse.');
+                if (superClasses.length === 0) {
+                    this.superclasseAtual = simboloSuperclasse.lexema;
+                }
+                superClasses.push(new construtos_1.Variavel(this.hashArquivo, this.simbolos[this.atual - 1], simboloSuperclasse.lexema));
+            } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         }
         // Verificar `implementa InterfaceA, InterfaceB`
         const implementaInterfaces = [];
@@ -3873,6 +3918,14 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 implementaInterfaces.push(this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome de interface após "implementa".'));
             } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         }
+        // Verificar `mescla MisturávelA, MisturávelB`
+        const mesclas = [];
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.MESCLA)) {
+            do {
+                const simboloMisturavel = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome de classe após "mescla".');
+                mesclas.push(new construtos_1.Variavel(this.hashArquivo, this.simbolos[this.atual - 1], simboloMisturavel.lexema));
+            } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
+        }
         this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo da classe.");
         this.pilhaDecoradores = [];
         const metodos = [];
@@ -3883,7 +3936,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
          */
         const compreenderMembros = async (acessoPadrao, ehEstaticoPadrao, ehAbstratoPadrao = false) => {
             var _a;
-            while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
+            while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) &&
+                !this.estaNoFinal()) {
                 // Pular comentários normais dentro do corpo da classe.
                 if (this.simbolos[this.atual].tipo === delegua_2.default.COMENTARIO ||
                     this.simbolos[this.atual].tipo === delegua_2.default.LINHA_COMENTARIO) {
@@ -3904,12 +3958,12 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 // Detecção de bloco de contexto: modificador seguido de '{'
                 const tipoAtual = this.simbolos[this.atual].tipo;
                 const tipoProximo = (_a = this.simbolos[this.atual + 1]) === null || _a === void 0 ? void 0 : _a.tipo;
-                const ehBlocoAcesso = [delegua_2.default.PRIVADO, delegua_2.default.PROTEGIDO].includes(tipoAtual)
-                    && tipoProximo === delegua_2.default.CHAVE_ESQUERDA;
-                const ehBlocoEstatico = tipoAtual === delegua_2.default.ESTATICO
-                    && tipoProximo === delegua_2.default.CHAVE_ESQUERDA;
-                const ehBlocoAbstrato = tipoAtual === delegua_2.default.ABSTRATO
-                    && tipoProximo === delegua_2.default.CHAVE_ESQUERDA;
+                const ehBlocoAcesso = [delegua_2.default.PRIVADO, delegua_2.default.PROTEGIDO].includes(tipoAtual) &&
+                    tipoProximo === delegua_2.default.CHAVE_ESQUERDA;
+                const ehBlocoEstatico = tipoAtual === delegua_2.default.ESTATICO &&
+                    tipoProximo === delegua_2.default.CHAVE_ESQUERDA;
+                const ehBlocoAbstrato = tipoAtual === delegua_2.default.ABSTRATO &&
+                    tipoProximo === delegua_2.default.CHAVE_ESQUERDA;
                 if (ehBlocoAcesso) {
                     const novoAcesso = tipoAtual === delegua_2.default.PRIVADO ? 'privado' : 'protegido';
                     this.avancarEDevolverAnterior(); // consume modificador de acesso
@@ -4006,14 +4060,17 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                             for (const declaracao of corpo) {
                                 expressoesRetorna = expressoesRetorna.concat((0, comum_1.buscarRetornos)(declaracao));
                             }
-                            const tiposRetornos = new Set(expressoesRetorna.filter((e) => e.tipo !== 'qualquer').map((e) => e.tipo));
+                            const tiposRetornos = new Set(expressoesRetorna
+                                .filter((e) => e.tipo !== 'qualquer')
+                                .map((e) => e.tipo));
                             const retornaChamadoExplicitamente = tiposRetornos.size > 0;
                             tiposRetornos.delete('qualquer');
                             if (tipoRetorno === 'qualquer') {
                                 if (tiposRetornos.size > 0) {
                                     tipoRetorno = tiposRetornos.values().next().value;
                                 }
-                                else if (!retornaChamadoExplicitamente && !definicaoExplicitaDeTipo) {
+                                else if (!retornaChamadoExplicitamente &&
+                                    !definicaoExplicitaDeTipo) {
                                     tipoRetorno = 'vazio';
                                 }
                             }
@@ -4035,7 +4092,13 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                         const nomePropriedade = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado identificador para nome de propriedade.');
                         this.consumir(delegua_2.default.DOIS_PONTOS, 'Esperado dois-pontos após nome de propriedade.');
                         const tipoPropriedade = this.avancarEDevolverAnterior();
-                        const prop = new declaracoes_1.PropriedadeClasse(nomePropriedade, tipoPropriedade.lexema, Array.from(this.pilhaDecoradores), modificadorAcesso, ehEstatico);
+                        let nomeTipoPropriedade = tipoPropriedade.lexema;
+                        if (this.verificarTipoSimboloAtual(delegua_2.default.COLCHETE_ESQUERDO)) {
+                            this.avancarEDevolverAnterior(); // consume '['
+                            this.consumir(delegua_2.default.COLCHETE_DIREITO, "Esperado ']' após '[' na definição do tipo de propriedade.");
+                            nomeTipoPropriedade = `${nomeTipoPropriedade}[]`;
+                        }
+                        const prop = new declaracoes_1.PropriedadeClasse(nomePropriedade, nomeTipoPropriedade, Array.from(this.pilhaDecoradores), modificadorAcesso, ehEstatico);
                         prop.documentacao = docAtual;
                         // Auto-propriedade: `nome: tipo { obter; definir; }`
                         // Ou corpo personalizado: `nome: tipo { obter() { ... } definir(valor) { ... } }`
@@ -4063,13 +4126,18 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                                         let tipoAcessor = 'qualquer';
                                         let expressoesRetornaAcessor = [];
                                         for (const declaracao of corpoAcessor) {
-                                            expressoesRetornaAcessor = expressoesRetornaAcessor.concat((0, comum_1.buscarRetornos)(declaracao));
+                                            expressoesRetornaAcessor =
+                                                expressoesRetornaAcessor.concat((0, comum_1.buscarRetornos)(declaracao));
                                         }
-                                        const tiposRetornosAcessor = new Set(expressoesRetornaAcessor.filter((e) => e.tipo !== 'qualquer').map((e) => e.tipo));
+                                        const tiposRetornosAcessor = new Set(expressoesRetornaAcessor
+                                            .filter((e) => e.tipo !== 'qualquer')
+                                            .map((e) => e.tipo));
                                         const retornaExplicitamenteAcessor = tiposRetornosAcessor.size > 0;
                                         tiposRetornosAcessor.delete('qualquer');
                                         if (tiposRetornosAcessor.size > 0) {
-                                            tipoAcessor = tiposRetornosAcessor.values().next().value;
+                                            tipoAcessor = tiposRetornosAcessor
+                                                .values()
+                                                .next().value;
                                         }
                                         else if (!retornaExplicitamenteAcessor) {
                                             tipoAcessor = 'vazio';
@@ -4121,28 +4189,59 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         await compreenderMembros('publico', false);
         this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
         // Verificação em tempo de análise: classe deve implementar todos os contratos das interfaces.
+        const linhaFinalClasse = this.simbolos[this.atual - 1].linha;
         for (const nomeInterface of implementaInterfaces) {
             const interfaceDecl = this.interfacesDeclaradas[nomeInterface.lexema];
             if (!interfaceDecl) {
                 this.erros.push(this.erro(nomeInterface, `Interface '${nomeInterface.lexema}' não foi declarada antes da classe '${simbolo.lexema}'.`));
                 continue;
             }
+            const membrosFaltando = [];
             for (const assinatura of interfaceDecl.metodos) {
                 const nomeMetodo = assinatura.nome.lexema;
                 const implementado = metodos.some((m) => m.simbolo.lexema === nomeMetodo);
                 if (!implementado) {
-                    this.erros.push(this.erro(simbolo, `Classe '${simbolo.lexema}' não implementa o método '${nomeMetodo}' exigido pela interface '${nomeInterface.lexema}'.`));
+                    membrosFaltando.push({
+                        tipo: 'metodo',
+                        nome: nomeMetodo,
+                        parametros: assinatura.parametros.map((p) => ({
+                            nome: p.nome.lexema,
+                            tipoDado: p.tipoDado,
+                        })),
+                        tipoRetorno: assinatura.tipoRetorno,
+                    });
                 }
             }
             for (const prop of interfaceDecl.propriedades) {
                 const nomeProp = prop.nome.lexema;
                 const implementada = propriedades.some((p) => p.nome.lexema === nomeProp);
                 if (!implementada) {
-                    this.erros.push(this.erro(simbolo, `Classe '${simbolo.lexema}' não declara a propriedade '${nomeProp}' exigida pela interface '${nomeInterface.lexema}'.`));
+                    membrosFaltando.push({
+                        tipo: 'propriedade',
+                        nome: nomeProp,
+                        tipoPropriedade: prop.tipo,
+                    });
+                }
+            }
+            if (membrosFaltando.length > 0) {
+                const correcaoSugerida = {
+                    tipo: 'implementar-interface',
+                    nomeInterface: nomeInterface.lexema,
+                    nomeClasse: simbolo.lexema,
+                    membrosFaltando,
+                    linhaFinalClasse,
+                };
+                for (const membro of membrosFaltando) {
+                    const mensagem = membro.tipo === 'metodo'
+                        ? `Classe '${simbolo.lexema}' não implementa o método '${membro.nome}' exigido pela interface '${nomeInterface.lexema}'.`
+                        : `Classe '${simbolo.lexema}' não declara a propriedade '${membro.nome}' exigida pela interface '${nomeInterface.lexema}'.`;
+                    const erro = this.erro(simbolo, mensagem);
+                    erro.correcaoSugerida = correcaoSugerida;
+                    this.erros.push(erro);
                 }
             }
         }
-        const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasse, metodos, propriedades, pilhaDecoradoresClasse, ehAbstrata, ehEstatica, implementaInterfaces);
+        const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasses, metodos, propriedades, pilhaDecoradoresClasse, ehAbstrata, ehEstatica, implementaInterfaces, mesclas);
         this.tiposDefinidosEmCodigo[definicaoClasse.simbolo.lexema] = definicaoClasse;
         this.superclasseAtual = undefined;
         return definicaoClasse;
@@ -4166,7 +4265,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         if (!this.primitivasConhecidas[nomeTipo]) {
             this.primitivasConhecidas[nomeTipo] = {};
         }
-        while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
+        while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) &&
+            !this.estaNoFinal()) {
             // Pular comentários dentro do corpo da extensão.
             if (this.simbolos[this.atual].tipo === delegua_2.default.COMENTARIO ||
                 this.simbolos[this.atual].tipo === delegua_2.default.LINHA_COMENTARIO) {
@@ -4214,7 +4314,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             const metodo = new declaracoes_1.FuncaoDeclaracao(nomeMetodo, corpoFuncao, tipoDaFuncao);
             metodos.push(metodo);
             const argumentos = params.map((parametro) => new informacao_elemento_sintatico_1.InformacaoElementoSintatico(parametro.nome.lexema, parametro.tipoDado || 'qualquer', parametro.valorPadrao === undefined));
-            this.primitivasConhecidas[nomeTipo][nomeMetodo.lexema] = new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeMetodo.lexema, tipoRetorno, true, argumentos);
+            this.primitivasConhecidas[nomeTipo][nomeMetodo.lexema] =
+                new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeMetodo.lexema, tipoRetorno, true, argumentos);
         }
         this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' ao final da extensão.");
         return new declaracoes_1.Extensao(simboloTipo, metodos, ehGlobal, this.hashArquivo);
@@ -4246,7 +4347,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 this.verificarTipoSimboloAtual(delegua_2.default.FUNÇÃO)) &&
                 this.verificarTipoProximoSimbolo(delegua_2.default.IDENTIFICADOR)) {
                 this.avancarEDevolverAnterior();
-                const declaracaoFuncao = await this.funcao('funcao');
+                const declaracaoFuncao = (await this.funcao('funcao'));
                 declaracaoFuncao.documentacao = docTopLevel;
                 return declaracaoFuncao;
             }
@@ -4320,7 +4421,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                     this.verificarTipoSimboloAtual(delegua_2.default.FUNÇÃO)) &&
                     this.verificarTipoProximoSimbolo(delegua_2.default.IDENTIFICADOR)) {
                     this.avancarEDevolverAnterior();
-                    const declaracaoFuncao = await this.funcao('funcao');
+                    const declaracaoFuncao = (await this.funcao('funcao'));
                     declaracaoFuncao.documentacao = new construtos_1.ComentarioComoConstruto(simboloDoc);
                     return declaracaoFuncao;
                 }
@@ -4390,7 +4491,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
     }
     async declaracaoAjuda() {
         const simboloAjuda = this.avancarEDevolverAnterior();
-        if (this.estaNoFinal() || this.simbolos[this.atual].tipo !== delegua_2.default.PARENTESE_ESQUERDO) {
+        if (this.estaNoFinal() ||
+            this.simbolos[this.atual].tipo !== delegua_2.default.PARENTESE_ESQUERDO) {
             return new declaracoes_1.Ajuda(simboloAjuda.hashArquivo, simboloAjuda.linha, undefined, false);
         }
         this.avancarEDevolverAnterior(); // parêntese esquerdo
@@ -4412,10 +4514,15 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.pilhaEscopos.empilhar(new informacao_escopo_1.InformacaoEscopo());
         // Funções nativas de Delégua
         this.pilhaEscopos.definirInformacoesVariavel('aleatorio', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('aleatorio', 'número'));
+        this.pilhaEscopos.definirInformacoesVariavel('aleatório', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('aleatório', 'número'));
         this.pilhaEscopos.definirInformacoesVariavel('aleatorioEntre', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('aleatorioEntre', 'número', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('minimo', 'número'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('maximo', 'número'),
         ]));
+        this.pilhaEscopos.definirInformacoesVariavel('aleatórioEntre', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('aleatórioEntre', 'número', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('minimo', 'número'),
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('maximo', 'número'),
+        ]));
         this.pilhaEscopos.definirInformacoesVariavel('algum', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('algum', 'lógico', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoPesquisa', 'função'),
@@ -4431,14 +4538,26 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoPesquisa', 'função'),
         ]));
+        this.pilhaEscopos.definirInformacoesVariavel('encontrarÍndice', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('encontrarÍndice', 'inteiro', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoPesquisa', 'função'),
+        ]));
         this.pilhaEscopos.definirInformacoesVariavel('encontrarUltimo', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('encontrarUltimo', 'inteiro', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoPesquisa', 'função'),
         ]));
+        this.pilhaEscopos.definirInformacoesVariavel('encontrarÚltimo', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('encontrarÚltimo', 'inteiro', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoPesquisa', 'função'),
+        ]));
         this.pilhaEscopos.definirInformacoesVariavel('encontrarUltimoIndice', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('encontrarUltimoIndice', 'inteiro', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoPesquisa', 'função'),
         ]));
+        this.pilhaEscopos.definirInformacoesVariavel('encontrarÚltimoÍndice', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('encontrarÚltimoÍndice', 'inteiro', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoPesquisa', 'função'),
+        ]));
         this.pilhaEscopos.definirInformacoesVariavel('filtrarPor', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('filtrarPor', 'qualquer[]', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoFiltragem', 'função'),
@@ -4447,6 +4566,10 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valor', 'qualquer'),
         ]));
+        this.pilhaEscopos.definirInformacoesVariavel('incluído', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('incluído', 'lógico', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valor', 'qualquer'),
+        ]));
         this.pilhaEscopos.definirInformacoesVariavel('inteiro', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('inteiro', 'inteiro', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valor', 'qualquer'),
         ]));
@@ -4462,6 +4585,18 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoMapeamento', 'função'),
         ]));
+        this.pilhaEscopos.definirInformacoesVariavel('maximo', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('maximo', 'qualquer', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('máximo', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('máximo', 'qualquer', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('minimo', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('minimo', 'qualquer', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('mínimo', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('mínimo', 'qualquer', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
+        ]));
         this.pilhaEscopos.definirInformacoesVariavel('numero', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('número', 'número', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valorParaConverter', 'qualquer'),
         ]));
@@ -4480,6 +4615,10 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoFiltragem', 'função'),
         ]));
+        this.pilhaEscopos.definirInformacoesVariavel('primeiroEmCondição', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('primeiroEmCondição', 'qualquer', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoFiltragem', 'função'),
+        ]));
         this.pilhaEscopos.definirInformacoesVariavel('real', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('real', 'número', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valorParaConverter', 'qualquer'),
         ]));
@@ -4495,12 +4634,16 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valorParaConverter', 'qualquer'),
         ]));
         this.pilhaEscopos.definirInformacoesVariavel('todos', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('todos', 'lógico', true, [
-            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('iteravel', 'qualquer')
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('iteravel', 'qualquer'),
         ]));
         this.pilhaEscopos.definirInformacoesVariavel('todosEmCondicao', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('todosEmCondicao', 'lógico', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('iteravel', 'qualquer'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoCondicional', 'função'),
         ]));
+        this.pilhaEscopos.definirInformacoesVariavel('todosEmCondição', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('todosEmCondição', 'lógico', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('iteravel', 'qualquer'),
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoCondicional', 'função'),
+        ]));
         this.pilhaEscopos.definirInformacoesVariavel('tupla', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tupla', 'tupla', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
         ]));
@@ -5276,7 +5419,7 @@ class AvaliadorSintaticoEguaClassico {
         }
         this.consumir(egua_classico_1.default.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
         this.superclasseAtual = undefined;
-        return new declaracoes_1.Classe(nome, superClasse, metodos);
+        return new declaracoes_1.Classe(nome, superClasse ? [superClasse] : [], metodos);
     }
     resolverDeclaracaoForaDeBloco() {
         try {
@@ -5370,20 +5513,16 @@ class AvaliadorSintaticoPitugues {
         // Uma delas é a variável/constante ser uma classe padrão.
         // Isso ocorre quando a importação é feita de uma biblioteca Node.js.
         // Nesse caso, o tipo de `entidadeChamada.objeto` começa com uma letra maiúscula.
-        if (entidadeChamada.objeto.tipo &&
-            entidadeChamada.objeto.tipo.match(/^[A-Z]/)) {
+        if (entidadeChamada.objeto.tipo && entidadeChamada.objeto.tipo.match(/^[A-Z]/)) {
             const tipoCorrespondente = this.tiposDefinidosPorBibliotecas[entidadeChamada.objeto.tipo];
             if (!tipoCorrespondente) {
                 throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamada.simbolo, `Tipo '${entidadeChamada.objeto.tipo}' não foi encontrado entre os tipos definidos por bibliotecas.`);
             }
-            if (!(entidadeChamada.simbolo.lexema in
-                tipoCorrespondente.metodos) &&
-                !(entidadeChamada.simbolo.lexema in
-                    tipoCorrespondente.propriedades)) {
+            if (!(entidadeChamada.simbolo.lexema in tipoCorrespondente.metodos) &&
+                !(entidadeChamada.simbolo.lexema in tipoCorrespondente.propriedades)) {
                 throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamada.simbolo, `Membro '${entidadeChamada.simbolo.lexema}' não existe no tipo '${entidadeChamada.objeto.tipo}'.`);
             }
-            if (entidadeChamada.simbolo.lexema in
-                tipoCorrespondente.metodos) {
+            if (entidadeChamada.simbolo.lexema in tipoCorrespondente.metodos) {
                 const metodoCorrespondente = tipoCorrespondente.metodos[entidadeChamada.simbolo.lexema];
                 return metodoCorrespondente.tipoRetorno || 'qualquer';
             }
@@ -5516,7 +5655,8 @@ class AvaliadorSintaticoPitugues {
                 pos++;
             }
             // Verifica se há um identificador obrigatório
-            if (pos >= this.simbolos.length || this.simbolos[pos].tipo !== pitugues_2.default.IDENTIFICADOR) {
+            if (pos >= this.simbolos.length ||
+                this.simbolos[pos].tipo !== pitugues_2.default.IDENTIFICADOR) {
                 return false;
             }
             pos++;
@@ -5539,7 +5679,7 @@ class AvaliadorSintaticoPitugues {
     }
     temPadraoVarComoPalavraChave() {
         // Verifica padrão: var identificador = ...
-        if (this.simbolos[this.atual].lexema !== "var") {
+        if (this.simbolos[this.atual].lexema !== 'var') {
             return false;
         }
         const proximo = this.simbolos[this.atual + 1];
@@ -5572,7 +5712,9 @@ class AvaliadorSintaticoPitugues {
                 this.consumir(pitugues_2.default.MULTIPLICACAO, '');
                 ehRestoAtual = true;
             }
-            const identificador = this.consumir(pitugues_2.default.IDENTIFICADOR, ehRestoAtual ? 'Esperado nome de variável após operador *.' : 'Esperado nome de variável.');
+            const identificador = this.consumir(pitugues_2.default.IDENTIFICADOR, ehRestoAtual
+                ? 'Esperado nome de variável após operador *.'
+                : 'Esperado nome de variável.');
             // Verifica * no nome da variável
             if (identificador.lexema.startsWith('*')) {
                 ehRestoAtual = true;
@@ -5600,10 +5742,10 @@ class AvaliadorSintaticoPitugues {
     }
     construirValidacaoDesempacotamento(identificador, origem, qtdEsperada) {
         const linha = identificador.linha;
-        const chamadaTamanho = new construtos_1.Chamada(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, new lexador_1.Simbolo(pitugues_2.default.IDENTIFICADOR, "tamanho", null, linha, -1)), [origem]);
-        const condicaoErro = new construtos_1.Binario(this.hashArquivo, chamadaTamanho, new lexador_1.Simbolo(pitugues_2.default.DIFERENTE, "!=", null, linha, -1), new construtos_1.Literal(this.hashArquivo, linha, qtdEsperada, 'número'));
+        const chamadaTamanho = new construtos_1.Chamada(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, new lexador_1.Simbolo(pitugues_2.default.IDENTIFICADOR, 'tamanho', null, linha, -1)), [origem]);
+        const condicaoErro = new construtos_1.Binario(this.hashArquivo, chamadaTamanho, new lexador_1.Simbolo(pitugues_2.default.DIFERENTE, '!=', null, linha, -1), new construtos_1.Literal(this.hashArquivo, linha, qtdEsperada, 'número'));
         const mensagem = `Erro de execução: Você tentou desempacotar em ${qtdEsperada} variáveis, mas o vetor possui tamanho diferente.`;
-        const falha = new declaracoes_1.Falhar(new lexador_1.Simbolo(pitugues_2.default.FALHAR, "falhar", null, linha, -1), new construtos_1.Literal(this.hashArquivo, linha, mensagem, 'texto'));
+        const falha = new declaracoes_1.Falhar(new lexador_1.Simbolo(pitugues_2.default.FALHAR, 'falhar', null, linha, -1), new construtos_1.Literal(this.hashArquivo, linha, mensagem, 'texto'));
         return new declaracoes_1.Se(condicaoErro, new declaracoes_1.Bloco(this.hashArquivo, linha, [falha]), [], null);
     }
     async declaracaoDeVariaveis() {
@@ -5615,7 +5757,8 @@ class AvaliadorSintaticoPitugues {
         const ehDesempacotamento = qtdIdentificadores > 1 && qtdValores === 1;
         if (indexResto > -1) {
             if (qtdValores < qtdIdentificadores - 1) {
-                if (!ehDesempacotamento || (ehDesempacotamento && inicializadores[0] instanceof construtos_1.Literal)) {
+                if (!ehDesempacotamento ||
+                    (ehDesempacotamento && inicializadores[0] instanceof construtos_1.Literal)) {
                     throw this.erro(this.simboloAnterior(), 'Quantidade insuficiente de valores para desempacotamento com operador de resto.');
                 }
             }
@@ -5651,7 +5794,7 @@ class AvaliadorSintaticoPitugues {
         for (let i = 0; i < identificadores.length; i++) {
             const identificador = identificadores[i];
             let inicializador;
-            let tipo = "qualquer";
+            let tipo = 'qualquer';
             if (i === indexResto) {
                 const valoresResto = inicializadores.slice(cursorValores, cursorValores + qtdParaResto);
                 let tipoInferido = (0, inferenciador_1.inferirTipoVariavel)(valoresResto);
@@ -5858,17 +6001,19 @@ class AvaliadorSintaticoPitugues {
             case pitugues_2.default.INTERPOLACAO:
                 const simboloInterpolacao = this.avancarEDevolverAnterior();
                 const conteudoOriginal = simboloInterpolacao.literal;
-                const codigoTransformado = '"' + conteudoOriginal.replace(/\{(.*?)\}/g, (_, miolo) => {
-                    // 'miolo' é o texto que estava dentro das chaves. Ex: "valor" ou "valor:.2f"
-                    if (miolo.includes(':')) {
-                        const [variavel, formato] = miolo.split(':').map(s => s.trim());
-                        if (variavel !== "") {
-                            // Transforma {valor:.2f} em "{:.2f}".formatar(valor)
-                            return '" + "{:' + formato + '}".formatar(' + variavel + ') + "';
+                const codigoTransformado = '"' +
+                    conteudoOriginal.replace(/\{(.*?)\}/g, (_, miolo) => {
+                        // 'miolo' é o texto que estava dentro das chaves. Ex: "valor" ou "valor:.2f"
+                        if (miolo.includes(':')) {
+                            const [variavel, formato] = miolo.split(':').map((s) => s.trim());
+                            if (variavel !== '') {
+                                // Transforma {valor:.2f} em "{:.2f}".formatar(valor)
+                                return '" + "{:' + formato + '}".formatar(' + variavel + ') + "';
+                            }
                         }
-                    }
-                    return '" + (' + miolo.trim() + ') + "';
-                }) + '"';
+                        return '" + (' + miolo.trim() + ') + "';
+                    }) +
+                    '"';
                 const microLexador = new micro_lexador_pitugues_1.MicroLexadorPitugues();
                 const retornoMicroLexador = microLexador.mapear(codigoTransformado);
                 const microAvaliadorSintatico = new micro_avaliador_sintatico_pitugues_1.MicroAvaliadorSintaticoPitugues();
@@ -5881,7 +6026,7 @@ class AvaliadorSintaticoPitugues {
                 }
                 catch (erro) {
                     this.erros.push(erro);
-                    return new construtos_1.Literal(this.hashArquivo, simboloInterpolacao.linha, "");
+                    return new construtos_1.Literal(this.hashArquivo, simboloInterpolacao.linha, '');
                 }
                 const declaracao = retornoMicroAvaliador.declaracoes[0];
                 return declaracao.expressao;
@@ -5939,11 +6084,11 @@ class AvaliadorSintaticoPitugues {
                 let passo = null;
                 if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DOIS_PONTOS)) {
                     ehFatiamento = true;
-                    if (!this.verificarTipoSimboloAtual(pitugues_2.default.DOIS_PONTOS)
-                        && !this.verificarTipoSimboloAtual(pitugues_2.default.COLCHETE_DIREITO))
+                    if (!this.verificarTipoSimboloAtual(pitugues_2.default.DOIS_PONTOS) &&
+                        !this.verificarTipoSimboloAtual(pitugues_2.default.COLCHETE_DIREITO))
                         fim = await this.expressao();
-                    if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DOIS_PONTOS)
-                        && !this.verificarTipoSimboloAtual(pitugues_2.default.COLCHETE_DIREITO))
+                    if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DOIS_PONTOS) &&
+                        !this.verificarTipoSimboloAtual(pitugues_2.default.COLCHETE_DIREITO))
                         passo = await this.expressao();
                 }
                 const simboloFechamento = this.consumir(pitugues_2.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
@@ -6075,11 +6220,13 @@ class AvaliadorSintaticoPitugues {
     }
     async seTernario() {
         let expressaoEntao = await this.ou();
-        if (this.simbolos[this.atual] && this.simbolos[this.atual].tipo === pitugues_2.default.SE && expressaoEntao.linha === this.simbolos[this.atual].linha) {
+        if (this.simbolos[this.atual] &&
+            this.simbolos[this.atual].tipo === pitugues_2.default.SE &&
+            expressaoEntao.linha === this.simbolos[this.atual].linha) {
             while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.SE)) {
                 const operador = this.simbolos[this.atual - 1];
                 const expressaoOuCondicao = await this.seTernario();
-                this.consumir(pitugues_2.default.SENAO, `Esperado 'senão' ou 'senao' após caminho positivo em se ternário. Atual:
+                this.consumir(pitugues_2.default.SENAO, `Esperado 'senão' ou 'senao' após caminho positivo em se ternário. Atual:
                     ${this.simbolos[this.atual].lexema}.`);
                 const expressaoSenao = await this.seTernario();
                 expressaoEntao = new construtos_1.SeTernario(this.hashArquivo, expressaoOuCondicao, expressaoEntao, operador, expressaoSenao);
@@ -6224,7 +6371,8 @@ class AvaliadorSintaticoPitugues {
                 simboloAtual = this.simboloAtual();
                 if (!simboloAtual)
                     break;
-                espacosIndentacaoLinhaAtual = this.localizacoes[simboloAtual.linha].espacosIndentacao;
+                espacosIndentacaoLinhaAtual =
+                    this.localizacoes[simboloAtual.linha].espacosIndentacao;
             }
         }
         this.pilhaEscopos.removerUltimo();
@@ -6234,7 +6382,7 @@ class AvaliadorSintaticoPitugues {
         try {
             this.blocos += 1;
             const condicao = await this.expressao();
-            const bloco = await this.resolverDeclaracao();
+            const bloco = (await this.resolverDeclaracao());
             return new declaracoes_1.Enquanto(condicao, bloco);
         }
         finally {
@@ -6308,7 +6456,7 @@ class AvaliadorSintaticoPitugues {
         }
         this.pilhaEscopos.definirInformacoesVariavel(nomeVariavelIteracao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeVariavelIteracao.lexema, tipoVetor.slice(0, -2)));
         // TODO: Talvez não seja uma ideia melhor chamar o método de `Bloco` aqui?
-        const corpo = await this.resolverDeclaracao();
+        const corpo = (await this.resolverDeclaracao());
         return new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Variavel(this.hashArquivo, nomeVariavelIteracao), vetor, corpo);
     }
     async declaracaoPara() {
@@ -6340,7 +6488,7 @@ class AvaliadorSintaticoPitugues {
                 this.pilhaEscopos.definirInformacoesVariavel(simboloSegundaVariavel.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(simboloSegundaVariavel.lexema, 'qualquer'));
             }
             // TODO: Talvez não seja uma ideia melhor chamar o método de `Bloco` aqui?
-            const corpo = await this.resolverDeclaracao();
+            const corpo = (await this.resolverDeclaracao());
             return new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), variavelIteracao, alvoIteracao, corpo);
         }
         finally {
@@ -6369,7 +6517,7 @@ class AvaliadorSintaticoPitugues {
     }
     async declaracaoSe() {
         const condicao = await this.expressao();
-        const caminhoEntao = await this.resolverDeclaracao();
+        const caminhoEntao = (await this.resolverDeclaracao());
         let caminhoSenao = null;
         if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.SENAO, pitugues_2.default.SENÃO)) {
             caminhoSenao = await this.resolverDeclaracao();
@@ -6447,11 +6595,13 @@ class AvaliadorSintaticoPitugues {
                 this.consumir(pitugues_2.default.DOIS_PONTOS, `Esperado ':' antes do escopo do bloco 'pegue'.`);
                 this.pilhaEscopos.definirInformacoesVariavel(variavelExcecao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(variavelExcecao.lexema, 'qualquer'));
                 const corpo = await this.blocoEscopo();
-                blocoPegue = new construtos_1.FuncaoConstruto(this.hashArquivo, simboloTente.linha, [{
-                        abrangencia: "padrao",
+                blocoPegue = new construtos_1.FuncaoConstruto(this.hashArquivo, simboloTente.linha, [
+                    {
+                        abrangencia: 'padrao',
                         nome: variavelExcecao,
-                        tipoDado: "qualquer",
-                    }], corpo, "vazio", false);
+                        tipoDado: 'qualquer',
+                    },
+                ], corpo, 'vazio', false);
             }
             else {
                 // Caso 2: sem parâmetro de erro.
@@ -6476,7 +6626,7 @@ class AvaliadorSintaticoPitugues {
         const simboloFazer = this.simboloAnterior();
         try {
             this.blocos += 1;
-            const declaracaoOuBlocoFazer = await this.resolverDeclaracao();
+            const declaracaoOuBlocoFazer = (await this.resolverDeclaracao());
             this.consumir(pitugues_2.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo da declaração 'fazer'.");
             const condicaoEnquanto = await this.expressao();
             return new declaracoes_1.Fazer(simboloFazer.hashArquivo, Number(simboloFazer.linha), declaracaoOuBlocoFazer, condicaoEnquanto);
@@ -6642,7 +6792,7 @@ class AvaliadorSintaticoPitugues {
             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 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);
             }
@@ -6651,7 +6801,7 @@ class AvaliadorSintaticoPitugues {
             }
         }
         this.superclasseAtual = undefined;
-        const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasse, metodos, propriedades);
+        const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasse ? [superClasse] : [], metodos, propriedades);
         if (possivelDocumentacao) {
             definicaoClasse.documentacao = possivelDocumentacao;
         }
@@ -6797,8 +6947,10 @@ class AvaliadorSintaticoPitugues {
             case pitugues_2.default.DE: {
                 const proximo = this.simbolos[this.atual + 1];
                 const aposProximo = this.simbolos[this.atual + 2];
-                if (proximo && proximo.tipo === pitugues_2.default.IDENTIFICADOR &&
-                    aposProximo && aposProximo.tipo === pitugues_2.default.IMPORTAR) {
+                if (proximo &&
+                    proximo.tipo === pitugues_2.default.IDENTIFICADOR &&
+                    aposProximo &&
+                    aposProximo.tipo === pitugues_2.default.IMPORTAR) {
                     this.avancarEDevolverAnterior();
                     return this.declaracaoImportarDe();
                 }
@@ -6913,7 +7065,7 @@ class AvaliadorSintaticoPitugues {
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('elemento', 'qualquer'),
         ]));
         this.pilhaEscopos.definirInformacoesVariavel('todos', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('todos', 'lógico', true, [
-            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('iteravel', 'qualquer')
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('iteravel', 'qualquer'),
         ]));
         this.pilhaEscopos.definirInformacoesVariavel('todosEmCondicao', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('todosEmCondicao', 'lógico', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('iteravel', 'qualquer'),
@@ -6923,7 +7075,7 @@ class AvaliadorSintaticoPitugues {
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
         ]));
         this.pilhaEscopos.definirInformacoesVariavel('vetor', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'vetor', true, [
-            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tupla', 'qualquer')
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tupla', 'qualquer'),
         ]));
     }
     async analisar(retornoLexador, hashArquivo) {
@@ -6950,7 +7102,8 @@ class AvaliadorSintaticoPitugues {
             else {
                 declaracoes.push(retornoDeclaracao);
             }
-            if (!this.estaNoFinal() && this.verificarTipoSimboloAtual(pitugues_2.default.PONTO_E_VIRGULA)) {
+            if (!this.estaNoFinal() &&
+                this.verificarTipoSimboloAtual(pitugues_2.default.PONTO_E_VIRGULA)) {
                 // Verificar se este ; está na mesma linha da declaração anterior
                 const declaracaoAnterior = declaracoes[declaracoes.length - 1];
                 const linhaDeclaraoAnterior = declaracaoAnterior.linha || 0;
@@ -7336,12 +7489,12 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
      */
     construtoTextoMultilinhas() {
         const segundoColchete = this.consumir(prisma_1.default.COLCHETE_ESQUERDO, "Esperado '[' antes do texto multilinhas.");
-        let texto = "";
+        let texto = '';
         let linha = segundoColchete.linha;
         while (!this.verificarSeSimboloAtualEIgualA(prisma_1.default.COLCHETE_DIREITO)) {
-            texto += this.simbolos[this.atual].lexema + " ";
+            texto += this.simbolos[this.atual].lexema + ' ';
             if (this.simbolos[this.atual].linha !== linha) {
-                texto += "\n";
+                texto += '\n';
                 linha = this.simbolos[this.atual].linha;
             }
             this.avancarEDevolverAnterior();
@@ -7573,7 +7726,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         try {
             this.blocos += 1;
             const condicao = await this.expressao();
-            const bloco = await this.resolverDeclaracao();
+            const bloco = (await this.resolverDeclaracao());
             return new declaracoes_1.Enquanto(condicao, bloco);
         }
         finally {
@@ -7829,7 +7982,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         }
         this.consumir(prisma_1.default.CHAVE_DIREITA, "Esperado '}' após métodos da classe.");
         this.superclasseAtual = undefined;
-        const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasse, metodos);
+        const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasse ? [superClasse] : [], metodos);
         this.tiposDefinidosEmCodigo[definicaoClasse.simbolo.lexema] = definicaoClasse;
         return definicaoClasse;
     }
@@ -8599,7 +8752,7 @@ class AvaliadorSintaticoTenda extends avaliador_sintatico_base_1.AvaliadorSintat
     async declaracaoSe() {
         const condicao = await this.expressao();
         this.consumir(tenda_1.default.ENTÃO, "Esperado 'então' após a condição.");
-        const caminhoEntao = await this.resolverDeclaracao();
+        const caminhoEntao = (await this.resolverDeclaracao());
         let caminhoSenao = null;
         if (this.verificarSeSimboloAtualEIgualA(tenda_1.default.SENÃO)) {
             caminhoSenao = await this.resolverDeclaracao();
@@ -9710,15 +9863,51 @@ const estruturas_1 = require("../interpretador/estruturas");
 const construtos_1 = require("../construtos");
 const quebras_1 = require("../quebras");
 const configTuplas = {
-    'Dupla': { Classe: construtos_1.Dupla, props: ['primeiro', 'segundo'] },
-    'Trio': { Classe: construtos_1.Trio, props: ['primeiro', 'segundo', 'terceiro'] },
-    'Quarteto': { Classe: construtos_1.Quarteto, props: ['primeiro', 'segundo', 'terceiro', 'quarto'] },
-    'Quinteto': { Classe: construtos_1.Quinteto, props: ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto'] },
-    'Sexteto': { Classe: construtos_1.Sexteto, props: ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto'] },
-    'Septeto': { Classe: construtos_1.Septeto, props: ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto', 'setimo'] },
-    'Octeto': { Classe: construtos_1.Octeto, props: ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto', 'setimo', 'oitavo'] },
-    'Noneto': { Classe: construtos_1.Noneto, props: ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto', 'setimo', 'oitavo', 'nono'] },
-    'Deceto': { Classe: construtos_1.Deceto, props: ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto', 'setimo', 'oitavo', 'nono', 'decimo'] },
+    Dupla: { Classe: construtos_1.Dupla, props: ['primeiro', 'segundo'] },
+    Trio: { Classe: construtos_1.Trio, props: ['primeiro', 'segundo', 'terceiro'] },
+    Quarteto: { Classe: construtos_1.Quarteto, props: ['primeiro', 'segundo', 'terceiro', 'quarto'] },
+    Quinteto: { Classe: construtos_1.Quinteto, props: ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto'] },
+    Sexteto: {
+        Classe: construtos_1.Sexteto,
+        props: ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto'],
+    },
+    Septeto: {
+        Classe: construtos_1.Septeto,
+        props: ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto', 'setimo'],
+    },
+    Octeto: {
+        Classe: construtos_1.Octeto,
+        props: ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto', 'setimo', 'oitavo'],
+    },
+    Noneto: {
+        Classe: construtos_1.Noneto,
+        props: [
+            'primeiro',
+            'segundo',
+            'terceiro',
+            'quarto',
+            'quinto',
+            'sexto',
+            'setimo',
+            'oitavo',
+            'nono',
+        ],
+    },
+    Deceto: {
+        Classe: construtos_1.Deceto,
+        props: [
+            'primeiro',
+            'segundo',
+            'terceiro',
+            'quarto',
+            'quinto',
+            'sexto',
+            'setimo',
+            'oitavo',
+            'nono',
+            'decimo',
+        ],
+    },
 };
 const mapaConstrutoresTupla = {
     2: construtos_1.Dupla,
@@ -9729,18 +9918,39 @@ const mapaConstrutoresTupla = {
     7: construtos_1.Septeto,
     8: construtos_1.Octeto,
     9: construtos_1.Noneto,
-    10: construtos_1.Deceto
+    10: construtos_1.Deceto,
 };
 const mapaPropriedadesTuplas = {
-    'Dupla': ['primeiro', 'segundo'],
-    'Trio': ['primeiro', 'segundo', 'terceiro'],
-    'Quarteto': ['primeiro', 'segundo', 'terceiro', 'quarto'],
-    'Quinteto': ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto'],
-    'Sexteto': ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto'],
-    'Septeto': ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto', 'setimo'],
-    'Octeto': ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto', 'setimo', 'oitavo'],
-    'Noneto': ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto', 'setimo', 'oitavo', 'nono'],
-    'Deceto': ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto', 'setimo', 'oitavo', 'nono', 'decimo'],
+    Dupla: ['primeiro', 'segundo'],
+    Trio: ['primeiro', 'segundo', 'terceiro'],
+    Quarteto: ['primeiro', 'segundo', 'terceiro', 'quarto'],
+    Quinteto: ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto'],
+    Sexteto: ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto'],
+    Septeto: ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto', 'setimo'],
+    Octeto: ['primeiro', 'segundo', 'terceiro', 'quarto', 'quinto', 'sexto', 'setimo', 'oitavo'],
+    Noneto: [
+        'primeiro',
+        'segundo',
+        'terceiro',
+        'quarto',
+        'quinto',
+        'sexto',
+        'setimo',
+        'oitavo',
+        'nono',
+    ],
+    Deceto: [
+        'primeiro',
+        'segundo',
+        'terceiro',
+        'quarto',
+        'quinto',
+        'sexto',
+        'setimo',
+        'oitavo',
+        'nono',
+        'decimo',
+    ],
 };
 /**
  * Compara dois valores (números ou vetores).
@@ -9858,16 +10068,15 @@ async function arredondar(interpretador, numero, casasDecimais) {
     const valorNumero = interpretador.resolverValor(numero);
     const valorCasas = interpretador.resolverValor(casasDecimais);
     if (numero == undefined || numero == null) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(null, "Erro: arredondar() deve receber um número.", interpretador.linhaDeclaracaoAtual));
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(null, 'Erro: arredondar() deve receber um número.', interpretador.linhaDeclaracaoAtual));
     }
-    if (typeof numero !== "number") {
+    if (typeof numero !== 'number') {
         return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(null, `Erro de Tipo: arredondar() espera um número, mas recebeu '${typeof valorNumero}'.`, interpretador.linhaDeclaracaoAtual));
     }
     const fator = Math.pow(10, valorCasas);
     const resultado = Math.round(valorNumero * fator) / fator;
     return Promise.resolve(resultado);
 }
-;
 /**
  * Clona profundamente uma variável ou constante em Delégua.
  * @param {InterpretadorInterface} interpretador A instância do interpretador.
@@ -10256,8 +10465,10 @@ async function intervalo(interpretador, valorInicial, valorFinal, valorPasso) {
     }
     // intervalo(inicio, parada) ou intervalo(inicio, parada, passo)
     else {
-        if (typeof primeiroParam !== 'number' || isNaN(primeiroParam) ||
-            typeof segundoParam !== 'number' || isNaN(segundoParam)) {
+        if (typeof primeiroParam !== 'number' ||
+            isNaN(primeiroParam) ||
+            typeof segundoParam !== 'number' ||
+            isNaN(segundoParam)) {
             return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
                 hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
                 linha: interpretador.linhaDeclaracaoAtual,
@@ -10640,14 +10851,18 @@ async function tamanho(interpretador, objeto) {
         const metodos = valorObjeto.metodos;
         let tamanho = 0;
         const metodoInicializacao = metodos.inicializacao;
-        if (metodoInicializacao && !Array.isArray(metodoInicializacao) && metodoInicializacao.eInicializador) {
+        if (metodoInicializacao &&
+            !Array.isArray(metodoInicializacao) &&
+            metodoInicializacao.eInicializador) {
             tamanho = metodoInicializacao.declaracao.parametros.length;
         }
         else if (Array.isArray(metodoInicializacao)) {
             // Em caso de construtores sobrecarregados, `metodos.inicializacao` pode ser um array.
             // Usamos o maior número de parâmetros entre as sobrecargas que são inicializadores.
             for (const inicializador of metodoInicializacao) {
-                if (inicializador && inicializador.eInicializador && ((_a = inicializador.declaracao) === null || _a === void 0 ? void 0 : _a.parametros)) {
+                if (inicializador &&
+                    inicializador.eInicializador &&
+                    ((_a = inicializador.declaracao) === null || _a === void 0 ? void 0 : _a.parametros)) {
                     const aridade = inicializador.declaracao.parametros.length;
                     if (aridade > tamanho) {
                         tamanho = aridade;
@@ -10717,8 +10932,7 @@ async function todosEmCondicao(interpretador, iteravel, funcaoCondicional) {
         }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.'));
     }
     const valorFuncao = interpretador.resolverValor(funcaoCondicional);
-    const ehFuncaoValida = valorFuncao instanceof estruturas_1.DeleguaFuncao ||
-        valorFuncao instanceof funcao_padrao_1.FuncaoPadrao;
+    const ehFuncaoValida = valorFuncao instanceof estruturas_1.DeleguaFuncao || valorFuncao instanceof funcao_padrao_1.FuncaoPadrao;
     if (!ehFuncaoValida) {
         return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
@@ -10743,7 +10957,7 @@ async function todosEmCondicao(interpretador, iteravel, funcaoCondicional) {
  */
 async function tupla(interpretador, vetor) {
     const valorVetor = interpretador.resolverValor(vetor);
-    const elementos = valorVetor.map(item => new construtos_1.Literal(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, interpretador.resolverValor(item)));
+    const elementos = valorVetor.map((item) => new construtos_1.Literal(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, interpretador.resolverValor(item)));
     return new construtos_1.TuplaN(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, elementos);
 }
 async function vetor(interpretador, tupla) {
@@ -10762,9 +10976,10 @@ async function vetor(interpretador, tupla) {
         const nomeClasse = objetoTupla.constructor.name;
         const props = mapaPropriedadesTuplas[nomeClasse];
         if (props) {
-            resultado = props.map(prop => objetoTupla[prop]);
+            resultado = props.map((prop) => objetoTupla[prop]);
         }
-        else if (objetoTupla.elementos && Array.isArray(objetoTupla.elementos)) {
+        else if (objetoTupla.elementos &&
+            Array.isArray(objetoTupla.elementos)) {
             resultado = objetoTupla.elementos;
         }
     }
@@ -10790,14 +11005,13 @@ exports.default = {
             if (!(objetoTupla instanceof construtos_1.TuplaN)) {
                 return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(null, `A função "paraVetor" só pode ser chamada em tuplas.`, interpretador.linhaDeclaracaoAtual));
             }
-            const valoresPuros = objetoTupla.elementos.map(elemento => interpretador.resolverValor(elemento));
+            const valoresPuros = objetoTupla.elementos.map((elemento) => interpretador.resolverValor(elemento));
             return Promise.resolve(valoresPuros);
         },
         assinaturaFormato: 'tupla.paraVetor()',
-        documentacao: '# `tupla.paraVetor()` \n \n' +
-            'Converte a tupla atual em um array.',
+        documentacao: '# `tupla.paraVetor()` \n \n' + 'Converte a tupla atual em um array.',
         exemploCodigo: 'tupla.paraVetor()',
-    }
+    },
 };
 
 },{"../../../construtos":62,"../../../excecoes":131}],29:[function(require,module,exports){
@@ -10879,7 +11093,7 @@ exports.default = {
         implementacao: (interpretador, valor) => {
             return Promise.resolve(Object.values(valor));
         },
-    }
+    },
 };
 
 },{"../construtos":62,"../informacao-elemento-sintatico":138}],30:[function(require,module,exports){
@@ -11000,7 +11214,7 @@ const implementacaoParticao = (interpretador, texto, separador, ...args) => {
         const depois = texto.substring(indice + separador.length);
         partes = [antes, separador, depois];
     }
-    const elementos = partes.map(p => new construtos_1.Literal(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, p, 'texto'));
+    const elementos = partes.map((p) => new construtos_1.Literal(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, p, 'texto'));
     const tupla = new construtos_1.TuplaN(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, elementos);
     return Promise.resolve(tupla);
 };
@@ -11295,6 +11509,75 @@ exports.default = {
             '\n\n ### Formas de uso \n',
         exemploCodigo: 'texto.tudoMinusculo()',
     },
+    apararInício: {
+        tipoRetorno: 'texto',
+        argumentos: [],
+        implementacao: (interpretador, texto) => Promise.resolve(texto.trimStart()),
+        assinaturaFormato: 'texto.apararInício()',
+        documentacao: '# `texto.apararInício()` \n \n' +
+            'Remover espaços em branco no início e no fim de um texto.' +
+            '\n\n ## Exemplo de Código\n' +
+            '\n\n```delegua\nvar t = "   meu texto com espaços no início e no fim       "\n' +
+            'escreva("|" + t.apararInício() + "|") // "|meu texto com espaços no início e no fim       |"\n```' +
+            '\n\n ### Formas de uso \n',
+        exemploCodigo: 'texto.apararInício()',
+    },
+    maiúsculo: {
+        tipoRetorno: 'texto',
+        argumentos: [],
+        implementacao: (interpretador, texto) => Promise.resolve(texto.toUpperCase()),
+        assinaturaFormato: 'texto.maiúsculo()',
+        documentacao: '# `texto.maiúsculo()` \n \n' +
+            'Converte todos os caracteres alfabéticos para suas respectivas formas em maiúsculo.' +
+            '\n\n ## Exemplo de Código\n' +
+            '\n\n```delegua\nvar t = "tudo em minúsculo"\n' +
+            'escreva(t.maiúsculo()) // "TUDO EM MINÚSCULO"\n```' +
+            '\n\n ### Formas de uso \n',
+        exemploCodigo: 'texto.maiúsculo()',
+    },
+    minúsculo: {
+        tipoRetorno: 'texto',
+        argumentos: [],
+        implementacao: (interpretador, texto) => Promise.resolve(texto.toLowerCase()),
+        assinaturaFormato: 'texto.minúsculo()',
+        documentacao: '# `texto.minúsculo()` \n \n' +
+            'Converte todos os caracteres alfabéticos para suas respectivas formas em minúsculo.' +
+            '\n\n ## Exemplo de Código\n' +
+            '\n\n```delegua\nvar t = "TUDO EM MAIÚSCULO"\n' +
+            'escreva(t.minúsculo()) // "tudo em maiúsculo"\n```' +
+            '\n\n ### Formas de uso \n',
+        exemploCodigo: 'texto.minúsculo()',
+    },
+    tudoMaiúsculo: {
+        tipoRetorno: 'lógico',
+        argumentos: [],
+        implementacao: (interpretador, texto) => Promise.resolve(texto === texto.toUpperCase()),
+        assinaturaFormato: 'texto.tudoMaiúsculo()',
+        documentacao: '# `texto.tudoMaiúsculo()` \n\n' +
+            'Devolve verdadeiro se todos os caracteres alfabéticos do texto estão em maiúsculo, e falso em caso contrário.' +
+            '\n\n ## Exemplo de Código\n' +
+            '\n\n```delegua\nvar t1 = "TUDO EM MAIÚSCULO"\n' +
+            'var t2 = "Tudo em Maiúsculo"\n' +
+            't1.tudoMaiúsculo() // verdadeiro\n' +
+            't2.tudoMaiúsculo() // falso\n```' +
+            '\n\n ### Formas de uso \n',
+        exemploCodigo: 'texto.tudoMaiúsculo()',
+    },
+    tudoMinúsculo: {
+        tipoRetorno: 'lógico',
+        argumentos: [],
+        implementacao: (interpretador, texto) => Promise.resolve(texto === texto.toLowerCase()),
+        assinaturaFormato: 'texto.tudoMinúsculo()',
+        documentacao: '# `texto.tudoMinúsculo()` \n\n' +
+            'Devolve verdadeiro se todos os caracteres alfabéticos do texto estão em minúsculo, e falso em caso contrário.' +
+            '\n\n ## Exemplo de Código\n' +
+            '\n\n```delegua\nvar t1 = "tudo em minúsculo"\n' +
+            'var t2 = "Tudo em Minúsculo"\n' +
+            't1.tudoMinúsculo() // verdadeiro\n' +
+            't2.tudoMinúsculo() // falso\n```' +
+            '\n\n ### Formas de uso \n',
+        exemploCodigo: 'texto.tudoMinúsculo()',
+    },
 };
 
 },{"../construtos":62,"../excecoes":131,"../informacao-elemento-sintatico":138}],32:[function(require,module,exports){
@@ -11313,7 +11596,7 @@ const mapaConstrutoresTupla = {
     7: construtos_1.Septeto,
     8: construtos_1.Octeto,
     9: construtos_1.Noneto,
-    10: construtos_1.Deceto
+    10: construtos_1.Deceto,
 };
 exports.default = {
     adicionar: {
@@ -11660,6 +11943,24 @@ exports.default = {
             '\n\n ### Formas de uso \n',
         exemploCodigo: 'vetor.removerUltimo()',
     },
+    removerÚltimo: {
+        tipoRetorno: 'qualquer',
+        argumentos: [],
+        implementacao: (interpretador, vetor) => {
+            let elemento = vetor.pop();
+            return Promise.resolve(elemento);
+        },
+        assinaturaFormato: 'vetor.removerÚltimo()',
+        documentacao: '# `vetor.removerÚltimo()` \n \n' +
+            'Remove o último elemento do vetor caso o elemento exista no vetor.\n' +
+            '\n\n ## Exemplo de Código\n' +
+            '\n\n```delegua\nvar vetor = [1, 2, 3]\n' +
+            'var ultimoElemento = vetor.removerÚltimo()\n' +
+            'escreva(ultimoElemento) // 3\n' +
+            'escreva(vetor) // [1, 2]\n```' +
+            '\n\n ### Formas de uso \n',
+        exemploCodigo: 'vetor.removerÚltimo()',
+    },
     somar: {
         tipoRetorno: 'qualquer',
         argumentos: [],
@@ -11926,7 +12227,7 @@ class AjudaComoConstruto {
         return retorno;
     }
     paraTextoSaida() {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
 }
 exports.AjudaComoConstruto = AjudaComoConstruto;
@@ -12032,9 +12333,12 @@ class Atribuir {
             const alvoComoVariavel = alvo;
             const tipoAlvo = alvoComoVariavel === null || alvoComoVariavel === void 0 ? void 0 : alvoComoVariavel.tipo;
             const alvoSuportaIndice = alvo instanceof variavel_1.Variavel &&
-                (tipoAlvo === 'vetor' || tipoAlvo === 'dicionário' || tipoAlvo === 'qualquer' || (tipoAlvo === null || tipoAlvo === void 0 ? void 0 : tipoAlvo.endsWith('[]')));
+                (tipoAlvo === 'vetor' ||
+                    tipoAlvo === 'dicionário' ||
+                    tipoAlvo === 'qualquer' ||
+                    (tipoAlvo === null || tipoAlvo === void 0 ? void 0 : tipoAlvo.endsWith('[]')));
             if (!alvoSuportaIndice) {
-                throw new Error("`indice` só pode ser informado quando o alvo for uma variável de vetor ou dicionário.");
+                throw new Error('`indice` só pode ser informado quando o alvo for uma variável de vetor ou dicionário.');
             }
             this.indice = indice;
         }
@@ -12103,8 +12407,7 @@ class Binario {
             ['logico', 'lógico'].includes(this.direita.tipo)) {
             return 'lógico';
         }
-        if (this.esquerda.tipo === 'texto' ||
-            this.direita.tipo === 'texto') {
+        if (this.esquerda.tipo === 'texto' || this.direita.tipo === 'texto') {
             return 'texto';
         }
         if (['numero', 'número'].includes(this.esquerda.tipo) ||
@@ -12270,7 +12573,9 @@ class Decorador {
                 continue;
             }
             const valor = this.atributos[chave];
-            const valorTexto = valor && typeof valor === 'object' && typeof valor.paraTexto === 'function' ? valor.paraTexto() : valor;
+            const valorTexto = valor && typeof valor === 'object' && typeof valor.paraTexto === 'function'
+                ? valor.paraTexto()
+                : valor;
             atributos += `${chave}=${valorTexto} `;
         }
         if (atributos.length > 0) {
@@ -12971,11 +13276,13 @@ class TuplaN extends tupla_1.Tupla {
         return await visitante.visitarExpressaoTuplaN(this);
     }
     paraTexto() {
-        const elementosTexto = this.elementos.map(elemento => elemento.paraTexto()).join(', ');
+        const elementosTexto = this.elementos.map((elemento) => elemento.paraTexto()).join(', ');
         return `(${elementosTexto})`;
     }
     paraTextoSaida() {
-        const elementosTexto = this.elementos.map(elemento => elemento.paraTextoSaida()).join(', ');
+        const elementosTexto = this.elementos
+            .map((elemento) => elemento.paraTextoSaida())
+            .join(', ');
         return `(${elementosTexto})`;
     }
 }
@@ -13522,10 +13829,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Classe = void 0;
 const declaracao_1 = require("./declaracao");
 class Classe extends declaracao_1.Declaracao {
-    constructor(simbolo, superClasse, metodos, propriedades = [], decoradores = [], abstrata = false, classeEstatica = false, implementa = []) {
+    /** Compat com tradutores e analisador semântico que ainda usam .superClasse */
+    get superClasse() {
+        var _a;
+        return (_a = this.superClasses[0]) !== null && _a !== void 0 ? _a : null;
+    }
+    constructor(simbolo, superClasses = [], metodos, propriedades = [], decoradores = [], abstrata = false, classeEstatica = false, implementa = [], mesclas = []) {
         super(Number(simbolo.linha), simbolo.hashArquivo);
         this.simbolo = simbolo;
-        this.superClasse = superClasse;
+        this.superClasses = superClasses;
+        this.mesclas = mesclas;
         this.metodos = metodos;
         this.propriedades = propriedades;
         this.decoradores = decoradores;
@@ -13538,8 +13851,11 @@ class Classe extends declaracao_1.Declaracao {
     }
     paraTexto() {
         let resultado = `<classe nome=${this.simbolo.lexema} `;
-        if (this.superClasse) {
-            resultado += `herda=${this.superClasse} `;
+        if (this.superClasses.length > 0) {
+            resultado += `herda=${this.superClasses.map((s) => { var _a, _b; return (_b = (_a = s === null || s === void 0 ? void 0 : s.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) !== null && _b !== void 0 ? _b : s; }).join(', ')} `;
+        }
+        if (this.mesclas.length > 0) {
+            resultado += `mescla=${this.mesclas.map((m) => { var _a, _b; return (_b = (_a = m === null || m === void 0 ? void 0 : m.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) !== null && _b !== void 0 ? _b : m; }).join(', ')} `;
         }
         resultado += '>';
         for (const propriedade of this.propriedades) {
@@ -14507,7 +14823,11 @@ class EstilizadorDelegua {
      * Verifica se um objeto é uma Declaração.
      */
     ehDeclaracao(obj) {
-        return obj && typeof obj === 'object' && 'paraTexto' in obj && 'linha' in obj && 'hashArquivo' in obj;
+        return (obj &&
+            typeof obj === 'object' &&
+            'paraTexto' in obj &&
+            'linha' in obj &&
+            'hashArquivo' in obj);
     }
     /**
      * Verifica se um objeto é um Construto.
@@ -15734,24 +16054,60 @@ class FormatadorPitugues {
         this.nívelIndentação -= this.tamanhoIndentação;
     }
     // Métodos obrigatórios da interface, não usados no Pituguês.
-    visitarDeclaracaoCabecalhoPrograma() { return Promise.resolve(); }
-    visitarDeclaracaoConstMultiplo() { return Promise.resolve(); }
-    visitarDeclaracaoEscrevaMesmaLinha() { return Promise.resolve(); }
-    visitarDeclaracaoInicioAlgoritmo() { return Promise.resolve(); }
-    visitarDeclaracaoTendoComo() { return Promise.resolve(); }
-    visitarDeclaracaoVarMultiplo() { return Promise.resolve(); }
-    visitarExpressaoAcessoElementoMatriz() { return Promise.resolve(); }
-    visitarExpressaoAcessoMetodo() { return Promise.resolve(); }
-    visitarExpressaoAcessoPropriedade() { return Promise.resolve(); }
-    visitarExpressaoArgumentoReferenciaFuncao() { return Promise.resolve(); }
-    visitarExpressaoAtribuicaoPorIndicesMatriz() { return Promise.resolve(); }
-    visitarExpressaoComentario() { return Promise.resolve(); }
-    visitarExpressaoExpressaoRegular() { return Promise.resolve(); }
-    visitarExpressaoFimPara() { return Promise.resolve(); }
-    visitarExpressaoFormatacaoEscrita() { return Promise.resolve(); }
-    visitarExpressaoReferenciaFuncao() { return Promise.resolve(); }
-    visitarExpressaoSeparador() { return Promise.resolve(); }
-    visitarExpressaoTupla() { return Promise.resolve(); }
+    visitarDeclaracaoCabecalhoPrograma() {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoConstMultiplo() {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoEscrevaMesmaLinha() {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoInicioAlgoritmo() {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoTendoComo() {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoVarMultiplo() {
+        return Promise.resolve();
+    }
+    visitarExpressaoAcessoElementoMatriz() {
+        return Promise.resolve();
+    }
+    visitarExpressaoAcessoMetodo() {
+        return Promise.resolve();
+    }
+    visitarExpressaoAcessoPropriedade() {
+        return Promise.resolve();
+    }
+    visitarExpressaoArgumentoReferenciaFuncao() {
+        return Promise.resolve();
+    }
+    visitarExpressaoAtribuicaoPorIndicesMatriz() {
+        return Promise.resolve();
+    }
+    visitarExpressaoComentario() {
+        return Promise.resolve();
+    }
+    visitarExpressaoExpressaoRegular() {
+        return Promise.resolve();
+    }
+    visitarExpressaoFimPara() {
+        return Promise.resolve();
+    }
+    visitarExpressaoFormatacaoEscrita() {
+        return Promise.resolve();
+    }
+    visitarExpressaoReferenciaFuncao() {
+        return Promise.resolve();
+    }
+    visitarExpressaoSeparador() {
+        return Promise.resolve();
+    }
+    visitarExpressaoTupla() {
+        return Promise.resolve();
+    }
     async visitarExpressaoTuplaN(expressao) {
         this.códigoFormatado += '(';
         for (let i = 0; i < expressao.elementos.length; i++) {
@@ -15765,7 +16121,7 @@ class FormatadorPitugues {
     }
     async visitarDeclaracaoDeExpressao(declaracao) {
         this.códigoFormatado += this.indentar();
-        this.códigoFormatado += await declaracao.expressao.aceitar(this) + `\n`;
+        this.códigoFormatado += (await declaracao.expressao.aceitar(this)) + `\n`;
     }
     async visitarDeclaracaoClasse(declaração) {
         this.adicionarLinha(`classe ${declaração.simbolo.lexema}:`);
@@ -15920,7 +16276,9 @@ class FormatadorPitugues {
         if (declaração.caminhoPegue) {
             this.adicionarLinha('pegue como erro:');
             this.aumentarIndentação();
-            const declaracoes = declaração.caminhoPegue instanceof construtos_1.FuncaoConstruto ? declaração.caminhoPegue.corpo : declaração.caminhoPegue;
+            const declaracoes = declaração.caminhoPegue instanceof construtos_1.FuncaoConstruto
+                ? declaração.caminhoPegue.corpo
+                : declaração.caminhoPegue;
             for (const instrução of declaracoes) {
                 await instrução.aceitar(this);
             }
@@ -15935,7 +16293,9 @@ class FormatadorPitugues {
         }
     }
     async visitarDeclaracaoEscreva(declaração) {
-        this.códigoFormatado += this.indentar() + `${declaração.simboloEscreva ? declaração.simboloEscreva.lexema : 'imprima'}(`;
+        this.códigoFormatado +=
+            this.indentar() +
+                `${declaração.simboloEscreva ? declaração.simboloEscreva.lexema : 'imprima'}(`;
         for (let i = 0; i < declaração.argumentos.length; i++) {
             this.códigoFormatado += await declaração.argumentos[i].aceitar(this);
             if (i < declaração.argumentos.length - 1)
@@ -16010,8 +16370,10 @@ class FormatadorPitugues {
         return `(${await expressão.expressao.aceitar(this)})`;
     }
     async visitarExpressaoUnaria(expressão) {
-        const operador = expressão.operador.tipo === pitugues_1.default.SUBTRACAO ? '-'
-            : expressão.operador.tipo === pitugues_1.default.NEGACAO ? 'não '
+        const operador = expressão.operador.tipo === pitugues_1.default.SUBTRACAO
+            ? '-'
+            : expressão.operador.tipo === pitugues_1.default.NEGACAO
+                ? 'não '
                 : '';
         const operando = await expressão.operando.aceitar(this);
         return expressão.incidenciaOperador === 'ANTES'
@@ -16020,7 +16382,7 @@ class FormatadorPitugues {
     }
     async visitarExpressaoDeChamada(expressão) {
         const função = await expressão.entidadeChamada.aceitar(this);
-        const argumentos = await Promise.all(expressão.argumentos.map(a => a.aceitar(this)));
+        const argumentos = await Promise.all(expressão.argumentos.map((a) => a.aceitar(this)));
         return `${função}(${argumentos.join(', ')})`;
     }
     visitarExpressaoIsto() {
@@ -16030,7 +16392,7 @@ class FormatadorPitugues {
         return 'super()';
     }
     async visitarExpressaoVetor(expressão) {
-        const valores = await Promise.all(expressão.valores.map(v => v.aceitar(this)));
+        const valores = await Promise.all(expressão.valores.map((v) => v.aceitar(this)));
         return `[${valores.join(', ')}]`;
     }
     async visitarExpressaoDicionario(expressão) {
@@ -16068,15 +16430,18 @@ class FormatadorPitugues {
         return `${objeto}.${expressão.nome.lexema} = ${valor}`;
     }
     async visitarExpressaoFuncaoConstruto(expressão) {
-        const parâmetros = expressão.parametros.map(p => {
+        const parâmetros = expressão.parametros
+            .map((p) => {
             const tipo = p.tipoDado ? `: ${p.tipoDado}` : '';
             return p.nome.lexema + tipo;
-        }).join(', ');
+        })
+            .join(', ');
         let funçãoStr = `função(${parâmetros || ''}):\n`;
         this.aumentarIndentação();
         for (const instrução of expressão.corpo) {
             const linha = await instrução.aceitar(this);
-            if (linha) { // Only add if it returns something
+            if (linha) {
+                // Only add if it returns something
                 funçãoStr += this.indentar() + linha;
                 if (!linha.endsWith('\n'))
                     funçãoStr += '\n';
@@ -16086,7 +16451,7 @@ class FormatadorPitugues {
         return funçãoStr.trimEnd();
     }
     async visitarExpressaoLeia(expressão) {
-        const argumentos = await Promise.all(expressão.argumentos.map(a => a.aceitar(this)));
+        const argumentos = await Promise.all(expressão.argumentos.map((a) => a.aceitar(this)));
         return argumentos.length > 0 ? `input(${argumentos.join(', ')})` : 'input()';
     }
     async visitarExpressaoTipoDe(expressão) {
@@ -16172,12 +16537,12 @@ function uuidv4() {
         let r = Math.random() * 16; // random number between 0 and 16
         if (d > 0) {
             // Use timestamp until depleted
-            r = (d + r) % 16 | 0;
+            r = ((d + r) % 16) | 0;
             d = Math.floor(d / 16);
         }
         else {
             // Use microseconds since page-load if supported
-            r = (d2 + r) % 16 | 0;
+            r = ((d2 + r) % 16) | 0;
             d2 = Math.floor(d2 / 16);
         }
         return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
@@ -16606,27 +16971,36 @@ const bibliotecaGlobal = __importStar(require("../bibliotecas/biblioteca-global"
 const construtos_1 = require("../construtos");
 function carregarBibliotecasGlobais(pilhaEscoposExecucao) {
     pilhaEscoposExecucao.definirVariavel('aleatorio', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.aleatorio));
+    pilhaEscoposExecucao.definirVariavel('aleatório', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.aleatorio));
     pilhaEscoposExecucao.definirVariavel('aleatorioEntre', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.aleatorioEntre));
+    pilhaEscoposExecucao.definirVariavel('aleatórioEntre', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.aleatorioEntre));
     pilhaEscoposExecucao.definirVariavel('algum', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.algum));
     pilhaEscoposExecucao.definirVariavel('arredondar', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.arredondar));
     pilhaEscoposExecucao.definirVariavel('clonar', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.clonar));
     pilhaEscoposExecucao.definirVariavel('encontrar', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.encontrar));
     pilhaEscoposExecucao.definirVariavel('encontrarIndice', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.encontrarIndice));
+    pilhaEscoposExecucao.definirVariavel('encontrarÍndice', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.encontrarIndice));
     pilhaEscoposExecucao.definirVariavel('encontrarUltimo', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.encontrarUltimo));
+    pilhaEscoposExecucao.definirVariavel('encontrarÚltimo', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.encontrarUltimo));
     pilhaEscoposExecucao.definirVariavel('encontrarUltimoIndice', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.encontrarUltimoIndice));
+    pilhaEscoposExecucao.definirVariavel('encontrarÚltimoÍndice', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.encontrarUltimoIndice));
     pilhaEscoposExecucao.definirVariavel('filtrarPor', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.filtrarPor));
     pilhaEscoposExecucao.definirVariavel('incluido', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.incluido));
+    pilhaEscoposExecucao.definirVariavel('incluído', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.incluido));
     pilhaEscoposExecucao.definirVariavel('inteiro', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.inteiro));
     pilhaEscoposExecucao.definirVariavel('longo', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.longo));
     pilhaEscoposExecucao.definirVariavel('intervalo', new funcao_padrao_1.FuncaoPadrao(3, bibliotecaGlobal.intervalo));
     pilhaEscoposExecucao.definirVariavel('mapear', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.mapear));
     pilhaEscoposExecucao.definirVariavel('maximo', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.maximo));
+    pilhaEscoposExecucao.definirVariavel('máximo', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.maximo));
     pilhaEscoposExecucao.definirVariavel('minimo', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.minimo));
+    pilhaEscoposExecucao.definirVariavel('mínimo', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.minimo));
     pilhaEscoposExecucao.definirVariavel('numero', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.numero));
     pilhaEscoposExecucao.definirVariavel('número', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.numero));
     pilhaEscoposExecucao.definirVariavel('ordenar', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.ordenar));
     pilhaEscoposExecucao.definirVariavel('paraCada', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.paraCada));
     pilhaEscoposExecucao.definirVariavel('primeiroEmCondicao', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.primeiroEmCondicao));
+    pilhaEscoposExecucao.definirVariavel('primeiroEmCondição', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.primeiroEmCondicao));
     pilhaEscoposExecucao.definirVariavel('real', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.real));
     pilhaEscoposExecucao.definirVariavel('reduzir', new funcao_padrao_1.FuncaoPadrao(3, bibliotecaGlobal.reduzir));
     pilhaEscoposExecucao.definirVariavel('somar', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.somar));
@@ -16634,28 +17008,29 @@ function carregarBibliotecasGlobais(pilhaEscoposExecucao) {
     pilhaEscoposExecucao.definirVariavel('texto', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.texto));
     pilhaEscoposExecucao.definirVariavel('todos', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.todos));
     pilhaEscoposExecucao.definirVariavel('todosEmCondicao', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.todosEmCondicao));
+    pilhaEscoposExecucao.definirVariavel('todosEmCondição', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.todosEmCondicao));
     pilhaEscoposExecucao.definirVariavel('tupla', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.tupla));
     pilhaEscoposExecucao.definirVariavel('vetor', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.vetor));
 }
 function pontoEntradaAjuda(funcao, topico) {
     if (!funcao) {
-        return "Para usar a ajuda, use como uma função: ajuda(objeto).";
+        return 'Para usar a ajuda, use como uma função: ajuda(objeto).';
     }
     if (!topico) {
-        return "Te damos as boas-vindas ao utilitário de ajuda de Delégua!\n\n" +
-            "Use ajuda(objeto) para obter informações sobre um objeto, função, classe ou módulo.\n" +
-            "Use ajuda('tópico') para obter informações sobre um tópico específico.\n\n";
+        return ('Te damos as boas-vindas ao utilitário de ajuda de Delégua!\n\n' +
+            'Use ajuda(objeto) para obter informações sobre um objeto, função, classe ou módulo.\n' +
+            "Use ajuda('tópico') para obter informações sobre um tópico específico.\n\n");
     }
     return obterTopicoAjuda(topico);
 }
 function obterTopicoAjuda(topico) {
     switch (topico.constructor) {
         case construtos_1.Leia:
-            return `A instrução 'leia' permite capturar a entrada do usuário durante a execução do programa. ` +
+            return (`A instrução 'leia' permite capturar a entrada do usuário durante a execução do programa. ` +
                 `Você pode usar 'leia()' para ler uma linha de entrada do usuário e armazená-la em uma variável. ` +
                 `Exemplo de uso:\n\n` +
                 `\tvar minhaVariavel = leia()\n\n` +
-                `Isto irá ler a entrada do usuário e atribuí-la à variável 'minhaVariavel'.`;
+                `Isto irá ler a entrada do usuário e atribuí-la à variável 'minhaVariavel'.`);
         case funcao_padrao_1.FuncaoPadrao:
             return obterAjudaFuncaoPadrao(topico);
         case delegua_funcao_1.DeleguaFuncao:
@@ -16710,21 +17085,21 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
     const aridade = funcaoPadrao.valorAridade;
     const implementacao = funcaoPadrao.funcao;
     // Mapeamento de funções por nome
-    const nomeFuncao = Object.keys(bibliotecaGlobal).find(key => bibliotecaGlobal[key] === implementacao);
+    const nomeFuncao = Object.keys(bibliotecaGlobal).find((key) => bibliotecaGlobal[key] === implementacao);
     if (!nomeFuncao) {
         return 'Função não identificada. Não há documentação disponível.';
     }
     switch (nomeFuncao) {
         case 'aleatorio':
-            return `# aleatorio()\n\n` +
+            return (`# aleatorio()\n\n` +
                 `Retorna um número aleatório entre 0 e 1.\n\n` +
                 `**Sintaxe:** aleatorio()\n\n` +
                 `**Retorno:** Número real entre 0 (inclusivo) e 1 (exclusivo).\n\n` +
                 `**Exemplo:**\n` +
                 `\tvar numeroSorteado = aleatorio()\n` +
-                `\tescreva(numeroSorteado) // Pode retornar algo como 0.4829374657\n`;
+                `\tescreva(numeroSorteado) // Pode retornar algo como 0.4829374657\n`);
         case 'aleatorioEntre':
-            return `# aleatorioEntre(minimo, maximo)\n\n` +
+            return (`# aleatorioEntre(minimo, maximo)\n\n` +
                 `Retorna um número aleatório inteiro de acordo com os parâmetros passados.\n` +
                 `Mínimo (inclusivo) - Máximo (exclusivo).\n\n` +
                 `**Sintaxe:** aleatorioEntre(minimo: número, maximo: número)\n\n` +
@@ -16734,9 +17109,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Retorno:** Número inteiro entre minimo e maximo-1.\n\n` +
                 `**Exemplo:**\n` +
                 `\tvar dado = aleatorioEntre(1, 7)\n` +
-                `\tescreva(dado) // Retorna um número entre 1 e 6\n`;
+                `\tescreva(dado) // Retorna um número entre 1 e 6\n`);
         case 'algum':
-            return `# algum(vetor, funcaoPesquisa)\n\n` +
+            return (`# algum(vetor, funcaoPesquisa)\n\n` +
                 `Verifica se algum dos elementos do vetor satisfaz a condição definida pela função de pesquisa.\n\n` +
                 `**Sintaxe:** algum(vetor: qualquer[], funcaoPesquisa: função)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16746,9 +17121,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tvar numeros = [1, 2, 3, 4, 5]\n` +
                 `\tvar temPar = algum(numeros, funcao(n) { retorna n % 2 == 0 })\n` +
-                `\tescreva(temPar) // verdadeiro\n`;
+                `\tescreva(temPar) // verdadeiro\n`);
         case 'clonar':
-            return `# clonar(valor)\n\n` +
+            return (`# clonar(valor)\n\n` +
                 `Clona profundamente uma variável ou constante em Delégua, criando uma cópia independente.\n\n` +
                 `**Sintaxe:** clonar(valor: qualquer)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16759,9 +17134,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `\tvar copia = clonar(original)\n` +
                 `\tcopia[2][0] = 99\n` +
                 `\tescreva(original[2][0]) // 3 (não foi modificado)\n` +
-                `\tescreva(copia[2][0]) // 99\n`;
+                `\tescreva(copia[2][0]) // 99\n`);
         case 'encontrar':
-            return `# encontrar(vetor, funcaoPesquisa)\n\n` +
+            return (`# encontrar(vetor, funcaoPesquisa)\n\n` +
                 `Encontra o primeiro elemento de um vetor cuja função de pesquisa retorne verdadeiro.\n\n` +
                 `**Sintaxe:** encontrar(vetor: qualquer[], funcaoPesquisa: função)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16771,9 +17146,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tvar numeros = [1, 3, 5, 8, 10]\n` +
                 `\tvar primeiroPar = encontrar(numeros, funcao(n) { retorna n % 2 == 0 })\n` +
-                `\tescreva(primeiroPar) // 8\n`;
+                `\tescreva(primeiroPar) // 8\n`);
         case 'encontrarIndice':
-            return `# encontrarIndice(vetor, funcaoPesquisa)\n\n` +
+            return (`# encontrarIndice(vetor, funcaoPesquisa)\n\n` +
                 `Encontra o índice do primeiro elemento de um vetor cuja função de pesquisa retorne verdadeiro.\n\n` +
                 `**Sintaxe:** encontrarIndice(vetor: qualquer[], funcaoPesquisa: função)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16783,9 +17158,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tvar frutas = ["maçã", "banana", "laranja"]\n` +
                 `\tvar indice = encontrarIndice(frutas, funcao(f) { retorna f == "banana" })\n` +
-                `\tescreva(indice) // 1\n`;
+                `\tescreva(indice) // 1\n`);
         case 'encontrarUltimo':
-            return `# encontrarUltimo(vetor, funcaoPesquisa)\n\n` +
+            return (`# encontrarUltimo(vetor, funcaoPesquisa)\n\n` +
                 `Encontra o último elemento de um vetor cuja função de pesquisa retorne verdadeiro.\n\n` +
                 `**Sintaxe:** encontrarUltimo(vetor: qualquer[], funcaoPesquisa: função)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16795,9 +17170,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tvar numeros = [2, 4, 6, 7, 9]\n` +
                 `\tvar ultimoPar = encontrarUltimo(numeros, funcao(n) { retorna n % 2 == 0 })\n` +
-                `\tescreva(ultimoPar) // 6\n`;
+                `\tescreva(ultimoPar) // 6\n`);
         case 'encontrarUltimoIndice':
-            return `# encontrarUltimoIndice(vetor, funcaoPesquisa)\n\n` +
+            return (`# encontrarUltimoIndice(vetor, funcaoPesquisa)\n\n` +
                 `Encontra o índice do último elemento de um vetor cuja função de pesquisa retorne verdadeiro.\n\n` +
                 `**Sintaxe:** encontrarUltimoIndice(vetor: qualquer[], funcaoPesquisa: função)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16807,9 +17182,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tvar numeros = [2, 4, 6, 7, 9]\n` +
                 `\tvar indiceUltimoPar = encontrarUltimoIndice(numeros, funcao(n) { retorna n % 2 == 0 })\n` +
-                `\tescreva(indiceUltimoPar) // 2\n`;
+                `\tescreva(indiceUltimoPar) // 2\n`);
         case 'filtrarPor':
-            return `# filtrarPor(vetor, funcaoFiltragem)\n\n` +
+            return (`# filtrarPor(vetor, funcaoFiltragem)\n\n` +
                 `Cria um novo vetor com todos os elementos que passam no teste implementado pela função de filtragem.\n\n` +
                 `**Sintaxe:** filtrarPor(vetor: qualquer[], funcaoFiltragem: função)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16819,9 +17194,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tvar numeros = [1, 2, 3, 4, 5, 6]\n` +
                 `\tvar pares = filtrarPor(numeros, funcao(n) { retorna n % 2 == 0 })\n` +
-                `\tescreva(pares) // [2, 4, 6]\n`;
+                `\tescreva(pares) // [2, 4, 6]\n`);
         case 'incluido':
-            return `# incluido(vetor, valor)\n\n` +
+            return (`# incluido(vetor, valor)\n\n` +
                 `Verifica se um valor está incluído em um vetor.\n\n` +
                 `**Sintaxe:** incluido(vetor: qualquer[], valor: qualquer)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16831,9 +17206,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tvar frutas = ["maçã", "banana", "laranja"]\n` +
                 `\tescreva(incluido(frutas, "banana")) // verdadeiro\n` +
-                `\tescreva(incluido(frutas, "uva")) // falso\n`;
+                `\tescreva(incluido(frutas, "uva")) // falso\n`);
         case 'inteiro':
-            return `# inteiro(valor)\n\n` +
+            return (`# inteiro(valor)\n\n` +
                 `Converte um valor em um número inteiro.\n\n` +
                 `**Sintaxe:** inteiro(valor: número | texto)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16842,9 +17217,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tescreva(inteiro(3.14)) // 3\n` +
                 `\tescreva(inteiro("42")) // 42\n` +
-                `\tescreva(inteiro("3.99")) // 3\n`;
+                `\tescreva(inteiro("3.99")) // 3\n`);
         case 'intervalo':
-            return `# intervalo(valorInicial, valorFinal)\n\n` +
+            return (`# intervalo(valorInicial, valorFinal)\n\n` +
                 `Cria um vetor com números inteiros no intervalo especificado.\n` +
                 `O valor inicial é inclusivo e o valor final é exclusivo.\n\n` +
                 `**Sintaxe:** intervalo(valorInicial: número, valorFinal: número)\n\n` +
@@ -16854,9 +17229,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Retorno:** Vetor com os números no intervalo especificado.\n\n` +
                 `**Exemplo:**\n` +
                 `\tvar numeros = intervalo(1, 6)\n` +
-                `\tescreva(numeros) // [1, 2, 3, 4, 5]\n`;
+                `\tescreva(numeros) // [1, 2, 3, 4, 5]\n`);
         case 'mapear':
-            return `# mapear(vetor, funcaoMapeamento)\n\n` +
+            return (`# mapear(vetor, funcaoMapeamento)\n\n` +
                 `Cria um novo vetor com os resultados da aplicação de uma função a cada elemento do vetor original.\n\n` +
                 `**Sintaxe:** mapear(vetor: qualquer[], funcaoMapeamento: função)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16866,13 +17241,13 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tvar numeros = [1, 2, 3, 4]\n` +
                 `\tvar quadrados = mapear(numeros, funcao(n) { retorna n * n })\n` +
-                `\tescreva(quadrados) // [1, 4, 9, 16]\n`;
+                `\tescreva(quadrados) // [1, 4, 9, 16]\n`);
         case 'maximo':
             return `# maximo(vetor)\n\nRetorna o maior valor encontrado em um vetor de números.`;
         case 'minimo':
             return `# minimo(vetor)\n\nRetorna o menor valor encontrado em um vetor de números.`;
         case 'numero':
-            return `# numero(valor)\n\n` +
+            return (`# numero(valor)\n\n` +
                 `Converte um valor em um número (pode ter parte decimal).\n\n` +
                 `**Sintaxe:** numero(valor: número | texto)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16881,9 +17256,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tescreva(numero("3.14")) // 3.14\n` +
                 `\tescreva(numero("42")) // 42\n` +
-                `\tescreva(numero(5)) // 5\n`;
+                `\tescreva(numero(5)) // 5\n`);
         case 'ordenar':
-            return `# ordenar(vetor)\n\n` +
+            return (`# ordenar(vetor)\n\n` +
                 `Ordena os elementos de um vetor em ordem crescente (números) ou alfabética (textos).\n\n` +
                 `**Sintaxe:** ordenar(vetor: qualquer[])\n\n` +
                 `**Parâmetros:**\n` +
@@ -16892,9 +17267,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tvar numeros = [5, 2, 8, 1, 9]\n` +
                 `\tordenar(numeros)\n` +
-                `\tescreva(numeros) // [1, 2, 5, 8, 9]\n`;
+                `\tescreva(numeros) // [1, 2, 5, 8, 9]\n`);
         case 'paraCada':
-            return `# paraCada(vetor, funcao)\n\n` +
+            return (`# paraCada(vetor, funcao)\n\n` +
                 `Executa uma função para cada elemento do vetor.\n\n` +
                 `**Sintaxe:** paraCada(vetor: qualquer[], funcao: função)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16905,9 +17280,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `\tvar nomes = ["Ana", "Bruno", "Carlos"]\n` +
                 `\tparaCada(nomes, funcao(nome) {\n` +
                 `\t\tescreva("Olá, " + nome)\n` +
-                `\t})\n`;
+                `\t})\n`);
         case 'primeiroEmCondicao':
-            return `# primeiroEmCondicao(vetor, funcaoFiltragem)\n\n` +
+            return (`# primeiroEmCondicao(vetor, funcaoFiltragem)\n\n` +
                 `Retorna o primeiro elemento que satisfaz a condição especificada pela função de filtragem.\n\n` +
                 `**Sintaxe:** primeiroEmCondicao(vetor: qualquer[], funcaoFiltragem: função)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16917,9 +17292,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tvar numeros = [1, 3, 5, 8, 10]\n` +
                 `\tvar resultado = primeiroEmCondicao(numeros, funcao(n) { retorna n > 5 })\n` +
-                `\tescreva(resultado) // 8\n`;
+                `\tescreva(resultado) // 8\n`);
         case 'real':
-            return `# real(valor)\n\n` +
+            return (`# real(valor)\n\n` +
                 `Converte um valor em um número real (ponto flutuante).\n\n` +
                 `**Sintaxe:** real(valor: número | texto)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16927,9 +17302,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Retorno:** Número real correspondente ao valor fornecido.\n\n` +
                 `**Exemplo:**\n` +
                 `\tescreva(real("3.14")) // 3.14\n` +
-                `\tescreva(real(42)) // 42.0\n`;
+                `\tescreva(real(42)) // 42.0\n`);
         case 'reduzir':
-            return `# reduzir(vetor, funcaoReducao, valorInicial)\n\n` +
+            return (`# reduzir(vetor, funcaoReducao, valorInicial)\n\n` +
                 `Aplica uma função a um acumulador e cada elemento do vetor para reduzi-lo a um único valor.\n\n` +
                 `**Sintaxe:** reduzir(vetor: qualquer[], funcaoReducao: função, valorInicial?: qualquer)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16940,11 +17315,11 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tvar numeros = [1, 2, 3, 4]\n` +
                 `\tvar soma = reduzir(numeros, funcao(acc, n) { retorna acc + n }, 0)\n` +
-                `\tescreva(soma) // 10\n`;
+                `\tescreva(soma) // 10\n`);
         case 'somar':
             return `# somar(vetor)\n\nRetorna a soma de todos os elementos de um vetor numérico.`;
         case 'tamanho':
-            return `# tamanho(objeto)\n\n` +
+            return (`# tamanho(objeto)\n\n` +
                 `Retorna o tamanho de um objeto (vetor, texto, função, etc.).\n\n` +
                 `**Sintaxe:** tamanho(objeto: qualquer)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16953,9 +17328,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `Para funções, retorna o número de parâmetros.\n\n` +
                 `**Exemplo:**\n` +
                 `\tescreva(tamanho([1, 2, 3])) // 3\n` +
-                `\tescreva(tamanho("Delégua")) // 7\n`;
+                `\tescreva(tamanho("Delégua")) // 7\n`);
         case 'texto':
-            return `# texto(valor)\n\n` +
+            return (`# texto(valor)\n\n` +
                 `Transforma o valor ou variável em texto.\n\n` +
                 `**Sintaxe:** texto(valor: qualquer)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16964,9 +17339,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tescreva(texto(42)) // "42"\n` +
                 `\tescreva(texto(verdadeiro)) // "verdadeiro"\n` +
-                `\tescreva(texto([1, 2, 3])) // "[1, 2, 3]"\n`;
+                `\tescreva(texto([1, 2, 3])) // "[1, 2, 3]"\n`);
         case 'todosEmCondicao':
-            return `# todosEmCondicao(vetor, funcaoCondicional)\n\n` +
+            return (`# todosEmCondicao(vetor, funcaoCondicional)\n\n` +
                 `Retorna verdadeiro se todos os elementos do vetor satisfazem a condição especificada pela função.\n\n` +
                 `**Sintaxe:** todosEmCondicao(vetor: qualquer[], funcaoCondicional: função)\n\n` +
                 `**Parâmetros:**\n` +
@@ -16976,9 +17351,9 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tvar numeros = [2, 4, 6, 8]\n` +
                 `\tvar todosPares = todosEmCondicao(numeros, funcao(n) { retorna n % 2 == 0 })\n` +
-                `\tescreva(todosPares) // verdadeiro\n`;
+                `\tescreva(todosPares) // verdadeiro\n`);
         case 'tupla':
-            return `# tupla(vetor)\n\n` +
+            return (`# tupla(vetor)\n\n` +
                 `Transforma um vetor de elementos em uma tupla de N elementos, sendo N a largura do vetor.\n` +
                 `Tuplas são estruturas imutáveis de tamanho fixo.\n\n` +
                 `**Sintaxe:** tupla(vetor: qualquer[])\n\n` +
@@ -16988,10 +17363,10 @@ function obterAjudaFuncaoPadrao(funcaoPadrao) {
                 `**Exemplo:**\n` +
                 `\tvar coordenadas = tupla([10, 20])\n` +
                 `\tescreva(coordenadas.primeiro) // 10\n` +
-                `\tescreva(coordenadas.segundo) // 20\n`;
+                `\tescreva(coordenadas.segundo) // 20\n`);
         default:
-            return `Função global identificada, mas documentação específica não disponível.\n` +
-                `Aridade: ${aridade} parâmetro(s).`;
+            return (`Função global identificada, mas documentação específica não disponível.\n` +
+                `Aridade: ${aridade} parâmetro(s).`);
     }
 }
 
@@ -17248,7 +17623,9 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
         if (this.instancia !== undefined) {
             ambiente.valores['isto'] = {
                 valor: this.instancia,
-                tipo: this.instancia instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse ? 'objeto' : tipoDeDados(this.instancia),
+                tipo: this.instancia instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse
+                    ? 'objeto'
+                    : tipoDeDados(this.instancia),
                 imutavel: false,
             };
         }
@@ -17331,11 +17708,11 @@ const chamavel_1 = require("./chamavel");
 const metodo_polimorfico_1 = require("./metodo-polimorfico");
 const objeto_delegua_classe_1 = require("./objeto-delegua-classe");
 const mapaDeNormalizacao = {
-    'numero': 'número',
-    'logico': 'lógico',
-    'funcao': 'função',
-    'dicionario': 'dicionário',
-    'modulo': 'módulo',
+    numero: 'número',
+    logico: 'lógico',
+    funcao: 'função',
+    dicionario: 'dicionário',
+    modulo: 'módulo',
 };
 function normalizarTipo(tipo) {
     if (!tipo || tipo === 'qualquer')
@@ -17362,10 +17739,28 @@ function assinaturasIguais(a, b) {
  * de classe é criada, a referência para a instância é implementada aqui.
  */
 class DescritorTipoClasse extends chamavel_1.Chamavel {
-    constructor(simboloOriginal, superClasse, metodos, propriedades) {
+    /** Obtenedor de compat: primeiro pai direto (usado por tradutores e partes do interpretador). */
+    get superClasse() {
+        var _a;
+        return (_a = this.superClasses[0]) !== null && _a !== void 0 ? _a : null;
+    }
+    /** Definidor de compat: atribui um único pai direto (usado pela atribuição implícita de OBJETO_BASE). */
+    set superClasse(v) {
+        this.superClasses = v ? [v] : [];
+    }
+    constructor(simboloOriginal, superClasses, metodos, propriedades) {
         super();
         this.simboloOriginal = simboloOriginal;
-        this.superClasse = superClasse;
+        if (Array.isArray(superClasses)) {
+            this.superClasses = superClasses;
+        }
+        else if (superClasses) {
+            this.superClasses = [superClasses];
+        }
+        else {
+            this.superClasses = [];
+        }
+        this.orem = [this];
         this.metodos = metodos || {};
         this.metodosEstaticos = {};
         this.membrosEstaticos = {};
@@ -17381,6 +17776,44 @@ class DescritorTipoClasse extends chamavel_1.Chamavel {
         this.acessoMetodos = {};
         this.acessoPropriedades = {};
     }
+    // ─── C3 OReM ──────────────────────────────────────────────────────────────
+    static mesclaC3(listas) {
+        const resultado = [];
+        while (true) {
+            const listasNaoVazias = listas.filter((l) => l.length > 0);
+            if (listasNaoVazias.length === 0)
+                break;
+            let candidato = null;
+            for (const lista of listasNaoVazias) {
+                const cabeca = lista[0];
+                const naCauda = listasNaoVazias.some((l) => l.slice(1).indexOf(cabeca) >= 0);
+                if (!naCauda) {
+                    candidato = cabeca;
+                    break;
+                }
+            }
+            if (candidato === null) {
+                throw new excecoes_1.ErroEmTempoDeExecucao(null, 'Hierarquia de classes inconsistente: não foi possível calcular o OReM (C3).');
+            }
+            resultado.push(candidato);
+            for (const lista of listas) {
+                const idx = lista.indexOf(candidato);
+                if (idx === 0)
+                    lista.shift();
+            }
+        }
+        return resultado;
+    }
+    /** Calcula e armazena o OReM (linearização C3) para esta classe e retorna a lista resultante. */
+    static computarOReM(cls) {
+        if (cls.superClasses.length === 0) {
+            return [cls];
+        }
+        const oremsDePais = cls.superClasses.map((p) => DescritorTipoClasse.computarOReM(p));
+        const listas = [...oremsDePais.map((m) => [...m]), [...cls.superClasses]];
+        return [cls, ...DescritorTipoClasse.mesclaC3(listas)];
+    }
+    // ─── Verificação abstrata ─────────────────────────────────────────────────
     /**
      * Verifica se todos os métodos abstratos da superclasse estão implementados
      * na subclasse fornecida. Lança erro em tempo de execução se algum faltar.
@@ -17395,13 +17828,17 @@ class DescritorTipoClasse extends chamavel_1.Chamavel {
             }
         }
     }
+    // ─── Obtenedores e definidores ────────────────────────────────────────────
     encontrarObtenedor(nome, estatico = false) {
         const mapa = estatico ? this.obtenedoresEstaticos : this.obtenedores;
         if (Object.prototype.hasOwnProperty.call(mapa, nome)) {
             return mapa[nome];
         }
-        if (this.superClasse !== null && this.superClasse !== undefined) {
-            return this.superClasse.encontrarObtenedor(nome, estatico);
+        for (const ancestral of this.orem.slice(1)) {
+            const mapaAnc = estatico ? ancestral.obtenedoresEstaticos : ancestral.obtenedores;
+            if (Object.prototype.hasOwnProperty.call(mapaAnc, nome)) {
+                return mapaAnc[nome];
+            }
         }
         return undefined;
     }
@@ -17410,11 +17847,15 @@ class DescritorTipoClasse extends chamavel_1.Chamavel {
         if (Object.prototype.hasOwnProperty.call(mapa, nome)) {
             return mapa[nome];
         }
-        if (this.superClasse !== null && this.superClasse !== undefined) {
-            return this.superClasse.encontrarDefinidor(nome, estatico);
+        for (const ancestral of this.orem.slice(1)) {
+            const mapaAnc = estatico ? ancestral.definidoresEstaticos : ancestral.definidores;
+            if (Object.prototype.hasOwnProperty.call(mapaAnc, nome)) {
+                return mapaAnc[nome];
+            }
         }
         return undefined;
     }
+    // ─── Membros estáticos ────────────────────────────────────────────────────
     async obterEstatico(nome, visitante) {
         var _a;
         const obtenedor = this.encontrarObtenedor(nome, true);
@@ -17443,9 +17884,10 @@ class DescritorTipoClasse extends chamavel_1.Chamavel {
         }
         this.membrosEstaticos[nome] = valor;
     }
+    // ─── Resolução de métodos via OReM ─────────────────────────────────────────
     /**
-     * Mescla sobrecargas da classe atual com as da superclasse.
-     * Sobrecargas da subclasse com mesma assinatura substituem as da superclasse.
+     * Mescla sobrecargas da classe atual com as de ancestrais (respeitando MRO).
+     * Sobrecargas da subclasse com mesma assinatura substituem as do ancestral.
      */
     mesclarComSuperclasse(metodosAtuais, metodosSuperclasse) {
         const resultado = [...metodosAtuais];
@@ -17458,28 +17900,20 @@ class DescritorTipoClasse extends chamavel_1.Chamavel {
         return resultado;
     }
     obterSobrecargasDaSuperclasse(nome) {
-        if (!this.superClasse)
-            return [];
-        const metodoSuper = this.superClasse.metodos.hasOwnProperty(nome)
-            ? this.superClasse.metodos[nome]
-            : undefined;
-        let sobrecargasSuper = [];
-        if (metodoSuper) {
-            sobrecargasSuper = Array.isArray(metodoSuper) ? metodoSuper : [metodoSuper];
-        }
-        // Recursivamente mesclar com a superclasse da superclasse
-        const sobrecargasAncestral = this.superClasse.obterSobrecargasDaSuperclasse(nome);
-        if (sobrecargasAncestral.length > 0) {
-            const resultado = [...sobrecargasSuper];
-            for (const metodoAnc of sobrecargasAncestral) {
-                const jaSobrescrito = resultado.some((m) => assinaturasIguais(m, metodoAnc));
-                if (!jaSobrescrito) {
-                    resultado.push(metodoAnc);
+        let sobrecarga = [];
+        // Percorre a OReM[1:] na ordem do OReM — o primeiro ancestral vence
+        for (const ancestral of this.orem.slice(1)) {
+            if (!ancestral.metodos.hasOwnProperty(nome))
+                continue;
+            const metodo = ancestral.metodos[nome];
+            const novos = Array.isArray(metodo) ? metodo : [metodo];
+            for (const m of novos) {
+                if (!sobrecarga.some((s) => assinaturasIguais(s, m))) {
+                    sobrecarga.push(m);
                 }
             }
-            sobrecargasSuper = resultado;
         }
-        return sobrecargasSuper;
+        return sobrecarga;
     }
     encontrarMetodo(nome) {
         let metodosAtuais = [];
@@ -17510,14 +17944,17 @@ class DescritorTipoClasse extends chamavel_1.Chamavel {
         if (nome in this.propriedades) {
             return this.propriedades[nome];
         }
-        if (this.superClasse !== null && this.superClasse !== undefined) {
-            return this.superClasse.encontrarPropriedade(nome);
+        for (const ancestral of this.orem.slice(1)) {
+            if (nome in ancestral.propriedades) {
+                return ancestral.propriedades[nome];
+            }
         }
         if (this.dialetoRequerDeclaracaoPropriedades) {
             throw new excecoes_1.ErroEmTempoDeExecucao(this.simboloOriginal, `Propriedade "${nome}" não declarada na classe ${this.simboloOriginal.lexema}.`);
         }
         return undefined;
     }
+    // ─── Representação textual ────────────────────────────────────────────────
     /**
      * Método utilizado por Delégua para representar esta classe quando impressa.
      * @returns {string} A representação da classe como texto.
@@ -17526,7 +17963,7 @@ class DescritorTipoClasse extends chamavel_1.Chamavel {
         var _a, _b;
         const nome = (_b = (_a = this.simboloOriginal) === null || _a === void 0 ? void 0 : _a.lexema) !== null && _b !== void 0 ? _b : 'Objeto';
         const nomesMetodos = Object.keys(this.metodos).join(', ');
-        const nomesPropriedades = this.propriedades.map(p => p.nome.lexema).join(', ');
+        const nomesPropriedades = this.propriedades.map((p) => p.nome.lexema).join(', ');
         return `<[ ${nome} estático métodos=[${nomesMetodos}] propriedades=[${nomesPropriedades}] ]>`;
     }
     /**
@@ -17655,11 +18092,11 @@ const excecoes_1 = require("../../excecoes");
 const chamavel_1 = require("./chamavel");
 const tiposNumericos = ['inteiro', 'número', 'real', 'longo'];
 const mapaDeNormalizacao = {
-    'numero': 'número',
-    'logico': 'lógico',
-    'funcao': 'função',
-    'dicionario': 'dicionário',
-    'modulo': 'módulo',
+    numero: 'número',
+    logico: 'lógico',
+    funcao: 'função',
+    dicionario: 'dicionário',
+    modulo: 'módulo',
 };
 function normalizarTipo(tipo) {
     if (!tipo || tipo === 'qualquer')
@@ -17749,8 +18186,10 @@ class MetodoPolimorfico extends chamavel_1.Chamavel {
                     ? argumentos[i].valor
                     : argumentos[i];
                 // Se o valor é uma VariavelInterface, extrair o valor real
-                if (valorArgumento && typeof valorArgumento === 'object'
-                    && valorArgumento.hasOwnProperty('valor') && valorArgumento.hasOwnProperty('tipo')) {
+                if (valorArgumento &&
+                    typeof valorArgumento === 'object' &&
+                    valorArgumento.hasOwnProperty('valor') &&
+                    valorArgumento.hasOwnProperty('tipo')) {
                     valorArgumento = valorArgumento.valor;
                 }
                 const tipoArgumento = (0, inferenciador_1.inferirTipoVariavel)(valorArgumento);
@@ -17771,8 +18210,10 @@ class MetodoPolimorfico extends chamavel_1.Chamavel {
         if (!melhorSobrecarga) {
             const tiposArgs = argumentos.map((a) => {
                 let val = a && a.hasOwnProperty('valor') ? a.valor : a;
-                if (val && typeof val === 'object'
-                    && val.hasOwnProperty('valor') && val.hasOwnProperty('tipo')) {
+                if (val &&
+                    typeof val === 'object' &&
+                    val.hasOwnProperty('valor') &&
+                    val.hasOwnProperty('tipo')) {
                     val = val.valor;
                 }
                 return normalizarTipo((0, inferenciador_1.inferirTipoVariavel)(val));
@@ -17926,7 +18367,7 @@ function criarDescritorObjeto() {
     descritor.metodos['igual'] = new delegua_funcao_nativa_1.DeleguaFuncaoNativa('igual', 1, (instancia, args) => {
         return instancia === args[0];
     });
-    descritor.metodos['eInstanciaDe'] = new delegua_funcao_nativa_1.DeleguaFuncaoNativa('eInstanciaDe', 1, (instancia, args) => {
+    const implementacaoEInstanciaDe = (instancia, args) => {
         if (!instancia)
             return false;
         const classeAlvo = args[0];
@@ -17939,8 +18380,10 @@ function criarDescritorObjeto() {
             cls = cls.superClasse;
         }
         return false;
-    });
-    descritor.metodos['metodos'] = new delegua_funcao_nativa_1.DeleguaFuncaoNativa('metodos', 0, (instancia) => {
+    };
+    descritor.metodos['eInstanciaDe'] = new delegua_funcao_nativa_1.DeleguaFuncaoNativa('eInstanciaDe', 1, implementacaoEInstanciaDe);
+    descritor.metodos['éInstânciaDe'] = new delegua_funcao_nativa_1.DeleguaFuncaoNativa('éInstânciaDe', 1, implementacaoEInstanciaDe);
+    const implementacaoMetodos = (instancia) => {
         if (!instancia)
             return [];
         const nomes = [];
@@ -17953,7 +18396,9 @@ function criarDescritorObjeto() {
             cls = cls.superClasse;
         }
         return nomes;
-    });
+    };
+    descritor.metodos['metodos'] = new delegua_funcao_nativa_1.DeleguaFuncaoNativa('metodos', 0, implementacaoMetodos);
+    descritor.metodos['métodos'] = new delegua_funcao_nativa_1.DeleguaFuncaoNativa('métodos', 0, implementacaoMetodos);
     descritor.metodos['propriedades'] = new delegua_funcao_nativa_1.DeleguaFuncaoNativa('propriedades', 0, (instancia) => {
         if (!instancia)
             return [];
@@ -17980,55 +18425,73 @@ const excecoes_1 = require("../../excecoes");
  * Métodos são extraídos do descritor da classe, uma `DeleguaClasse`.
  */
 class ObjetoDeleguaClasse {
+    valorPadraoParaTipo(tipo) {
+        switch (tipo) {
+            case 'numero':
+                return 0;
+            case 'texto':
+                return '';
+            case 'logico':
+                return false;
+            default:
+                return undefined;
+        }
+    }
     constructor(classe) {
         this.classe = classe;
         this.propriedades = {};
-        if (this.classe.superClasse) {
-            for (let propriedade of this.classe.superClasse.propriedades) {
+        // Inicializar propriedades herdadas do OReM (do mais genérico ao mais específico)
+        // para que ancestrais mais próximos sobrescrevam os mais distantes.
+        const ancestrais = classe.orem.slice(1).reverse();
+        for (const ancestral of ancestrais) {
+            for (const propriedade of ancestral.propriedades) {
                 if (propriedade.estatico)
                     continue;
                 if (propriedade.autoObter || propriedade.autoDefinir) {
-                    this.propriedades['_' + propriedade.nome.lexema] = undefined;
+                    this.propriedades['_' + propriedade.nome.lexema] = this.valorPadraoParaTipo(propriedade.tipo);
                 }
                 else {
-                    this.propriedades[propriedade.nome.lexema] = undefined;
+                    this.propriedades[propriedade.nome.lexema] = this.valorPadraoParaTipo(propriedade.tipo);
                 }
             }
         }
-        for (let propriedade of classe.propriedades) {
+        // Propriedades da própria classe (têm prioridade máxima no valor padrão)
+        for (const propriedade of classe.propriedades) {
             if (propriedade.estatico)
                 continue;
             if (propriedade.autoObter || propriedade.autoDefinir) {
-                this.propriedades['_' + propriedade.nome.lexema] = undefined;
+                this.propriedades['_' + propriedade.nome.lexema] = this.valorPadraoParaTipo(propriedade.tipo);
             }
             else {
-                this.propriedades[propriedade.nome.lexema] = undefined;
+                this.propriedades[propriedade.nome.lexema] = this.valorPadraoParaTipo(propriedade.tipo);
             }
         }
     }
     verificarAcessoLeitura(nome, simbolo, visitante) {
-        var _a, _b, _c, _d, _e;
-        const acesso = (_b = (_a = this.classe.acessoPropriedades) === null || _a === void 0 ? void 0 : _a[nome]) !== null && _b !== void 0 ? _b : (_c = this.classe.acessoMetodos) === null || _c === void 0 ? void 0 : _c[nome];
+        var _a, _b, _c, _d, _e, _f, _g;
+        // Percorre o OReM para encontrar a classe que declarou o membro com um modificador de acesso.
+        let declaradorClasse = undefined;
+        let acesso = undefined;
+        for (const cls of this.classe.orem) {
+            const acessoCls = (_b = (_a = cls.acessoPropriedades) === null || _a === void 0 ? void 0 : _a[nome]) !== null && _b !== void 0 ? _b : (_c = cls.acessoMetodos) === null || _c === void 0 ? void 0 : _c[nome];
+            if (acessoCls) {
+                acesso = acessoCls;
+                declaradorClasse = cls;
+                break;
+            }
+        }
         if (!acesso || acesso === 'publico')
             return;
         const classeAtual = visitante === null || visitante === void 0 ? void 0 : visitante.classeAtualEmExecucao;
         if (acesso === 'privado') {
-            if (classeAtual !== this.classe) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(simbolo, `Membro '${nome}' é privado e não pode ser acessado fora da classe '${(_d = this.classe.simboloOriginal) === null || _d === void 0 ? void 0 : _d.lexema}'.`);
+            if (classeAtual !== declaradorClasse) {
+                throw new excecoes_1.ErroEmTempoDeExecucao(simbolo, `Membro '${nome}' é privado e não pode ser acessado fora da classe '${(_d = declaradorClasse.simboloOriginal) === null || _d === void 0 ? void 0 : _d.lexema}'.`);
             }
         }
         else if (acesso === 'protegido') {
-            let cls = classeAtual;
-            let eAcessivel = false;
-            while (cls) {
-                if (cls === this.classe) {
-                    eAcessivel = true;
-                    break;
-                }
-                cls = cls.superClasse;
-            }
+            const eAcessivel = (_f = (_e = classeAtual === null || classeAtual === void 0 ? void 0 : classeAtual.orem) === null || _e === void 0 ? void 0 : _e.includes(declaradorClasse)) !== null && _f !== void 0 ? _f : false;
             if (!eAcessivel) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(simbolo, `Membro '${nome}' é protegido e não pode ser acessado fora da hierarquia da classe '${(_e = this.classe.simboloOriginal) === null || _e === void 0 ? void 0 : _e.lexema}'.`);
+                throw new excecoes_1.ErroEmTempoDeExecucao(simbolo, `Membro '${nome}' é protegido e não pode ser acessado fora da hierarquia da classe '${(_g = declaradorClasse.simboloOriginal) === null || _g === void 0 ? void 0 : _g.lexema}'.`);
             }
         }
     }
@@ -18042,7 +18505,7 @@ class ObjetoDeleguaClasse {
             return await metodoObtenedor.chamar(visitante, []);
         }
         // Auto-property: acessa o campo de armazenamento interno '_nome'
-        const propAuto = this.classe.propriedades.find(p => p.nome.lexema === simbolo.lexema);
+        const propAuto = this.classe.propriedades.find((p) => p.nome.lexema === simbolo.lexema);
         if (propAuto === null || propAuto === void 0 ? void 0 : propAuto.autoObter) {
             this.verificarAcessoLeitura(simbolo.lexema, simbolo, visitante);
             return this.propriedades['_' + simbolo.lexema];
@@ -18087,7 +18550,7 @@ class ObjetoDeleguaClasse {
             return;
         }
         // Auto-property: armazena no campo interno '_nome'
-        const propAuto = this.classe.propriedades.find(p => p.nome.lexema === simbolo.lexema);
+        const propAuto = this.classe.propriedades.find((p) => p.nome.lexema === simbolo.lexema);
         if (propAuto === null || propAuto === void 0 ? void 0 : propAuto.autoDefinir) {
             this.verificarAcessoLeitura(simbolo.lexema, simbolo, visitante);
             this.propriedades['_' + simbolo.lexema] = valor;
@@ -18384,7 +18847,7 @@ class InterpretadorBase {
         }
         // Se é array, resolve recursivamente todos os elementos
         if (Array.isArray(objeto)) {
-            return objeto.map(elemento => this.resolverValorRecursivo(elemento));
+            return objeto.map((elemento) => this.resolverValorRecursivo(elemento));
         }
         // Se é objeto plano, resolve recursivamente todas as propriedades
         if (objeto && objeto.constructor && objeto.constructor === Object) {
@@ -18427,8 +18890,18 @@ class InterpretadorBase {
     async visitarExpressaoTupla(expressao) {
         // Lista de propriedades válidas para tuplas (ignorar propriedades de controle)
         const propriedadesValidas = [
-            'primeiro', 'segundo', 'terceiro', 'quarto', 'quinto',
-            'sexto', 'sétimo', 'setimo', 'oitavo', 'nono', 'décimo', 'decimo'
+            'primeiro',
+            'segundo',
+            'terceiro',
+            'quarto',
+            'quinto',
+            'sexto',
+            'sétimo',
+            'setimo',
+            'oitavo',
+            'nono',
+            'décimo',
+            'decimo',
         ];
         const valores = [];
         for (let propriedade of propriedadesValidas) {
@@ -18445,7 +18918,7 @@ class InterpretadorBase {
             const res = await this.avaliar(expressao.elementos[i]);
             elementos.push(this.resolverValor(res));
         }
-        const elementosComoConstrutos = elementos.map(valor => new construtos_1.Literal(expressao.hashArquivo, expressao.linha, valor));
+        const elementosComoConstrutos = elementos.map((valor) => new construtos_1.Literal(expressao.hashArquivo, expressao.linha, valor));
         return new construtos_1.TuplaN(expressao.hashArquivo, expressao.linha, elementosComoConstrutos);
     }
     async visitarExpressaoAtribuicaoPorIndicesMatriz(expressao) {
@@ -18787,8 +19260,12 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq ** dir;
                 }
                 const resultadoExponenciacao = Math.pow(valorEsquerdo, valorDireito);
@@ -18816,8 +19293,12 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq - dir;
                 }
                 return Number(valorEsquerdo) - Number(valorDireito);
@@ -18829,8 +19310,12 @@ class InterpretadorBase {
                 }
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq + dir;
                 }
                 if (this.tiposNumericos.includes(tipoEsquerdo) &&
@@ -18860,8 +19345,12 @@ class InterpretadorBase {
                 }
                 // Retorna BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq / dir; // Trunca automaticamente
                 }
                 return Math.floor(Number(valorEsquerdo) / Number(valorDireito));
@@ -18871,8 +19360,12 @@ class InterpretadorBase {
                 if ((typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') &&
                     tipoEsquerdo !== delegua_2.default.TEXTO &&
                     tipoDireito !== delegua_2.default.TEXTO) {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq * dir;
                 }
                 if (tipoEsquerdo === delegua_2.default.TEXTO ||
@@ -18905,7 +19398,8 @@ class InterpretadorBase {
             case delegua_1.default.MODULO:
             case delegua_1.default.MODULO_IGUAL:
                 // Se o operando esquerdo é uma string, usar formatação de string
-                if (tipoEsquerdo === delegua_2.default.TEXTO || typeof valorEsquerdo === 'string') {
+                if (tipoEsquerdo === delegua_2.default.TEXTO ||
+                    typeof valorEsquerdo === 'string') {
                     return this.formatarStringComOperadorPorcentagem(String(valorEsquerdo), direita, // Passar 'direita' ao invés de 'valorDireito' para preservar arrays de tuplas
                     expressao.operador);
                 }
@@ -18919,8 +19413,12 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq & dir;
                 }
                 return Number(valorEsquerdo) & Number(valorDireito);
@@ -18931,8 +19429,12 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq ^ dir;
                 }
                 return Number(valorEsquerdo) ^ Number(valorDireito);
@@ -18943,8 +19445,12 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq | dir;
                 }
                 return Number(valorEsquerdo) | Number(valorDireito);
@@ -18952,9 +19458,15 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt (interno para longo) se qualquer operando for BigInt ou se deslocamento >= 32
                 const tamanhoDeslocamentoEsquerda = Number(valorDireito);
-                if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint' || tamanhoDeslocamentoEsquerda >= 32) {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                if (typeof valorEsquerdo === 'bigint' ||
+                    typeof valorDireito === 'bigint' ||
+                    tamanhoDeslocamentoEsquerda >= 32) {
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq << dir;
                 }
                 return Number(valorEsquerdo) << Number(valorDireito);
@@ -18962,9 +19474,15 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt (interno para longo) se qualquer operando for BigInt ou se deslocamento >= 32
                 const tamanhoDeslocamentoDireita = Number(valorDireito);
-                if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint' || tamanhoDeslocamentoDireita >= 32) {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                if (typeof valorEsquerdo === 'bigint' ||
+                    typeof valorDireito === 'bigint' ||
+                    tamanhoDeslocamentoDireita >= 32) {
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq >> dir;
                 }
                 return Number(valorEsquerdo) >> Number(valorDireito);
@@ -19085,7 +19603,8 @@ class InterpretadorBase {
             // Casos que passam aqui: chamadas a métodos de bibliotecas de Delégua.
             if (typeof entidadeChamada === primitivos_1.default.FUNCAO) {
                 let objeto = null;
-                if (expressao.entidadeChamada.objeto) { // TODO: Qual o tipo certo aqui?
+                if (expressao.entidadeChamada.objeto) {
+                    // TODO: Qual o tipo certo aqui?
                     objeto = await this.avaliar(expressao.entidadeChamada.objeto);
                 }
                 return entidadeChamada.apply(this.resolverValor(objeto), argumentos);
@@ -19144,7 +19663,8 @@ class InterpretadorBase {
     }
     logicaContemOuEm(esquerda, direita, expressao) {
         const valorDireitoResolvido = this.resolverValor(direita);
-        if (Array.isArray(valorDireitoResolvido) || typeof valorDireitoResolvido === primitivos_1.default.TEXTO) {
+        if (Array.isArray(valorDireitoResolvido) ||
+            typeof valorDireitoResolvido === primitivos_1.default.TEXTO) {
             const avaliacao = valorDireitoResolvido.includes(esquerda);
             return expressao.negado ? !avaliacao : avaliacao;
         }
@@ -19176,13 +19696,19 @@ class InterpretadorBase {
                 const valorDireito = this.resolverValor(direita);
                 if (typeof valorDireito === 'number' || typeof valorDireito === 'bigint') {
                     if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                        const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                        const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
-                        return expressao.operador.tipo === delegua_1.default.E ? (esq & dir) : (esq | dir);
+                        const esq = typeof valorEsquerdo === 'bigint'
+                            ? valorEsquerdo
+                            : BigInt(Math.floor(Number(valorEsquerdo)));
+                        const dir = typeof valorDireito === 'bigint'
+                            ? valorDireito
+                            : BigInt(Math.floor(Number(valorDireito)));
+                        return expressao.operador.tipo === delegua_1.default.E
+                            ? esq & dir
+                            : esq | dir;
                     }
                     return expressao.operador.tipo === delegua_1.default.E
-                        ? (Number(valorEsquerdo) & Number(valorDireito))
-                        : (Number(valorEsquerdo) | Number(valorDireito));
+                        ? Number(valorEsquerdo) & Number(valorDireito)
+                        : Number(valorEsquerdo) | Number(valorDireito);
                 }
                 // Demais casos sem diferença de tipos
                 if (expressao.operador.tipo === delegua_1.default.OU) {
@@ -19276,7 +19802,7 @@ class InterpretadorBase {
                     const valorComoDupla = valorVetorResolvido[declaracao.posicaoAtual];
                     const promises = await Promise.all([
                         this.avaliar(declaracao.variavelIteracao.primeiro),
-                        this.avaliar(declaracao.variavelIteracao.segundo)
+                        this.avaliar(declaracao.variavelIteracao.segundo),
                     ]);
                     // TODO: O que fazer quando não forem literais?
                     this.pilhaEscoposExecucao.definirVariavel(String(promises[0].valor), valorComoDupla.primeiro);
@@ -19456,7 +19982,9 @@ class InterpretadorBase {
         let formatoTexto = '';
         for (const argumento of argumentos) {
             let resultadoAvaliacao = await this.avaliar(argumento);
-            if (resultadoAvaliacao && resultadoAvaliacao.hasOwnProperty && resultadoAvaliacao.hasOwnProperty('valorRetornado')) {
+            if (resultadoAvaliacao &&
+                resultadoAvaliacao.hasOwnProperty &&
+                resultadoAvaliacao.hasOwnProperty('valorRetornado')) {
                 resultadoAvaliacao = resultadoAvaliacao.valorRetornado;
             }
             let valor = this.resolverValor(resultadoAvaliacao);
@@ -19697,12 +20225,12 @@ class InterpretadorBase {
         }, 'Somente listas, dicionários, classes e objetos podem ter seus valores indexados.', expressao.linha));
     }
     /**
-        * Método base para acesso a intervalo.
-        * Por padrão lança erro, pois a maioria dos dialetos (como Delégua padrão)
-        * ainda não suporta isso nativamente, apenas Pituguês.
-    */
+     * Método base para acesso a intervalo.
+     * Por padrão lança erro, pois a maioria dos dialetos (como Delégua padrão)
+     * ainda não suporta isso nativamente, apenas Pituguês.
+     */
     visitarExpressaoAcessoIntervaloVariavel(expressao) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, "Acesso por intervalo não implementado para este dialeto.", expressao.linha));
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Acesso por intervalo não implementado para este dialeto.', expressao.linha));
     }
     async visitarExpressaoDefinirValor(expressao) {
         const variavelObjeto = await this.avaliar(expressao.objeto);
@@ -19735,18 +20263,30 @@ class InterpretadorBase {
      * @returns Sempre retorna nulo, por ser requerido pelo contrato de visita.
      */
     async visitarDeclaracaoClasse(declaracao) {
-        let superClasse = null;
-        if (declaracao.superClasse !== null && declaracao.superClasse !== undefined) {
-            const variavelSuperClasse = await this.avaliar(declaracao.superClasse);
-            superClasse = variavelSuperClasse.valor;
+        // Resolver cada superclasse listada em `herda A, B, ...`
+        const superClassesResolvidas = [];
+        for (const superClasseVariavel of declaracao.superClasses) {
+            const variavelSuperClasse = await this.avaliar(superClasseVariavel);
+            const superClasse = variavelSuperClasse.valor;
             if (!(superClasse instanceof estruturas_1.DescritorTipoClasse)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.superClasse.nome, 'Superclasse precisa ser uma classe.', declaracao.linha);
+                throw new excecoes_1.ErroEmTempoDeExecucao(superClasseVariavel.nome, 'Superclasse precisa ser uma classe.', declaracao.linha);
+            }
+            superClassesResolvidas.push(superClasse);
+        }
+        // Resolver cada misturável listado em `mescla X, Y, ...`
+        const mesclaResolvidas = [];
+        for (const mesclaVariavel of declaracao.mesclas) {
+            const variavelMisturavel = await this.avaliar(mesclaVariavel);
+            const misturável = variavelMisturavel.valor;
+            if (!(misturável instanceof estruturas_1.DescritorTipoClasse)) {
+                throw new excecoes_1.ErroEmTempoDeExecucao(mesclaVariavel.nome, 'Misturável precisa ser uma classe.', declaracao.linha);
             }
+            mesclaResolvidas.push(misturável);
         }
         // TODO: Precisamos disso?
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, declaracao);
-        if (declaracao.superClasse !== null && declaracao.superClasse !== undefined) {
-            this.pilhaEscoposExecucao.definirVariavel('super', superClasse);
+        if (superClassesResolvidas.length > 0) {
+            this.pilhaEscoposExecucao.definirVariavel('super', superClassesResolvidas[0]);
         }
         const metodos = {};
         const metodosEstaticos = {};
@@ -19774,9 +20314,7 @@ class InterpretadorBase {
             const funcao = new estruturas_1.DeleguaFuncao(nomeMetodo, metodoAtual.funcao, undefined, eInicializador);
             funcao.documentacao = metodoAtual.documentacao;
             // Numa classe estática, todos os métodos (exceto construtor) são estáticos.
-            const ehEstatico = declaracao.classeEstatica
-                ? !eInicializador
-                : metodoAtual.estatico;
+            const ehEstatico = declaracao.classeEstatica ? !eInicializador : metodoAtual.estatico;
             if (metodoAtual.eObtenedor) {
                 if (ehEstatico) {
                     obtenedoresEstaticos[nomeMetodo] = funcao;
@@ -19817,7 +20355,7 @@ class InterpretadorBase {
                 acessoPropriedades[prop.nome.lexema] = prop.acesso;
             }
         }
-        const descritorTipoClasse = new estruturas_1.DescritorTipoClasse(declaracao.simbolo, superClasse, metodos, declaracao.propriedades);
+        const descritorTipoClasse = new estruturas_1.DescritorTipoClasse(declaracao.simbolo, superClassesResolvidas, metodos, declaracao.propriedades);
         descritorTipoClasse.metodosEstaticos = metodosEstaticos;
         descritorTipoClasse.membrosEstaticos = membrosEstaticos;
         descritorTipoClasse.obtenedores = obtenedores;
@@ -19832,13 +20370,45 @@ class InterpretadorBase {
         // Toda classe sem superclasse explícita herda implicitamente de `Objeto`.
         // Isso só deve acontecer quando OBJETO_BASE já estiver inicializado e a classe
         // atual não for o próprio OBJETO_BASE, para evitar cadeias de herança recursivas.
-        if (!descritorTipoClasse.superClasse && estruturas_1.OBJETO_BASE && descritorTipoClasse !== estruturas_1.OBJETO_BASE) {
-            descritorTipoClasse.superClasse = estruturas_1.OBJETO_BASE;
+        if (descritorTipoClasse.superClasses.length === 0 &&
+            estruturas_1.OBJETO_BASE &&
+            descritorTipoClasse !== estruturas_1.OBJETO_BASE) {
+            descritorTipoClasse.superClasses = [estruturas_1.OBJETO_BASE];
+        }
+        // Calcular o OReM (linearização C3) após os pais estarem definidos.
+        descritorTipoClasse.orem = estruturas_1.DescritorTipoClasse.computarOReM(descritorTipoClasse);
+        // Mesclar métodos e propriedades dos misturávels (primeiro misturável ganha se não definido na classe).
+        for (const misturável of mesclaResolvidas) {
+            for (const [nome, funcao] of Object.entries(misturável.metodos)) {
+                if (!descritorTipoClasse.metodos.hasOwnProperty(nome)) {
+                    descritorTipoClasse.metodos[nome] = funcao;
+                }
+            }
+            for (const [nome, funcao] of Object.entries(misturável.obtenedores)) {
+                if (!descritorTipoClasse.obtenedores.hasOwnProperty(nome)) {
+                    descritorTipoClasse.obtenedores[nome] = funcao;
+                }
+            }
+            for (const [nome, funcao] of Object.entries(misturável.definidores)) {
+                if (!descritorTipoClasse.definidores.hasOwnProperty(nome)) {
+                    descritorTipoClasse.definidores[nome] = funcao;
+                }
+            }
+            for (const prop of misturável.propriedades) {
+                const jaDeclarada = descritorTipoClasse.propriedades.some((p) => p.nome.lexema === prop.nome.lexema);
+                if (!jaDeclarada) {
+                    descritorTipoClasse.propriedades.push(prop);
+                }
+            }
         }
         // Verifica se a subclasse concreta implementa todos os métodos abstratos
-        // da superclasse abstrata.
-        if (!declaracao.abstrata && superClasse && superClasse.abstrata) {
-            superClasse.verificarImplementacaoAbstrata(descritorTipoClasse);
+        // da(s) superclasse(s) abstrata(s).
+        if (!declaracao.abstrata) {
+            for (const superClasse of superClassesResolvidas) {
+                if (superClasse.abstrata) {
+                    superClasse.verificarImplementacaoAbstrata(descritorTipoClasse);
+                }
+            }
         }
         // TODO: Até então, a única exceção a isso é Égua Clássico.
         // Por enquanto, tudo bem deixar isso aqui.
@@ -20065,21 +20635,25 @@ class InterpretadorBase {
         let valoresArray;
         // Verificar se é uma TuplaN (verifica instanceof OU propriedade elementos/tipo para maior compatibilidade)
         if (valores instanceof construtos_1.TuplaN ||
-            (valores && valores.tipo === 'tupla' && valores.elementos && Array.isArray(valores.elementos))) {
+            (valores &&
+                valores.tipo === 'tupla' &&
+                valores.elementos &&
+                Array.isArray(valores.elementos))) {
             valoresArray = valores.elementos.map((elem) => {
-                if (elem instanceof construtos_1.Literal || (elem && typeof elem === 'object' && elem.hasOwnProperty('valor'))) {
+                if (elem instanceof construtos_1.Literal ||
+                    (elem && typeof elem === 'object' && elem.hasOwnProperty('valor'))) {
                     return this.resolverValor(elem.valor);
                 }
                 return this.resolverValor(elem);
             });
         }
         else if (Array.isArray(valores)) {
-            valoresArray = valores.map(v => this.resolverValor(v));
+            valoresArray = valores.map((v) => this.resolverValor(v));
         }
         else {
             const valorResolvido = this.resolverValor(valores);
             if (Array.isArray(valorResolvido)) {
-                valoresArray = valorResolvido.map(v => this.resolverValor(v));
+                valoresArray = valorResolvido.map((v) => this.resolverValor(v));
             }
             else {
                 valoresArray = [valorResolvido];
@@ -20201,7 +20775,9 @@ class InterpretadorBase {
             return objeto.valor.paraTexto();
         if (objeto instanceof construtos_1.Literal)
             return this.paraTexto(objeto.valor);
-        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse || objeto instanceof estruturas_1.DeleguaFuncao)
+        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
+            objeto instanceof estruturas_1.DeleguaFuncao ||
+            objeto instanceof estruturas_1.DescritorTipoClasse)
             return objeto.paraTexto();
         if (objeto instanceof quebras_1.RetornoQuebra) {
             if (typeof objeto.valor === 'boolean')
@@ -20466,10 +21042,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         return objeto;
     }
     serializarSemEspacos(objeto) {
-        return JSON
-            .stringify(objeto)
-            .replace(/,\s+/g, ',')
-            .replace(/:\s+/g, ':');
+        return JSON.stringify(objeto).replace(/,\s+/g, ',').replace(/:\s+/g, ':');
     }
     paraTexto(objeto) {
         if (objeto === null || objeto === undefined)
@@ -20484,7 +21057,9 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
             return objeto.valor.paraTexto();
         if (objeto instanceof construtos_1.Literal || objeto instanceof construtos_1.Tupla)
             return objeto.paraTextoSaida();
-        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse || objeto instanceof estruturas_1.DeleguaFuncao)
+        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
+            objeto instanceof estruturas_1.DeleguaFuncao ||
+            objeto instanceof estruturas_1.DescritorTipoClasse)
             return objeto.paraTexto();
         if (objeto instanceof quebras_1.RetornoQuebra) {
             if (typeof objeto.valor === 'boolean')
@@ -20760,11 +21335,11 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                     const valorComoDupla = valorVetorOuDicionarioResolvido[paraCada.posicaoAtual];
                     const nomesVariaveis = await Promise.all([
                         this.avaliar(paraCada.variavelIteracao.primeiro),
-                        this.avaliar(paraCada.variavelIteracao.segundo)
+                        this.avaliar(paraCada.variavelIteracao.segundo),
                     ]);
                     const valoresDupla = await Promise.all([
                         this.avaliar(valorComoDupla.primeiro),
-                        this.avaliar(valorComoDupla.segundo)
+                        this.avaliar(valorComoDupla.segundo),
                     ]);
                     // nomesVariaveis são strings (nomes das variáveis)
                     this.pilhaEscoposExecucao.definirVariavel(String(nomesVariaveis[0]), valoresDupla[0]);
@@ -21510,18 +22085,20 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         // Tratamento especial para expressões unárias aplicadas a chamadas de método em literais numéricos.
         // Por exemplo: -5.absoluto() deve ser avaliado como (-5).absoluto(), não como -(5.absoluto())
         // Isso garante que o operador unário seja aplicado ao literal antes de chamar o método.
-        if ((expressao.operador.tipo === delegua_2.default.SUBTRACAO || expressao.operador.tipo === delegua_2.default.ADICAO) &&
+        if ((expressao.operador.tipo === delegua_2.default.SUBTRACAO ||
+            expressao.operador.tipo === delegua_2.default.ADICAO) &&
             expressao.operando instanceof construtos_1.Chamada) {
             const entidadeChamada = expressao.operando.entidadeChamada;
             // Verifica se é AcessoMetodo ou AcessoMetodoOuPropriedade
-            if (entidadeChamada instanceof construtos_1.AcessoMetodo || entidadeChamada instanceof construtos_1.AcessoMetodoOuPropriedade) {
+            if (entidadeChamada instanceof construtos_1.AcessoMetodo ||
+                entidadeChamada instanceof construtos_1.AcessoMetodoOuPropriedade) {
                 const objetoAcesso = entidadeChamada.objeto;
                 // Verifica se o objeto do método é um literal numérico
                 if (objetoAcesso instanceof construtos_1.Literal && typeof objetoAcesso.valor === 'number') {
                     // Cria um novo literal com o sinal aplicado
-                    const novoLiteral = new construtos_1.Literal(objetoAcesso.hashArquivo, objetoAcesso.linha, expressao.operador.tipo === delegua_2.default.SUBTRACAO ?
-                        -objetoAcesso.valor :
-                        +objetoAcesso.valor);
+                    const novoLiteral = new construtos_1.Literal(objetoAcesso.hashArquivo, objetoAcesso.linha, expressao.operador.tipo === delegua_2.default.SUBTRACAO
+                        ? -objetoAcesso.valor
+                        : +objetoAcesso.valor);
                     // Cria um novo acesso com o literal modificado
                     let novoAcesso;
                     if (entidadeChamada instanceof construtos_1.AcessoMetodo) {
@@ -21543,7 +22120,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
     async visitarExpressaoVetor(expressao) {
         // Delega ao interpretador base para processar o vetor
         const vetor = await super.visitarExpressaoVetor(expressao);
-        // Adiciona referência no montão (comportamento específico deste interpretador)                                                                             
+        // Adiciona referência no montão (comportamento específico deste interpretador)
         const enderecoVetorMontao = this.montao.adicionarReferencia(vetor);
         this.pilhaEscoposExecucao.registrarReferenciaMontao(enderecoVetorMontao);
         return new estruturas_1.ReferenciaMontao(enderecoVetorMontao);
@@ -22877,7 +23454,9 @@ class LexadorPitugues {
         }
         const deslocamento = ehFString ? 2 : 1;
         const textoCompleto = this.codigo[this.linha].substring(this.inicioSimbolo + deslocamento, this.atual);
-        if (textoCompleto.length === 0 && !this.eFinalDoCodigo() && this.codigo[this.linha].charAt(this.atual + 1) === delimitador) {
+        if (textoCompleto.length === 0 &&
+            !this.eFinalDoCodigo() &&
+            this.codigo[this.linha].charAt(this.atual + 1) === delimitador) {
             this.avancar(); // Avança para o próximo delimitador
             this.analisarTextoMultilinha(delimitador);
             return;
@@ -23488,9 +24067,31 @@ class LexadorPrisma {
     }
     eAlfabeto(caractere) {
         const acentuacoes = [
-            'á', 'Á', 'ã', 'Ã', 'â', 'Â', 'à', 'À',
-            'é', 'É', 'ê', 'Ê', 'í', 'Í', 'ó', 'Ó',
-            'õ', 'Õ', 'ô', 'Ô', 'ú', 'Ú', 'ç', 'Ç', '_',
+            'á',
+            'Á',
+            'ã',
+            'Ã',
+            'â',
+            'Â',
+            'à',
+            'À',
+            'é',
+            'É',
+            'ê',
+            'Ê',
+            'í',
+            'Í',
+            'ó',
+            'Ó',
+            'õ',
+            'Õ',
+            'ô',
+            'Ô',
+            'ú',
+            'Ú',
+            'ç',
+            'Ç',
+            '_',
         ];
         return ((caractere >= 'a' && caractere <= 'z') ||
             (caractere >= 'A' && caractere <= 'Z') ||
@@ -26010,13 +26611,14 @@ exports.palavrasReservadasDelegua = {
     falso: delegua_1.default.FALSO,
     faca: delegua_1.default.FAZER,
     fazer: delegua_1.default.FAZER,
-    'faça': delegua_1.default.FAZER,
+    faça: delegua_1.default.FAZER,
     finalmente: delegua_1.default.FINALMENTE,
     fixo: delegua_1.default.CONSTANTE,
     funcao: delegua_1.default.FUNCAO,
     função: delegua_1.default.FUNÇÃO,
     herda: delegua_1.default.HERDA,
     implementa: delegua_1.default.IMPLEMENTA,
+    mescla: delegua_1.default.MESCLA,
     importar: delegua_1.default.IMPORTAR,
     importe: delegua_1.default.IMPORTAR,
     interface: delegua_1.default.INTERFACE,
@@ -26055,7 +26657,7 @@ exports.palavrasReservadasDelegua = {
     var: delegua_1.default.VARIAVEL,
     variavel: delegua_1.default.VARIAVEL,
     variável: delegua_1.default.VARIAVEL,
-    verdadeiro: delegua_1.default.VERDADEIRO
+    verdadeiro: delegua_1.default.VERDADEIRO,
 };
 exports.palavrasReservadasMicroGramatica = {
     e: delegua_1.default.E,
@@ -26318,6 +26920,7 @@ exports.default = {
     HERDA: 'HERDA',
     IDENTIFICADOR: 'IDENTIFICADOR',
     IMPLEMENTA: 'IMPLEMENTA',
+    MESCLA: 'MESCLA',
     INTERFACE: 'INTERFACE',
     IGUAL: 'IGUAL',
     IGUAL_IGUAL: 'IGUAL_IGUAL',
@@ -39540,10 +40143,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() {
@@ -39585,11 +40188,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';
@@ -39613,12 +40216,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);
     }
@@ -39637,9 +40240,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) {
@@ -39649,75 +40252,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);
@@ -39735,35 +40338,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)) {
@@ -39773,8 +40376,8 @@ ${labelFuncao}:
                 }
             });
         }
-        this.text += `
-    mov sp, fp
+        this.text += `
+    mov sp, fp
     pop {fp, pc}`;
     }
     traduzirConstrutoLiteral(construto) {
@@ -39789,29 +40392,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';
@@ -39823,16 +40426,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';
@@ -39842,8 +40445,8 @@ ${labelFim}:`;
         const nomeVar = (_a = construto.simbolo) === null || _a === void 0 ? void 0 : _a.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';
         }
@@ -39858,9 +40461,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}]`;
                 }
             });
@@ -39880,17 +40483,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) {
@@ -39901,10 +40504,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) => {
@@ -39913,23 +40516,24 @@ ${labelFim}:`;
                             }
                         });
                     }
-                    this.text += `
-    b ${labelFim}
+                    this.text += `
+    b ${labelFim}
 ${labelProximo}:`;
                 }
             });
         }
-        this.text += `
+        this.text += `
 ${labelFim}:`;
     }
     traduzirDeclaracaoExpressao(declaracao) {
-        if (declaracao.expressao && this.dicionarioConstrutos[declaracao.expressao.constructor.name]) {
+        if (declaracao.expressao &&
+            this.dicionarioConstrutos[declaracao.expressao.constructor.name]) {
             this.dicionarioConstrutos[declaracao.expressao.constructor.name](declaracao.expressao);
         }
     }
     traduzirDeclaracaoFazer(declaracao) {
         const labelInicio = this.gerarLabel();
-        this.text += `
+        this.text += `
 ${labelInicio}:`;
         if (declaracao.caminhoFazer && declaracao.caminhoFazer.declaracoes) {
             declaracao.caminhoFazer.declaracoes.forEach((decl) => {
@@ -39940,52 +40544,58 @@ ${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}`;
         }
     }
     traduzirDeclaracaoFalhar(declaracao) {
         let mensagem = '"Erro"';
-        if (declaracao.explicacao && typeof declaracao.explicacao === 'object' && 'constructor' in declaracao.explicacao) {
+        if (declaracao.explicacao &&
+            typeof declaracao.explicacao === 'object' &&
+            'constructor' in declaracao.explicacao) {
             const explicacao = declaracao.explicacao;
             if (explicacao.constructor && this.dicionarioConstrutos[explicacao.constructor.name]) {
                 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) {
         var _a;
         const nomeFuncao = ((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'funcao';
-        this.text += `
-
-${nomeFuncao}:
-    push {fp, lr}
+        this.text += `
+
+${nomeFuncao}:
+    push {fp, lr}
     mov fp, sp`;
-        if (declaracao.funcao && declaracao.funcao.corpo && Array.isArray(declaracao.funcao.corpo)) {
+        if (declaracao.funcao &&
+            declaracao.funcao.corpo &&
+            Array.isArray(declaracao.funcao.corpo)) {
             declaracao.funcao.corpo.forEach((decl) => {
                 if (this.dicionarioDeclaracoes[decl.constructor.name]) {
                     this.dicionarioDeclaracoes[decl.constructor.name](decl);
                 }
             });
         }
-        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) {
         var _a;
         let nomeVar;
-        if (declaracao.argumentos && declaracao.argumentos[0] && declaracao.argumentos[0] instanceof construtos_1.Variavel) {
+        if (declaracao.argumentos &&
+            declaracao.argumentos[0] &&
+            declaracao.argumentos[0] instanceof construtos_1.Variavel) {
             nomeVar = (_a = declaracao.argumentos[0].simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
         }
         if (!nomeVar)
@@ -39995,11 +40605,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) {
@@ -40014,12 +40624,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]) {
@@ -40030,8 +40640,8 @@ ${labelInicio}:`;
                 this.dicionarioConstrutos[declaracao.incrementar.constructor.name](declaracao.incrementar);
             }
         }
-        this.text += `
-    b ${labelInicio}
+        this.text += `
+    b ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoParaCada(declaracao) {
@@ -40047,55 +40657,56 @@ ${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]) {
+        if (declaracao.caminhoSenao &&
+            this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name](declaracao.caminhoSenao);
         }
-        this.text += `
+        this.text += `
 ${labelFim}:`;
     }
     traduzirDeclaracaoClasse(declaracao) {
         var _a;
-        this.text += `
+        this.text += `
     @ Classe: ${((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'unknown'}`;
     }
     traduzirDeclaracaoTente(declaracao) {
-        this.text += `
+        this.text += `
     @ Tente-pegue`;
         if (declaracao.caminhoTente && Array.isArray(declaracao.caminhoTente)) {
             declaracao.caminhoTente.forEach((decl) => {
@@ -40134,9 +40745,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]`;
             }
         }
@@ -40163,20 +40774,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) {
@@ -40251,13 +40862,14 @@ class TradutorAssemblyX64 {
             Escreva: this.traduzirDeclaracaoEscreva.bind(this),
         };
         this.indentacao = 0;
-        this.text = `
-section .text
-    ${this.alvo === 'linux' ? 'global _start' : 'global main'}
+        this.text = `
+section .text
+    ${this.alvo === 'linux' ? 'global _start' : 'global main'}
 ${this.alvo === 'linux' ? '_start:' : 'main:'}`;
         if (this.alvo === 'windows') {
-            this.text = `
-extern printf
+            this.text =
+                `
+extern printf
 ` + this.text;
         }
     }
@@ -40319,8 +40931,8 @@ extern printf
         }
         const indice = this.dicionarioConstrutos[construto.indice.constructor.name](construto.indice);
         const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
-        this.text += `
-    mov rax, ${valor}
+        this.text += `
+    mov rax, ${valor}
     mov [${nomeVar} + ${indice} * 8], rax`;
     }
     traduzirConstrutoAtribuir(construto) {
@@ -40339,8 +40951,8 @@ extern printf
             this.bss += `    ${varLabel} resq 1\n`;
             this.variaveis.set(nomeVar, varLabel);
         }
-        this.text += `
-    mov rax, ${valor}
+        this.text += `
+    mov rax, ${valor}
     mov [${this.variaveis.get(nomeVar)}], rax`;
     }
     traduzirConstrutoBinario(construto) {
@@ -40348,35 +40960,35 @@ extern printf
         const direita = this.dicionarioConstrutos[construto.direita.constructor.name](construto.direita);
         const operador = construto.operador.lexema;
         const reg = this.obterRegistrador();
-        this.text += `
-    mov rax, ${esquerda}
+        this.text += `
+    mov rax, ${esquerda}
     mov ${reg}, ${direita}`;
         switch (operador) {
             case '+':
-                this.text += `
+                this.text += `
     add rax, ${reg}`;
                 break;
             case '-':
-                this.text += `
+                this.text += `
     sub rax, ${reg}`;
                 break;
             case '*':
-                this.text += `
+                this.text += `
     imul rax, ${reg}`;
                 break;
             case '/':
-                this.text += `
-    xor rdx, rdx
+                this.text += `
+    xor rdx, rdx
     idiv ${reg}`;
                 break;
             case '%':
-                this.text += `
-    xor rdx, rdx
-    idiv ${reg}
+                this.text += `
+    xor rdx, rdx
+    idiv ${reg}
     mov rax, rdx`;
                 break;
             default:
-                this.text += `
+                this.text += `
     ; Operador ${operador} não implementado`;
         }
         this.liberarRegistrador(reg);
@@ -40395,28 +41007,28 @@ extern printf
         construto.argumentos.forEach((arg, index) => {
             if (index < registrosArgs.length) {
                 const valorArg = this.dicionarioConstrutos[arg.constructor.name](arg);
-                this.text += `
+                this.text += `
     mov ${registrosArgs[index]}, ${valorArg}`;
             }
             else {
                 // TODO: push extra args on stack according to target ABI
             }
         });
-        this.text += `
+        this.text += `
     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.text += `
-    mov rax, ${valor}
+        this.text += `
+    mov rax, ${valor}
     mov [${objeto}], rax`;
     }
     traduzirFuncaoConstruto(construto) {
         const labelFuncao = `func_${this.gerarDigitoAleatorio()}`;
-        this.text += `
-${labelFuncao}:
-    push rbp
+        this.text += `
+${labelFuncao}:
+    push rbp
     mov rbp, rsp`;
         // Traduzir corpo da função
         if (construto.corpo && Array.isArray(construto.corpo)) {
@@ -40426,8 +41038,8 @@ ${labelFuncao}:
                 }
             });
         }
-        this.text += `
-    pop rbp
+        this.text += `
+    pop rbp
     ret`;
     }
     traduzirConstrutoLiteral(construto) {
@@ -40442,29 +41054,29 @@ ${labelFuncao}:
         const operador = construto.operador.lexema;
         const labelVerdadeiro = this.gerarLabel();
         const labelFim = this.gerarLabel();
-        this.text += `
-    mov rax, ${esquerda}
+        this.text += `
+    mov rax, ${esquerda}
     cmp rax, 0`;
         if (operador === 'e' || operador === '&&') {
-            this.text += `
-    je ${labelFim}
-    mov rax, ${direita}
-    cmp rax, 0
-    je ${labelFim}
-${labelVerdadeiro}:
-    mov rax, 1
+            this.text += `
+    je ${labelFim}
+    mov rax, ${direita}
+    cmp rax, 0
+    je ${labelFim}
+${labelVerdadeiro}:
+    mov rax, 1
 ${labelFim}:`;
         }
         else if (operador === 'ou' || operador === '||') {
-            this.text += `
-    jne ${labelVerdadeiro}
-    mov rax, ${direita}
-    cmp rax, 0
-    jne ${labelVerdadeiro}
-    mov rax, 0
-    jmp ${labelFim}
-${labelVerdadeiro}:
-    mov rax, 1
+            this.text += `
+    jne ${labelVerdadeiro}
+    mov rax, ${direita}
+    cmp rax, 0
+    jne ${labelVerdadeiro}
+    mov rax, 0
+    jmp ${labelFim}
+${labelVerdadeiro}:
+    mov rax, 1
 ${labelFim}:`;
         }
         return 'rax';
@@ -40477,16 +41089,16 @@ ${labelFim}:`;
     traduzirConstrutoUnario(construto) {
         const operando = this.dicionarioConstrutos[construto.operando.constructor.name](construto.operando);
         const operador = construto.operador.lexema;
-        this.text += `
+        this.text += `
     mov rax, ${operando}`;
         if (operador === '-') {
-            this.text += `
+            this.text += `
     neg rax`;
         }
         else if (operador === '!' || operador === 'nao') {
-            this.text += `
-    cmp rax, 0
-    sete al
+            this.text += `
+    cmp rax, 0
+    sete al
     movzx rax, al`;
         }
         return 'rax';
@@ -40508,8 +41120,8 @@ ${labelFim}:`;
             construto.valores.forEach((valor, index) => {
                 if (this.dicionarioConstrutos[valor.constructor.name]) {
                     const valorTraduzido = this.dicionarioConstrutos[valor.constructor.name](valor);
-                    this.text += `
-    mov rax, ${valorTraduzido}
+                    this.text += `
+    mov rax, ${valorTraduzido}
     mov [${labelVetor} + ${index * 8}], rax`;
                 }
             });
@@ -40529,17 +41141,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
     je ${labelFim}`;
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
         }
-        this.text += `
-    jmp ${labelInicio}
+        this.text += `
+    jmp ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoEscolha(declaracao) {
@@ -40550,9 +41162,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.text += `
-    mov rax, ${valorEscolha}
-    cmp rax, ${valorCaso}
+                    this.text += `
+    mov rax, ${valorEscolha}
+    cmp rax, ${valorCaso}
     jne ${labelProximo}`;
                     if (caminho.declaracoes && Array.isArray(caminho.declaracoes)) {
                         caminho.declaracoes.forEach((decl) => {
@@ -40561,23 +41173,24 @@ ${labelFim}:`;
                             }
                         });
                     }
-                    this.text += `
-    jmp ${labelFim}
+                    this.text += `
+    jmp ${labelFim}
 ${labelProximo}:`;
                 }
             });
         }
-        this.text += `
+        this.text += `
 ${labelFim}:`;
     }
     traduzirDeclaracaoExpressao(declaracao) {
-        if (declaracao.expressao && this.dicionarioConstrutos[declaracao.expressao.constructor.name]) {
+        if (declaracao.expressao &&
+            this.dicionarioConstrutos[declaracao.expressao.constructor.name]) {
             this.dicionarioConstrutos[declaracao.expressao.constructor.name](declaracao.expressao);
         }
     }
     traduzirDeclaracaoFazer(declaracao) {
         const labelInicio = this.gerarLabel();
-        this.text += `
+        this.text += `
 ${labelInicio}:`;
         // Em Delégua, fazer-enquanto tem caminhoFazer que é um Bloco
         if (declaracao.caminhoFazer && declaracao.caminhoFazer.declaracoes) {
@@ -40589,60 +41202,66 @@ ${labelInicio}:`;
         }
         if (declaracao.condicaoEnquanto) {
             const condicao = this.dicionarioConstrutos[declaracao.condicaoEnquanto.constructor.name](declaracao.condicaoEnquanto);
-            this.text += `
-    cmp ${condicao}, 0
+            this.text += `
+    cmp ${condicao}, 0
     jne ${labelInicio}`;
         }
     }
     traduzirDeclaracaoFalhar(declaracao) {
         let mensagem = '"Erro"';
-        if (declaracao.explicacao && typeof declaracao.explicacao === 'object' && 'constructor' in declaracao.explicacao) {
+        if (declaracao.explicacao &&
+            typeof declaracao.explicacao === 'object' &&
+            'constructor' in declaracao.explicacao) {
             const explicacao = declaracao.explicacao;
             if (explicacao.constructor && this.dicionarioConstrutos[explicacao.constructor.name]) {
                 mensagem = this.dicionarioConstrutos[explicacao.constructor.name](explicacao);
             }
         }
         if (this.alvo === 'linux') {
-            this.text += `
-        ; Falhar com mensagem: ${mensagem}
-        mov eax, 1
-        mov ebx, 1
+            this.text += `
+        ; Falhar com mensagem: ${mensagem}
+        mov eax, 1
+        mov ebx, 1
         int 0x80`;
         }
         else {
-            this.text += `
-        ; Falhar com mensagem: ${mensagem}
-        mov eax, 1
+            this.text += `
+        ; Falhar com mensagem: ${mensagem}
+        mov eax, 1
         ret`;
         }
     }
     traduzirDeclaracaoFuncao(declaracao) {
         var _a;
         const nomeFuncao = ((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'funcao';
-        this.text += `
-${nomeFuncao}:
-    push rbp
+        this.text += `
+${nomeFuncao}:
+    push rbp
     mov rbp, rsp`;
-        if (declaracao.funcao && declaracao.funcao.corpo && Array.isArray(declaracao.funcao.corpo)) {
+        if (declaracao.funcao &&
+            declaracao.funcao.corpo &&
+            Array.isArray(declaracao.funcao.corpo)) {
             declaracao.funcao.corpo.forEach((decl) => {
                 if (this.dicionarioDeclaracoes[decl.constructor.name]) {
                     this.dicionarioDeclaracoes[decl.constructor.name](decl);
                 }
             });
         }
-        this.text += `
-    pop rbp
+        this.text += `
+    pop rbp
     ret`;
     }
     traduzirDeclaracaoImportar(declaracao) {
         // Importação é tratada em tempo de linkagem
-        this.text += `
+        this.text += `
     ; Importar: ${declaracao.caminho || 'unknown'}`;
     }
     traduzirDeclaracaoLeia(declaracao) {
         var _a;
         let nomeVar;
-        if (declaracao.argumentos && declaracao.argumentos[0] && declaracao.argumentos[0] instanceof construtos_1.Variavel) {
+        if (declaracao.argumentos &&
+            declaracao.argumentos[0] &&
+            declaracao.argumentos[0] instanceof construtos_1.Variavel) {
             nomeVar = (_a = declaracao.argumentos[0].simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
         }
         if (!nomeVar)
@@ -40652,11 +41271,11 @@ ${nomeFuncao}:
             this.bss += `    ${varLabel} resb 256\n`;
             this.variaveis.set(nomeVar, varLabel);
         }
-        this.text += `
-    mov eax, 3
-    mov ebx, 0
-    mov ecx, ${this.variaveis.get(nomeVar)}
-    mov edx, 256
+        this.text += `
+    mov eax, 3
+    mov ebx, 0
+    mov ecx, ${this.variaveis.get(nomeVar)}
+    mov edx, 256
     int 0x80`;
     }
     traduzirDeclaracaoPara(declaracao) {
@@ -40672,12 +41291,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
     je ${labelFim}`;
         }
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
@@ -40688,8 +41307,8 @@ ${labelInicio}:`;
                 this.dicionarioConstrutos[declaracao.incrementar.constructor.name](declaracao.incrementar);
             }
         }
-        this.text += `
-    jmp ${labelInicio}
+        this.text += `
+    jmp ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoParaCada(declaracao) {
@@ -40705,57 +41324,58 @@ ${labelFim}:`;
         if (vetor instanceof construtos_1.Vetor) {
             tamanhoVetor = vetor.tamanho || 0;
         }
-        this.text += `
-    xor rcx, rcx
-${labelInicio}:
-    cmp rcx, ${tamanhoVetor}
+        this.text += `
+    xor rcx, rcx
+${labelInicio}:
+    cmp rcx, ${tamanhoVetor}
     jge ${labelFim}`;
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
         }
-        this.text += `
-    inc rcx
-    jmp ${labelInicio}
+        this.text += `
+    inc rcx
+    jmp ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoRetorna(declaracao) {
         if (declaracao.valor) {
             const valor = this.dicionarioConstrutos[declaracao.valor.constructor.name](declaracao.valor);
-            this.text += `
+            this.text += `
     mov rax, ${valor}`;
         }
-        this.text += `
-    pop rbp
+        this.text += `
+    pop rbp
     ret`;
     }
     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
     je ${labelSenao}`;
         if (this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name](declaracao.caminhoEntao);
         }
-        this.text += `
-    jmp ${labelFim}
+        this.text += `
+    jmp ${labelFim}
 ${labelSenao}:`;
-        if (declaracao.caminhoSenao && this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name]) {
+        if (declaracao.caminhoSenao &&
+            this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name](declaracao.caminhoSenao);
         }
-        this.text += `
+        this.text += `
 ${labelFim}:`;
     }
     traduzirDeclaracaoClasse(declaracao) {
         var _a;
         // Classes em assembly são complexas - implementação básica
-        this.text += `
+        this.text += `
     ; Classe: ${((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'unknown'}`;
     }
     traduzirDeclaracaoTente(declaracao) {
         // Try-catch em assembly requer handler complexo
-        this.text += `
+        this.text += `
     ; Tente-pegue`;
         if (declaracao.caminhoTente && Array.isArray(declaracao.caminhoTente)) {
             declaracao.caminhoTente.forEach((decl) => {
@@ -40794,8 +41414,8 @@ ${labelFim}:`;
             }
             else if (this.dicionarioConstrutos[tipoInicializador]) {
                 const valor = this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
-                this.text += `
-    mov rax, ${valor}
+                this.text += `
+    mov rax, ${valor}
     mov [${varLabel}], rax`;
             }
         }
@@ -40818,32 +41438,32 @@ ${labelFim}:`;
             tam_string_literal = this.criaTamanhoNaMemoriaReferenteAVar(nome_string_literal);
         }
         if (this.alvo === 'linux') {
-            this.text += `
-    mov edx, ${tam_string_literal}
-    mov ecx, ${nome_string_literal}
-    mov ebx, 1        ; fd stdout
-    mov eax, 4        ; sys_write
+            this.text += `
+    mov edx, ${tam_string_literal}
+    mov ecx, ${nome_string_literal}
+    mov ebx, 1        ; fd stdout
+    mov eax, 4        ; sys_write
     int 0x80`;
         }
         else {
             // Windows: prototype `extern printf` and follow Win64 calling convention
             // RCX = format pointer; here we use the literal directly as a C string
-            this.text += `
-    lea rcx, [rel ${nome_string_literal}]
+            this.text += `
+    lea rcx, [rel ${nome_string_literal}]
     call printf`;
         }
     }
     saidaSistema() {
         if (this.alvo === 'linux') {
-            this.text += `
-        mov eax, 1        ; sys_exit
-        xor ebx, ebx      ; status 0
+            this.text += `
+        mov eax, 1        ; sys_exit
+        xor ebx, ebx      ; status 0
         int 0x80`;
         }
         else {
             // Windows: return from main with 0 in EAX
-            this.text += `
-        xor eax, eax
+            this.text += `
+        xor eax, eax
         ret`;
         }
     }
@@ -41311,7 +41931,7 @@ class TradutorAssemblyScript {
         return resultado;
     }
     traduzirDeclaracaoVarMultiplo(declaracaoVarMultiplo) {
-        const variaveis = declaracaoVarMultiplo.simbolos.map(s => s.lexema).join(', ');
+        const variaveis = declaracaoVarMultiplo.simbolos.map((s) => s.lexema).join(', ');
         let resultado = 'let ';
         resultado += variaveis;
         resultado += this.resolveTipoDeclaracaoVarEContante(declaracaoVarMultiplo.tipo);
@@ -41330,7 +41950,7 @@ class TradutorAssemblyScript {
         return resultado;
     }
     traduzirDeclaracaoConstMultiplo(declaracaoConstMultiplo) {
-        const constantes = declaracaoConstMultiplo.simbolos.map(s => s.lexema).join(', ');
+        const constantes = declaracaoConstMultiplo.simbolos.map((s) => s.lexema).join(', ');
         let resultado = 'const ';
         resultado += constantes;
         resultado += this.resolveTipoDeclaracaoVarEContante(declaracaoConstMultiplo.tipo);
@@ -41485,7 +42105,9 @@ class TradutorAssemblyScript {
         const declaracoesCorpo = corpoBloco.declaracoes || [];
         let resultadoCorpo = '{\n';
         this.indentacao += 4;
-        resultadoCorpo += ' '.repeat(this.indentacao) + `const ${nomeVariavel} = ${nomeVetor}[__i_${nomeVariavel}];\n`;
+        resultadoCorpo +=
+            ' '.repeat(this.indentacao) +
+                `const ${nomeVariavel} = ${nomeVetor}[__i_${nomeVariavel}];\n`;
         for (const declaracaoOuConstruto of declaracoesCorpo) {
             resultadoCorpo += ' '.repeat(this.indentacao);
             const nomeConstrutor = declaracaoOuConstruto.constructor.name;
@@ -41706,7 +42328,9 @@ class TradutorAssemblyScript {
             if (typeof chave === 'string') {
                 chaveStr = `"${chave}"`;
             }
-            else if (chave && chave.constructor && this.dicionarioConstrutos[chave.constructor.name]) {
+            else if (chave &&
+                chave.constructor &&
+                this.dicionarioConstrutos[chave.constructor.name]) {
                 // Se for um Construto, traduzi-lo
                 chaveStr = this.dicionarioConstrutos[chave.constructor.name](chave);
             }
@@ -41801,7 +42425,7 @@ class TradutorAssemblyScript {
         return `[${primeiro}, ${segundo}, ${terceiro}, ${quarto}, ${quinto}, ${sexto}, ${setimo}, ${oitavo}, ${nono}, ${decimo}]`;
     }
     traduzirConstrutoTuplaN(tuplaN) {
-        const elementos = tuplaN.elementos.map(elemento => this.dicionarioConstrutos[elemento.constructor.name](elemento));
+        const elementos = tuplaN.elementos.map((elemento) => this.dicionarioConstrutos[elemento.constructor.name](elemento));
         return `[${elementos.join(', ')}]`;
     }
     traduzirConstrutoSeTernario(seTernario) {
@@ -41880,7 +42504,7 @@ class TradutorAssemblyScript {
         // Check if this is a native library function call
         if (chamada.entidadeChamada instanceof construtos_1.Variavel) {
             const nomeVariavel = chamada.entidadeChamada.simbolo.lexema;
-            const argumentosTexto = chamada.argumentos.map(arg => this.dicionarioConstrutos[arg.constructor.name](arg));
+            const argumentosTexto = chamada.argumentos.map((arg) => this.dicionarioConstrutos[arg.constructor.name](arg));
             const funcaoNativa = this.traduzirFuncaoNativaGlobal(nomeVariavel, argumentosTexto);
             if (funcaoNativa) {
                 return funcaoNativa;
@@ -42227,7 +42851,7 @@ class TradutorElixir {
     async extrairCamposStruct(declaracao) {
         const campos = new Set();
         // Procurar pelo construtor
-        const construtor = declaracao.metodos.find(m => m.simbolo.lexema === 'construtor' || m.simbolo.lexema === 'inicializar');
+        const construtor = declaracao.metodos.find((m) => m.simbolo.lexema === 'construtor' || m.simbolo.lexema === 'inicializar');
         if (!construtor) {
             return [];
         }
@@ -42236,7 +42860,7 @@ class TradutorElixir {
             this.extrairCamposDeDeclaracao(declaracaoCorpo, campos);
         }
         // Converter para atoms do Elixir
-        return Array.from(campos).map(c => `:${this.converterIdentificador(c)}`);
+        return Array.from(campos).map((c) => `:${this.converterIdentificador(c)}`);
     }
     /**
      * Extrai campos de uma declaração recursivamente
@@ -42278,7 +42902,7 @@ class TradutorElixir {
         // Construtor vira função new/N
         if (metodo.simbolo.lexema === 'construtor' || metodo.simbolo.lexema === 'inicializar') {
             resultado += `def new(`;
-            const parametros = metodo.funcao.parametros.map(p => this.converterIdentificador(p.nome.lexema));
+            const parametros = metodo.funcao.parametros.map((p) => this.converterIdentificador(p.nome.lexema));
             resultado += parametros.join(', ');
             resultado += ') do\n';
             this.aumentarIndentacao();
@@ -42296,7 +42920,7 @@ class TradutorElixir {
             resultado += `def ${nomeMetodo}(`;
             const nomeParametroStruct = this.converterIdentificador(nomeModulo.toLowerCase());
             this.nomeParametroStruct = nomeParametroStruct;
-            const parametros = [nomeParametroStruct].concat(metodo.funcao.parametros.map(p => this.converterIdentificador(p.nome.lexema)));
+            const parametros = [nomeParametroStruct].concat(metodo.funcao.parametros.map((p) => this.converterIdentificador(p.nome.lexema)));
             resultado += parametros.join(', ');
             resultado += ') do\n';
             this.aumentarIndentacao();
@@ -42386,7 +43010,7 @@ class TradutorElixir {
         let resultado = this.adicionarIndentacao();
         resultado += `def ${nomeFuncao}(`;
         // Parâmetros
-        const parametros = declaracao.funcao.parametros.map(p => this.converterIdentificador(p.nome.lexema));
+        const parametros = declaracao.funcao.parametros.map((p) => this.converterIdentificador(p.nome.lexema));
         resultado += parametros.join(', ');
         resultado += ') do\n';
         // Corpo
@@ -42663,7 +43287,9 @@ class TradutorElixir {
             case 'ordenar':
                 return `Enum.sort(${objeto})`;
             case 'juntar':
-                return argumentos.length > 0 ? `Enum.join(${objeto}, ${argumentos[0]})` : `Enum.join(${objeto})`;
+                return argumentos.length > 0
+                    ? `Enum.join(${objeto}, ${argumentos[0]})`
+                    : `Enum.join(${objeto})`;
             case 'fatiar':
                 if (argumentos.length >= 2) {
                     return `Enum.slice(${objeto}, ${argumentos[0]}, ${argumentos[1]})`;
@@ -42802,7 +43428,7 @@ class TradutorElixir {
     async visitarExpressaoFuncaoConstruto(expressao) {
         let resultado = 'fn ';
         // Parâmetros
-        const parametros = expressao.parametros.map(p => this.converterIdentificador(p.nome.lexema));
+        const parametros = expressao.parametros.map((p) => this.converterIdentificador(p.nome.lexema));
         resultado += parametros.join(', ');
         resultado += ' ->';
         // Corpo - se for uma única expressão, inline; se for bloco, multi-linha
@@ -43568,7 +44194,8 @@ class TradutorJavaScript {
         if (argumento instanceof construtos_1.Variavel) {
             return argumento.simbolo.lexema;
         }
-        if (argumento instanceof construtos_1.ReferenciaFuncao || argumento instanceof construtos_1.ArgumentoReferenciaFuncao) {
+        if (argumento instanceof construtos_1.ReferenciaFuncao ||
+            argumento instanceof construtos_1.ArgumentoReferenciaFuncao) {
             return argumento.simboloFuncao.lexema;
         }
         return (_c = (_b = (_a = this.dicionarioConstrutos)[argumento.constructor.name]) === null || _b === void 0 ? void 0 : _b.call(_a, argumento)) !== null && _c !== void 0 ? _c : '';
@@ -43809,7 +44436,7 @@ class TradutorMermaidJs {
         var _a, _b;
         const nomeClasse = declaracao.simbolo.lexema;
         const superClasse = declaracao.superClasse
-            ? (((_a = declaracao.superClasse.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || ((_b = declaracao.superClasse.nome) === null || _b === void 0 ? void 0 : _b.lexema))
+            ? ((_a = declaracao.superClasse.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || ((_b = declaracao.superClasse.nome) === null || _b === void 0 ? void 0 : _b.lexema)
             : undefined;
         const linha = declaracao.linha;
         // Cria arestas de entrada e saída para a classe
@@ -44070,9 +44697,7 @@ class TradutorMermaidJs {
         // Caminho então, normalmente um `Bloco`.
         const verticesEntao = await declaracao.caminhoEntao.aceitar(this);
         vertices = vertices.concat(verticesEntao);
-        const ultimaArestaEntao = verticesEntao.length > 0
-            ? verticesEntao[verticesEntao.length - 1].destino
-            : aresta;
+        const ultimaArestaEntao = verticesEntao.length > 0 ? verticesEntao[verticesEntao.length - 1].destino : aresta;
         if (declaracao.caminhoSenao) {
             this.anteriores = [];
             // Verifica se é "senão se" ou apenas "senão"
@@ -44120,9 +44745,7 @@ class TradutorMermaidJs {
             verticesTente.push(...verticesDeclaracao);
         }
         vertices = vertices.concat(verticesTente);
-        const ultimaArestaTente = verticesTente.length > 0
-            ? verticesTente[verticesTente.length - 1].destino
-            : aresta;
+        const ultimaArestaTente = verticesTente.length > 0 ? verticesTente[verticesTente.length - 1].destino : aresta;
         const anterioresAposTente = [];
         // Caminho pegue (catch) - se existir
         if (declaracao.caminhoPegue) {
@@ -44308,7 +44931,7 @@ class TradutorMermaidJs {
     async visitarExpressaoFuncaoConstruto(expressao) {
         let texto = 'função anônima';
         if (expressao.parametros && expressao.parametros.length > 0) {
-            const parametros = expressao.parametros.map(p => p.nome.lexema).join(', ');
+            const parametros = expressao.parametros.map((p) => p.nome.lexema).join(', ');
             texto += `(${parametros})`;
         }
         else {
@@ -44850,7 +45473,7 @@ class TradutorPython {
         }
         const funcao = argumento;
         // Extrai os nomes dos parâmetros
-        const parametros = funcao.parametros.map(param => param.nome.lexema).join(', ');
+        const parametros = funcao.parametros.map((param) => param.nome.lexema).join(', ');
         // Python lambdas suportam apenas uma expressão
         // Assumimos que a função tem um corpo simples com uma declaração de retorno
         let expressao = '';
@@ -46595,7 +47218,7 @@ class TradutorRuby {
         }
         const funcao = argumento;
         // Extrai os nomes dos parâmetros
-        const parametros = funcao.parametros.map(param => param.nome.lexema).join(', ');
+        const parametros = funcao.parametros.map((param) => param.nome.lexema).join(', ');
         // Assumimos que a função tem um corpo simples com uma declaração de retorno
         let expressao = '';
         if (funcao.corpo.length > 0) {