@designliquido/delegua 1.16.2 → 1.17.0

package/umd/delegua.js

@@ -557,6 +557,13 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
     visitarExpressaoTipoDe(expressao) {
         return this.verificarTipoDe(expressao.valor);
     }
+    /**
+     * Método recursivo para verificar o tipo de um construto, usado principalmente para validar
+     * o uso de `tipoDe` e `falhar()`.
+     * @param {Construto} valor O construto a ser avaliado.
+     * @returns {Promise<any>} O tipo do construto, ou `Promise.resolve()` se o tipo não puder ser
+     * determinado neste estágio da análise.
+     */
     verificarTipoDe(valor) {
         switch (valor.constructor) {
             case construtos_1.Agrupamento:
@@ -576,6 +583,13 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
     visitarExpressaoFalhar(expressao) {
         return this.verificarFalhar(expressao.explicacao);
     }
+    /**
+     * Método recursivo para verificar se um construto passado para `falhar()` é válido, ou seja, se é
+     * do tipo texto ou pode ser avaliado como texto.
+     * @param {Construto} valor O construto a ser avaliado.
+     * @returns {Promise<any>} O tipo do construto, ou `Promise.resolve()` se o tipo não puder ser
+     * determinado neste estágio da análise.
+     */
     verificarFalhar(valor) {
         if (valor instanceof construtos_1.Binario) {
             this.verificarFalhar(valor.direita);
@@ -612,9 +626,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         }
     }
     visitarChamadaPorArgumentoReferenciaFuncao(argumentoReferenciaFuncao, argumentos) {
-        const variavelCorrespondente = 
-        // this.variaveis[argumentoReferenciaFuncao.simboloFuncao.lexema].valor;
-        this.gerenciadorEscopos.buscar(argumentoReferenciaFuncao.simboloFuncao.lexema)?.valor;
+        const variavelCorrespondente = this.gerenciadorEscopos.buscar(argumentoReferenciaFuncao.simboloFuncao.lexema)?.valor;
         if (!variavelCorrespondente) {
             return;
         }
@@ -761,14 +773,6 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                 }
             }
         }
-        /* if (valor.imutavel) {
-            this.erro(simboloAlvo, `Constante ${simboloAlvo.lexema} não pode ser modificada.`);
-            return Promise.resolve();
-        } else {
-            if (this.variaveis[simboloAlvo.lexema]) {
-                this.variaveis[simboloAlvo.lexema].valor = expressao.valor;
-            }
-        } */
         return Promise.resolve();
     }
     async visitarDeclaracaoDeExpressao(declaracao) {
@@ -2097,6 +2101,14 @@ const primitivas_vetor_1 = __importDefault(require("../bibliotecas/primitivas-ve
 class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBase {
     constructor(performance = false) {
         super();
+        this.pilhaDecoradores = [];
+        this.simbolos = [];
+        this.erros = [];
+        this.tiposDefinidosEmCodigo = {};
+        this.interfacesDeclaradas = {};
+        this.tiposDefinidosPorBibliotecas = {};
+        this.tiposDeFerramentasExternas = {};
+        this.primitivasConhecidas = {};
         this.hashArquivo = 0;
         this.atual = 0;
         this.blocos = 0;
@@ -2347,7 +2359,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         return new construtos_1.ListaCompreensao(Number(this.simbolos[this.atual]), this.hashArquivo, retornoExpressao, vetor, new construtos_1.ParaCadaComoConstruto(retornoExpressao.hashArquivo, retornoExpressao.linha, variavelIteracao, vetor, new declaracoes_1.Bloco(retornoExpressao.hashArquivo, retornoExpressao.linha, [
             new declaracoes_1.Se(condicao, new declaracoes_1.Bloco(retornoExpressao.hashArquivo, retornoExpressao.linha, [
                 new declaracoes_1.Retorna(simboloVariavelIteracao, retornoExpressao),
-            ]), [], null),
+            ]), [], undefined),
         ])), retornoExpressao.tipo ? `${retornoExpressao.tipo}[]` : 'qualquer[]');
     }
     async primario() {
@@ -2570,7 +2582,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                                 construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaVetorSelecionada.tipoRetorno);
                                 break;
                             default:
-                                if (construtoTipado.tipo in this.tiposDefinidosEmCodigo) {
+                                if (construtoTipado.tipo && construtoTipado.tipo in this.tiposDefinidosEmCodigo) {
                                     const tipoCorrespondente = this.tiposDefinidosEmCodigo[construtoTipado.tipo];
                                     const possivelMetodo = tipoCorrespondente.metodos.filter((m) => m.simbolo.lexema === construtoTipado.simbolo.lexema);
                                     if (possivelMetodo.length > 0) {
@@ -3210,7 +3222,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             if (Array.isArray(retornoDeclaracao)) {
                 declaracoes = declaracoes.concat(retornoDeclaracao);
             }
-            else if (retornoDeclaracao !== null) {
+            else if (retornoDeclaracao != null) {
                 declaracoes.push(retornoDeclaracao);
             }
         }
@@ -3271,7 +3283,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                     const caminhoCondicoes = [await this.expressao()];
                     this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
                     while (this.verificarTipoSimboloAtual(delegua_2.default.CASO)) {
-                        this.consumir(delegua_2.default.CASO, null);
+                        this.avancarEDevolverAnterior();
                         caminhoCondicoes.push(await this.expressao());
                         this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
                     }
@@ -3400,6 +3412,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 const identificadorModulo = this.avancarEDevolverAnterior();
                 construtoCaminhoModulo = new construtos_1.Literal(identificadorModulo.hashArquivo, Number(identificadorModulo.linha), identificadorModulo.lexema);
                 break;
+            default:
+                throw this.erro(this.simbolos[this.atual], "Esperado caminho do módulo como texto ou identificador em declaração de importação.");
         }
         const importar = new declaracoes_1.Importar(construtoCaminhoModulo);
         if (identificadorDeTudo !== null) {
@@ -3570,7 +3584,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
     async declaracaoSe() {
         const condicao = await this.expressao();
         const caminhoEntao = (await this.resolverDeclaracao());
-        let caminhoSenao = null;
+        let caminhoSenao = undefined;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.SENAO, delegua_2.default.SENÃO)) {
             caminhoSenao = await this.resolverDeclaracao();
         }
@@ -3687,7 +3701,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         const inicializador = await this.expressao();
         const retornos = [];
         for (let identificador of identificadores) {
-            this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, this.logicaComumInferenciaTiposVariaveisEConstantes(inicializador, 'qualquer')));
+            this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, this.logicaComumInferenciaTiposVariaveisEConstantes(inicializador, 'qualquer') ?? 'qualquer'));
             const declaracaoVar = new declaracoes_1.Var(identificador, new construtos_1.AcessoMetodoOuPropriedade(this.hashArquivo, inicializador, identificador));
             declaracaoVar.decoradores = Array.from(this.pilhaDecoradores);
             retornos.push(declaracaoVar);
@@ -3738,8 +3752,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 if (entidadeChamadaAcessoIndiceVariavel.constructor === construtos_1.AcessoIndiceVariavel) {
                     return this.logicaComumInferenciaTiposVariaveisEConstantes(entidadeChamadaAcessoIndiceVariavel, tipo);
                 }
-                if (entidadeChamadaAcessoIndiceVariavel.tipo.endsWith('[]')) {
-                    return entidadeChamadaAcessoIndiceVariavel.tipo.slice(0, -2);
+                const tipoEntidadeChamadaAcessoIndiceVariavel = entidadeChamadaAcessoIndiceVariavel.tipo;
+                if (tipoEntidadeChamadaAcessoIndiceVariavel.endsWith('[]')) {
+                    return tipoEntidadeChamadaAcessoIndiceVariavel.slice(0, -2);
                 }
                 // Normalmente, `entidadeChamadaAcessoIndiceVariavel.tipo` aqui será 'vetor'.
                 return 'qualquer';
@@ -3842,7 +3857,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             // Inicialização de variáveis sem valor.
             for (let identificador of identificadores.values()) {
                 this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, tipo));
-                retorno.push(new declaracoes_1.Var(identificador, null, tipo, tipoExplicito, Array.from(this.pilhaDecoradores)));
+                retorno.push(new declaracoes_1.Var(identificador, undefined, tipo, tipoExplicito, Array.from(this.pilhaDecoradores)));
             }
             this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
             this.pilhaDecoradores = [];
@@ -3857,7 +3872,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         for (let [indice, identificador] of identificadores.entries()) {
             const tipoOriginal = tipo; // Preserva o tipo antes da inferência
-            tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(inicializadores[indice], tipo);
+            tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(inicializadores[indice], tipo) ?? tipo;
             if (tipo !== 'dicionário') {
                 this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, tipo));
             }
@@ -3925,7 +3940,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         let retorno = [];
         for (let [indice, identificador] of identificadores.entries()) {
             // Se tipo ainda não foi definido, infere.
-            tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(inicializadores[indice], tipo);
+            tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(inicializadores[indice], tipo) ?? tipo;
             if (tipo !== 'dicionário') {
                 this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, tipo));
             }
@@ -3965,8 +3980,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         const parametros = [];
         do {
             const parametro = {};
-            if (this.simbolos[this.atual].tipo === delegua_2.default.MULTIPLICACAO) {
-                this.consumir(delegua_2.default.MULTIPLICACAO, null);
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.RETICENCIAS)) {
                 parametro.abrangencia = 'multiplo';
             }
             else {
@@ -4163,7 +4177,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                     continue;
                 }
                 // Documentário (/** ... */)
-                let docAtual = null;
+                let docAtual = undefined;
                 if (this.simbolos[this.atual].tipo === delegua_2.default.DOCUMENTARIO) {
                     const simboloDoc = this.avancarEDevolverAnterior();
                     docAtual = new construtos_1.ComentarioComoConstruto(simboloDoc);
@@ -4566,10 +4580,10 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 await this.resolverDecoradores();
             }
             // Documentário (/** ... */) antes de uma declaração de função.
-            let docTopLevel = null;
+            let documentacaoTopo = undefined;
             if (this.verificarTipoSimboloAtual(delegua_2.default.DOCUMENTARIO)) {
                 const simboloDoc = this.avancarEDevolverAnterior();
-                docTopLevel = new construtos_1.ComentarioComoConstruto(simboloDoc);
+                documentacaoTopo = new construtos_1.ComentarioComoConstruto(simboloDoc);
             }
             // Decoradores podem aparecer após um documentário.
             while (this.verificarTipoSimboloAtual(delegua_2.default.ARROBA)) {
@@ -4586,13 +4600,13 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                     }
                     const declaracaoFuncao = (await this.funcao('funcao'));
                     declaracaoFuncao.eFuncaoDeDecorador = true;
-                    declaracaoFuncao.documentacao = docTopLevel;
+                    declaracaoFuncao.documentacao = documentacaoTopo;
                     return declaracaoFuncao;
                 }
                 if (this.verificarTipoProximoSimbolo(delegua_2.default.IDENTIFICADOR)) {
                     this.avancarEDevolverAnterior();
                     const declaracaoFuncao = (await this.funcao('funcao'));
-                    declaracaoFuncao.documentacao = docTopLevel;
+                    declaracaoFuncao.documentacao = documentacaoTopo;
                     return declaracaoFuncao;
                 }
             }
