@designliquido/delegua 1.2.0 → 1.3.1

package/tradutores/tradutor-mermaidjs.js

@@ -4,8 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorMermaidJs = void 0;
-const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
+const construtos_1 = require("../construtos");
 const mermaid_1 = require("./mermaid");
+const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
 /**
  * [MermaidJs](https://mermaid.js.org/) é uma especificação que nos permite
  * criar fluxogramas através de uma notação por texto.
@@ -19,249 +20,28 @@ const mermaid_1 = require("./mermaid");
  * @see VerticeFluxograma
  */
 class TradutorMermaidJs {
-    constructor() {
-        this.dicionarioConstrutos = {
-            AcessoIndiceVariavel: this.traduzirConstrutoAcessoIndiceVariavel.bind(this),
-            AcessoMetodo: this.traduzirConstrutoAcessoMetodo.bind(this),
-            AcessoMetodoOuPropriedade: this.traduzirConstrutoAcessoMetodoOuPropriedade.bind(this),
-            AcessoPropriedade: this.traduzirConstrutoAcessoPropriedade.bind(this),
-            Agrupamento: this.traduzirConstrutoAgrupamento.bind(this),
-            Atribuir: this.traduzirConstrutoAtribuir.bind(this),
-            Binario: this.traduzirConstrutoBinario.bind(this),
-            Chamada: this.traduzirConstrutoChamada.bind(this),
-            ComentarioComoConstruto: () => '',
-            DefinirValor: this.traduzirConstrutoDefinirValor.bind(this),
-            Dicionario: this.traduzirConstrutoDicionario.bind(this),
-            // FuncaoConstruto: this.traduzirFuncaoConstruto.bind(this),
-            FuncaoConstruto: () => { throw new Error("Fluxogramas de funções ainda não é suportado."); },
-            Isto: () => 'this',
-            Leia: this.traduzirConstrutoLeia.bind(this),
-            Literal: this.traduzirConstrutoLiteral.bind(this),
-            Separador: this.traduzirConstrutoSeparador.bind(this),
-            Unario: this.traduzirConstrutoUnario.bind(this),
-            Variavel: this.traduzirConstrutoVariavel.bind(this),
-            Vetor: this.traduzirConstrutoVetor.bind(this),
-        };
-        this.dicionarioDeclaracoes = {
-            Bloco: this.traduzirDeclaracaoBloco.bind(this),
-            Classe: this.traduzirDeclaracaoClasse.bind(this),
-            Comentario: () => '',
-            Const: this.traduzirDeclaracaoConst.bind(this),
-            Enquanto: this.traduzirDeclaracaoEnquanto.bind(this),
-            Escolha: this.traduzirDeclaracaoEscolha.bind(this),
-            Expressao: this.traduzirDeclaracaoExpressao.bind(this),
-            Escreva: this.traduzirDeclaracaoEscreva.bind(this),
-            Fazer: this.traduzirDeclaracaoFazerEnquanto.bind(this),
-            FuncaoDeclaracao: this.traduzirDeclaracaoFuncao.bind(this),
-            Para: this.traduzirDeclaracaoPara.bind(this),
-            ParaCada: this.traduzirDeclaracaoParaCada.bind(this),
-            Retorna: this.traduzirDeclaracaoRetorna.bind(this),
-            Se: this.traduzirDeclaracaoSe.bind(this),
-            Var: this.traduzirDeclaracaoVar.bind(this),
-        };
-    }
-    traduzirConstrutoAcessoIndiceVariavel(acessoIndiceVariavel) {
-        const textoIndice = this.dicionarioConstrutos[acessoIndiceVariavel.indice.constructor.name](acessoIndiceVariavel.indice);
-        return `no índice ${textoIndice}`;
-    }
-    traduzirConstrutoAcessoMetodo(acessoMetodo) {
-        return `método ${acessoMetodo.nomeMetodo}`;
-    }
-    traduzirConstrutoAcessoMetodoOuPropriedade(acessoMetodoOuPropriedade) {
-        return `método ou propriedade ${acessoMetodoOuPropriedade.simbolo.lexema}`;
-    }
-    traduzirConstrutoAcessoPropriedade(acessoPropriedade) {
-        return `propriedade ${acessoPropriedade.nomePropriedade}`;
-    }
-    traduzirConstrutoAgrupamento(agrupamento) {
-        return this.dicionarioConstrutos[agrupamento.expressao.constructor.name](agrupamento.expressao);
-    }
-    traduzirConstrutoAtribuir(atribuir) {
-        const textoAlvo = this.dicionarioConstrutos[atribuir.alvo.constructor.name](atribuir.alvo);
-        const textoValor = this.dicionarioConstrutos[atribuir.valor.constructor.name](atribuir.valor);
-        return `${textoAlvo} recebe: ${textoValor}`;
-    }
-    traduzirConstrutoBinario(binario) {
-        const operandoEsquerdo = this.dicionarioConstrutos[binario.esquerda.constructor.name](binario.esquerda);
-        const operandoDireito = this.dicionarioConstrutos[binario.direita.constructor.name](binario.direita);
-        switch (binario.operador.tipo) {
-            case delegua_1.default.ADICAO:
-                return `somar ${operandoEsquerdo} e ${operandoDireito}`;
-            case delegua_1.default.MENOR:
-                return `${operandoEsquerdo} for menor que ${operandoDireito}`;
-        }
-        return '';
-    }
-    traduzirConstrutoChamada(chamada) {
-        const textoEntidadeChamada = this.dicionarioConstrutos[chamada.entidadeChamada.constructor.name](chamada.entidadeChamada);
-        let texto = `chamada a ${textoEntidadeChamada}`;
-        if (chamada.argumentos.length > 0) {
-            texto += `, com argumentos: `;
-            for (const argumento of chamada.argumentos) {
-                const textoArgumento = this.dicionarioConstrutos[argumento.constructor.name](argumento);
-                texto += `${textoArgumento}, `;
-            }
-            texto = texto.slice(0, -2);
-        }
-        else {
-            texto += `, sem argumentos`;
-        }
-        return texto;
-    }
-    /**
-     * Traduz uma declaração de Expressao que contém uma chamada de função,
-     * criando os vértices necessários para conectar ao subgrafo da função.
-     */
-    traduzirChamadaFuncao(declaracaoExpressao, chamada) {
-        // Verifica se é uma chamada a uma função conhecida
-        if (chamada.entidadeChamada.constructor.name === 'Variavel') {
-            const variavel = chamada.entidadeChamada;
-            const nomeFuncao = variavel.simbolo.lexema;
-            if (this.declaracoesFuncoes[nomeFuncao]) {
-                const subgrafo = this.declaracoesFuncoes[nomeFuncao];
-                let vertices = [];
-                // Conecta do fluxo atual para a entrada da função
-                const textoPreChamada = `Linha${declaracaoExpressao.linha}(${this.traduzirConstrutoChamada(chamada)})`;
-                const arestaPreChamada = new mermaid_1.ArestaFluxograma(declaracaoExpressao, textoPreChamada);
-                vertices = vertices.concat(this.logicaComumConexaoArestas(arestaPreChamada));
-                // Conecta a pré-chamada ao início da função
-                vertices.push(new mermaid_1.VerticeFluxograma(arestaPreChamada, subgrafo.arestaInicial));
-                // A saída da função volta para o fluxo principal
-                this.anteriores = [subgrafo.arestaFinal];
-                return vertices;
-            }
-        }
-        // Se não for uma função conhecida, trata como expressão normal
-        return [];
-    }
-    traduzirConstrutoDefinirValor(definirValor) {
-        const textoObjeto = this.dicionarioConstrutos[definirValor.objeto.constructor.name](definirValor.objeto);
-        const textoValor = this.dicionarioConstrutos[definirValor.valor.constructor.name](definirValor.valor);
-        return `${definirValor.nome.lexema} em ${textoObjeto} recebe ${textoValor}`;
+    visitarDeclaracaoCabecalhoPrograma(declaracao) {
+        throw new Error('Método não implementado.');
     }
-    traduzirConstrutoDicionario(dicionario) {
-        let texto = `dicionário`;
-        if (dicionario.chaves.length > 0) {
-            texto += `, com `;
-            for (const [chave, indice] of Object.entries(dicionario.chaves)) {
-                texto += `chave ${chave} definida com o valor ${dicionario.valores[0]}`;
-            }
-        }
-        else {
-            texto += ' vazio';
-        }
-        return texto;
-    }
-    traduzirFuncaoConstruto(funcaoConstruto) {
-        let vertices = [];
-        let arestas = [];
-        if (funcaoConstruto.corpo && funcaoConstruto.corpo.length > 0) {
-            for (const declaracaoCorpo of funcaoConstruto.corpo) {
-                // Usa o mesmo caminho de outras declarações,
-                // então todas as arestas passam por logicaComumConexaoArestas.
-                const verticesCorpo = this.dicionarioDeclaracoes[declaracaoCorpo.constructor.name](declaracaoCorpo);
-                vertices = vertices.concat(verticesCorpo);
-                arestas = arestas.concat(this.anteriores);
-                this.anteriores = [];
-            }
-        }
-        let primeiraAresta = undefined;
-        if (this.anteriores.length > 0) {
-            primeiraAresta = this.anteriores[0];
-            const verticesRestantes = this.logicaComumConexaoArestas(primeiraAresta);
-            console.log(verticesRestantes);
-        }
-        return vertices;
-    }
-    traduzirConstrutoLeia(leia) {
-        let texto = 'leia da entrada';
-        if (leia.argumentos && leia.argumentos.length > 0) {
-            const textoArgumento = this.dicionarioConstrutos[leia.argumentos[0].constructor.name](leia.argumentos[0]);
-            texto += `, imprimindo antes: \\'${textoArgumento}\\'`;
-        }
-        return texto;
-    }
-    traduzirConstrutoLiteral(literal) {
-        switch (literal.tipo) {
-            case 'lógico':
-                return literal.valor ? 'verdadeiro' : 'falso';
-            case 'texto':
-                return `\\'${literal.valor}\\'`;
-            default:
-                return String(literal.valor);
-        }
-    }
-    traduzirConstrutoSeparador(separador) {
-        return `${separador.conteudo} `;
-    }
-    traduzirConstrutoUnario(unario) {
-        const textoOperando = this.dicionarioConstrutos[unario.operando.constructor.name](unario.operando);
-        let textoOperador = '';
-        switch (unario.operador.tipo) {
-            case delegua_1.default.INCREMENTAR:
-                textoOperador = `incrementar ${textoOperando} em 1`;
-                break;
-            case delegua_1.default.DECREMENTAR:
-                textoOperador = `decrementar ${textoOperando} de 1`;
-                break;
-        }
-        switch (unario.incidenciaOperador) {
-            case 'ANTES':
-                return `${textoOperador}, devolver valor de ${textoOperando}`;
-            case 'DEPOIS':
-                return `devolver valor de ${textoOperando}, ${textoOperador}`;
-        }
-    }
-    traduzirConstrutoVariavel(variavel) {
-        return variavel.simbolo.lexema;
-    }
-    traduzirConstrutoVetor(vetor) {
-        let texto = `vetor: `;
-        for (const elemento of vetor.valores) {
-            texto += this.dicionarioConstrutos[elemento.constructor.name](elemento);
-        }
-        return texto;
-    }
-    logicaComumConexaoArestas(aresta) {
-        const vertices = [];
-        while (this.anteriores.length > 0) {
-            const anterior = this.anteriores.shift();
-            let textoVertice = undefined;
-            if (this.ultimaDicaVertice) {
-                textoVertice = String(this.ultimaDicaVertice);
-                this.ultimaDicaVertice = undefined;
-            }
-            vertices.push(new mermaid_1.VerticeFluxograma(anterior, aresta, textoVertice));
-        }
-        return vertices;
-    }
-    traduzirDeclaracaoBloco(declaracaoBloco) {
-        let vertices = [];
-        for (const declaracao of declaracaoBloco.declaracoes) {
-            const verticesDeclaracao = this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao);
-            vertices = vertices.concat(verticesDeclaracao);
-        }
-        return vertices;
-    }
-    traduzirDeclaracaoClasse(declaracaoClasse) {
+    async visitarDeclaracaoClasse(declaracao) {
         var _a, _b;
-        const nomeClasse = declaracaoClasse.simbolo.lexema;
-        const superClasse = declaracaoClasse.superClasse
-            ? (((_a = declaracaoClasse.superClasse.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || ((_b = declaracaoClasse.superClasse.nome) === null || _b === void 0 ? void 0 : _b.lexema))
+        const nomeClasse = declaracao.simbolo.lexema;
+        const superClasse = declaracao.superClasse
+            ? (((_a = declaracao.superClasse.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || ((_b = declaracao.superClasse.nome) === null || _b === void 0 ? void 0 : _b.lexema))
             : undefined;
-        const linha = declaracaoClasse.linha;
+        const linha = declaracao.linha;
         // Cria arestas de entrada e saída para a classe
         const textoInicio = `Classe${nomeClasse}Inicio[Início: Classe ${nomeClasse}]`;
-        const arestaInicial = new mermaid_1.ArestaFluxograma(declaracaoClasse, textoInicio);
+        const arestaInicial = new mermaid_1.ArestaFluxograma(declaracao, textoInicio);
         const textoFim = `Classe${nomeClasse}Fim[Fim: Classe ${nomeClasse}]`;
-        const arestaFinal = new mermaid_1.ArestaFluxograma(declaracaoClasse, textoFim);
+        const arestaFinal = new mermaid_1.ArestaFluxograma(declaracao, textoFim);
         // Cria o subgrafo da classe
         const subgrafo = new mermaid_1.SubgrafoClasse(nomeClasse, linha, arestaInicial, arestaFinal, superClasse);
         // Salva o estado anterior
         const anterioresAntes = [...this.anteriores];
         // Processa métodos
-        if (declaracaoClasse.metodos && declaracaoClasse.metodos.length > 0) {
-            for (const metodoDeclaracao of declaracaoClasse.metodos) {
+        if (declaracao.metodos && declaracao.metodos.length > 0) {
+            for (const metodoDeclaracao of declaracao.metodos) {
                 const nomeMetodo = metodoDeclaracao.simbolo.lexema;
                 const linhaMetodo = metodoDeclaracao.linha;
                 const ehConstrutor = nomeMetodo === 'construtor' || nomeMetodo === 'iniciar';
@@ -276,7 +56,7 @@ class TradutorMermaidJs {
                 this.anteriores = [arestaInicialMetodo];
                 if (metodoDeclaracao.funcao.corpo && metodoDeclaracao.funcao.corpo.length > 0) {
                     for (const declaracaoCorpo of metodoDeclaracao.funcao.corpo) {
-                        const verticesCorpo = this.dicionarioDeclaracoes[declaracaoCorpo.constructor.name](declaracaoCorpo);
+                        const verticesCorpo = await declaracaoCorpo.aceitar(this);
                         subgrafoMetodo.vertices = subgrafoMetodo.vertices.concat(verticesCorpo);
                     }
                 }
@@ -299,73 +79,101 @@ class TradutorMermaidJs {
         this.anteriores = anterioresAntes;
         // Armazena o subgrafo da classe
         this.declaracoesClasses[nomeClasse] = subgrafo;
-        return [];
+        return Promise.resolve([]);
     }
-    traduzirDeclaracaoConst(declaracaoConst) {
-        let texto = `Linha${declaracaoConst.linha}(variável: ${declaracaoConst.simbolo.lexema}`;
-        texto += this.logicaComumTraducaoVarEConst(declaracaoConst, texto);
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoConst, texto);
+    async visitarDeclaracaoComentario(declaracao) {
+        return Promise.resolve('');
+    }
+    async visitarDeclaracaoConst(declaracao) {
+        let texto = `Linha${declaracao.linha}(variável: ${declaracao.simbolo.lexema}`;
+        texto += await this.logicaComumTraducaoVarEConst(declaracao, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
         const vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
-        return vertices;
+        return Promise.resolve(vertices);
+    }
+    visitarDeclaracaoConstMultiplo(declaracao) {
+        throw new Error('Método não implementado.');
     }
-    traduzirDeclaracaoEnquanto(declaracaoEnquanto) {
-        let texto = `Linha${declaracaoEnquanto.linha}(enquanto `;
-        const condicao = this.dicionarioConstrutos[declaracaoEnquanto.condicao.constructor.name](declaracaoEnquanto.condicao);
+    async visitarDeclaracaoDeExpressao(declaracao) {
+        // Verifica se é uma chamada de função
+        if (declaracao.expressao.constructor === construtos_1.Chamada) {
+            const chamada = declaracao.expressao;
+            const verticesChamada = await this.traduzirChamadaFuncao(declaracao, chamada);
+            if (verticesChamada.length > 0) {
+                return Promise.resolve(verticesChamada);
+            }
+        }
+        // Se não for uma chamada de função ou não for uma função conhecida,
+        // trata como expressão normal
+        let texto = `Linha${declaracao.linha}(`;
+        const textoConstruto = await declaracao.expressao.aceitar(this);
+        texto += textoConstruto + ')';
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
+        const vertices = this.logicaComumConexaoArestas(aresta);
+        this.anteriores.push(aresta);
+        return Promise.resolve(vertices);
+    }
+    async visitarDeclaracaoDefinicaoFuncao(declaracao) {
+        const nomeFuncao = declaracao.simbolo.lexema;
+        const linha = declaracao.linha;
+        // Cria arestas de entrada e saída para a função
+        const textoInicio = `Func${nomeFuncao}Inicio[Início: ${nomeFuncao}()]`;
+        const arestaInicial = new mermaid_1.ArestaFluxograma(declaracao, textoInicio);
+        const textoFim = `Func${nomeFuncao}Fim[Fim: ${nomeFuncao}()]`;
+        const arestaFinal = new mermaid_1.ArestaFluxograma(declaracao, textoFim);
+        // Cria o subgrafo da função
+        const subgrafo = new mermaid_1.SubgrafoFuncao(nomeFuncao, linha, arestaInicial, arestaFinal);
+        // Salva o estado atual de anteriores
+        const anterioresAntes = [...this.anteriores];
+        this.anteriores = [arestaInicial];
+        // Processa o corpo da função
+        if (declaracao.funcao.corpo && declaracao.funcao.corpo.length > 0) {
+            for (const declaracaoCorpo of declaracao.funcao.corpo) {
+                const verticesCorpo = await declaracaoCorpo.aceitar(this);
+                subgrafo.vertices = subgrafo.vertices.concat(verticesCorpo);
+            }
+        }
+        // Conecta o fim do corpo à aresta final
+        if (this.anteriores.length > 0) {
+            for (const anterior of this.anteriores) {
+                subgrafo.vertices.push(new mermaid_1.VerticeFluxograma(anterior, arestaFinal));
+            }
+        }
+        // Restaura o estado anterior
+        this.anteriores = anterioresAntes;
+        // Armazena o subgrafo
+        this.declaracoesFuncoes[nomeFuncao] = subgrafo;
+        // Não adiciona ao fluxo principal
+        return Promise.resolve([]);
+    }
+    async visitarDeclaracaoEnquanto(declaracao) {
+        let texto = `Linha${declaracao.linha}(enquanto `;
+        const condicao = await declaracao.condicao.aceitar(this);
         texto += condicao + ')';
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoEnquanto, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
         let vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
         // Corpo, normalmente um `Bloco`.
-        const verticesCorpo = this.dicionarioDeclaracoes[declaracaoEnquanto.corpo.constructor.name](declaracaoEnquanto.corpo);
+        const verticesCorpo = await declaracao.corpo.aceitar(this);
         vertices = vertices.concat(verticesCorpo);
         const ultimaArestaCorpo = verticesCorpo[verticesCorpo.length - 1].destino;
         const verticeLaco = new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, aresta);
         vertices.push(verticeLaco);
-        return vertices;
-    }
-    logicaComumCaminhoEscolha(declaracaoEscolha, caminhoEscolha, linha, textoIdentificadorOuLiteral, caminhoPadrao) {
-        let textoCaso = '';
-        if (!caminhoPadrao) {
-            textoCaso = `caso ${textoIdentificadorOuLiteral} seja igual a `;
-            for (const condicao of caminhoEscolha.condicoes) {
-                const textoCondicao = this.dicionarioConstrutos[condicao.constructor.name](condicao);
-                textoCaso += `${textoCondicao} ou `;
-            }
-            textoCaso = textoCaso.slice(0, -4);
-            textoCaso += ':';
-        }
-        else {
-            textoCaso = `caso ${textoIdentificadorOuLiteral} tenha qualquer outro valor:`;
-        }
-        let textoCaminho = `Linha${linha}(${textoCaso})`;
-        const arestaCondicaoCaminho = new mermaid_1.ArestaFluxograma(declaracaoEscolha, textoCaminho);
-        this.anteriores.push(arestaCondicaoCaminho);
-        let verticesResolvidos = [];
-        for (const declaracaoCaminho of caminhoEscolha.declaracoes) {
-            const verticesDeclaracoes = this.dicionarioDeclaracoes[declaracaoCaminho.constructor.name](declaracaoCaminho);
-            verticesResolvidos = verticesResolvidos.concat(verticesDeclaracoes);
-            this.anteriores.pop();
-            this.anteriores.push(verticesDeclaracoes[verticesDeclaracoes.length - 1].destino);
-        }
-        this.anteriores.pop();
-        return {
-            caminho: arestaCondicaoCaminho,
-            declaracoesCaminho: verticesResolvidos,
-        };
+        return Promise.resolve(vertices);
     }
-    traduzirDeclaracaoEscolha(declaracaoEscolha) {
-        let texto = `Linha${declaracaoEscolha.linha}(escolha um caminho pelo valor de `;
-        const textoIdentificadorOuLiteral = this.dicionarioConstrutos[declaracaoEscolha.identificadorOuLiteral.constructor.name](declaracaoEscolha.identificadorOuLiteral);
+    async visitarDeclaracaoEscolha(declaracao) {
+        let texto = `Linha${declaracao.linha}(escolha um caminho pelo valor de `;
+        const textoIdentificadorOuLiteral = await declaracao.identificadorOuLiteral.aceitar(this);
         texto += textoIdentificadorOuLiteral + ')';
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoEscolha, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
         let vertices = this.logicaComumConexaoArestas(aresta);
         const arestasCaminho = [];
-        for (const caminho of declaracaoEscolha.caminhos) {
-            arestasCaminho.push(this.logicaComumCaminhoEscolha(declaracaoEscolha, caminho, caminho.condicoes[0].linha, textoIdentificadorOuLiteral, false));
+        for (const caminho of declaracao.caminhos) {
+            arestasCaminho.push(await this.logicaComumCaminhoEscolha(declaracao, caminho, caminho.condicoes[0].linha, textoIdentificadorOuLiteral, false));
         }
-        if (declaracaoEscolha.caminhoPadrao) {
-            arestasCaminho.push(this.logicaComumCaminhoEscolha(declaracaoEscolha, declaracaoEscolha.caminhoPadrao, declaracaoEscolha.caminhoPadrao.declaracoes[0].linha - 1, textoIdentificadorOuLiteral, true));
+        if (declaracao.caminhoPadrao) {
+            arestasCaminho.push(await this.logicaComumCaminhoEscolha(declaracao, declaracao.caminhoPadrao, declaracao.caminhoPadrao.declaracoes[0].linha - 1, textoIdentificadorOuLiteral, true));
         }
         for (const conjunto of Object.values(arestasCaminho)) {
             const verticeEscolhaECaminho = new mermaid_1.VerticeFluxograma(aresta, conjunto.caminho);
@@ -373,122 +181,91 @@ class TradutorMermaidJs {
             vertices = vertices.concat(conjunto.declaracoesCaminho);
             this.anteriores.push(conjunto.declaracoesCaminho[conjunto.declaracoesCaminho.length - 1].destino);
         }
-        return vertices;
+        return Promise.resolve(vertices);
     }
-    traduzirDeclaracaoEscreva(declaracaoEscreva) {
-        let texto = `Linha${declaracaoEscreva.linha}(escreva: `;
-        for (const argumento of declaracaoEscreva.argumentos) {
-            const valor = this.dicionarioConstrutos[argumento.constructor.name](argumento);
+    async visitarDeclaracaoEscreva(declaracao) {
+        let texto = `Linha${declaracao.linha}(escreva: `;
+        for (const argumento of declaracao.argumentos) {
+            const valor = await argumento.aceitar(this);
             texto += valor + ', ';
         }
         texto = texto.slice(0, -2);
         texto += ')';
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoEscreva, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
         const vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
-        return vertices;
+        return Promise.resolve(vertices);
     }
-    traduzirDeclaracaoExpressao(declaracaoExpressao) {
-        // Verifica se é uma chamada de função
-        if (declaracaoExpressao.expressao.constructor.name === 'Chamada') {
-            const chamada = declaracaoExpressao.expressao;
-            const verticesChamada = this.traduzirChamadaFuncao(declaracaoExpressao, chamada);
-            if (verticesChamada.length > 0) {
-                return verticesChamada;
-            }
-        }
-        // Se não for uma chamada de função ou não for uma função conhecida,
-        // trata como expressão normal
-        let texto = `Linha${declaracaoExpressao.linha}(`;
-        const textoConstruto = this.dicionarioConstrutos[declaracaoExpressao.expressao.constructor.name](declaracaoExpressao.expressao);
-        texto += textoConstruto + ')';
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoExpressao, texto);
-        const vertices = this.logicaComumConexaoArestas(aresta);
-        this.anteriores.push(aresta);
-        return vertices;
+    visitarDeclaracaoEscrevaMesmaLinha(declaracao) {
+        throw new Error('Método não implementado.');
     }
-    traduzirDeclaracaoFazerEnquanto(declaracaoFazerEnquanto) {
-        const texto = `Linha${declaracaoFazerEnquanto.linha}(fazer)`;
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoFazerEnquanto, texto);
+    async visitarDeclaracaoFazer(declaracao) {
+        const texto = `Linha${declaracao.linha}(fazer)`;
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
         let vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
         // Corpo, normalmente um `Bloco`.
-        const verticesCorpo = this.dicionarioDeclaracoes[declaracaoFazerEnquanto.caminhoFazer.constructor.name](declaracaoFazerEnquanto.caminhoFazer);
+        const verticesCorpo = await declaracao.caminhoFazer.aceitar(this);
         vertices = vertices.concat(verticesCorpo);
         const ultimaArestaCorpo = verticesCorpo[verticesCorpo.length - 1].destino;
-        const condicao = this.dicionarioConstrutos[declaracaoFazerEnquanto.condicaoEnquanto.constructor.name](declaracaoFazerEnquanto.condicaoEnquanto);
-        let textoEnquanto = `Linha${declaracaoFazerEnquanto.condicaoEnquanto.linha}(enquanto ${condicao})`;
-        const arestaEnquanto = new mermaid_1.ArestaFluxograma(declaracaoFazerEnquanto, textoEnquanto);
+        const condicao = await declaracao.condicaoEnquanto.aceitar(this);
+        let textoEnquanto = `Linha${declaracao.condicaoEnquanto.linha}(enquanto ${condicao})`;
+        const arestaEnquanto = new mermaid_1.ArestaFluxograma(declaracao, textoEnquanto);
         const verticeEnquanto = new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, arestaEnquanto);
         vertices.push(verticeEnquanto);
         const verticeCondicaoComFazer = new mermaid_1.VerticeFluxograma(arestaEnquanto, aresta);
         vertices.push(verticeCondicaoComFazer);
         this.anteriores.pop();
         this.anteriores.push(arestaEnquanto);
-        return vertices;
+        return Promise.resolve(vertices);
     }
-    traduzirDeclaracaoFuncao(declaracaoFuncao) {
-        const nomeFuncao = declaracaoFuncao.simbolo.lexema;
-        const linha = declaracaoFuncao.linha;
-        // Cria arestas de entrada e saída para a função
-        const textoInicio = `Func${nomeFuncao}Inicio[Início: ${nomeFuncao}()]`;
-        const arestaInicial = new mermaid_1.ArestaFluxograma(declaracaoFuncao, textoInicio);
-        const textoFim = `Func${nomeFuncao}Fim[Fim: ${nomeFuncao}()]`;
-        const arestaFinal = new mermaid_1.ArestaFluxograma(declaracaoFuncao, textoFim);
-        // Cria o subgrafo da função
-        const subgrafo = new mermaid_1.SubgrafoFuncao(nomeFuncao, linha, arestaInicial, arestaFinal);
-        // Salva o estado atual de anteriores
-        const anterioresAntes = [...this.anteriores];
-        this.anteriores = [arestaInicial];
-        // Processa o corpo da função
-        if (declaracaoFuncao.funcao.corpo && declaracaoFuncao.funcao.corpo.length > 0) {
-            for (const declaracaoCorpo of declaracaoFuncao.funcao.corpo) {
-                const verticesCorpo = this.dicionarioDeclaracoes[declaracaoCorpo.constructor.name](declaracaoCorpo);
-                subgrafo.vertices = subgrafo.vertices.concat(verticesCorpo);
-            }
-        }
-        // Conecta o fim do corpo à aresta final
-        if (this.anteriores.length > 0) {
-            for (const anterior of this.anteriores) {
-                subgrafo.vertices.push(new mermaid_1.VerticeFluxograma(anterior, arestaFinal));
-            }
-        }
-        // Restaura o estado anterior
-        this.anteriores = anterioresAntes;
-        // Armazena o subgrafo
-        this.declaracoesFuncoes[nomeFuncao] = subgrafo;
-        // Não adiciona ao fluxo principal
-        return [];
+    visitarDeclaracaoInicioAlgoritmo(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarDeclaracaoParaCada(declaracao) {
+        const textoVariavelIteracao = await declaracao.variavelIteracao.aceitar(this);
+        let texto = `Linha${declaracao.linha}(para cada ${textoVariavelIteracao} em `;
+        const textoVariavelIterada = await declaracao.vetorOuDicionario.aceitar(this);
+        texto += textoVariavelIterada + ')';
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
+        let vertices = this.logicaComumConexaoArestas(aresta);
+        this.anteriores.push(aresta);
+        // Corpo, normalmente um `Bloco`.
+        const verticesCorpo = await declaracao.corpo.aceitar(this);
+        vertices = vertices.concat(verticesCorpo);
+        const ultimaArestaCorpo = verticesCorpo[verticesCorpo.length - 1].destino;
+        vertices.push(new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, aresta));
+        return Promise.resolve(vertices);
     }
-    traduzirDeclaracaoPara(declaracaoPara) {
-        let texto = `Linha${declaracaoPara.linha}(para `;
-        if (declaracaoPara.inicializador) {
-            for (const declaracaoInicializadora of declaracaoPara.inicializador) {
+    async visitarDeclaracaoPara(declaracao) {
+        let texto = `Linha${declaracao.linha}(para `;
+        if (declaracao.inicializador) {
+            for (const declaracaoInicializadora of declaracao.inicializador) {
                 // Normalmente é `Var`.
                 const declaracaoVar = declaracaoInicializadora;
-                const valorInicializacao = this.dicionarioConstrutos[declaracaoVar.inicializador.constructor.name](declaracaoVar.inicializador);
+                const valorInicializacao = await declaracaoVar.inicializador.aceitar(this);
                 texto += `uma variável ${declaracaoVar.simbolo.lexema} inicializada com ${valorInicializacao}, `;
             }
             texto = texto.slice(0, -2);
         }
         texto += ')';
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoPara, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
         let vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
         // Condição
-        const textoCondicao = this.dicionarioConstrutos[declaracaoPara.condicao.constructor.name](declaracaoPara.condicao);
-        const textoArestaCondicao = `Linha${declaracaoPara.linha}Condicao{se ${textoCondicao}}`;
-        const arestaCondicao = new mermaid_1.ArestaFluxograma(declaracaoPara, textoArestaCondicao);
+        const textoCondicao = await declaracao.condicao.aceitar(this);
+        const textoArestaCondicao = `Linha${declaracao.linha}Condicao{se ${textoCondicao}}`;
+        const arestaCondicao = new mermaid_1.ArestaFluxograma(declaracao, textoArestaCondicao);
         vertices = vertices.concat(this.logicaComumConexaoArestas(arestaCondicao));
         this.anteriores.push(arestaCondicao);
         this.ultimaDicaVertice = 'Sim';
         // Corpo, normalmente um `Bloco`.
-        const verticesCorpo = this.dicionarioDeclaracoes[declaracaoPara.corpo.constructor.name](declaracaoPara.corpo);
+        const verticesCorpo = await declaracao.corpo.aceitar(this);
         vertices = vertices.concat(verticesCorpo);
         // Incremento
         const ultimaArestaCorpo = verticesCorpo[verticesCorpo.length - 1].destino;
-        const textoIncremento = this.dicionarioConstrutos[declaracaoPara.incrementar.constructor.name](declaracaoPara.incrementar);
-        const arestaIncremento = new mermaid_1.ArestaFluxograma(declaracaoPara, `Linha${declaracaoPara.linha}Incremento(${textoIncremento})`);
+        const textoIncremento = await declaracao.incrementar.aceitar(this);
+        const arestaIncremento = new mermaid_1.ArestaFluxograma(declaracao, `Linha${declaracao.linha}Incremento(${textoIncremento})`);
         const verticeIncremento = new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, arestaIncremento);
         vertices.push(verticeIncremento);
         const verticeLaco = new mermaid_1.VerticeFluxograma(arestaIncremento, arestaCondicao);
@@ -497,80 +274,495 @@ class TradutorMermaidJs {
         this.anteriores.pop();
         this.anteriores.push(arestaCondicao);
         this.ultimaDicaVertice = 'Não';
-        return vertices;
+        return Promise.resolve(vertices);
     }
-    traduzirDeclaracaoParaCada(declaracaoParaCada) {
-        const textoVariavelIteracao = this.dicionarioConstrutos[declaracaoParaCada.variavelIteracao.constructor.name](declaracaoParaCada.variavelIteracao);
-        let texto = `Linha${declaracaoParaCada.linha}(para cada ${textoVariavelIteracao} em `;
-        const textoVariavelIterada = this.dicionarioConstrutos[declaracaoParaCada.vetorOuDicionario.constructor.name](declaracaoParaCada.vetorOuDicionario);
-        texto += textoVariavelIterada + ')';
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoParaCada, texto);
-        let vertices = this.logicaComumConexaoArestas(aresta);
-        this.anteriores.push(aresta);
-        // Corpo, normalmente um `Bloco`.
-        const verticesCorpo = this.dicionarioDeclaracoes[declaracaoParaCada.corpo.constructor.name](declaracaoParaCada.corpo);
-        vertices = vertices.concat(verticesCorpo);
-        const ultimaArestaCorpo = verticesCorpo[verticesCorpo.length - 1].destino;
-        vertices.push(new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, aresta));
-        return vertices;
-    }
-    traduzirDeclaracaoSe(declaracaoSe) {
-        let texto = `Linha${declaracaoSe.linha}{se `;
-        const condicao = this.dicionarioConstrutos[declaracaoSe.condicao.constructor.name](declaracaoSe.condicao);
+    async visitarDeclaracaoSe(declaracao) {
+        let texto = `Linha${declaracao.linha}{se `;
+        const condicao = await declaracao.condicao.aceitar(this);
         texto += condicao;
         texto += `}`;
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoSe, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
         let vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
         this.ultimaDicaVertice = 'Sim';
         // Caminho então, normalmente um `Bloco`.
-        const verticesEntao = this.dicionarioDeclaracoes[declaracaoSe.caminhoEntao.constructor.name](declaracaoSe.caminhoEntao);
+        const verticesEntao = await declaracao.caminhoEntao.aceitar(this);
         vertices = vertices.concat(verticesEntao);
-        const ultimaArestaEntao = verticesEntao[verticesEntao.length - 1].destino;
-        if (declaracaoSe.caminhoSenao) {
+        const ultimaArestaEntao = verticesEntao.length > 0
+            ? verticesEntao[verticesEntao.length - 1].destino
+            : aresta;
+        if (declaracao.caminhoSenao) {
             this.anteriores = [];
-            const arestaSenao = new mermaid_1.ArestaFluxograma(declaracaoSe, `Linha${declaracaoSe.caminhoSenao.linha}(senão)`);
+            const arestaSenao = new mermaid_1.ArestaFluxograma(declaracao, `Linha${declaracao.caminhoSenao.linha}(senão)`);
             vertices.push(new mermaid_1.VerticeFluxograma(aresta, arestaSenao, 'Não'));
             this.anteriores.push(arestaSenao);
-            const verticesSenao = this.dicionarioDeclaracoes[declaracaoSe.caminhoSenao.constructor.name](declaracaoSe.caminhoSenao);
+            const verticesSenao = await declaracao.caminhoSenao.aceitar(this);
             vertices = vertices.concat(verticesSenao);
         }
         this.anteriores.push(ultimaArestaEntao);
-        return vertices;
+        return Promise.resolve(vertices);
     }
-    logicaComumTraducaoVarEConst(declaracaoVarOuConst, textoInicial) {
-        if (declaracaoVarOuConst.inicializador) {
-            textoInicial += `, iniciada com: ${this.dicionarioConstrutos[declaracaoVarOuConst.inicializador.constructor.name](declaracaoVarOuConst.inicializador)}`;
+    async visitarDeclaracaoTendoComo(declaracao) {
+        const textoVariavelIteracao = await declaracao.inicializacaoVariavel.aceitar(this);
+        let texto = `Linha${declaracao.linha}(tendo ${textoVariavelIteracao} como `;
+        texto += declaracao.simboloVariavel.lexema + ')';
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
+        let vertices = this.logicaComumConexaoArestas(aresta);
+        this.anteriores.push(aresta);
+        // Corpo, normalmente um `Bloco`.
+        const verticesCorpo = await declaracao.corpo.aceitar(this);
+        vertices = vertices.concat(verticesCorpo);
+        const ultimaArestaCorpo = verticesCorpo[verticesCorpo.length - 1].destino;
+        vertices.push(new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, aresta));
+        return Promise.resolve(vertices);
+    }
+    async visitarDeclaracaoTente(declaracao) {
+        const texto = `Linha${declaracao.linha}(tente)`;
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
+        let vertices = this.logicaComumConexaoArestas(aresta);
+        this.anteriores.push(aresta);
+        // Caminho tente (try)
+        const verticesTente = [];
+        for (const declaracaoTente of declaracao.caminhoTente) {
+            const verticesDeclaracao = await declaracaoTente.aceitar(this);
+            verticesTente.push(...verticesDeclaracao);
+        }
+        vertices = vertices.concat(verticesTente);
+        const ultimaArestaTente = verticesTente.length > 0
+            ? verticesTente[verticesTente.length - 1].destino
+            : aresta;
+        const anterioresAposTente = [];
+        // Caminho pegue (catch) - se existir
+        if (declaracao.caminhoPegue) {
+            this.anteriores = [aresta];
+            const arestaPegue = new mermaid_1.ArestaFluxograma(declaracao, `Linha${declaracao.linha}Pegue(pegue)`);
+            vertices.push(new mermaid_1.VerticeFluxograma(aresta, arestaPegue, 'Erro'));
+            this.anteriores.push(arestaPegue);
+            const verticesPegue = [];
+            if (Array.isArray(declaracao.caminhoPegue)) {
+                for (const declaracaoPegue of declaracao.caminhoPegue) {
+                    const verticesDeclaracao = await declaracaoPegue.aceitar(this);
+                    verticesPegue.push(...verticesDeclaracao);
+                }
+            }
+            vertices = vertices.concat(verticesPegue);
+            const ultimaArestaPegue = verticesPegue.length > 0
+                ? verticesPegue[verticesPegue.length - 1].destino
+                : arestaPegue;
+            anterioresAposTente.push(ultimaArestaPegue);
+        }
+        // Caminho senão (else) - se existir
+        if (declaracao.caminhoSenao && declaracao.caminhoSenao.length > 0) {
+            this.anteriores = [ultimaArestaTente];
+            const arestaSenao = new mermaid_1.ArestaFluxograma(declaracao, `Linha${declaracao.linha}Senao(senão - sem erro)`);
+            vertices.push(new mermaid_1.VerticeFluxograma(ultimaArestaTente, arestaSenao, 'Sucesso'));
+            this.anteriores.push(arestaSenao);
+            const verticesSenao = [];
+            for (const declaracaoSenao of declaracao.caminhoSenao) {
+                const verticesDeclaracao = await declaracaoSenao.aceitar(this);
+                verticesSenao.push(...verticesDeclaracao);
+            }
+            vertices = vertices.concat(verticesSenao);
+            const ultimaArestaSenao = verticesSenao.length > 0
+                ? verticesSenao[verticesSenao.length - 1].destino
+                : arestaSenao;
+            anterioresAposTente.push(ultimaArestaSenao);
         }
-        textoInicial += ')';
-        return textoInicial;
+        else {
+            // Se não há senão, o caminho de sucesso também continua
+            anterioresAposTente.push(ultimaArestaTente);
+        }
+        // Caminho finalmente (finally) - se existir
+        if (declaracao.caminhoFinalmente && declaracao.caminhoFinalmente.length > 0) {
+            this.anteriores = anterioresAposTente;
+            const arestaFinalmente = new mermaid_1.ArestaFluxograma(declaracao, `Linha${declaracao.linha}Finalmente(finalmente)`);
+            vertices = vertices.concat(this.logicaComumConexaoArestas(arestaFinalmente));
+            this.anteriores.push(arestaFinalmente);
+            const verticesFinalmente = [];
+            for (const declaracaoFinalmente of declaracao.caminhoFinalmente) {
+                const verticesDeclaracao = await declaracaoFinalmente.aceitar(this);
+                verticesFinalmente.push(...verticesDeclaracao);
+            }
+            vertices = vertices.concat(verticesFinalmente);
+        }
+        else {
+            // Se não há finalmente, os anteriores são os caminhos após tente
+            this.anteriores = anterioresAposTente;
+        }
+        return Promise.resolve(vertices);
     }
-    traduzirDeclaracaoVar(declaracaoVar) {
-        let texto = `Linha${declaracaoVar.linha}(variável: ${declaracaoVar.simbolo.lexema}`;
-        texto += this.logicaComumTraducaoVarEConst(declaracaoVar, texto);
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoVar, texto);
+    visitarDeclaracaoTextoDocumentacao(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarDeclaracaoVar(declaracao) {
+        let texto = `Linha${declaracao.linha}(variável: ${declaracao.simbolo.lexema}`;
+        texto += await this.logicaComumTraducaoVarEConst(declaracao, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
         const vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
-        return vertices;
+        return Promise.resolve(vertices);
+    }
+    visitarDeclaracaoVarMultiplo(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoDeAtribuicao(expressao) {
+        const textoAlvo = await expressao.alvo.aceitar(this);
+        const textoValor = await expressao.valor.aceitar(this);
+        return Promise.resolve(`${textoAlvo} recebe: ${textoValor}`);
+    }
+    async visitarExpressaoAcessoIndiceVariavel(expressao) {
+        const textoIndice = await expressao.indice.aceitar(this);
+        return Promise.resolve(`no índice ${textoIndice}`);
+    }
+    visitarExpressaoAcessoIntervaloVariavel(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoAcessoElementoMatriz(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoAcessoMetodo(expressao) {
+        return Promise.resolve(`método ${expressao.nomeMetodo}`);
+    }
+    async visitarExpressaoAcessoMetodoOuPropriedade(expressao) {
+        return Promise.resolve(`método ou propriedade ${expressao.simbolo.lexema}`);
+    }
+    async visitarExpressaoAcessoPropriedade(expressao) {
+        return Promise.resolve(`propriedade ${expressao.nomePropriedade}`);
+    }
+    async visitarExpressaoAgrupamento(expressao) {
+        return await expressao.expressao.aceitar(this);
+    }
+    async visitarExpressaoArgumentoReferenciaFuncao(expressao) {
+        const nomeFuncao = expressao.simboloFuncao.lexema;
+        return Promise.resolve(`referência à função ${nomeFuncao}`);
     }
-    traduzirDeclaracaoRetorna(declaracaoRetorna) {
-        let texto = `Linha${declaracaoRetorna.linha}(retorna`;
-        if (declaracaoRetorna.valor) {
-            texto += `: ${this.dicionarioConstrutos[declaracaoRetorna.valor.constructor.name](declaracaoRetorna.valor)}`;
+    async visitarExpressaoAtribuicaoPorIndice(expressao) {
+        const textoObjeto = await expressao.objeto.aceitar(this);
+        const textoIndice = await expressao.indice.aceitar(this);
+        const textoValor = await expressao.valor.aceitar(this);
+        return Promise.resolve(`${textoObjeto} no índice ${textoIndice} recebe: ${textoValor}`);
+    }
+    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoBinaria(expressao) {
+        const operandoEsquerdo = await expressao.esquerda.aceitar(this);
+        const operandoDireito = await expressao.direita.aceitar(this);
+        switch (expressao.operador.tipo) {
+            case delegua_1.default.ADICAO:
+                return Promise.resolve(`somar ${operandoEsquerdo} e ${operandoDireito}`);
+            case delegua_1.default.SUBTRACAO:
+                return Promise.resolve(`subtrair ${operandoDireito} de ${operandoEsquerdo}`);
+            case delegua_1.default.MULTIPLICACAO:
+                return Promise.resolve(`multiplicar ${operandoEsquerdo} por ${operandoDireito}`);
+            case delegua_1.default.DIVISAO:
+                return Promise.resolve(`dividir ${operandoEsquerdo} por ${operandoDireito}`);
+            case delegua_1.default.MODULO:
+                return Promise.resolve(`resto de ${operandoEsquerdo} dividido por ${operandoDireito}`);
+            case delegua_1.default.MENOR:
+                return Promise.resolve(`${operandoEsquerdo} for menor que ${operandoDireito}`);
+            case delegua_1.default.MENOR_IGUAL:
+                return Promise.resolve(`${operandoEsquerdo} for menor ou igual a ${operandoDireito}`);
+            case delegua_1.default.MAIOR:
+                return Promise.resolve(`${operandoEsquerdo} for maior que ${operandoDireito}`);
+            case delegua_1.default.MAIOR_IGUAL:
+                return Promise.resolve(`${operandoEsquerdo} for maior ou igual a ${operandoDireito}`);
+            case delegua_1.default.IGUAL_IGUAL:
+                return Promise.resolve(`${operandoEsquerdo} for igual a ${operandoDireito}`);
+            case delegua_1.default.DIFERENTE:
+                return Promise.resolve(`${operandoEsquerdo} for diferente de ${operandoDireito}`);
+        }
+        return Promise.resolve('');
+    }
+    async visitarExpressaoBloco(bloco) {
+        let vertices = [];
+        for (const declaracao of bloco.declaracoes) {
+            const verticesDeclaracao = await declaracao.aceitar(this);
+            vertices = vertices.concat(verticesDeclaracao);
+        }
+        return Promise.resolve(vertices);
+    }
+    async visitarExpressaoComentario(expressao) {
+        return Promise.resolve('');
+    }
+    async visitarExpressaoContinua(declaracao) {
+        const texto = `Linha${declaracao.linha}(continua)`;
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
+        const vertices = this.logicaComumConexaoArestas(aresta);
+        this.anteriores.push(aresta);
+        return Promise.resolve(vertices);
+    }
+    async visitarExpressaoDeChamada(expressao) {
+        const textoEntidadeChamada = await expressao.entidadeChamada.aceitar(this);
+        let texto = `chamada a ${textoEntidadeChamada}`;
+        if (expressao.argumentos.length > 0) {
+            texto += `, com argumentos: `;
+            for (const argumento of expressao.argumentos) {
+                const textoArgumento = await argumento.aceitar(this);
+                texto += `${textoArgumento}, `;
+            }
+            texto = texto.slice(0, -2);
+        }
+        else {
+            texto += `, sem argumentos`;
+        }
+        return Promise.resolve(texto);
+    }
+    async visitarExpressaoDefinirValor(expressao) {
+        const textoObjeto = await expressao.objeto.aceitar(this);
+        const textoValor = await expressao.valor.aceitar(this);
+        return Promise.resolve(`${expressao.nome.lexema} em ${textoObjeto} recebe ${textoValor}`);
+    }
+    async visitarExpressaoFuncaoConstruto(expressao) {
+        let texto = 'função anônima';
+        if (expressao.parametros && expressao.parametros.length > 0) {
+            const parametros = expressao.parametros.map(p => p.nome.lexema).join(', ');
+            texto += `(${parametros})`;
+        }
+        else {
+            texto += '()';
+        }
+        return Promise.resolve(texto);
+    }
+    async visitarExpressaoDeVariavel(expressao) {
+        return Promise.resolve(expressao.simbolo.lexema);
+    }
+    async visitarExpressaoDicionario(expressao) {
+        let texto = `dicionário`;
+        if (expressao.chaves.length > 0) {
+            texto += `, com `;
+            for (const [chave, indice] of Object.entries(expressao.chaves)) {
+                texto += `chave ${chave} definida com o valor ${expressao.valores[0]}`;
+            }
+        }
+        else {
+            texto += ' vazio';
+        }
+        return Promise.resolve(texto);
+    }
+    async visitarExpressaoExpressaoRegular(expressao) {
+        // Representa a expressão regular como texto para o fluxograma
+        const padraoRegex = expressao.valor ? String(expressao.valor) : expressao.simbolo.lexema;
+        return Promise.resolve(`expressão regular: /${padraoRegex}/`);
+    }
+    async visitarExpressaoFalhar(expressao) {
+        let texto = `Linha${expressao.linha}(falhar`;
+        if (expressao.explicacao) {
+            const textoExplicacao = await expressao.explicacao.aceitar(this);
+            texto += `: ${textoExplicacao}`;
         }
         texto += ')';
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoRetorna, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(expressao, texto);
         const vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
+        return Promise.resolve(vertices);
+    }
+    visitarExpressaoFimPara(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoFormatacaoEscrita(declaracao) {
+        const textoExpressao = await declaracao.expressao.aceitar(this);
+        let formato = textoExpressao;
+        // Adiciona informações de formatação se especificadas
+        const partes = [textoExpressao];
+        if (declaracao.espacos > 0) {
+            partes.push(`${declaracao.espacos} espaços`);
+        }
+        if (declaracao.casasDecimais > 0) {
+            partes.push(`${declaracao.casasDecimais} casas decimais`);
+        }
+        if (partes.length > 1) {
+            formato = `${partes[0]} (${partes.slice(1).join(', ')})`;
+        }
+        return Promise.resolve(formato);
+    }
+    async visitarExpressaoIsto(expressao) {
+        return Promise.resolve('this');
+    }
+    async visitarExpressaoLeia(expressao) {
+        let texto = 'leia da entrada';
+        if (expressao.argumentos && expressao.argumentos.length > 0) {
+            const textoArgumento = await expressao.argumentos[0].aceitar(this);
+            texto += `, imprimindo antes: \\'${textoArgumento}\\'`;
+        }
+        return Promise.resolve(texto);
+    }
+    async visitarExpressaoLiteral(expressao) {
+        switch (expressao.tipo) {
+            case 'lógico':
+                return Promise.resolve(expressao.valor ? 'verdadeiro' : 'falso');
+            case 'texto':
+                return Promise.resolve(`\\'${expressao.valor}\\'`);
+            default:
+                return Promise.resolve(String(expressao.valor));
+        }
+    }
+    async visitarExpressaoLogica(expressao) {
+        const operandoEsquerdo = await expressao.esquerda.aceitar(this);
+        const operandoDireito = await expressao.direita.aceitar(this);
+        switch (expressao.operador.tipo) {
+            case delegua_1.default.E:
+                return Promise.resolve(`${operandoEsquerdo} e ${operandoDireito}`);
+            case delegua_1.default.OU:
+                return Promise.resolve(`${operandoEsquerdo} ou ${operandoDireito}`);
+        }
+        return Promise.resolve('');
+    }
+    async visitarExpressaoReferenciaFuncao(expressao) {
+        const nomeFuncao = expressao.simboloFuncao.lexema;
+        return Promise.resolve(`@${nomeFuncao}`);
+    }
+    async visitarExpressaoRetornar(expressao) {
+        let texto = `Linha${expressao.linha}(retorna`;
+        if (expressao.valor) {
+            texto += `: ${await expressao.valor.aceitar(this)}`;
+        }
+        texto += ')';
+        const aresta = new mermaid_1.ArestaFluxograma(expressao, texto);
+        const vertices = this.logicaComumConexaoArestas(aresta);
+        this.anteriores.push(aresta);
+        return Promise.resolve(vertices);
+    }
+    async visitarExpressaoSeparador(expressao) {
+        return Promise.resolve(`${expressao.conteudo} `);
+    }
+    async visitarExpressaoSuper(expressao) {
+        return Promise.resolve('super');
+    }
+    async visitarExpressaoSustar(declaracao) {
+        const texto = `Linha${declaracao.linha}(sustar)`;
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
+        const vertices = this.logicaComumConexaoArestas(aresta);
+        this.anteriores.push(aresta);
+        return Promise.resolve(vertices);
+    }
+    async visitarExpressaoTupla(expressao) {
+        // Tupla base pode ter um único valor
+        if (expressao.valor !== undefined) {
+            return Promise.resolve(`tupla(${expressao.valor})`);
+        }
+        // Se não houver valor, tupla vazia
+        return Promise.resolve('tupla()');
+    }
+    async visitarExpressaoTuplaN(expressao) {
+        const valores = [];
+        for (const elemento of expressao.elementos) {
+            const valorTraduzido = await elemento.aceitar(this);
+            valores.push(valorTraduzido);
+        }
+        return Promise.resolve(`tupla(${valores.join(', ')})`);
+    }
+    visitarExpressaoTipoDe(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoUnaria(expressao) {
+        const textoOperando = await expressao.operando.aceitar(this);
+        let textoOperador = '';
+        switch (expressao.operador.tipo) {
+            case delegua_1.default.INCREMENTAR:
+                textoOperador = `incrementar ${textoOperando} em 1`;
+                break;
+            case delegua_1.default.DECREMENTAR:
+                textoOperador = `decrementar ${textoOperando} de 1`;
+                break;
+        }
+        switch (expressao.incidenciaOperador) {
+            case 'ANTES':
+                return Promise.resolve(`${textoOperador}, devolver valor de ${textoOperando}`);
+            case 'DEPOIS':
+                return Promise.resolve(`devolver valor de ${textoOperando}, ${textoOperador}`);
+        }
+    }
+    async visitarExpressaoVetor(expressao) {
+        let texto = `vetor: `;
+        for (const elemento of expressao.valores) {
+            texto += await elemento.aceitar(this);
+        }
+        return Promise.resolve(texto);
+    }
+    /**
+     * Traduz uma declaração de Expressao que contém uma chamada de função,
+     * criando os vértices necessários para conectar ao subgrafo da função.
+     */
+    async traduzirChamadaFuncao(declaracaoExpressao, chamada) {
+        // Verifica se é uma chamada a uma função conhecida
+        if (chamada.entidadeChamada.constructor === construtos_1.Variavel) {
+            const variavel = chamada.entidadeChamada;
+            const nomeFuncao = variavel.simbolo.lexema;
+            if (this.declaracoesFuncoes[nomeFuncao]) {
+                const subgrafo = this.declaracoesFuncoes[nomeFuncao];
+                let vertices = [];
+                // Conecta do fluxo atual para a entrada da função
+                const textoPreChamada = `Linha${declaracaoExpressao.linha}(${await chamada.aceitar(this)})`;
+                const arestaPreChamada = new mermaid_1.ArestaFluxograma(declaracaoExpressao, textoPreChamada);
+                vertices = vertices.concat(this.logicaComumConexaoArestas(arestaPreChamada));
+                // Conecta a pré-chamada ao início da função
+                vertices.push(new mermaid_1.VerticeFluxograma(arestaPreChamada, subgrafo.arestaInicial));
+                // A saída da função volta para o fluxo principal
+                this.anteriores = [subgrafo.arestaFinal];
+                return Promise.resolve(vertices);
+            }
+        }
+        // Se não for uma função conhecida, trata como expressão normal
+        return Promise.resolve([]);
+    }
+    logicaComumConexaoArestas(aresta) {
+        const vertices = [];
+        while (this.anteriores.length > 0) {
+            const anterior = this.anteriores.shift();
+            let textoVertice = undefined;
+            if (this.ultimaDicaVertice) {
+                textoVertice = String(this.ultimaDicaVertice);
+                this.ultimaDicaVertice = undefined;
+            }
+            vertices.push(new mermaid_1.VerticeFluxograma(anterior, aresta, textoVertice));
+        }
         return vertices;
     }
+    async logicaComumCaminhoEscolha(declaracaoEscolha, caminhoEscolha, linha, textoIdentificadorOuLiteral, caminhoPadrao) {
+        let textoCaso = '';
+        if (!caminhoPadrao) {
+            textoCaso = `caso ${textoIdentificadorOuLiteral} seja igual a `;
+            for (const condicao of caminhoEscolha.condicoes) {
+                const textoCondicao = await condicao.aceitar(this);
+                textoCaso += `${textoCondicao} ou `;
+            }
+            textoCaso = textoCaso.slice(0, -4);
+            textoCaso += ':';
+        }
+        else {
+            textoCaso = `caso ${textoIdentificadorOuLiteral} tenha qualquer outro valor:`;
+        }
+        let textoCaminho = `Linha${linha}(${textoCaso})`;
+        const arestaCondicaoCaminho = new mermaid_1.ArestaFluxograma(declaracaoEscolha, textoCaminho);
+        this.anteriores.push(arestaCondicaoCaminho);
+        let verticesResolvidos = [];
+        for (const declaracaoCaminho of caminhoEscolha.declaracoes) {
+            const verticesDeclaracoes = await declaracaoCaminho.aceitar(this);
+            verticesResolvidos = verticesResolvidos.concat(verticesDeclaracoes);
+            this.anteriores.pop();
+            this.anteriores.push(verticesDeclaracoes[verticesDeclaracoes.length - 1].destino);
+        }
+        this.anteriores.pop();
+        return Promise.resolve({
+            caminho: arestaCondicaoCaminho,
+            declaracoesCaminho: verticesResolvidos,
+        });
+    }
+    async logicaComumTraducaoVarEConst(declaracaoVarOuConst, textoInicial) {
+        if (declaracaoVarOuConst.inicializador) {
+            textoInicial += `, iniciada com: ${await declaracaoVarOuConst.inicializador.aceitar(this)}`;
+        }
+        textoInicial += ')';
+        return Promise.resolve(textoInicial);
+    }
     /**
      * Ponto de entrada para a tradução de declarações em um fluxograma
      * no formato MermaidJs.
      * @param {Declaracao[]} declaracoes As declarações a serem traduzidas.
      * @returns {string} Texto no formato MermaidJs representando o fluxograma.
      */
-    traduzir(declaracoes) {
+    async traduzir(declaracoes) {
         this.anteriores = [];
         this.vertices = [];
         let resultado = 'graph TD;\n';
@@ -578,7 +770,7 @@ class TradutorMermaidJs {
         this.declaracoesFuncoes = {};
         this.declaracoesClasses = {};
         for (const declaracao of declaracoes) {
-            this.vertices = this.vertices.concat(this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao));
+            this.vertices = this.vertices.concat(await declaracao.aceitar(this));
         }
         // Renderiza os subgrafos de funções
         if (Object.keys(this.declaracoesFuncoes).length > 0) {