@@ -4610,7 +4624,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         catch (erro) {
             this.sincronizar();
             this.erros.push(erro);
-            return null;
+            return undefined;
         }
     }
     /**
@@ -4925,7 +4939,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             if (Array.isArray(retornoDeclaracao)) {
                 declaracoes = declaracoes.concat(retornoDeclaracao);
             }
-            else if (retornoDeclaracao !== null) {
+            else if (retornoDeclaracao != null) {
                 declaracoes.push(retornoDeclaracao);
             }
         }
@@ -18505,6 +18519,9 @@ exports.EspacoMemoria = EspacoMemoria;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Chamavel = void 0;
 class Chamavel {
+    constructor() {
+        this.valorAridade = 0;
+    }
     aridade() {
         return this.valorAridade;
     }
@@ -18642,7 +18659,7 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
         this.eInicializador = eInicializador;
     }
     aridade() {
-        return this.declaracao?.parametros?.length || 0;
+        return this.declaracao?.parametros?.filter(p => p.abrangencia !== 'multiplo').length || 0;
     }
     /**
      * Método utilizado por Delégua para representar esta função quando impressa.
@@ -18709,7 +18726,7 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
             else {
                 let argumento = argumentos[i];
                 if (argumento.valor === null) {
-                    argumentos[i].valor = parametro['padrao'] ? parametro['padrao'].valor : null;
+                    argumentos[i].valor = parametro.valorPadrao ? parametro.valorPadrao : null;
                 }
                 ambiente.valores[nome] =
                     argumento && argumento.hasOwnProperty('valor') ? argumento.valor : argumento;
@@ -19142,7 +19159,9 @@ class FuncaoPadrao extends chamavel_1.Chamavel {
         this.funcao = funcao;
     }
     async chamar(visitante, argumentos, simbolo) {
-        this.simbolo = simbolo;
+        if (simbolo) {
+            this.simbolo = simbolo;
+        }
         return await this.funcao.apply(this, [visitante, ...argumentos]);
     }
     /**
@@ -19150,7 +19169,7 @@ class FuncaoPadrao extends chamavel_1.Chamavel {
      * @returns {string} A representação da função como texto.
      */
     paraTexto() {
-        return `<função-padrão nome=${this.simbolo.lexema} />`;
+        return `<função-padrão nome=${this.simbolo?.lexema || '(função anônima)'} />`;
     }
     /**
      * Método utilizado pelo VSCode para representar esta função quando impressa.
@@ -19267,7 +19286,7 @@ class MetodoPolimorfico extends chamavel_1.Chamavel {
     resolverSobrecarga(argumentos) {
         const numArgs = argumentos.length;
         let melhorPontuacao = -1;
-        let melhorSobrecarga = null;
+        let melhorSobrecarga = undefined;
         for (const sobrecarga of this.sobrecargas) {
             const parametros = sobrecarga.declaracao?.parametros || [];
             const aridade = sobrecarga.aridade();
@@ -19332,7 +19351,7 @@ class MetodoPolimorfico extends chamavel_1.Chamavel {
                 const tipos = params.map((p) => p.tipoDado || 'qualquer');
                 return `${this.nome}(${tipos.join(', ')})`;
             });
-            throw new excecoes_1.ErroEmTempoDeExecucao(null, `Nenhuma sobrecarga do método "${this.nome}" corresponde aos argumentos fornecidos (${tiposArgs.join(', ')}). ` +
+            throw new excecoes_1.ErroEmTempoDeExecucao(this.instancia?.classe.simboloOriginal, `Nenhuma sobrecarga do método "${this.nome}" corresponde aos argumentos fornecidos (${tiposArgs.join(', ')}). ` +
                 `Sobrecargas disponíveis: ${assinaturas.join('; ')}.`);
         }
         return melhorSobrecarga;
@@ -19815,7 +19834,6 @@ __exportStar(require("./interpretador"), exports);
 __exportStar(require("./interpretador-base"), exports);
 
 },{"./estruturas":180,"./interpretador":191,"./interpretador-base":190}],190:[function(require,module,exports){
-(function (process,setImmediate){(function (){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -19848,14 +19866,16 @@ const primitivas_vetor_1 = __importDefault(require("../bibliotecas/primitivas-ve
  * recomendado para uso em execuções que ocorrem no navegador de internet.
  */
 class InterpretadorBase {
-    constructor(diretorioBase, performance = false, funcaoDeRetorno = null, funcaoDeRetornoMesmaLinha = null) {
+    constructor(diretorioBase, performance = false, funcaoDeRetorno = undefined, funcaoDeRetornoMesmaLinha = undefined) {
         this.resultadoInterpretador = [];
+        this.linhaDeclaracaoAtual = -1;
+        this.hashArquivoDeclaracaoAtual = -1;
         this.classeAtualEmExecucao = null;
-        this.funcaoDeRetorno = null;
-        this.funcaoDeRetornoMesmaLinha = null;
-        this.interfaceDeEntrada = null; // Originalmente é `readline.Interface`
-        this.interfaceEntradaSaida = null;
-        this.funcaoVerificarIteracao = null;
+        this.funcaoDeRetorno = undefined;
+        this.funcaoDeRetornoMesmaLinha = undefined;
+        this.interfaceDeEntrada = undefined; // Originalmente é `readline.Interface`
+        this.interfaceEntradaSaida = undefined;
+        this.funcaoVerificarIteracao = undefined;
         this.emDeclaracaoTente = false;
         // typeName → methodName → DeleguaFuncao
         this.extensoesGlobais = new Map();
@@ -19878,8 +19898,12 @@ class InterpretadorBase {
         this.diretorioBase = diretorioBase;
         this.performance = performance;
         this.funcaoDeRetorno = funcaoDeRetorno || console.log;
+        const _process = globalThis.process;
         this.funcaoDeRetornoMesmaLinha =
-            funcaoDeRetornoMesmaLinha || process.stdout.write.bind(process.stdout);
+            funcaoDeRetornoMesmaLinha ||
+                (_process?.stdout?.write
+                    ? _process.stdout.write.bind(_process.stdout)
+                    : (texto) => console.log(texto));
         this.erros = [];
         this.declaracoes = [];
         this.resultadoInterpretador = [];
@@ -19910,8 +19934,9 @@ class InterpretadorBase {
     async cederControle(iteracoes) {
         if (iteracoes % this.iteracoesParaCederControle === 0) {
             await new Promise((resolve) => {
-                if (typeof setImmediate !== 'undefined') {
-                    setImmediate(resolve);
+                const _setImmediate = globalThis.setImmediate;
+                if (_setImmediate) {
+                    _setImmediate(resolve);
                 }
                 else {
                     setTimeout(resolve, 0);
@@ -19950,6 +19975,7 @@ class InterpretadorBase {
             case construtos_1.AcessoMetodoOuPropriedade:
             case construtos_1.AcessoIndiceVariavel:
             case construtos_1.Dicionario:
+            case construtos_1.Leia:
             case construtos_1.Literal:
             case construtos_1.Vetor:
                 return '';
@@ -20065,10 +20091,10 @@ class InterpretadorBase {
         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) {
+    async visitarExpressaoAtribuicaoPorIndicesMatriz(_) {
         throw new Error('Método não implementado.');
     }
-    async visitarExpressaoAcessoElementoMatriz(expressao) {
+    async visitarExpressaoAcessoElementoMatriz(_) {
         throw new Error('Método não implementado.');
     }
     textoParaRegex(texto) {
@@ -20083,14 +20109,14 @@ class InterpretadorBase {
     visitarExpressaoExpressaoRegular(expressao) {
         return Promise.resolve(this.textoParaRegex(expressao.valor));
     }
-    visitarExpressaoTipoDe(expressao) {
+    visitarExpressaoTipoDe(_) {
         throw new Error('Método não implementado.');
     }
     async visitarExpressaoFalhar(expressao) {
         const textoFalha = expressao.explicacao.valor ?? (await this.avaliar(expressao.explicacao)).valor;
         throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, textoFalha, expressao.linha);
     }
-    async visitarExpressaoFimPara(declaracao) {
+    async visitarExpressaoFimPara(_) {
         throw new Error('Método não implementado.');
     }
     async visitarExpressaoReferenciaFuncao(expressao) {
@@ -20159,6 +20185,9 @@ class InterpretadorBase {
      */
     async resolverInterpolacoes(textoOriginal, linha) {
         const variaveis = textoOriginal.match(this.regexInterpolacao);
+        if (!variaveis) {
+            return [];
+        }
         return await Promise.all(variaveis.map(async (s) => {
             const expressaoInterpolacao = s.replace(/[\$\{\}]*/gm, '');
             const microLexador = this.microLexador.mapear(expressaoInterpolacao);
@@ -20373,6 +20402,9 @@ class InterpretadorBase {
         }
         throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
     }
+    converterParaBigInt(valor) {
+        return typeof valor === 'bigint' ? valor : BigInt(Math.floor(Number(valor)));
+    }
     async visitarExpressaoBinaria(expressao) {
         const esquerda = await this.avaliar(expressao.esquerda);
         const direita = await this.avaliar(expressao.direita);
@@ -20384,7 +20416,7 @@ class InterpretadorBase {
             const nomeOperador = 'operador' + expressao.operador.lexema;
             const metodoOperador = valorEsquerdo.classe.encontrarMetodo(nomeOperador);
             if (metodoOperador) {
-                const metodoBound = metodoOperador.funcaoPorMetodoDeClasse(valorEsquerdo);
+                const metodoASerChamado = metodoOperador.funcaoPorMetodoDeClasse(valorEsquerdo);
                 const argumentoOperador = direita && Object.prototype.hasOwnProperty.call(direita, 'tipo')
                     ? direita
                     : {
@@ -20392,7 +20424,7 @@ class InterpretadorBase {
                         valor: valorDireito,
                         imutavel: false,
                     };
-                return await metodoBound.chamar(this, [{ nome: null, valor: argumentoOperador }]);
+                return await metodoASerChamado.chamar(this, [{ nome: null, valor: argumentoOperador }]);
             }
         }
         const tipoEsquerdo = esquerda?.hasOwnProperty('tipo')
@@ -20406,13 +20438,7 @@ 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)));
-                    return esq ** dir;
+                    return this.converterParaBigInt(valorEsquerdo) ** this.converterParaBigInt(valorDireito);
                 }
                 const resultadoExponenciacao = Math.pow(valorEsquerdo, valorDireito);
                 return resultadoExponenciacao;
@@ -20439,13 +20465,7 @@ 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)));
-                    return esq - dir;
+                    return this.converterParaBigInt(valorEsquerdo) - this.converterParaBigInt(valorDireito);
                 }
                 return Number(valorEsquerdo) - Number(valorDireito);
             case delegua_1.default.ADICAO:
@@ -20456,13 +20476,13 @@ class InterpretadorBase {
                 }
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint'
+                    const valorResolvidoEsquerdo = typeof valorEsquerdo === 'bigint'
                         ? valorEsquerdo
                         : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint'
+                    const valorResolvidoDireito = typeof valorDireito === 'bigint'
                         ? valorDireito
                         : BigInt(Math.floor(Number(valorDireito)));
-                    return esq + dir;
+                    return valorResolvidoEsquerdo + valorResolvidoDireito;
                 }
                 if (this.tiposNumericos.includes(tipoEsquerdo) &&
                     this.tiposNumericos.includes(tipoDireito)) {
@@ -20492,13 +20512,13 @@ class InterpretadorBase {
                 }
                 // Retorna BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint'
+                    const valorResolvidoEsquerdo = typeof valorEsquerdo === 'bigint'
                         ? valorEsquerdo
                         : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint'
+                    const valorResolvidoDireito = typeof valorDireito === 'bigint'
                         ? valorDireito
                         : BigInt(Math.floor(Number(valorDireito)));
-                    return esq / dir; // Trunca automaticamente
+                    return valorResolvidoEsquerdo / valorResolvidoDireito; // Trunca automaticamente
                 }
                 return Math.floor(Number(valorEsquerdo) / Number(valorDireito));
             case delegua_1.default.MULTIPLICACAO:
@@ -20507,13 +20527,13 @@ class InterpretadorBase {
                 if ((typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') &&
                     tipoEsquerdo !== delegua_2.default.TEXTO &&
                     tipoDireito !== delegua_2.default.TEXTO) {
-                    const esq = typeof valorEsquerdo === 'bigint'
+                    const valorResolvidoEsquerdo = typeof valorEsquerdo === 'bigint'
                         ? valorEsquerdo
                         : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint'
+                    const valorResolvidoDireito = typeof valorDireito === 'bigint'
                         ? valorDireito
                         : BigInt(Math.floor(Number(valorDireito)));
-                    return esq * dir;
+                    return valorResolvidoEsquerdo * valorResolvidoDireito;
                 }
                 if (tipoEsquerdo === delegua_2.default.TEXTO ||
                     tipoDireito === delegua_2.default.TEXTO) {
@@ -20560,13 +20580,7 @@ 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)));
-                    return esq & dir;
+                    return this.converterParaBigInt(valorEsquerdo) & this.converterParaBigInt(valorDireito);
                 }
                 return Number(valorEsquerdo) & Number(valorDireito);
             case delegua_1.default.CIRCUMFLEXO:
@@ -20576,13 +20590,7 @@ 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)));
-                    return esq ^ dir;
+                    return this.converterParaBigInt(valorEsquerdo) ^ this.converterParaBigInt(valorDireito);
                 }
                 return Number(valorEsquerdo) ^ Number(valorDireito);
             case delegua_1.default.BIT_OR:
@@ -20592,45 +20600,21 @@ 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)));
-                    return esq | dir;
+                    return this.converterParaBigInt(valorEsquerdo) | this.converterParaBigInt(valorDireito);
                 }
                 return Number(valorEsquerdo) | Number(valorDireito);
             case delegua_1.default.MENOR_MENOR:
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt (interno para longo) se qualquer operando for BigInt ou se deslocamento >= 32
-                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)));
-                    return esq << dir;
+                if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint' || Number(valorDireito) >= 32) {
+                    return this.converterParaBigInt(valorEsquerdo) << this.converterParaBigInt(valorDireito);
                 }
                 return Number(valorEsquerdo) << Number(valorDireito);
             case delegua_1.default.MAIOR_MAIOR:
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt (interno para longo) se qualquer operando for BigInt ou se deslocamento >= 32
-                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)));
-                    return esq >> dir;
+                if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint' || Number(valorDireito) >= 32) {
+                    return this.converterParaBigInt(valorEsquerdo) >> this.converterParaBigInt(valorDireito);
                 }
                 return Number(valorEsquerdo) >> Number(valorDireito);
             case delegua_1.default.DIFERENTE:
@@ -20663,7 +20647,7 @@ class InterpretadorBase {
                 : undefined;
             let valor = await this.avaliar(variavelArgumento);
             argumentos.push({
-                nome: nomeArgumento,
+                nome: nomeArgumento ?? null,
                 valor,
             });
         }
@@ -20732,8 +20716,8 @@ class InterpretadorBase {
             // mesmo que esteja tudo certo com `DeleguaFuncao`,
             // então precisamos testar o nome do construtor também.
             if (entidadeChamada instanceof estruturas_1.Chamavel ||
-                entidadeChamada.constructor.name === 'DeleguaFuncao' ||
-                entidadeChamada.constructor.name === 'MetodoPolimorfico') {
+                entidadeChamada.constructor === estruturas_1.DeleguaFuncao ||
+                entidadeChamada.constructor === estruturas_1.MetodoPolimorfico) {
                 const retornoEntidadeChamada = await entidadeChamada.chamar(this, argumentos);
                 return retornoEntidadeChamada;
             }
@@ -20779,10 +20763,6 @@ class InterpretadorBase {
             indice = this.resolverValor(await this.avaliar(expressao.indice));
         }
         switch (expressao.alvo.constructor) {
-            case construtos_1.Variavel:
-                const alvoVariavel = expressao.alvo;
-                this.pilhaEscoposExecucao.atribuirVariavel(alvoVariavel.simbolo, valorResolvido, indice);
-                break;
             case construtos_1.AcessoMetodoOuPropriedade:
                 // Nunca será método aqui: apenas propriedade.
                 const alvoPropriedade = expressao.alvo;
@@ -20794,8 +20774,12 @@ class InterpretadorBase {
                     await objetoDeleguaClasse.definir(alvoPropriedade.simbolo, valor, this);
                 }
                 break;
+            case construtos_1.Variavel:
+                const alvoVariavel = expressao.alvo;
+                this.pilhaEscoposExecucao.atribuirVariavel(alvoVariavel.simbolo, valorResolvido, indice);
+                break;
             default:
-                throw new excecoes_1.ErroEmTempoDeExecucao(null, `Atribuição com caso faltante: ${JSON.stringify(expressao)}.`);
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloOperador, `Atribuição com caso faltante: ${JSON.stringify(expressao)}.`);
         }
         return valorResolvido;
     }
@@ -20887,10 +20871,10 @@ class InterpretadorBase {
         const declaracaoInicializador = Array.isArray(declaracao.inicializador)
             ? declaracao.inicializador[0]
             : declaracao.inicializador;
-        if (declaracaoInicializador !== null) {
+        if (declaracaoInicializador !== null && declaracaoInicializador !== undefined) {
             await this.avaliar(declaracaoInicializador);
         }
-        let retornoExecucao;
+        let retornoExecucao = undefined;
         let iteracoes = 0;
         while (!(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra)) {
             if (declaracao.condicao !== null &&
@@ -20904,7 +20888,7 @@ class InterpretadorBase {
                     return null;
                 }
                 if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.ContinuarQuebra) {
-                    retornoExecucao = null;
+                    retornoExecucao = undefined;
                 }
             }
             catch (erro) {
@@ -20915,15 +20899,19 @@ class InterpretadorBase {
                 });
                 return Promise.reject(erro);
             }
-            if (declaracao.incrementar !== null) {
+            if (declaracao.incrementar) {
                 await this.avaliar(declaracao.incrementar);
             }
         }
         return retornoExecucao;
     }
-    // TODO: Descobrir se mais algum dialeto, fora Delégua e Pituguês, usam isso.
+    /**
+     * Lógica de `para cada`, usada por Delégua, Pituguês, e Tenda.
+     * @param {ParaCada} declaracao A declaração de `para cada` a ser executada.
+     * @returns {Promise<any>} O resultado da execução da declaração.
+     */
     async visitarDeclaracaoParaCada(declaracao) {
-        let retornoExecucao;
+        let retornoExecucao = undefined;
         // Posição atual precisa ser reiniciada, pois pode estar dentro de outro
         // laço de repetição.
         declaracao.posicaoAtual = 0;
@@ -20961,7 +20949,7 @@ class InterpretadorBase {
                     return null;
                 }
                 if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.ContinuarQuebra) {
-                    retornoExecucao = null;
+                    retornoExecucao = undefined;
                 }
                 declaracao.posicaoAtual++;
             }
@@ -20987,19 +20975,20 @@ class InterpretadorBase {
         if (this.eVerdadeiro(avaliacaoCondicaoSe)) {
             return await this.executar(declaracao.caminhoEntao);
         }
-        for (let i = 0; i < declaracao.caminhosSeSenao.length; i++) {
-            const atual = declaracao.caminhosSeSenao[i];
+        const declaracaoCaminhosSeSenao = declaracao.caminhosSeSenao || [];
+        for (let i = 0; i < declaracaoCaminhosSeSenao.length; i++) {
+            const atual = declaracaoCaminhosSeSenao[i];
             if (this.eVerdadeiro(await this.avaliar(atual.condicao))) {
                 return await this.executar(atual.caminho);
             }
         }
-        if (declaracao.caminhoSenao !== null) {
+        if (declaracao.caminhoSenao) {
             return await this.executar(declaracao.caminhoSenao);
         }
         return null;
     }
     async visitarDeclaracaoEnquanto(declaracao) {
-        let retornoExecucao;
+        let retornoExecucao = undefined;
         let iteracoes = 0;
         while (!(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra) &&
             this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
@@ -21010,7 +20999,7 @@ class InterpretadorBase {
                     return null;
                 }
                 if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.ContinuarQuebra) {
-                    retornoExecucao = null;
+                    retornoExecucao = undefined;
                 }
             }
             catch (erro) {
@@ -21065,17 +21054,17 @@ class InterpretadorBase {
         }
     }
     async visitarDeclaracaoFazer(declaracao) {
-        let retornoExecucao;
+        let retornoExecucao = undefined;
         let iteracoes = 0;
         do {
             try {
                 await this.cederControle(++iteracoes);
                 retornoExecucao = await this.executar(declaracao.caminhoFazer);
                 if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.SustarQuebra) {
-                    return null;
+                    return undefined;
                 }
                 if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.ContinuarQuebra) {
-                    retornoExecucao = null;
+                    retornoExecucao = undefined;
                 }
             }
             catch (erro) {
@@ -21117,7 +21106,7 @@ class InterpretadorBase {
             }
         }
         finally {
-            if (declaracao.caminhoFinalmente !== null)
+            if (declaracao.caminhoFinalmente)
                 valorRetorno = await this.executarBloco(declaracao.caminhoFinalmente);
             this.emDeclaracaoTente = false;
         }
@@ -21149,7 +21138,7 @@ class InterpretadorBase {
     async visitarDeclaracaoEscrevaMesmaLinha(declaracao) {
         try {
             const formatoTexto = await this.avaliarArgumentosEscreva(declaracao.argumentos);
-            this.funcaoDeRetornoMesmaLinha(formatoTexto);
+            this.funcaoDeRetornoMesmaLinha?.(formatoTexto);
             return {
                 tipo: 'vazio',
                 tipoExplicito: false,
@@ -21172,7 +21161,7 @@ class InterpretadorBase {
     async visitarDeclaracaoEscreva(declaracao) {
         try {
             const formatoTexto = await this.avaliarArgumentosEscreva(declaracao.argumentos);
-            this.funcaoDeRetorno(formatoTexto);
+            this.funcaoDeRetorno?.(formatoTexto);
             return {
                 tipo: 'vazio',
                 tipoExplicito: false,
@@ -21216,7 +21205,7 @@ class InterpretadorBase {
     }
     async avaliacaoDeclaracaoVarOuConst(declaracao) {
         let valorOuOutraVariavel = null;
-        if (declaracao.inicializador !== null) {
+        if (declaracao.inicializador != null) {
             valorOuOutraVariavel = await this.avaliar(declaracao.inicializador);
         }
         let valorFinal = null;
@@ -21245,16 +21234,16 @@ class InterpretadorBase {
      */
     async visitarDeclaracaoConstMultiplo(declaracao) {
         const valoresFinais = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
-        const tipoIndividual = declaracao.tipo.replace('[]', '');
+        const tipoIndividual = (declaracao.tipo || '').replace('[]', '');
         for (let [indice, valor] of valoresFinais.entries()) {
             this.pilhaEscoposExecucao.definirConstante(declaracao.simbolos[indice].lexema, valor, tipoIndividual);
         }
         return null;
     }
-    visitarExpressaoContinua(declaracao) {
+    visitarExpressaoContinua(_) {
         return new quebras_1.ContinuarQuebra();
     }
-    visitarExpressaoSustar(declaracao) {
+    visitarExpressaoSustar(_) {
         return new quebras_1.SustarQuebra();
     }
     async visitarExpressaoRetornar(declaracao) {
@@ -21434,133 +21423,29 @@ class InterpretadorBase {
         if (superClassesResolvidas.length > 0) {
             this.pilhaEscoposExecucao.definirVariavel('super', superClassesResolvidas[0]);
         }
+        const descritorTipoClasse = this.resolverMetodoDeClasse(declaracao, superClassesResolvidas, mesclaResolvidas);
+        // TODO: Até então, a única exceção a isso é Égua Clássico.
+        // Por enquanto, tudo bem deixar isso aqui.
+        descritorTipoClasse.dialetoRequerDeclaracaoPropriedades = this.requerDeclaracaoPropriedades;
+        this.pilhaEscoposExecucao.atribuirVariavel(declaracao.simbolo, descritorTipoClasse);
+        return descritorTipoClasse;
+    }
+    resolverMetodoDeClasse(declaracao, superClassesResolvidas, _mesclaResolvidas) {
         const metodos = {};
-        const metodosEstaticos = {};
-        const obtenedores = {};
-        const definidores = {};
-        const obtenedoresEstaticos = {};
-        const definidoresEstaticos = {};
-        const metodosAbstratos = [];
-        const acessoMetodos = {};
-        const acessoPropriedades = {};
-        const definirMetodos = declaracao.metodos;
-        for (let i = 0; i < declaracao.metodos.length; i++) {
-            const metodoAtual = definirMetodos[i];
+        for (const metodoAtual of declaracao.metodos) {
             const nomeMetodo = metodoAtual.simbolo.lexema;
-            // Registrar nível de acesso do método.
-            if (metodoAtual.acesso && metodoAtual.acesso !== 'publico') {
-                acessoMetodos[nomeMetodo] = metodoAtual.acesso;
-            }
-            // Métodos abstratos: registrar apenas o nome, não criar função executável.
-            if (metodoAtual.abstrato) {
-                metodosAbstratos.push(nomeMetodo);
-                continue;
-            }
             const eInicializador = nomeMetodo === 'construtor';
             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;
-            if (metodoAtual.eObtenedor) {
-                if (ehEstatico) {
-                    obtenedoresEstaticos[nomeMetodo] = funcao;
-                }
-                else {
-                    obtenedores[nomeMetodo] = funcao;
-                }
-                continue;
-            }
-            if (metodoAtual.eDefinidor) {
-                if (ehEstatico) {
-                    definidoresEstaticos[nomeMetodo] = funcao;
-                }
-                else {
-                    definidores[nomeMetodo] = funcao;
-                }
-                continue;
-            }
-            const destino = ehEstatico && !eInicializador ? metodosEstaticos : metodos;
-            if (destino[nomeMetodo]) {
-                if (!Array.isArray(destino[nomeMetodo])) {
-                    destino[nomeMetodo] = [destino[nomeMetodo]];
-                }
-                destino[nomeMetodo].push(funcao);
-            }
-            else {
-                destino[nomeMetodo] = funcao;
-            }
-        }
-        // Registrar propriedades estáticas no mapa de membros estáticos e níveis de acesso.
-        // Numa classe estática, todas as propriedades são tratadas como estáticas.
-        const membrosEstaticos = {};
-        for (const prop of declaracao.propriedades) {
-            if (prop.estatico || declaracao.classeEstatica) {
-                membrosEstaticos[prop.nome.lexema] = undefined;
-            }
-            if (prop.acesso && prop.acesso !== 'publico') {
-                acessoPropriedades[prop.nome.lexema] = prop.acesso;
-            }
+            metodos[nomeMetodo] = funcao;
         }
         const descritorTipoClasse = new estruturas_1.DescritorTipoClasse(declaracao.simbolo, superClassesResolvidas, metodos, declaracao.propriedades);
-        descritorTipoClasse.metodosEstaticos = metodosEstaticos;
-        descritorTipoClasse.membrosEstaticos = membrosEstaticos;
-        descritorTipoClasse.obtenedores = obtenedores;
-        descritorTipoClasse.definidores = definidores;
-        descritorTipoClasse.obtenedoresEstaticos = obtenedoresEstaticos;
-        descritorTipoClasse.definidoresEstaticos = definidoresEstaticos;
-        descritorTipoClasse.abstrata = declaracao.abstrata;
-        descritorTipoClasse.estrangeira = declaracao.estrangeira;
-        descritorTipoClasse.classeEstatica = declaracao.classeEstatica;
-        descritorTipoClasse.metodosAbstratos = metodosAbstratos;
-        descritorTipoClasse.acessoMetodos = acessoMetodos;
-        descritorTipoClasse.acessoPropriedades = acessoPropriedades;
-        // 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.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(s) superclasse(s) abstrata(s).
-        if (!declaracao.abstrata && !declaracao.estrangeira) {
-            for (const superClasse of superClassesResolvidas) {
-                if (superClasse.abstrata || superClasse.estrangeira) {
-                    superClasse.verificarImplementacaoAbstrata(descritorTipoClasse);
-                }
-            }
-        }
-        // TODO: Até então, a única exceção a isso é Égua Clássico.
-        // Por enquanto, tudo bem deixar isso aqui.
-        descritorTipoClasse.dialetoRequerDeclaracaoPropriedades = this.requerDeclaracaoPropriedades;
-        this.pilhaEscoposExecucao.atribuirVariavel(declaracao.simbolo, descritorTipoClasse);
         return descritorTipoClasse;
     }
     /**
@@ -21607,7 +21492,8 @@ class InterpretadorBase {
                 if (!this.extensoesGlobais.has(tipoNome)) {
                     this.extensoesGlobais.set(tipoNome, new Map());
                 }
-                this.extensoesGlobais.get(tipoNome).set(nomeMetodo, funcao);
+                const extensaoGlobal = this.extensoesGlobais.get(tipoNome);
+                extensaoGlobal?.set(nomeMetodo, funcao);
             }
             else {
                 const hash = declaracao.hashArquivo;
@@ -21615,10 +21501,13 @@ class InterpretadorBase {
                     this.extensoesModulo.set(hash, new Map());
                 }
                 const mapa = this.extensoesModulo.get(hash);
+                if (!mapa) {
+                    throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.simboloTipo, 'Erro interno: mapa de extensões do módulo não encontrado.', declaracao.linha);
+                }
                 if (!mapa.has(tipoNome)) {
-                    mapa.set(tipoNome, new Map());
+                    mapa?.set(tipoNome, new Map());
                 }
-                mapa.get(tipoNome).set(nomeMetodo, funcao);
+                mapa.get(tipoNome)?.set(nomeMetodo, funcao);
             }
         }
     }
@@ -21721,7 +21610,7 @@ class InterpretadorBase {
                     dicionario[chaveLogico] = this.resolverValor(promises[1]);
                     continue;
                 }
-                dicionario[promises[0]] = this.resolverValor(promises[1]);
+                dicionario[promises[0].toString()] = this.resolverValor(promises[1]);
             }
         }
         return dicionario;
@@ -21764,7 +21653,7 @@ class InterpretadorBase {
      */
     async visitarDeclaracaoVarMultiplo(declaracao) {
         const valoresFinais = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
-        const tipoIndividual = declaracao.tipo.replace('[]', '');
+        const tipoIndividual = (declaracao.tipo || '').replace('[]', '');
         for (let [indice, valor] of valoresFinais.entries()) {
             this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolos[indice].lexema, valor, tipoIndividual);
         }
@@ -22122,8 +22011,7 @@ class InterpretadorBase {
 }
 exports.InterpretadorBase = InterpretadorBase;
 
-}).call(this)}).call(this,require('_process'),require("timers").setImmediate)
-},{"../avaliador-sintatico":21,"../bibliotecas/primitivas-dicionario":29,"../bibliotecas/primitivas-vetor":32,"../construtos":62,"../excecoes":132,"../inferenciador":138,"../lexador":209,"../quebras":218,"../tipos-de-dados/delegua":219,"../tipos-de-dados/primitivos":221,"../tipos-de-simbolos/delegua":224,"./espaco-memoria":172,"./estruturas":180,"./estruturas/metodo-primitiva":182,"./pilha-escopos-execucao":193,"_process":471,"browser-process-hrtime":417,"timers":474}],191:[function(require,module,exports){
+},{"../avaliador-sintatico":21,"../bibliotecas/primitivas-dicionario":29,"../bibliotecas/primitivas-vetor":32,"../construtos":62,"../excecoes":132,"../inferenciador":138,"../lexador":209,"../quebras":218,"../tipos-de-dados/delegua":219,"../tipos-de-dados/primitivos":221,"../tipos-de-simbolos/delegua":224,"./espaco-memoria":172,"./estruturas":180,"./estruturas/metodo-primitiva":182,"./pilha-escopos-execucao":193,"browser-process-hrtime":417}],191:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -22320,7 +22208,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
     }
     async avaliacaoDeclaracaoVarOuConst(declaracao) {
         let valorOuOutraVariavel = null;
-        if (declaracao.inicializador !== null) {
+        if (declaracao.inicializador != null) {
             valorOuOutraVariavel = await this.avaliar(declaracao.inicializador);
         }
         let valorFinal = null;
@@ -22684,22 +22572,137 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
             linha: this.linhaDeclaracaoAtual,
         }, 'Somente listas, dicionários, classes e objetos podem ter seus valores indexados.', expressao.linha));
     }
-    /**
-     * Marca a `classeDefinidora` nos métodos próprios do descritor retornado pelo
-     * interpretador base. Isso é necessário para que `super()` localize corretamente
-     * a posição da classe em execução dentro do OReM (herança cooperativa).
-     */
-    async visitarDeclaracaoClasse(declaracao) {
-        const descritor = await super.visitarDeclaracaoClasse(declaracao);
-        for (const funcaoOuSobrecargas of Object.values(descritor.metodos)) {
+    logicaPropriedadesEMetodosDeClasse(declaracao, superClassesResolvidas, mesclaResolvidas) {
+        const metodos = {};
+        const metodosEstaticos = {};
+        const obtenedores = {};
+        const definidores = {};
+        const obtenedoresEstaticos = {};
+        const definidoresEstaticos = {};
+        const metodosAbstratos = [];
+        const acessoMetodos = {};
+        const acessoPropriedades = {};
+        for (const metodoAtual of declaracao.metodos) {
+            const nomeMetodo = metodoAtual.simbolo.lexema;
+            if (metodoAtual.acesso && metodoAtual.acesso !== 'publico') {
+                acessoMetodos[nomeMetodo] = metodoAtual.acesso;
+            }
+            if (metodoAtual.abstrato) {
+                metodosAbstratos.push(nomeMetodo);
+                continue;
+            }
+            const eInicializador = nomeMetodo === 'construtor';
+            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;
+            if (metodoAtual.eObtenedor) {
+                if (ehEstatico) {
+                    obtenedoresEstaticos[nomeMetodo] = funcao;
+                }
+                else {
+                    obtenedores[nomeMetodo] = funcao;
+                }
+                continue;
+            }
+            if (metodoAtual.eDefinidor) {
+                if (ehEstatico) {
+                    definidoresEstaticos[nomeMetodo] = funcao;
+                }
+                else {
+                    definidores[nomeMetodo] = funcao;
+                }
+                continue;
+            }
+            const destino = ehEstatico && !eInicializador ? metodosEstaticos : metodos;
+            if (destino[nomeMetodo]) {
+                if (!Array.isArray(destino[nomeMetodo])) {
+                    destino[nomeMetodo] = [destino[nomeMetodo]];
+                }
+                destino[nomeMetodo].push(funcao);
+            }
+            else {
+                destino[nomeMetodo] = funcao;
+            }
+        }
+        // Registrar propriedades estáticas no mapa de membros estáticos e níveis de acesso.
+        // Numa classe estática, todas as propriedades são tratadas como estáticas.
+        const membrosEstaticos = {};
+        for (const prop of declaracao.propriedades) {
+            if (prop.estatico || declaracao.classeEstatica) {
+                membrosEstaticos[prop.nome.lexema] = undefined;
+            }
+            if (prop.acesso && prop.acesso !== 'publico') {
+                acessoPropriedades[prop.nome.lexema] = prop.acesso;
+            }
+        }
+        const descritorTipoClasse = new estruturas_1.DescritorTipoClasse(declaracao.simbolo, superClassesResolvidas, metodos, declaracao.propriedades);
+        descritorTipoClasse.metodosEstaticos = metodosEstaticos;
+        descritorTipoClasse.membrosEstaticos = membrosEstaticos;
+        descritorTipoClasse.obtenedores = obtenedores;
+        descritorTipoClasse.definidores = definidores;
+        descritorTipoClasse.obtenedoresEstaticos = obtenedoresEstaticos;
+        descritorTipoClasse.definidoresEstaticos = definidoresEstaticos;
+        descritorTipoClasse.abstrata = declaracao.abstrata;
+        descritorTipoClasse.estrangeira = declaracao.estrangeira;
+        descritorTipoClasse.classeEstatica = declaracao.classeEstatica;
+        descritorTipoClasse.metodosAbstratos = metodosAbstratos;
+        descritorTipoClasse.acessoMetodos = acessoMetodos;
+        descritorTipoClasse.acessoPropriedades = acessoPropriedades;
+        // Toda classe sem superclasse explícita herda implicitamente de `Objeto`.
+        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(s) superclasse(s) abstrata(s).
+        if (!declaracao.abstrata && !declaracao.estrangeira) {
+            for (const superClasse of superClassesResolvidas) {
+                if (superClasse.abstrata || superClasse.estrangeira) {
+                    superClasse.verificarImplementacaoAbstrata(descritorTipoClasse);
+                }
+            }
+        }
+        // Marcar classeDefinidora em todos os métodos para que `super()` funcione.
+        for (const funcaoOuSobrecargas of Object.values(descritorTipoClasse.metodos)) {
             const lista = Array.isArray(funcaoOuSobrecargas)
                 ? funcaoOuSobrecargas
                 : [funcaoOuSobrecargas];
             for (const funcao of lista) {
-                funcao.classeDefinidora = descritor;
+                funcao.classeDefinidora = descritorTipoClasse;
             }
         }
-        return descritor;
+        return descritorTipoClasse;
+    }
+    resolverMetodoDeClasse(declaracao, superClassesResolvidas, mesclaResolvidas) {
+        return this.logicaPropriedadesEMetodosDeClasse(declaracao, superClassesResolvidas, mesclaResolvidas);
     }
     /**
      * Retorna um `SuperProxy` que aponta para a próxima classe no OReM após a classe
@@ -26780,6 +26783,7 @@ const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
  */
 class Lexador {
     constructor(performance = false) {
+        this.codigo = [];
         this.performance = performance;
         this.simbolos = [];
         this.erros = [];
@@ -27161,8 +27165,26 @@ class Lexador {
                 this.avancar();
                 break;
             case '.':
-                this.adicionarSimbolo(delegua_1.default.PONTO, '.');
+                this.inicioSimbolo = this.atual;
                 this.avancar();
+                if (this.simboloAtual() === '.') {
+                    this.avancar();
+                    if (this.simboloAtual() !== '.') {
+                        this.erros.push({
+                            linha: this.linha + 1,
+                            caractere: this.simboloAtual(),
+                            mensagem: 'Esperado ou apenas um ponto, ou três pontos em sequência.',
+                        });
+                        this.adicionarSimbolo(delegua_1.default.PONTO, '.');
+                    }
+                    else {
+                        this.avancar();
+                        this.adicionarSimbolo(delegua_1.default.RETICENCIAS, '...');
+                    }
+                }
+                else {
+                    this.adicionarSimbolo(delegua_1.default.PONTO, '.');
+                }
                 break;
             case '-':
                 this.inicioSimbolo = this.atual;
@@ -28478,6 +28500,7 @@ exports.default = {
     PONTO_E_VIRGULA: 'PONTO_E_VIRGULA',
     QUEBRAR: 'QUEBRAR',
     RETORNA: 'RETORNA',
+    RETICENCIAS: 'RETICENCIAS',
     SUBTRACAO: 'SUBTRACAO',
     SE: 'SE',
     SENAO: 'SENAO',
@@ -28976,7 +28999,7 @@ __exportStar(require("./tradutor-assembly-risc-v"), exports);
 __exportStar(require("./tradutor-webassembly"), exports);
 __exportStar(require("./tradutor-assembly-x64"), exports);
 __exportStar(require("./tradutor-assemblyscript"), exports);
-__exportStar(require("./tradutor-calango"), exports);
+__exportStar(require("./tradutor-reverso-calango"), exports);
 __exportStar(require("./tradutor-elixir"), exports);
 __exportStar(require("./tradutor-javascript"), exports);
 __exportStar(require("./tradutor-mermaidjs"), exports);
@@ -28987,7 +29010,7 @@ __exportStar(require("./tradutor-reverso-python"), exports);
 __exportStar(require("./tradutor-reverso-tenda"), exports);
 __exportStar(require("./tradutor-ruby"), exports);
 
-},{"./tradutor-assembly-arm":241,"./tradutor-assembly-risc-v":242,"./tradutor-assembly-x64":243,"./tradutor-assemblyscript":244,"./tradutor-calango":245,"./tradutor-elixir":246,"./tradutor-javascript":247,"./tradutor-mermaidjs":248,"./tradutor-portugol-ipt":249,"./tradutor-python":250,"./tradutor-reverso-javascript":251,"./tradutor-reverso-python":252,"./tradutor-reverso-tenda":253,"./tradutor-ruby":254,"./tradutor-webassembly":255}],233:[function(require,module,exports){
+},{"./tradutor-assembly-arm":241,"./tradutor-assembly-risc-v":242,"./tradutor-assembly-x64":243,"./tradutor-assemblyscript":244,"./tradutor-elixir":245,"./tradutor-javascript":246,"./tradutor-mermaidjs":247,"./tradutor-portugol-ipt":248,"./tradutor-python":249,"./tradutor-reverso-calango":250,"./tradutor-reverso-javascript":251,"./tradutor-reverso-python":252,"./tradutor-reverso-tenda":253,"./tradutor-ruby":254,"./tradutor-webassembly":255}],233:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArestaFluxograma = void 0;
@@ -44347,7 +44370,7 @@ class TradutorAssemblyScript {
         resultado += condicao;
         resultado += ')';
         resultado += this.dicionarioDeclaracoes[declaracaoSe.caminhoEntao.constructor.name](declaracaoSe.caminhoEntao);
-        if (declaracaoSe.caminhoSenao !== null) {
+        if (declaracaoSe.caminhoSenao != null) {
             resultado += ' '.repeat(this.indentacao);
             resultado += 'else ';
             const se = declaracaoSe?.caminhoSenao;
@@ -44975,61 +44998,6 @@ exports.TradutorAssemblyScript = TradutorAssemblyScript;
 
 },{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":224}],245:[function(require,module,exports){
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TradutorCalango = void 0;
-class TradutorCalango {
-    constructor() {
-        this.indentacao = 0;
-        this.dicionarioConstrutos = {
-            FormatacaoEscrita: this.traduzirConstrutoFormatacaoEscrita.bind(this),
-            Literal: this.traduzirConstrutoLiteral.bind(this),
-        };
-        this.dicionarioDeclaracoes = {
-            Escreva: this.traduzirDeclaracaoEscreva.bind(this),
-            EscrevaMesmaLinha: this.traduzirDeclaracaoEscrevaMesmaLinha.bind(this),
-        };
-    }
-    traduzirConstrutoFormatacaoEscrita(formatacaoEscrita) {
-        const avaliacaoExpressao = this.dicionarioConstrutos[formatacaoEscrita.expressao.constructor.name](formatacaoEscrita.expressao);
-        return `${avaliacaoExpressao}`;
-    }
-    traduzirConstrutoLiteral(literal) {
-        if (typeof literal.valor === 'string')
-            return `'${literal.valor}'`;
-        return String(literal.valor);
-    }
-    traduzirDeclaracaoEscreva(declaracaoEscreva) {
-        let resultado = 'escreva(';
-        for (const argumento of declaracaoEscreva.argumentos) {
-            const valor = this.dicionarioConstrutos[argumento.constructor.name](argumento);
-            resultado += valor + ', ';
-        }
-        resultado = resultado.slice(0, -2);
-        resultado += ')';
-        return resultado;
-    }
-    traduzirDeclaracaoEscrevaMesmaLinha(declaracaoEscreva) {
-        let resultado = 'escreva(';
-        for (const argumento of declaracaoEscreva.argumentos) {
-            const valor = this.dicionarioConstrutos[argumento.constructor.name](argumento);
-            resultado += valor + ', ';
-        }
-        resultado = resultado.slice(0, -2);
-        resultado += ')';
-        return resultado;
-    }
-    traduzir(declaracoes) {
-        let resultado = '';
-        for (const declaracao of declaracoes) {
-            resultado += `${this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao)} \n`;
-        }
-        return resultado;
-    }
-}
-exports.TradutorCalango = TradutorCalango;
-
-},{}],246:[function(require,module,exports){
-"use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -45979,7 +45947,7 @@ class TradutorElixir {
 }
 exports.TradutorElixir = TradutorElixir;
 
-},{"../tipos-de-simbolos/delegua":224}],247:[function(require,module,exports){
+},{"../tipos-de-simbolos/delegua":224}],246:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -46459,7 +46427,7 @@ class TradutorJavaScript {
         resultado += condicao;
         resultado += ')';
         resultado += this.dicionarioDeclaracoes[declaracaoSe.caminhoEntao.constructor.name](declaracaoSe.caminhoEntao);
-        if (declaracaoSe.caminhoSenao !== null) {
+        if (declaracaoSe.caminhoSenao != null) {
             resultado += ' '.repeat(this.indentacao);
             resultado += 'else ';
             const se = declaracaoSe?.caminhoSenao;
@@ -46771,7 +46739,7 @@ class TradutorJavaScript {
 }
 exports.TradutorJavaScript = TradutorJavaScript;
 
-},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":224}],248:[function(require,module,exports){
+},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":224}],247:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -47595,7 +47563,7 @@ class TradutorMermaidJs {
 }
 exports.TradutorMermaidJs = TradutorMermaidJs;
 
-},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":224,"./mermaid":234}],249:[function(require,module,exports){
+},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":224,"./mermaid":234}],248:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorPortugolIpt = void 0;
@@ -47657,7 +47625,7 @@ class TradutorPortugolIpt {
 }
 exports.TradutorPortugolIpt = TradutorPortugolIpt;
 
-},{"../avaliador-sintatico/dialetos":17,"../lexador/dialetos":194}],250:[function(require,module,exports){
+},{"../avaliador-sintatico/dialetos":17,"../lexador/dialetos":194}],249:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -48342,7 +48310,359 @@ class TradutorPython {
 }
 exports.TradutorPython = TradutorPython;
 
-},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":224}],251:[function(require,module,exports){
+},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":224}],250:[function(require,module,exports){
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradutorReversoCalango = void 0;
+const calango_1 = __importDefault(require("../tipos-de-simbolos/calango"));
+class TradutorReversoCalango {
+    constructor() {
+        this.indentacao = 0;
+        this.dicionarioConstrutos = {
+            AcessoIndiceVariavel: this.traduzirConstrutoAcessoIndiceVariavel.bind(this),
+            Agrupamento: this.traduzirConstrutoAgrupamento.bind(this),
+            AtribuicaoPorIndice: this.traduzirConstrutoAtribuicaoPorIndice.bind(this),
+            Atribuir: this.traduzirConstrutoAtribuir.bind(this),
+            Binario: this.traduzirConstrutoBinario.bind(this),
+            Chamada: this.traduzirConstrutoChamada.bind(this),
+            FormatacaoEscrita: this.traduzirConstrutoFormatacaoEscrita.bind(this),
+            FuncaoConstruto: this.traduzirConstrutoFuncao.bind(this),
+            Leia: this.traduzirConstrutoLeia.bind(this),
+            Literal: this.traduzirConstrutoLiteral.bind(this),
+            Logico: this.traduzirConstrutoLogico.bind(this),
+            Unario: this.traduzirConstrutoUnario.bind(this),
+            Variavel: this.traduzirConstrutoVariavel.bind(this),
+            Vetor: this.traduzirConstrutoVetor.bind(this),
+        };
+        this.dicionarioDeclaracoes = {
+            Bloco: this.traduzirDeclaracaoBloco.bind(this),
+            Enquanto: this.traduzirDeclaracaoEnquanto.bind(this),
+            Escolha: this.traduzirDeclaracaoEscolha.bind(this),
+            Escreva: this.traduzirDeclaracaoEscreva.bind(this),
+            EscrevaMesmaLinha: this.traduzirDeclaracaoEscrevaMesmaLinha.bind(this),
+            Expressao: this.traduzirDeclaracaoExpressao.bind(this),
+            Fazer: this.traduzirDeclaracaoFazer.bind(this),
+            FuncaoDeclaracao: this.traduzirDeclaracaoFuncao.bind(this),
+            Para: this.traduzirDeclaracaoPara.bind(this),
+            Retorna: this.traduzirDeclaracaoRetorna.bind(this),
+            Se: this.traduzirDeclaracaoSe.bind(this),
+            Sustar: this.traduzirDeclaracaoSustar.bind(this),
+            Var: this.traduzirDeclaracaoVar.bind(this),
+        };
+    }
+    traduzirSimboloOperador(simbolo) {
+        switch (simbolo?.tipo) {
+            case calango_1.default.ADICAO:
+                return '+';
+            case calango_1.default.SUBTRACAO:
+                return '-';
+            case calango_1.default.MULTIPLICACAO:
+                return '*';
+            case calango_1.default.DIVISAO:
+                return '/';
+            case calango_1.default.DIVISAO_INTEIRA:
+                return '\\';
+            case calango_1.default.MODULO:
+                return '%';
+            case calango_1.default.EXPONENCIACAO:
+                return '^';
+            case calango_1.default.IGUAL:
+            case calango_1.default.IGUAL_IGUAL:
+                return '==';
+            case calango_1.default.IGUAL_ATRIBUICAO:
+                return '=';
+            case calango_1.default.DIFERENTE:
+                return '!=';
+            case calango_1.default.MAIOR:
+                return '>';
+            case calango_1.default.MAIOR_IGUAL:
+                return '>=';
+            case calango_1.default.MENOR:
+                return '<';
+            case calango_1.default.MENOR_IGUAL:
+                return '<=';
+            case calango_1.default.E:
+                return 'e';
+            case calango_1.default.OU:
+                return 'ou';
+            case calango_1.default.NEGACAO:
+                return 'nao';
+            default:
+                return simbolo?.lexema || '';
+        }
+    }
+    traduzirQualquer(elemento) {
+        if (!elemento) {
+            return '';
+        }
+        const nomeConstrutor = elemento.constructor.name;
+        if (this.dicionarioDeclaracoes.hasOwnProperty(nomeConstrutor)) {
+            return this.dicionarioDeclaracoes[nomeConstrutor](elemento);
+        }
+        if (this.dicionarioConstrutos.hasOwnProperty(nomeConstrutor)) {
+            return this.dicionarioConstrutos[nomeConstrutor](elemento);
+        }
+        throw new Error(`Elemento não suportado pelo tradutor Calango reverso: ${nomeConstrutor}`);
+    }
+    traduzirParametro(parametro) {
+        const nome = parametro?.nome?.lexema;
+        const tipo = parametro?.tipoDado;
+        if (!nome) {
+            return '';
+        }
+        if (!tipo || tipo === 'qualquer') {
+            return nome;
+        }
+        return `${nome}: ${tipo}`;
+    }
+    logicaComumBlocoEscopo(declaracoes) {
+        let resultado = '{\n';
+        this.indentacao += 4;
+        for (const declaracaoOuConstruto of declaracoes || []) {
+            const traducao = this.traduzirQualquer(declaracaoOuConstruto);
+            if (!traducao) {
+                continue;
+            }
+            resultado += `${' '.repeat(this.indentacao)}${traducao}\n`;
+        }
+        this.indentacao -= 4;
+        resultado += `${' '.repeat(this.indentacao)}}`;
+        return resultado;
+    }
+    traduzirConstrutoAcessoIndiceVariavel(acessoIndiceVariavel) {
+        const entidade = this.traduzirQualquer(acessoIndiceVariavel.entidadeChamada);
+        const indice = this.traduzirQualquer(acessoIndiceVariavel.indice);
+        return `${entidade}[${indice}]`;
+    }
+    traduzirConstrutoAgrupamento(agrupamento) {
+        return `(${this.traduzirQualquer(agrupamento.expressao)})`;
+    }
+    traduzirConstrutoAtribuicaoPorIndice(atribuicao) {
+        const objeto = this.traduzirQualquer(atribuicao.objeto);
+        const indice = this.traduzirQualquer(atribuicao.indice);
+        const valor = this.traduzirQualquer(atribuicao.valor);
+        return `${objeto}[${indice}] = ${valor}`;
+    }
+    traduzirConstrutoAtribuir(atribuir) {
+        let alvo = this.traduzirQualquer(atribuir.alvo);
+        if (atribuir.indice) {
+            alvo += `[${this.traduzirQualquer(atribuir.indice)}]`;
+        }
+        const operador = atribuir.simboloOperador
+            ? this.traduzirSimboloOperador(atribuir.simboloOperador)
+            : '=';
+        const valor = this.traduzirQualquer(atribuir.valor);
+        return `${alvo} ${operador} ${valor}`;
+    }
+    traduzirConstrutoBinario(binario) {
+        const esquerda = this.traduzirQualquer(binario.esquerda);
+        const direita = this.traduzirQualquer(binario.direita);
+        const operador = this.traduzirSimboloOperador(binario.operador);
+        return `${esquerda} ${operador} ${direita}`;
+    }
+    traduzirConstrutoChamada(chamada) {
+        const entidade = this.traduzirQualquer(chamada.entidadeChamada);
+        const argumentos = (chamada.argumentos || []).map((argumento) => this.traduzirQualquer(argumento));
+        return `${entidade}(${argumentos.join(', ')})`;
+    }
+    traduzirConstrutoFormatacaoEscrita(formatacaoEscrita) {
+        const avaliacaoExpressao = this.traduzirQualquer(formatacaoEscrita.expressao);
+        return `${avaliacaoExpressao}`;
+    }
+    traduzirConstrutoFuncao(funcaoConstruto) {
+        const parametros = (funcaoConstruto.parametros || [])
+            .map((parametro) => this.traduzirParametro(parametro))
+            .filter((p) => p)
+            .join(', ');
+        let resultado = `funcao(${parametros}) `;
+        resultado += this.logicaComumBlocoEscopo(funcaoConstruto.corpo);
+        return resultado;
+    }
+    traduzirConstrutoLeia(leia) {
+        const argumentos = (leia.argumentos || []).map((argumento) => this.traduzirQualquer(argumento));
+        return `leia(${argumentos.join(', ')})`;
+    }
+    traduzirConstrutoLiteral(literal) {
+        if (typeof literal.valor === 'string') {
+            const valorEscapado = literal.valor.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+            return `'${valorEscapado}'`;
+        }
+        if (literal.valor === null || literal.valor === undefined) {
+            return 'nulo';
+        }
+        if (typeof literal.valor === 'boolean') {
+            return literal.valor ? 'verdadeiro' : 'falso';
+        }
+        return String(literal.valor);
+    }
+    traduzirConstrutoLogico(logico) {
+        const esquerda = this.traduzirQualquer(logico.esquerda);
+        const direita = this.traduzirQualquer(logico.direita);
+        const operador = this.traduzirSimboloOperador(logico.operador);
+        return `${esquerda} ${operador} ${direita}`;
+    }
+    traduzirConstrutoUnario(unario) {
+        const operador = this.traduzirSimboloOperador(unario.operador);
+        const operando = this.traduzirQualquer(unario.operando);
+        if (unario.incidenciaOperador === 'DEPOIS') {
+            return `${operando}${operador}`;
+        }
+        if (operador === 'nao') {
+            return `${operador} ${operando}`;
+        }
+        return `${operador}${operando}`;
+    }
+    traduzirConstrutoVariavel(variavel) {
+        return variavel.simbolo.lexema;
+    }
+    traduzirConstrutoVetor(vetor) {
+        const elementos = (vetor.elementos || []).map((elemento) => this.traduzirQualquer(elemento));
+        return `[${elementos.join(', ')}]`;
+    }
+    traduzirDeclaracaoBloco(bloco) {
+        return this.logicaComumBlocoEscopo(bloco.declaracoes);
+    }
+    traduzirDeclaracaoEnquanto(declaracaoEnquanto) {
+        const condicao = this.traduzirQualquer(declaracaoEnquanto.condicao);
+        const corpo = this.traduzirDeclaracaoBloco(declaracaoEnquanto.corpo);
+        return `enquanto (${condicao}) ${corpo}`;
+    }
+    traduzirDeclaracaoEscolha(declaracaoEscolha) {
+        const expressao = this.traduzirQualquer(declaracaoEscolha.identificadorOuLiteral);
+        let resultado = `escolha (${expressao}) {\n`;
+        this.indentacao += 4;
+        for (const caminho of declaracaoEscolha.caminhos || []) {
+            for (const condicao of caminho.condicoes || []) {
+                resultado += `${' '.repeat(this.indentacao)}caso ${this.traduzirQualquer(condicao)}:\n`;
+            }
+            this.indentacao += 4;
+            for (const declaracao of caminho.declaracoes || []) {
+                const traducao = this.traduzirQualquer(declaracao);
+                if (traducao) {
+                    resultado += `${' '.repeat(this.indentacao)}${traducao}\n`;
+                }
+            }
+            this.indentacao -= 4;
+        }
+        if (declaracaoEscolha.caminhoPadrao) {
+            resultado += `${' '.repeat(this.indentacao)}padrao:\n`;
+            this.indentacao += 4;
+            for (const declaracao of declaracaoEscolha.caminhoPadrao.declaracoes || []) {
+                const traducao = this.traduzirQualquer(declaracao);
+                if (traducao) {
+                    resultado += `${' '.repeat(this.indentacao)}${traducao}\n`;
+                }
+            }
+            this.indentacao -= 4;
+        }
+        this.indentacao -= 4;
+        resultado += `${' '.repeat(this.indentacao)}}`;
+        return resultado;
+    }
+    traduzirDeclaracaoEscreva(declaracaoEscreva) {
+        let resultado = 'escreva(';
+        for (const argumento of declaracaoEscreva.argumentos) {
+            const valor = this.traduzirQualquer(argumento);
+            resultado += valor + ', ';
+        }
+        if (declaracaoEscreva.argumentos.length > 0) {
+            resultado = resultado.slice(0, -2);
+        }
+        resultado += ')';
+        return resultado;
+    }
+    traduzirDeclaracaoEscrevaMesmaLinha(declaracaoEscreva) {
+        let resultado = 'escreva(';
+        for (const argumento of declaracaoEscreva.argumentos) {
+            const valor = this.traduzirQualquer(argumento);
+            resultado += valor + ', ';
+        }
+        if (declaracaoEscreva.argumentos.length > 0) {
+            resultado = resultado.slice(0, -2);
+        }
+        resultado += ')';
+        return resultado;
+    }
+    traduzirDeclaracaoExpressao(expressao) {
+        return this.traduzirQualquer(expressao.expressao);
+    }
+    traduzirDeclaracaoFazer(fazer) {
+        const corpo = this.traduzirDeclaracaoBloco(fazer.caminhoFazer);
+        const condicao = this.traduzirQualquer(fazer.condicaoEnquanto);
+        return `fazer ${corpo} enquanto (${condicao})`;
+    }
+    traduzirDeclaracaoFuncao(declaracaoFuncao) {
+        const parametros = (declaracaoFuncao.funcao.parametros || [])
+            .map((parametro) => this.traduzirParametro(parametro))
+            .filter((p) => p)
+            .join(', ');
+        const tipoRetorno = declaracaoFuncao.tipo && declaracaoFuncao.tipo !== 'qualquer' && declaracaoFuncao.tipo !== 'vazio'
+            ? `: ${declaracaoFuncao.tipo}`
+            : '';
+        let resultado = `funcao ${declaracaoFuncao.simbolo.lexema}(${parametros})${tipoRetorno} `;
+        resultado += this.logicaComumBlocoEscopo(declaracaoFuncao.funcao.corpo);
+        return resultado;
+    }
+    traduzirDeclaracaoPara(declaracaoPara) {
+        let inicializador = '';
+        if (Array.isArray(declaracaoPara.inicializador)) {
+            inicializador = declaracaoPara.inicializador
+                .map((declaracao) => this.traduzirQualquer(declaracao))
+                .join(', ');
+        }
+        else if (declaracaoPara.inicializador) {
+            inicializador = this.traduzirQualquer(declaracaoPara.inicializador);
+        }
+        const condicao = this.traduzirQualquer(declaracaoPara.condicao);
+        const incremento = this.traduzirQualquer(declaracaoPara.incrementar);
+        const corpo = this.traduzirDeclaracaoBloco(declaracaoPara.corpo);
+        return `para (${inicializador}; ${condicao}; ${incremento}) ${corpo}`;
+    }
+    traduzirDeclaracaoRetorna(retorna) {
+        if (!retorna.valor) {
+            return 'retorna';
+        }
+        return `retorna ${this.traduzirQualquer(retorna.valor)}`;
+    }
+    traduzirDeclaracaoSe(declaracaoSe) {
+        const condicao = this.traduzirQualquer(declaracaoSe.condicao);
+        const caminhoEntao = this.traduzirQualquer(declaracaoSe.caminhoEntao);
+        let resultado = `se (${condicao}) ${caminhoEntao}`;
+        const caminhosSeSenao = declaracaoSe.caminhosSeSenao || [];
+        for (const caminhoSeSenao of caminhosSeSenao) {
+            resultado += ` senao se (${this.traduzirQualquer(caminhoSeSenao.condicao)}) ${this.traduzirQualquer(caminhoSeSenao.caminho)}`;
+        }
+        if (declaracaoSe.caminhoSenao) {
+            resultado += ` senao ${this.traduzirQualquer(declaracaoSe.caminhoSenao)}`;
+        }
+        return resultado;
+    }
+    traduzirDeclaracaoSustar(_sustar) {
+        return 'sustar';
+    }
+    traduzirDeclaracaoVar(declaracaoVar) {
+        if (!declaracaoVar.inicializador) {
+            return `var ${declaracaoVar.simbolo.lexema}`;
+        }
+        return `var ${declaracaoVar.simbolo.lexema} = ${this.traduzirQualquer(declaracaoVar.inicializador)}`;
+    }
+    traduzir(declaracoes) {
+        const linhas = [];
+        for (const declaracao of declaracoes) {
+            const traducao = this.traduzirQualquer(declaracao);
+            if (traducao) {
+                linhas.push(traducao);
+            }
+        }
+        return linhas.join('\n');
+    }
+}
+exports.TradutorReversoCalango = TradutorReversoCalango;
+
+},{"../tipos-de-simbolos/calango":222}],251:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorReversoJavaScript = void 0;
@@ -48742,75 +49062,632 @@ exports.TradutorReversoJavaScript = TradutorReversoJavaScript;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorReversoPython = void 0;
 const antlr4ts_1 = require("antlr4ts");
-const python3_parser_1 = require("./python/python3-parser");
-const ParseTreeWalker_1 = require("antlr4ts/tree/ParseTreeWalker");
+const AbstractParseTreeVisitor_1 = require("antlr4ts/tree/AbstractParseTreeVisitor");
 const python3_lexer_1 = require("./python/python3-lexer");
+const python3_parser_1 = require("./python/python3-parser");
 /**
  * Tradutor reverso de Python para Delégua.
- * Utiliza o ecossistema do ANTLR para percorrer código em
+ * Utiliza o visitor do ANTLR para percorrer a árvore sintática em
  * Python e traduzir para Delégua.
  */
-class TradutorReversoPython {
-    /**
-     * Aqui é preciso contar se o contexto tem filhos.
-     * Há alguns casos em que este código é executado mais
-     * de uma vez por algum motivo.
-     * @param ctx O contexto da atribuição.
-     */
-    enterSimple_assign(ctx) {
-        if (ctx.childCount > 0) {
-            this.resultado += ' = ';
+class TradutorReversoPython extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
+    constructor() {
+        super(...arguments);
+        // Funções globais Python → Delégua
+        this.mapeamentoFuncoes = {
+            print: 'escreva',
+            input: 'leia',
+            len: 'tamanho',
+            int: 'inteiro',
+            float: 'real',
+            str: 'texto',
+            bool: 'logico',
+            type: 'tipoDe',
+            range: 'intervalo',
+            abs: 'absoluto',
+            round: 'arredondar',
+            min: 'minimo',
+            max: 'maximo',
+            sum: 'somar',
+        };
+        // Métodos de instância Python → Delégua
+        this.mapeamentoMetodos = {
+            // Lista / vetor
+            append: 'adicionar',
+            pop: 'removerUltimo',
+            reverse: 'inverter',
+            sort: 'ordenar',
+            clear: 'limpar',
+            // Texto / string
+            upper: 'maiusculo',
+            lower: 'minusculo',
+            strip: 'aparar',
+            lstrip: 'aparar',
+            rstrip: 'aparar',
+            split: 'dividir',
+            join: 'juntar',
+            startswith: 'iniciaCom',
+            endswith: 'terminaCom',
+            replace: 'substituir',
+            find: 'encontrar',
+            count: 'contar',
+            // Dicionário
+            keys: 'chaves',
+            values: 'valores',
+            items: 'itens',
+        };
+    }
+    defaultResult() {
+        return '';
+    }
+    aggregateResult(aggregate, nextResult) {
+        return aggregate + nextResult;
+    }
+    visitTerminal(node) {
+        return node.text;
+    }
+    visitFile_input(ctx) {
+        return ctx.stmt().map((s) => this.visit(s)).join('\n');
+    }
+    visitSimple_stmt(ctx) {
+        return ctx.small_stmt().map((s) => this.visit(s)).join('; ');
+    }
+    visitExpr_stmt(ctx) {
+        const lhs = this.visit(ctx.testlist_star_expr());
+        const simpleAssign = ctx.simple_assign();
+        if (simpleAssign && simpleAssign.childCount > 0) {
+            const rhs = this.visitSimple_assign(simpleAssign);
+            // Atribuições a atributos (a.b = x) ou índices (a[i] = x) não usam 'var'
+            const prefixo = lhs.includes('.') || lhs.includes('[') ? '' : 'var ';
+            return `${prefixo}${lhs} = ${rhs}`;
+        }
+        if (ctx.augassign()) {
+            const op = this.visitAugassign(ctx.augassign());
+            const testlist = ctx.testlist();
+            const yieldExpr = ctx.yield_expr();
+            const rhs = testlist
+                ? this.visit(testlist)
+                : yieldExpr
+                    ? this.visit(yieldExpr)
+                    : '';
+            return `${lhs} ${op} ${rhs}`;
+        }
+        return lhs;
+    }
+    visitSimple_assign(ctx) {
+        const exprs = ctx.testlist_star_expr();
+        return this.visit(exprs[exprs.length - 1]);
+    }
+    visitAugassign(ctx) {
+        if (ctx.ADD_ASSIGN())
+            return '+=';
+        if (ctx.SUB_ASSIGN())
+            return '-=';
+        if (ctx.MULT_ASSIGN())
+            return '*=';
+        if (ctx.DIV_ASSIGN())
+            return '/=';
+        if (ctx.MOD_ASSIGN())
+            return '%=';
+        if (ctx.AND_ASSIGN())
+            return '&=';
+        if (ctx.OR_ASSIGN())
+            return '|=';
+        if (ctx.XOR_ASSIGN())
+            return '^=';
+        if (ctx.LEFT_SHIFT_ASSIGN())
+            return '<<=';
+        if (ctx.RIGHT_SHIFT_ASSIGN())
+            return '>>=';
+        if (ctx.POWER_ASSIGN())
+            return '**=';
+        if (ctx.IDIV_ASSIGN())
+            return '//=';
+        return ctx.text;
+    }
+    visitTestlist_star_expr(ctx) {
+        return ctx.test().map((t) => this.visit(t)).join(', ');
+    }
+    visitTestlist(ctx) {
+        return ctx.test().map((t) => this.visit(t)).join(', ');
+    }
+    visitTest(ctx) {
+        const orTests = ctx.or_test();
+        if (orTests.length === 1)
+            return this.visit(orTests[0]);
+        const lambdef = ctx.lambdef();
+        if (lambdef)
+            return this.visit(lambdef);
+        // Expressão ternária (a if cond else b) — implementada em fase futura
+        return this.visitChildren(ctx);
+    }
+    visitOr_test(ctx) {
+        return ctx.and_test().map((t) => this.visit(t)).join(' ou ');
+    }
+    visitAnd_test(ctx) {
+        return ctx.not_test().map((t) => this.visit(t)).join(' e ');
+    }
+    visitNot_test(ctx) {
+        if (ctx.NOT()) {
+            return `nao ${this.visit(ctx.not_test())}`;
+        }
+        const comp = ctx.comparison();
+        if (comp)
+            return this.visit(comp);
+        return this.visitChildren(ctx);
+    }
+    visitComparison(ctx) {
+        const exprs = ctx.expr();
+        if (exprs.length === 1)
+            return this.visit(exprs[0]);
+        const ops = ctx.comp_op();
+        let resultado = this.visit(exprs[0]);
+        for (let i = 0; i < ops.length; i++) {
+            resultado += ` ${this.visitComp_op(ops[i])} ${this.visit(exprs[i + 1])}`;
         }
+        return resultado;
     }
-    /**
-     * Aparentemente é o melhor lugar para escrever quebras de linha.
-     * @param ctx Contexto da instrução.
-     */
-    exitStmt(ctx) {
-        this.resultado += ctx.stop.text;
+    visitComp_op(ctx) {
+        if (ctx.LESS_THAN())
+            return '<';
+        if (ctx.GREATER_THAN())
+            return '>';
+        if (ctx.EQUALS())
+            return '==';
+        if (ctx.GT_EQ())
+            return '>=';
+        if (ctx.LT_EQ())
+            return '<=';
+        if (ctx.NOT_EQ_1() || ctx.NOT_EQ_2())
+            return '!=';
+        if (ctx.NOT() && ctx.IN())
+            return 'nao em';
+        if (ctx.IN())
+            return 'em';
+        if (ctx.NOT() && ctx.IS())
+            return '!=';
+        if (ctx.IS())
+            return '==';
+        return ctx.text;
+    }
+    visitArith_expr(ctx) {
+        const termos = ctx.term();
+        if (termos.length === 1)
+            return this.visit(termos[0]);
+        let resultado = this.visit(termos[0]);
+        let idx = 1;
+        for (let i = 1; i < ctx.childCount; i++) {
+            const texto = ctx.getChild(i).text;
+            if (texto === '+' || texto === '-') {
+                resultado += ` ${texto} ${this.visit(termos[idx++])}`;
+            }
+        }
+        return resultado;
     }
-    enterExpr_stmt(ctx) {
-        // console.log(ctx.start.text);
+    visitTerm(ctx) {
+        const fatores = ctx.factor();
+        if (fatores.length === 1)
+            return this.visit(fatores[0]);
+        let resultado = this.visit(fatores[0]);
+        let idx = 1;
+        for (let i = 1; i < ctx.childCount; i++) {
+            const texto = ctx.getChild(i).text;
+            if (['*', '/', '%', '//', '@'].includes(texto)) {
+                resultado += ` ${texto} ${this.visit(fatores[idx++])}`;
+            }
+        }
+        return resultado;
     }
-    enterExpr(ctx) {
-        switch (ctx.start.text) {
-            case 'input':
-                this.resultado += 'leia(';
-                break;
-            case 'print':
-                this.resultado += 'escreva(';
-                break;
-            default:
-                this.resultado += ctx.start.text;
-                break;
+    visitFactor(ctx) {
+        if (ctx.ADD())
+            return `+${this.visit(ctx.factor())}`;
+        if (ctx.MINUS())
+            return `-${this.visit(ctx.factor())}`;
+        if (ctx.NOT_OP())
+            return `~${this.visit(ctx.factor())}`;
+        return this.visit(ctx.power());
+    }
+    visitPower(ctx) {
+        const base = this.visit(ctx.atom_expr());
+        if (ctx.POWER()) {
+            return `${base} ** ${this.visit(ctx.factor())}`;
+        }
+        return base;
+    }
+    visitAtom_expr(ctx) {
+        const textoAtomo = this.visit(ctx.atom());
+        const trailers = ctx.trailer();
+        if (trailers.length === 0)
+            return textoAtomo;
+        // Chamada de função simples: nome(args)
+        if (trailers.length === 1 && trailers[0].OPEN_PAREN()) {
+            const nomeFuncao = this.mapeamentoFuncoes[textoAtomo] ?? textoAtomo;
+            const arglist = trailers[0].arglist();
+            const args = arglist ? this.visit(arglist) : '';
+            return `${nomeFuncao}(${args})`;
+        }
+        // Chamada de método: obj.metodo(args)  →  dois trailers: .nome e (args)
+        if (trailers.length === 2 &&
+            trailers[0].DOT() &&
+            trailers[0].NAME() &&
+            trailers[1].OPEN_PAREN()) {
+            const nomeMetodoPython = trailers[0].NAME().text;
+            const arglist = trailers[1].arglist();
+            const args = arglist ? this.visit(arglist) : '';
+            // join é invertido: sep.join(iteravel) → iteravel.juntar(sep)
+            if (nomeMetodoPython === 'join') {
+                return `${args}.juntar(${textoAtomo})`;
+            }
+            const nomeMetodoDelégua = this.mapeamentoMetodos[nomeMetodoPython] ?? nomeMetodoPython;
+            return `${textoAtomo}.${nomeMetodoDelégua}(${args})`;
+        }
+        // Fallback: acesso a atributo, índice ou chamadas encadeadas
+        let resultado = textoAtomo;
+        for (const trailer of trailers) {
+            resultado += this.visitTrailer(trailer);
         }
+        return resultado;
     }
-    exitExpr(ctx) {
-        switch (ctx.start.text) {
-            case 'input':
-            case 'print':
-                this.resultado += ')';
+    visitTrailer(ctx) {
+        if (ctx.DOT() && ctx.NAME()) {
+            return `.${ctx.NAME().text}`;
+        }
+        if (ctx.OPEN_BRACK()) {
+            const subscriptlist = ctx.subscriptlist();
+            const conteudo = subscriptlist ? this.visit(subscriptlist) : '';
+            return `[${conteudo}]`;
+        }
+        if (ctx.OPEN_PAREN()) {
+            const arglist = ctx.arglist();
+            const args = arglist ? this.visit(arglist) : '';
+            return `(${args})`;
+        }
+        return ctx.text;
+    }
+    visitAtom(ctx) {
+        const nome = ctx.NAME();
+        if (nome)
+            return nome.text === 'self' ? 'isto' : nome.text;
+        const numero = ctx.NUMBER();
+        if (numero)
+            return numero.text;
+        if (ctx.TRUE())
+            return 'verdadeiro';
+        if (ctx.FALSE())
+            return 'falso';
+        if (ctx.NONE())
+            return 'nulo';
+        const strings = ctx.STRING();
+        if (strings.length > 0)
+            return strings.map((s) => s.text).join(' ');
+        if (ctx.OPEN_PAREN()) {
+            const testlistComp = ctx.testlist_comp();
+            if (testlistComp) {
+                // Tupla com vírgula → vetor em Delégua
+                if (testlistComp.COMMA().length > 0) {
+                    return `[${this.visitTestlist_comp(testlistComp)}]`;
+                }
+                return `(${this.visitTestlist_comp(testlistComp)})`;
+            }
+            return '()';
+        }
+        if (ctx.OPEN_BRACK()) {
+            const testlistComp = ctx.testlist_comp();
+            if (testlistComp) {
+                // Compreensão de lista: resultado já é um vetor, não envolve em []
+                if (testlistComp.comp_for()) {
+                    return this.visitTestlist_comp(testlistComp);
+                }
+                return `[${this.visitTestlist_comp(testlistComp)}]`;
+            }
+            return '[]';
+        }
+        if (ctx.OPEN_BRACE()) {
+            const dictorsetmaker = ctx.dictorsetmaker();
+            if (dictorsetmaker)
+                return `{${this.visitDictorsetmaker(dictorsetmaker)}}`;
+            return '{}';
+        }
+        return ctx.text;
+    }
+    visitArglist(ctx) {
+        return ctx.argument().map((a) => this.visit(a)).join(', ');
+    }
+    visitArgument(ctx) {
+        const testes = ctx.test();
+        if (testes.length === 1 && !ctx.ASSIGN()) {
+            return this.visit(testes[0]);
+        }
+        // Argumento nomeado: nome=valor
+        if (testes.length === 2 && ctx.ASSIGN()) {
+            return `${this.visit(testes[0])} = ${this.visit(testes[1])}`;
+        }
+        return this.visitChildren(ctx);
+    }
+    visitTestlist_comp(ctx) {
+        const compFor = ctx.comp_for();
+        if (compFor) {
+            return this.traduzirCompreensao(ctx.test(0), compFor);
+        }
+        return ctx.test().map((t) => this.visit(t)).join(', ');
+    }
+    traduzirCompreensao(exprCtx, compFor) {
+        const variavel = this.visit(compFor.exprlist());
+        const iteravel = this.visit(compFor.or_test());
+        const expr = this.visit(exprCtx);
+        const compIter = compFor.comp_iter();
+        const compIf = compIter?.comp_if();
+        if (compIf) {
+            const cond = this.visitChildren(compIf.test_nocond());
+            return `filtrarPor(${iteravel}, funcao(${variavel}) { retorna ${cond} }).mapear(funcao(${variavel}) { retorna ${expr} })`;
+        }
+        return `${iteravel}.mapear(funcao(${variavel}) { retorna ${expr} })`;
+    }
+    visitLambdef(ctx) {
+        const varargslist = ctx.varargslist();
+        const params = varargslist ? this.visitVarargslist(varargslist) : '';
+        const corpo = this.visit(ctx.test());
+        return `funcao(${params}) { retorna ${corpo} }`;
+    }
+    visitVarargslist(ctx) {
+        const params = [];
+        for (let i = 0; i < ctx.childCount;) {
+            const texto = ctx.getChild(i).text;
+            if (texto === ',') {
+                i++;
+                continue;
+            }
+            if (texto === '*' || texto === '**')
                 break;
-            default:
+            const nomeParam = texto;
+            if (i + 1 < ctx.childCount && ctx.getChild(i + 1).text === '=') {
+                const valorPadrao = this.visit(ctx.getChild(i + 2));
+                params.push(`${nomeParam} = ${valorPadrao}`);
+                i += 3;
+            }
+            else {
+                params.push(nomeParam);
+                i++;
+            }
+        }
+        return params.join(', ');
+    }
+    visitDictorsetmaker(ctx) {
+        const tests = ctx.test();
+        if (ctx.COLON().length > 0) {
+            // Dicionário: testes alternados como chave/valor
+            const pares = [];
+            for (let i = 0; i + 1 < tests.length; i += 2) {
+                pares.push(`${this.visit(tests[i])}: ${this.visit(tests[i + 1])}`);
+            }
+            return pares.join(', ');
+        }
+        // Conjunto (set) — representado como lista em Delégua
+        return tests.map((t) => this.visit(t)).join(', ');
+    }
+    visitSubscriptlist(ctx) {
+        return ctx.subscript().map((s) => this.visitSubscript(s)).join(', ');
+    }
+    visitSubscript(ctx) {
+        const tests = ctx.test();
+        if (!ctx.COLON()) {
+            // Índice simples
+            return tests.length > 0 ? this.visit(tests[0]) : '';
+        }
+        // Fatia: [inicio]:fim → inicio..fim
+        // Se o primeiro filho é ':', não há início (ex: texto[:3])
+        const temInicio = ctx.childCount > 0 && ctx.getChild(0).text !== ':';
+        const inicio = temInicio ? this.visit(tests[0]) : '';
+        const fimIdx = temInicio ? 1 : 0;
+        const fim = tests.length > fimIdx ? this.visit(tests[fimIdx]) : '';
+        return `${inicio}..${fim}`;
+    }
+    // Retorna as linhas já indentadas de um bloco, sem os colchetes externos.
+    visitLinhasCorpo(ctx) {
+        const linhas = [];
+        const simpleStmt = ctx.simple_stmt();
+        if (simpleStmt) {
+            linhas.push(`    ${this.visit(simpleStmt)}`);
+        }
+        else {
+            for (const stmt of ctx.stmt()) {
+                const traduzido = this.visit(stmt);
+                for (const linha of traduzido.split('\n')) {
+                    linhas.push(`    ${linha}`);
+                }
+            }
+        }
+        return linhas;
+    }
+    // Traduz um bloco indentado (suite) para o corpo entre chaves de Delégua.
+    visitCorpo(ctx) {
+        return `{\n${this.visitLinhasCorpo(ctx).join('\n')}\n}`;
+    }
+    visitTry_stmt(ctx) {
+        const corpoTente = this.visitCorpo(ctx.suite(0));
+        let resultado = `tente ${corpoTente}`;
+        const excepts = ctx.except_clause();
+        if (excepts.length > 0) {
+            // Detecta alias do erro na primeira cláusula except com `as nome`
+            const alias = excepts.find((e) => e.NAME())?.NAME()?.text;
+            // Junta todos os corpos except num único bloco pegue
+            const todasLinhas = [];
+            for (let i = 0; i < excepts.length; i++) {
+                todasLinhas.push(...this.visitLinhasCorpo(ctx.suite(i + 1)));
+            }
+            const corpoPegue = `{\n${todasLinhas.join('\n')}\n}`;
+            resultado += alias ? ` pegue (${alias}) ${corpoPegue}` : ` pegue ${corpoPegue}`;
+        }
+        // Índice da suite do else/finally começa após as suites de except
+        let suiteIdx = 1 + excepts.length;
+        if (ctx.ELSE()) {
+            suiteIdx++; // else não tem equivalente em Delégua — ignora
+        }
+        if (ctx.FINALLY()) {
+            resultado += ` finalmente ${this.visitCorpo(ctx.suite(suiteIdx))}`;
+        }
+        return resultado;
+    }
+    visitRaise_stmt(ctx) {
+        const tests = ctx.test();
+        if (tests.length === 0)
+            return 'levante';
+        return `levante ${this.visit(tests[0])}`;
+    }
+    visitWith_stmt(ctx) {
+        const linhasCorpo = this.visitLinhasCorpo(ctx.suite());
+        // Apenas itens com `as` podem ser traduzidos para `tendo...como`
+        const itemsComAs = ctx.with_item().filter((item) => item.expr());
+        if (itemsComAs.length === 0) {
+            // Nenhum item com `as`: traduz apenas o corpo, sem tendo
+            return linhasCorpo.map((l) => l.trimStart()).join('\n');
+        }
+        return this.construirTendo(itemsComAs, 0, linhasCorpo);
+    }
+    // Constrói blocos `tendo` aninhados para cada item do `with`.
+    // Items sem `as` são ignorados (Delégua exige um identificador).
+    construirTendo(items, i, linhas) {
+        if (i >= items.length) {
+            return `{\n${linhas.join('\n')}\n}`;
+        }
+        const item = items[i];
+        const varExpr = item.expr();
+        const expr = this.visit(item.test());
+        if (!varExpr) {
+            // Sem `as`: sem variável para ligar — pula este item
+            return this.construirTendo(items, i + 1, linhas);
+        }
+        const nomeVar = this.visit(varExpr);
+        // Para múltiplos itens, o próximo nível é indentado dentro deste bloco
+        let linhasInternas;
+        if (i + 1 < items.length) {
+            const blocoInterno = this.construirTendo(items, i + 1, linhas);
+            linhasInternas = blocoInterno.split('\n').map((l) => `    ${l}`);
+        }
+        else {
+            linhasInternas = linhas;
+        }
+        return `tendo ${expr} como ${nomeVar} {\n${linhasInternas.join('\n')}\n}`;
+    }
+    visitIf_stmt(ctx) {
+        const testes = ctx.test();
+        const suites = ctx.suite();
+        const elifs = ctx.ELIF();
+        // Primeiro bloco: se (cond) { ... }
+        let resultado = `se (${this.visit(testes[0])}) ${this.visitCorpo(suites[0])}`;
+        // Blocos elif: senão se (cond) { ... }
+        for (let i = 0; i < elifs.length; i++) {
+            resultado += ` senão se (${this.visit(testes[i + 1])}) ${this.visitCorpo(suites[i + 1])}`;
+        }
+        // Bloco else: senão { ... }
+        if (ctx.ELSE()) {
+            resultado += ` senão ${this.visitCorpo(suites[suites.length - 1])}`;
+        }
+        return resultado;
+    }
+    visitWhile_stmt(ctx) {
+        const cond = this.visit(ctx.test());
+        const corpo = this.visitCorpo(ctx.suite(0));
+        return `enquanto (${cond}) ${corpo}`;
+    }
+    visitFor_stmt(ctx) {
+        const variavel = this.visit(ctx.exprlist());
+        const iteravel = this.visit(ctx.testlist());
+        const corpo = this.visitCorpo(ctx.suite(0));
+        return `para cada ${variavel} em ${iteravel} ${corpo}`;
+    }
+    visitBreak_stmt(_ctx) {
+        return 'sustar';
+    }
+    visitContinue_stmt(_ctx) {
+        return 'continua';
+    }
+    visitReturn_stmt(ctx) {
+        const testlist = ctx.testlist();
+        if (testlist)
+            return `retorna ${this.visit(testlist)}`;
+        return 'retorna';
+    }
+    visitTfpdef(ctx) {
+        // Ignora anotação de tipo (: Tipo) — retorna apenas o nome
+        return ctx.NAME().text;
+    }
+    visitTypedargslist(ctx) {
+        const params = [];
+        for (let i = 0; i < ctx.childCount;) {
+            const filho = ctx.getChild(i);
+            const texto = filho.text;
+            if (texto === ',') {
+                i++;
+                continue;
+            }
+            // Para em *args ou **kwargs — suporte básico suficiente para fase 4
+            if (texto === '*' || texto === '**')
                 break;
+            const nomeParam = this.visit(filho); // → visitTfpdef → NAME
+            if (nomeParam === 'self') {
+                i++;
+                continue;
+            } // Remove self
+            // Verifica se há valor padrão: tfpdef '=' test
+            if (i + 1 < ctx.childCount && ctx.getChild(i + 1).text === '=') {
+                const valorPadrao = this.visit(ctx.getChild(i + 2));
+                params.push(`${nomeParam} = ${valorPadrao}`);
+                i += 3;
+            }
+            else {
+                params.push(nomeParam);
+                i++;
+            }
         }
+        return params.join(', ');
+    }
+    visitParameters(ctx) {
+        const argslist = ctx.typedargslist();
+        if (!argslist)
+            return '';
+        return this.visitTypedargslist(argslist);
+    }
+    visitFuncdef(ctx) {
+        const nomePython = ctx.NAME().text;
+        const params = this.visitParameters(ctx.parameters());
+        const corpo = this.visitCorpo(ctx.suite());
+        if (nomePython === '__init__') {
+            return `construtor(${params}) ${corpo}`;
+        }
+        return `funcao ${nomePython}(${params}) ${corpo}`;
+    }
+    visitClassdef(ctx) {
+        const nome = ctx.NAME().text;
+        const arglist = ctx.arglist();
+        const heranca = arglist ? ` herda ${this.visit(arglist)}` : '';
+        const corpo = this.visitCorpo(ctx.suite());
+        return `classe ${nome}${heranca} ${corpo}`;
+    }
+    visitDecorated(ctx) {
+        // Ignora decoradores — traduz apenas o funcdef ou classdef subjacente
+        const funcdef = ctx.funcdef();
+        if (funcdef)
+            return this.visitFuncdef(funcdef);
+        const classdef = ctx.classdef();
+        if (classdef)
+            return this.visitClassdef(classdef);
+        return this.visitChildren(ctx);
     }
     traduzir(codigo) {
-        this.inputStream = antlr4ts_1.CharStreams.fromString(codigo);
-        this.lexer = new python3_lexer_1.Python3Lexer(this.inputStream);
-        this.tokenStream = new antlr4ts_1.CommonTokenStream(this.lexer);
-        this.parser = new python3_parser_1.Python3Parser(this.tokenStream);
-        this.resultado = '';
-        // Aqui achei três bons pontos de entrada:
-        // single_input, file_input e eval_input. O que funcionou melhor foi o file_input.
-        let tree = this.parser.file_input();
-        ParseTreeWalker_1.ParseTreeWalker.DEFAULT.walk(this, tree);
-        return this.resultado;
+        // O lexer Python3 do ANTLR exige NEWLINE ao final de cada instrução.
+        const codigoNormalizado = codigo.endsWith('\n') ? codigo : codigo + '\n';
+        const inputStream = antlr4ts_1.CharStreams.fromString(codigoNormalizado);
+        const lexer = new python3_lexer_1.Python3Lexer(inputStream);
+        const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
+        const parser = new python3_parser_1.Python3Parser(tokenStream);
+        const tree = parser.file_input();
+        return this.visit(tree);
     }
 }
 exports.TradutorReversoPython = TradutorReversoPython;
 
-},{"./python/python3-lexer":239,"./python/python3-parser":240,"antlr4ts":371,"antlr4ts/tree/ParseTreeWalker":390}],253:[function(require,module,exports){
+},{"./python/python3-lexer":239,"./python/python3-parser":240,"antlr4ts":371,"antlr4ts/tree/AbstractParseTreeVisitor":389}],253:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -55532,7 +56409,7 @@ __decorate([
 exports.Parser = Parser;
 
 }).call(this)}).call(this,require('_process'))
-},{"./Decorators":269,"./DefaultErrorStrategy":270,"./Lexer":277,"./ProxyParserErrorListener":287,"./Recognizer":289,"./Token":294,"./atn/ATNDeserializationOptions":305,"./atn/ATNDeserializer":306,"./atn/ParseInfo":342,"./atn/ParserATNSimulator":343,"./atn/ProfilingATNSimulator":352,"./misc/IntegerStack":380,"./misc/Utils":388,"./tree/ErrorNode":389,"./tree/TerminalNode":392,"./tree/pattern/ParseTreePatternMatcher":397,"_process":471}],283:[function(require,module,exports){
+},{"./Decorators":269,"./DefaultErrorStrategy":270,"./Lexer":277,"./ProxyParserErrorListener":287,"./Recognizer":289,"./Token":294,"./atn/ATNDeserializationOptions":305,"./atn/ATNDeserializer":306,"./atn/ParseInfo":342,"./atn/ParserATNSimulator":343,"./atn/ProfilingATNSimulator":352,"./misc/IntegerStack":380,"./misc/Utils":388,"./tree/ErrorNode":390,"./tree/TerminalNode":392,"./tree/pattern/ParseTreePatternMatcher":397,"_process":471}],283:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -56249,7 +57126,7 @@ __decorate([
 ], ParserRuleContext.prototype, "sourceInterval", null);
 exports.ParserRuleContext = ParserRuleContext;
 
-},{"./Decorators":269,"./RuleContext":290,"./misc/Interval":381,"./tree/ErrorNode":389,"./tree/TerminalNode":392}],286:[function(require,module,exports){
+},{"./Decorators":269,"./RuleContext":290,"./misc/Interval":381,"./tree/ErrorNode":390,"./tree/TerminalNode":392}],286:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -70471,7 +71348,7 @@ class BitSetIterator {
     [Symbol.iterator]() { return this; }
 }
 
-},{"./MurmurHash":384,"util":477}],377:[function(require,module,exports){
+},{"./MurmurHash":384,"util":476}],377:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -72153,6 +73030,151 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractParseTreeVisitor = void 0;
+const Decorators_1 = require("../Decorators");
+class AbstractParseTreeVisitor {
+    /**
+     * {@inheritDoc}
+     *
+     * The default implementation calls {@link ParseTree#accept} on the
+     * specified tree.
+     */
+    visit(tree) {
+        return tree.accept(this);
+    }
+    /**
+     * {@inheritDoc}
+     *
+     * The default implementation initializes the aggregate result to
+     * {@link #defaultResult defaultResult()}. Before visiting each child, it
+     * calls {@link #shouldVisitNextChild shouldVisitNextChild}; if the result
+     * is `false` no more children are visited and the current aggregate
+     * result is returned. After visiting a child, the aggregate result is
+     * updated by calling {@link #aggregateResult aggregateResult} with the
+     * previous aggregate result and the result of visiting the child.
+     *
+     * The default implementation is not safe for use in visitors that modify
+     * the tree structure. Visitors that modify the tree should override this
+     * method to behave properly in respect to the specific algorithm in use.
+     */
+    visitChildren(node) {
+        let result = this.defaultResult();
+        let n = node.childCount;
+        for (let i = 0; i < n; i++) {
+            if (!this.shouldVisitNextChild(node, result)) {
+                break;
+            }
+            let c = node.getChild(i);
+            let childResult = c.accept(this);
+            result = this.aggregateResult(result, childResult);
+        }
+        return result;
+    }
+    /**
+     * {@inheritDoc}
+     *
+     * The default implementation returns the result of
+     * {@link #defaultResult defaultResult}.
+     */
+    visitTerminal(node) {
+        return this.defaultResult();
+    }
+    /**
+     * {@inheritDoc}
+     *
+     * The default implementation returns the result of
+     * {@link #defaultResult defaultResult}.
+     */
+    visitErrorNode(node) {
+        return this.defaultResult();
+    }
+    /**
+     * Aggregates the results of visiting multiple children of a node. After
+     * either all children are visited or {@link #shouldVisitNextChild} returns
+     * `false`, the aggregate value is returned as the result of
+     * {@link #visitChildren}.
+     *
+     * The default implementation returns `nextResult`, meaning
+     * {@link #visitChildren} will return the result of the last child visited
+     * (or return the initial value if the node has no children).
+     *
+     * @param aggregate The previous aggregate value. In the default
+     * implementation, the aggregate value is initialized to
+     * {@link #defaultResult}, which is passed as the `aggregate` argument
+     * to this method after the first child node is visited.
+     * @param nextResult The result of the immediately preceeding call to visit
+     * a child node.
+     *
+     * @returns The updated aggregate result.
+     */
+    aggregateResult(aggregate, nextResult) {
+        return nextResult;
+    }
+    /**
+     * This method is called after visiting each child in
+     * {@link #visitChildren}. This method is first called before the first
+     * child is visited; at that point `currentResult` will be the initial
+     * value (in the default implementation, the initial value is returned by a
+     * call to {@link #defaultResult}. This method is not called after the last
+     * child is visited.
+     *
+     * The default implementation always returns `true`, indicating that
+     * `visitChildren` should only return after all children are visited.
+     * One reason to override this method is to provide a "short circuit"
+     * evaluation option for situations where the result of visiting a single
+     * child has the potential to determine the result of the visit operation as
+     * a whole.
+     *
+     * @param node The {@link RuleNode} whose children are currently being
+     * visited.
+     * @param currentResult The current aggregate result of the children visited
+     * to the current point.
+     *
+     * @returns `true` to continue visiting children. Otherwise return
+     * `false` to stop visiting children and immediately return the
+     * current aggregate result from {@link #visitChildren}.
+     */
+    shouldVisitNextChild(node, currentResult) {
+        return true;
+    }
+}
+__decorate([
+    Decorators_1.Override,
+    __param(0, Decorators_1.NotNull)
+], AbstractParseTreeVisitor.prototype, "visit", null);
+__decorate([
+    Decorators_1.Override,
+    __param(0, Decorators_1.NotNull)
+], AbstractParseTreeVisitor.prototype, "visitChildren", null);
+__decorate([
+    Decorators_1.Override,
+    __param(0, Decorators_1.NotNull)
+], AbstractParseTreeVisitor.prototype, "visitTerminal", null);
+__decorate([
+    Decorators_1.Override,
+    __param(0, Decorators_1.NotNull)
+], AbstractParseTreeVisitor.prototype, "visitErrorNode", null);
+__decorate([
+    __param(0, Decorators_1.NotNull)
+], AbstractParseTreeVisitor.prototype, "shouldVisitNextChild", null);
+exports.AbstractParseTreeVisitor = AbstractParseTreeVisitor;
+
+},{"../Decorators":269}],390:[function(require,module,exports){
+"use strict";
+/*!
+ * Copyright 2016 The ANTLR Project. All rights reserved.
+ * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorNode = void 0;
 // ConvertTo-TS run at 2016-10-04T11:26:47.4646355-07:00
@@ -72177,112 +73199,7 @@ __decorate([
 ], ErrorNode.prototype, "accept", null);
 exports.ErrorNode = ErrorNode;
 
-},{"../Decorators":269,"./TerminalNode":392}],390:[function(require,module,exports){
-"use strict";
-/*!
- * Copyright 2016 The ANTLR Project. All rights reserved.
- * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParseTreeWalker = void 0;
-const ErrorNode_1 = require("./ErrorNode");
-const TerminalNode_1 = require("./TerminalNode");
-const RuleNode_1 = require("./RuleNode");
-class ParseTreeWalker {
-    /**
-     * Performs a walk on the given parse tree starting at the root and going down recursively
-     * with depth-first search. On each node, {@link ParseTreeWalker#enterRule} is called before
-     * recursively walking down into child nodes, then
-     * {@link ParseTreeWalker#exitRule} is called after the recursive call to wind up.
-     * @param listener The listener used by the walker to process grammar rules
-     * @param t The parse tree to be walked on
-     */
-    walk(listener, t) {
-        let nodeStack = [];
-        let indexStack = [];
-        let currentNode = t;
-        let currentIndex = 0;
-        while (currentNode) {
-            // pre-order visit
-            if (currentNode instanceof ErrorNode_1.ErrorNode) {
-                if (listener.visitErrorNode) {
-                    listener.visitErrorNode(currentNode);
-                }
-            }
-            else if (currentNode instanceof TerminalNode_1.TerminalNode) {
-                if (listener.visitTerminal) {
-                    listener.visitTerminal(currentNode);
-                }
-            }
-            else {
-                this.enterRule(listener, currentNode);
-            }
-            // Move down to first child, if exists
-            if (currentNode.childCount > 0) {
-                nodeStack.push(currentNode);
-                indexStack.push(currentIndex);
-                currentIndex = 0;
-                currentNode = currentNode.getChild(0);
-                continue;
-            }
-            // No child nodes, so walk tree
-            do {
-                // post-order visit
-                if (currentNode instanceof RuleNode_1.RuleNode) {
-                    this.exitRule(listener, currentNode);
-                }
-                // No parent, so no siblings
-                if (nodeStack.length === 0) {
-                    currentNode = undefined;
-                    currentIndex = 0;
-                    break;
-                }
-                // Move to next sibling if possible
-                let last = nodeStack[nodeStack.length - 1];
-                currentIndex++;
-                currentNode = currentIndex < last.childCount ? last.getChild(currentIndex) : undefined;
-                if (currentNode) {
-                    break;
-                }
-                // No next sibling, so move up
-                currentNode = nodeStack.pop();
-                currentIndex = indexStack.pop();
-            } while (currentNode);
-        }
-    }
-    /**
-     * Enters a grammar rule by first triggering the generic event {@link ParseTreeListener#enterEveryRule}
-     * then by triggering the event specific to the given parse tree node
-     * @param listener The listener responding to the trigger events
-     * @param r The grammar rule containing the rule context
-     */
-    enterRule(listener, r) {
-        let ctx = r.ruleContext;
-        if (listener.enterEveryRule) {
-            listener.enterEveryRule(ctx);
-        }
-        ctx.enterRule(listener);
-    }
-    /**
-     * Exits a grammar rule by first triggering the event specific to the given parse tree node
-     * then by triggering the generic event {@link ParseTreeListener#exitEveryRule}
-     * @param listener The listener responding to the trigger events
-     * @param r The grammar rule containing the rule context
-     */
-    exitRule(listener, r) {
-        let ctx = r.ruleContext;
-        ctx.exitRule(listener);
-        if (listener.exitEveryRule) {
-            listener.exitEveryRule(ctx);
-        }
-    }
-}
-exports.ParseTreeWalker = ParseTreeWalker;
-(function (ParseTreeWalker) {
-    ParseTreeWalker.DEFAULT = new ParseTreeWalker();
-})(ParseTreeWalker = exports.ParseTreeWalker || (exports.ParseTreeWalker = {}));
-
-},{"./ErrorNode":389,"./RuleNode":391,"./TerminalNode":392}],391:[function(require,module,exports){
+},{"../Decorators":269,"./TerminalNode":392}],391:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -72630,7 +73547,7 @@ __decorate([
 ], Trees, "getRootOfSubtreeEnclosingRegion", null);
 exports.Trees = Trees;
 
-},{"../CommonToken":265,"../Decorators":269,"../Parser":282,"../ParserRuleContext":285,"../Token":294,"../atn/ATN":302,"../misc/Utils":388,"./ErrorNode":389,"./RuleNode":391,"./TerminalNode":392}],394:[function(require,module,exports){
+},{"../CommonToken":265,"../Decorators":269,"../Parser":282,"../ParserRuleContext":285,"../Token":294,"../atn/ATN":302,"../misc/Utils":388,"./ErrorNode":390,"./RuleNode":391,"./TerminalNode":392}],394:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -77349,7 +78266,7 @@ module.exports = function isTypedArray(value) {
 	return !!whichTypedArray(value);
 };
 
-},{"which-typed-array":478}],457:[function(require,module,exports){
+},{"which-typed-array":477}],457:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./abs')} */
@@ -77957,87 +78874,8 @@ module.exports = function setFunctionLength(fn, length) {
 };
 
 },{"define-data-property":426,"es-errors/type":434,"get-intrinsic":440,"gopd":445,"has-property-descriptors":446}],474:[function(require,module,exports){
-(function (setImmediate,clearImmediate){(function (){
-var nextTick = require('process/browser.js').nextTick;
-var apply = Function.prototype.apply;
-var slice = Array.prototype.slice;
-var immediateIds = {};
-var nextImmediateId = 0;
-
-// DOM APIs, for completeness
-
-exports.setTimeout = function() {
-  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
-};
-exports.setInterval = function() {
-  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
-};
-exports.clearTimeout =
-exports.clearInterval = function(timeout) { timeout.close(); };
-
-function Timeout(id, clearFn) {
-  this._id = id;
-  this._clearFn = clearFn;
-}
-Timeout.prototype.unref = Timeout.prototype.ref = function() {};
-Timeout.prototype.close = function() {
-  this._clearFn.call(window, this._id);
-};
-
-// Does not start the time, just sets up the members needed.
-exports.enroll = function(item, msecs) {
-  clearTimeout(item._idleTimeoutId);
-  item._idleTimeout = msecs;
-};
-
-exports.unenroll = function(item) {
-  clearTimeout(item._idleTimeoutId);
-  item._idleTimeout = -1;
-};
-
-exports._unrefActive = exports.active = function(item) {
-  clearTimeout(item._idleTimeoutId);
-
-  var msecs = item._idleTimeout;
-  if (msecs >= 0) {
-    item._idleTimeoutId = setTimeout(function onTimeout() {
-      if (item._onTimeout)
-        item._onTimeout();
-    }, msecs);
-  }
-};
-
-// That's not how node.js implements it but the exposed api is the same.
-exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) {
-  var id = nextImmediateId++;
-  var args = arguments.length < 2 ? false : slice.call(arguments, 1);
-
-  immediateIds[id] = true;
-
-  nextTick(function onNextTick() {
-    if (immediateIds[id]) {
-      // fn.call() is faster so we optimize for the common use-case
-      // @see http://jsperf.com/call-apply-segu
-      if (args) {
-        fn.apply(null, args);
-      } else {
-        fn.call(null);
-      }
-      // Prevent ids from leaking
-      exports.clearImmediate(id);
-    }
-  });
-
-  return id;
-};
-
-exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) {
-  delete immediateIds[id];
-};
-}).call(this)}).call(this,require("timers").setImmediate,require("timers").clearImmediate)
-},{"process/browser.js":471,"timers":474}],475:[function(require,module,exports){
 arguments[4][414][0].apply(exports,arguments)
-},{"dup":414}],476:[function(require,module,exports){
+},{"dup":414}],475:[function(require,module,exports){
 // Currently in sync with Node.js lib/internal/util/types.js
 // https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9
 
@@ -78373,7 +79211,7 @@ exports.isAnyArrayBuffer = isAnyArrayBuffer;
   });
 });
 
-},{"is-arguments":452,"is-generator-function":454,"is-typed-array":456,"which-typed-array":478}],477:[function(require,module,exports){
+},{"is-arguments":452,"is-generator-function":454,"is-typed-array":456,"which-typed-array":477}],476:[function(require,module,exports){
 (function (process){(function (){
 // Copyright Joyent, Inc. and other Node contributors.
 //
@@ -79092,7 +79930,7 @@ function callbackify(original) {
 exports.callbackify = callbackify;
 
 }).call(this)}).call(this,require('_process'))
-},{"./support/isBuffer":475,"./support/types":476,"_process":471,"inherits":451}],478:[function(require,module,exports){
+},{"./support/isBuffer":474,"./support/types":475,"_process":471,"inherits":451}],477:[function(require,module,exports){
 (function (global){(function (){
 'use strict';