@designliquido/delegua 1.2.0 → 1.3.0

package/umd/delegua.js

@@ -3842,7 +3842,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
 }
 exports.AvaliadorSintatico = AvaliadorSintatico;
 
-},{"../bibliotecas/primitivas-dicionario":29,"../bibliotecas/primitivas-numero":30,"../bibliotecas/primitivas-texto":31,"../bibliotecas/primitivas-vetor":32,"../construtos":62,"../construtos/tuplas":80,"../declaracoes":109,"../inferenciador":135,"../informacao-elemento-sintatico":136,"../tipos-de-dados/delegua":207,"../tipos-de-simbolos/delegua":212,"./avaliador-sintatico-base":9,"./comum":11,"./elemento-montao-tipos":19,"./erro-avaliador-sintatico":20,"./informacao-escopo":22,"./montao-tipos":25,"./pilha-escopos":26,"browser-process-hrtime":402}],11:[function(require,module,exports){
+},{"../bibliotecas/primitivas-dicionario":29,"../bibliotecas/primitivas-numero":30,"../bibliotecas/primitivas-texto":31,"../bibliotecas/primitivas-vetor":32,"../construtos":62,"../construtos/tuplas":80,"../declaracoes":109,"../inferenciador":135,"../informacao-elemento-sintatico":136,"../tipos-de-dados/delegua":207,"../tipos-de-simbolos/delegua":212,"./avaliador-sintatico-base":9,"./comum":11,"./elemento-montao-tipos":19,"./erro-avaliador-sintatico":20,"./informacao-escopo":22,"./montao-tipos":25,"./pilha-escopos":26,"browser-process-hrtime":403}],11:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buscarRetornos = buscarRetornos;
@@ -6021,6 +6021,12 @@ class AvaliadorSintaticoPitugues {
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoMapeamento', 'função'),
         ]));
+        this.pilhaEscopos.definirInformacoesVariavel('maximo', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('maximo', 'número', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('minimo', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('minimo', 'número', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
+        ]));
         this.pilhaEscopos.definirInformacoesVariavel('numero', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('número', 'número', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valorParaConverter', 'qualquer'),
         ]));
@@ -6047,6 +6053,9 @@ class AvaliadorSintaticoPitugues {
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoReducao', 'função'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valorInicial', 'qualquer'),
         ]));
+        this.pilhaEscopos.definirInformacoesVariavel('somar', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('somar', 'número', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
+        ]));
         this.pilhaEscopos.definirInformacoesVariavel('tamanho', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tamanho', 'inteiro', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('objeto', 'qualquer'),
         ]));
@@ -6060,14 +6069,8 @@ class AvaliadorSintaticoPitugues {
         this.pilhaEscopos.definirInformacoesVariavel('tupla', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tupla', 'tupla', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
         ]));
-        this.pilhaEscopos.definirInformacoesVariavel('maximo', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('maximo', 'número', true, [
-            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
-        ]));
-        this.pilhaEscopos.definirInformacoesVariavel('minimo', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('minimo', 'número', true, [
-            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
-        ]));
-        this.pilhaEscopos.definirInformacoesVariavel('somar', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('somar', 'número', true, [
-            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
+        this.pilhaEscopos.definirInformacoesVariavel('vetor', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'vetor', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tupla', 'qualquer')
         ]));
     }
     async analisar(retornoLexador, hashArquivo) {
@@ -6118,7 +6121,7 @@ class AvaliadorSintaticoPitugues {
 }
 exports.AvaliadorSintaticoPitugues = AvaliadorSintaticoPitugues;
 
-},{"../../bibliotecas/dialetos/pitugues/primitivas-tupla":28,"../../bibliotecas/primitivas-dicionario":29,"../../bibliotecas/primitivas-numero":30,"../../bibliotecas/primitivas-texto":31,"../../bibliotecas/primitivas-vetor":32,"../../construtos":62,"../../declaracoes":109,"../../inferenciador":135,"../../informacao-elemento-sintatico":136,"../../lexador":197,"../../lexador/micro-lexador-pitugues":202,"../../tipos-de-dados/dialetos/pitugues":208,"../../tipos-de-simbolos/pitugues":216,"../comum":11,"../erro-avaliador-sintatico":20,"../informacao-escopo":22,"../pilha-escopos":26,"./micro-avaliador-sintatico-pitugues":18,"browser-process-hrtime":402}],14:[function(require,module,exports){
+},{"../../bibliotecas/dialetos/pitugues/primitivas-tupla":28,"../../bibliotecas/primitivas-dicionario":29,"../../bibliotecas/primitivas-numero":30,"../../bibliotecas/primitivas-texto":31,"../../bibliotecas/primitivas-vetor":32,"../../construtos":62,"../../declaracoes":109,"../../inferenciador":135,"../../informacao-elemento-sintatico":136,"../../lexador":197,"../../lexador/micro-lexador-pitugues":202,"../../tipos-de-dados/dialetos/pitugues":208,"../../tipos-de-simbolos/pitugues":216,"../comum":11,"../erro-avaliador-sintatico":20,"../informacao-escopo":22,"../pilha-escopos":26,"./micro-avaliador-sintatico-pitugues":18,"browser-process-hrtime":403}],14:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -7042,7 +7045,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
 }
 exports.AvaliadorSintaticoPrisma = AvaliadorSintaticoPrisma;
 
-},{"../../bibliotecas/primitivas-dicionario":29,"../../bibliotecas/primitivas-numero":30,"../../bibliotecas/primitivas-texto":31,"../../bibliotecas/primitivas-vetor":32,"../../construtos":62,"../../declaracoes":109,"../../inferenciador":135,"../../informacao-elemento-sintatico":136,"../../lexador":197,"../../tipos-de-simbolos/prisma":218,"../avaliador-sintatico-base":9,"../comum":11,"../informacao-escopo":22,"../pilha-escopos":26,"browser-process-hrtime":402}],16:[function(require,module,exports){
+},{"../../bibliotecas/primitivas-dicionario":29,"../../bibliotecas/primitivas-numero":30,"../../bibliotecas/primitivas-texto":31,"../../bibliotecas/primitivas-vetor":32,"../../construtos":62,"../../declaracoes":109,"../../inferenciador":135,"../../informacao-elemento-sintatico":136,"../../lexador":197,"../../tipos-de-simbolos/prisma":218,"../avaliador-sintatico-base":9,"../comum":11,"../informacao-escopo":22,"../pilha-escopos":26,"browser-process-hrtime":403}],16:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -8025,7 +8028,7 @@ class AvaliadorSintaticoTenda extends avaliador_sintatico_base_1.AvaliadorSintat
 }
 exports.AvaliadorSintaticoTenda = AvaliadorSintaticoTenda;
 
-},{"../../bibliotecas/primitivas-dicionario":29,"../../bibliotecas/primitivas-numero":30,"../../bibliotecas/primitivas-texto":31,"../../bibliotecas/primitivas-vetor":32,"../../construtos":62,"../../construtos/tuplas":80,"../../declaracoes":109,"../../inferenciador":135,"../../informacao-elemento-sintatico":136,"../../lexador/simbolo":205,"../../tipos-de-dados/delegua":207,"../../tipos-de-simbolos/tenda":219,"../avaliador-sintatico-base":9,"./../erro-avaliador-sintatico":20,"./../informacao-escopo":22,"./../pilha-escopos":26,"browser-process-hrtime":402}],17:[function(require,module,exports){
+},{"../../bibliotecas/primitivas-dicionario":29,"../../bibliotecas/primitivas-numero":30,"../../bibliotecas/primitivas-texto":31,"../../bibliotecas/primitivas-vetor":32,"../../construtos":62,"../../construtos/tuplas":80,"../../declaracoes":109,"../../inferenciador":135,"../../informacao-elemento-sintatico":136,"../../lexador/simbolo":205,"../../tipos-de-dados/delegua":207,"../../tipos-de-simbolos/tenda":219,"../avaliador-sintatico-base":9,"./../erro-avaliador-sintatico":20,"./../informacao-escopo":22,"./../pilha-escopos":26,"browser-process-hrtime":403}],17:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -8860,7 +8863,6 @@ const descritor_tipo_classe_1 = require("../interpretador/estruturas/descritor-t
 const estruturas_1 = require("../interpretador/estruturas");
 const construtos_1 = require("../construtos");
 const quebras_1 = require("../quebras");
-const inferenciador_1 = require("../inferenciador");
 const configTuplas = {
     'Dupla': { Classe: construtos_1.Dupla, props: ['primeiro', 'segundo'] },
     'Trio': { Classe: construtos_1.Trio, props: ['primeiro', 'segundo', 'terceiro'] },
@@ -9783,7 +9785,7 @@ async function todosEmCondicao(interpretador, vetor, funcaoCondicional) {
  * @returns A tupla resolvida.
  */
 async function tupla(interpretador, vetor) {
-    const valorVetor = !Array.isArray(vetor) && vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorVetor = interpretador.resolverValor(vetor);
     // TODO: As lógicas de validação abaixo deixam de fazer sentido com a validação de argumentos feita
     // na avaliação sintática. Estudar remoção.
     if (!Array.isArray(valorVetor)) {
@@ -9792,21 +9794,8 @@ async function tupla(interpretador, vetor) {
             linha: interpretador.linhaDeclaracaoAtual,
         }, 'Argumento de função nativa `tupla` não parece ser um vetor.'));
     }
-    const tamanho = valorVetor.length;
-    if (tamanho < 2) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
-            linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Para ser transformado em uma tupla, vetor precisa ter no mínimo 2 elementos.'));
-    }
-    const criarLiteral = (valor) => new construtos_1.Literal(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, valor, (0, inferenciador_1.inferirTipoVariavel)(valor));
-    if (mapaConstrutoresTupla.hasOwnProperty(tamanho)) {
-        const Construtor = mapaConstrutoresTupla[tamanho];
-        const args = valorVetor.map(criarLiteral);
-        return Promise.resolve(new Construtor(...args));
-    }
-    const elementos = valorVetor.map(criarLiteral);
-    return Promise.resolve(new construtos_1.TuplaN(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, elementos));
+    const elementos = valorVetor.map(item => new construtos_1.Literal(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, interpretador.resolverValor(item)));
+    return new construtos_1.TuplaN(interpretador.hashArquivoDeclaracaoAtual, interpretador.linhaDeclaracaoAtual, elementos);
 }
 async function vetor(interpretador, tupla) {
     const objetoTupla = interpretador.resolverValor(tupla);
@@ -9836,7 +9825,7 @@ async function vetor(interpretador, tupla) {
     return Promise.resolve(resultadoFinal);
 }
 
-},{"../construtos":62,"../excecoes":129,"../inferenciador":135,"../interpretador/estruturas":171,"../interpretador/estruturas/descritor-tipo-classe":169,"../interpretador/estruturas/funcao-padrao":170,"../interpretador/estruturas/objeto-delegua-classe":174,"../quebras":206}],28:[function(require,module,exports){
+},{"../construtos":62,"../excecoes":129,"../interpretador/estruturas":171,"../interpretador/estruturas/descritor-tipo-classe":169,"../interpretador/estruturas/funcao-padrao":170,"../interpretador/estruturas/objeto-delegua-classe":174,"../quebras":206}],28:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const excecoes_1 = require("../../../excecoes");
@@ -15549,6 +15538,7 @@ function carregarBibliotecasGlobais(pilhaEscoposExecucao) {
     pilhaEscoposExecucao.definirVariavel('todos', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.todosEmCondicao));
     pilhaEscoposExecucao.definirVariavel('todosEmCondicao', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.todosEmCondicao));
     pilhaEscoposExecucao.definirVariavel('tupla', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.tupla));
+    pilhaEscoposExecucao.definirVariavel('vetor', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.vetor));
 }
 function pontoEntradaAjuda(funcao, topico) {
     if (!funcao) {
@@ -16659,18 +16649,7 @@ class InterpretadorBase {
         return Promise.resolve();
     }
     async visitarDeclaracaoTendoComo(declaracao) {
-        const retornoInicializacao = await this.avaliar(declaracao.inicializacaoVariavel);
-        const retornoInicializacaoResolvido = this.resolverValor(retornoInicializacao);
-        this.pilhaEscoposExecucao.definirConstante(declaracao.simboloVariavel.lexema, retornoInicializacaoResolvido);
-        await this.executar(declaracao.corpo);
-        if (retornoInicializacao instanceof estruturas_1.ObjetoDeleguaClasse) {
-            const metodoFinalizar = retornoInicializacaoResolvido.classe.metodos['finalizar'];
-            if (metodoFinalizar) {
-                const chamavel = metodoFinalizar.funcaoPorMetodoDeClasse(retornoInicializacaoResolvido);
-                chamavel.chamar(this, []);
-            }
-        }
-        return null;
+        throw new Error('Método não implementado.');
     }
     async visitarDeclaracaoInicioAlgoritmo(declaracao) {
         throw new Error('Método não implementado.');
@@ -18319,7 +18298,7 @@ class InterpretadorBase {
 exports.InterpretadorBase = InterpretadorBase;
 
 }).call(this)}).call(this,require('_process'))
-},{"../avaliador-sintatico":21,"../bibliotecas/primitivas-dicionario":29,"../bibliotecas/primitivas-vetor":32,"../construtos":62,"../excecoes":129,"../inferenciador":135,"../lexador":197,"../quebras":206,"../tipos-de-dados/delegua":207,"../tipos-de-dados/primitivos":209,"../tipos-de-simbolos/delegua":212,"./espaco-memoria":164,"./estruturas":171,"./estruturas/metodo-primitiva":172,"./pilha-escopos-execucao":181,"_process":456,"browser-process-hrtime":402}],179:[function(require,module,exports){
+},{"../avaliador-sintatico":21,"../bibliotecas/primitivas-dicionario":29,"../bibliotecas/primitivas-vetor":32,"../construtos":62,"../excecoes":129,"../inferenciador":135,"../lexador":197,"../quebras":206,"../tipos-de-dados/delegua":207,"../tipos-de-dados/primitivos":209,"../tipos-de-simbolos/delegua":212,"./espaco-memoria":164,"./estruturas":171,"./estruturas/metodo-primitiva":172,"./pilha-escopos-execucao":181,"_process":457,"browser-process-hrtime":403}],179:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -18728,6 +18707,20 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
     async visitarDeclaracaoParaCada(declaracao) {
         return this.logicaComumExecucaoParaCada(declaracao, false);
     }
+    async visitarDeclaracaoTendoComo(declaracao) {
+        const retornoInicializacao = await this.avaliar(declaracao.inicializacaoVariavel);
+        const retornoInicializacaoResolvido = this.resolverValor(retornoInicializacao);
+        this.pilhaEscoposExecucao.definirConstante(declaracao.simboloVariavel.lexema, retornoInicializacaoResolvido);
+        await this.executar(declaracao.corpo);
+        if (retornoInicializacao instanceof estruturas_1.ObjetoDeleguaClasse) {
+            const metodoFinalizar = retornoInicializacaoResolvido.classe.metodos['finalizar'];
+            if (metodoFinalizar) {
+                const chamavel = metodoFinalizar.funcaoPorMetodoDeClasse(retornoInicializacaoResolvido);
+                chamavel.chamar(this, []);
+            }
+        }
+        return null;
+    }
     async visitarExpressaoAcessoIndiceVariavel(expressao) {
         const promises = await Promise.all([
             this.avaliar(expressao.entidadeChamada),
@@ -20935,7 +20928,7 @@ class LexadorPitugues {
 }
 exports.LexadorPitugues = LexadorPitugues;
 
-},{"../../tipos-de-simbolos/pitugues":216,"../simbolo":205,"./palavras-reservadas/pitugues":193,"browser-process-hrtime":402}],187:[function(require,module,exports){
+},{"../../tipos-de-simbolos/pitugues":216,"../simbolo":205,"./palavras-reservadas/pitugues":193,"browser-process-hrtime":403}],187:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -21545,7 +21538,7 @@ class LexadorPrisma {
 }
 exports.LexadorPrisma = LexadorPrisma;
 
-},{"../../tipos-de-simbolos/prisma":218,"../simbolo":205,"./palavras-reservadas/prisma":195,"browser-process-hrtime":402}],189:[function(require,module,exports){
+},{"../../tipos-de-simbolos/prisma":218,"../simbolo":205,"./palavras-reservadas/prisma":195,"browser-process-hrtime":403}],189:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -21936,7 +21929,7 @@ class LexadorTenda {
 }
 exports.LexadorTenda = LexadorTenda;
 
-},{"../../tipos-de-simbolos/tenda":219,"../simbolo":205,"./palavras-reservadas/tenda":196,"browser-process-hrtime":402}],190:[function(require,module,exports){
+},{"../../tipos-de-simbolos/tenda":219,"../simbolo":205,"./palavras-reservadas/tenda":196,"browser-process-hrtime":403}],190:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -22896,7 +22889,7 @@ class Lexador {
 }
 exports.Lexador = Lexador;
 
-},{"../tipos-de-simbolos/delegua":212,"./palavras-reservadas":204,"./simbolo":205,"browser-process-hrtime":402}],201:[function(require,module,exports){
+},{"../tipos-de-simbolos/delegua":212,"./palavras-reservadas":204,"./simbolo":205,"browser-process-hrtime":403}],201:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -24379,6 +24372,7 @@ __exportStar(require("./tradutor-assembly-arm"), exports);
 __exportStar(require("./tradutor-assembly-x64"), exports);
 __exportStar(require("./tradutor-assemblyscript"), exports);
 __exportStar(require("./tradutor-calango"), exports);
+__exportStar(require("./tradutor-elixir"), exports);
 __exportStar(require("./tradutor-javascript"), exports);
 __exportStar(require("./tradutor-mermaidjs"), exports);
 __exportStar(require("./tradutor-portugol-ipt"), exports);
@@ -24388,7 +24382,7 @@ __exportStar(require("./tradutor-reverso-python"), exports);
 __exportStar(require("./tradutor-reverso-tenda"), exports);
 __exportStar(require("./tradutor-ruby"), exports);
 
-},{"./tradutor-assembly-arm":229,"./tradutor-assembly-x64":230,"./tradutor-assemblyscript":231,"./tradutor-calango":232,"./tradutor-javascript":233,"./tradutor-mermaidjs":234,"./tradutor-portugol-ipt":235,"./tradutor-python":236,"./tradutor-reverso-javascript":237,"./tradutor-reverso-python":238,"./tradutor-reverso-tenda":239,"./tradutor-ruby":240}],221:[function(require,module,exports){
+},{"./tradutor-assembly-arm":229,"./tradutor-assembly-x64":230,"./tradutor-assemblyscript":231,"./tradutor-calango":232,"./tradutor-elixir":233,"./tradutor-javascript":234,"./tradutor-mermaidjs":235,"./tradutor-portugol-ipt":236,"./tradutor-python":237,"./tradutor-reverso-javascript":238,"./tradutor-reverso-python":239,"./tradutor-reverso-tenda":240,"./tradutor-ruby":241}],221:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArestaFluxograma = void 0;
@@ -25758,7 +25752,7 @@ __decorate([
     Decorators_1.Override
 ], Python3Lexer.prototype, "nextToken", null);
 
-},{"./python3-parser":228,"antlr4ts/CommonToken":250,"antlr4ts/Decorators":254,"antlr4ts/Lexer":262,"antlr4ts/Token":279,"antlr4ts/VocabularyImpl":285,"antlr4ts/atn/ATNDeserializer":291,"antlr4ts/atn/LexerATNSimulator":312,"antlr4ts/misc/Utils":373}],228:[function(require,module,exports){
+},{"./python3-parser":228,"antlr4ts/CommonToken":251,"antlr4ts/Decorators":255,"antlr4ts/Lexer":263,"antlr4ts/Token":280,"antlr4ts/VocabularyImpl":286,"antlr4ts/atn/ATNDeserializer":292,"antlr4ts/atn/LexerATNSimulator":313,"antlr4ts/misc/Utils":374}],228:[function(require,module,exports){
 "use strict";
 // Generated from fontes\tradutores\python\Python3.g4 by ANTLR 4.9.0-SNAPSHOT
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -37005,7 +36999,7 @@ class Yield_argContext extends ParserRuleContext_1.ParserRuleContext {
 }
 exports.Yield_argContext = Yield_argContext;
 
-},{"antlr4ts/FailedPredicateException":258,"antlr4ts/NoViableAltException":266,"antlr4ts/Parser":267,"antlr4ts/ParserRuleContext":270,"antlr4ts/RecognitionException":273,"antlr4ts/Token":279,"antlr4ts/VocabularyImpl":285,"antlr4ts/atn/ATN":287,"antlr4ts/atn/ATNDeserializer":291,"antlr4ts/atn/ParserATNSimulator":328,"antlr4ts/misc/Utils":373}],229:[function(require,module,exports){
+},{"antlr4ts/FailedPredicateException":259,"antlr4ts/NoViableAltException":267,"antlr4ts/Parser":268,"antlr4ts/ParserRuleContext":271,"antlr4ts/RecognitionException":274,"antlr4ts/Token":280,"antlr4ts/VocabularyImpl":286,"antlr4ts/atn/ATN":288,"antlr4ts/atn/ATNDeserializer":292,"antlr4ts/atn/ParserATNSimulator":329,"antlr4ts/misc/Utils":374}],229:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorAssemblyARM = void 0;
@@ -39085,6 +39079,933 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradutorElixir = void 0;
+const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
+/**
+ * Tradutor que converte código Delégua para Elixir.
+ *
+ * Elixir é uma linguagem funcional, então algumas conversões são necessárias:
+ * - Classes → Módulos com structs
+ * - Métodos → Funções que recebem structs como primeiro parâmetro
+ * - Loops imperativos → Funções recursivas ou Enum.each
+ * - Variables → Bindings imutáveis
+ */
+class TradutorElixir {
+    constructor() {
+        this.indentacaoAtual = 0;
+        this.moduloAtual = null;
+        this.modulosConhecidos = new Set();
+        this.funcoesConhecidas = new Set();
+        this.atributosModulo = new Map();
+        this.dentroDeMetodo = false;
+        this.nomeParametroStruct = null;
+        this.contadorVariavelTemporaria = 0;
+    }
+    /**
+     * Adiciona a indentação atual (Elixir usa 2 espaços por convenção)
+     */
+    adicionarIndentacao() {
+        return ' '.repeat(this.indentacaoAtual);
+    }
+    /**
+     * Aumenta o nível de indentação em 2 espaços
+     */
+    aumentarIndentacao() {
+        this.indentacaoAtual += 2;
+    }
+    /**
+     * Diminui o nível de indentação em 2 espaços
+     */
+    diminuirIndentacao() {
+        this.indentacaoAtual -= 2;
+        if (this.indentacaoAtual < 0) {
+            this.indentacaoAtual = 0;
+        }
+    }
+    /**
+     * Converte identificadores de camelCase para snake_case (convenção Elixir)
+     */
+    converterIdentificador(nome) {
+        return nome
+            .replace(/([A-Z])/g, '_$1')
+            .toLowerCase()
+            .replace(/^_/, '');
+    }
+    /**
+     * Converte nomes de classes/módulos, preservando PascalCase
+     */
+    converterNomeModulo(nome) {
+        return nome.charAt(0).toUpperCase() + nome.slice(1);
+    }
+    /**
+     * Gera nome único para variável temporária
+     */
+    gerarVariavelTemporaria() {
+        return `_temp_${this.contadorVariavelTemporaria++}`;
+    }
+    /**
+     * Mapeia operadores Delégua para Elixir
+     */
+    traduzirOperador(simbolo) {
+        const tipoSimbolo = simbolo.tipo;
+        switch (tipoSimbolo) {
+            // Aritméticos
+            case delegua_1.default.ADICAO:
+                return '+';
+            case delegua_1.default.SUBTRACAO:
+                return '-';
+            case delegua_1.default.MULTIPLICACAO:
+                return '*';
+            case delegua_1.default.DIVISAO:
+                return '/';
+            case delegua_1.default.MODULO:
+                return 'rem';
+            case delegua_1.default.EXPONENCIACAO:
+                return '**';
+            // Comparação
+            case delegua_1.default.MAIOR:
+                return '>';
+            case delegua_1.default.MAIOR_IGUAL:
+                return '>=';
+            case delegua_1.default.MENOR:
+                return '<';
+            case delegua_1.default.MENOR_IGUAL:
+                return '<=';
+            case delegua_1.default.IGUAL_IGUAL:
+                return '==';
+            case delegua_1.default.DIFERENTE:
+                return '!=';
+            // Lógicos
+            case delegua_1.default.E:
+                return 'and';
+            case delegua_1.default.OU:
+                return 'or';
+            case delegua_1.default.NEGACAO:
+                return 'not';
+            // Bitwise
+            case delegua_1.default.BIT_AND:
+                return '&&&';
+            case delegua_1.default.BIT_OR:
+                return '|||';
+            case delegua_1.default.BIT_XOR:
+                return '^^^';
+            case delegua_1.default.BIT_NOT:
+                return '~~~';
+            default:
+                return simbolo.lexema;
+        }
+    }
+    /**
+     * Ponto de entrada para tradução
+     */
+    async traduzir(declaracoes) {
+        let resultado = '';
+        for (const declaracao of declaracoes) {
+            const traducao = await declaracao.aceitar(this);
+            if (traducao) {
+                resultado += traducao + '\n';
+            }
+        }
+        return resultado;
+    }
+    // ========== DECLARAÇÕES ==========
+    visitarDeclaracaoCabecalhoPrograma(declaracao) {
+        // Elixir não tem conceito de cabeçalho de programa
+        return Promise.resolve('');
+    }
+    async visitarDeclaracaoClasse(declaracao) {
+        const nomeModulo = this.converterNomeModulo(declaracao.simbolo.lexema);
+        this.modulosConhecidos.add(nomeModulo);
+        let resultado = this.adicionarIndentacao();
+        resultado += `defmodule ${nomeModulo} do\n`;
+        this.aumentarIndentacao();
+        const moduloAnterior = this.moduloAtual;
+        this.moduloAtual = nomeModulo;
+        // Extrair campos do struct do construtor
+        const camposStruct = await this.extrairCamposStruct(declaracao);
+        if (camposStruct.length > 0) {
+            resultado += this.adicionarIndentacao();
+            resultado += `defstruct [${camposStruct.join(', ')}]\n\n`;
+        }
+        // Traduzir métodos
+        for (const metodo of declaracao.metodos) {
+            const traducaoMetodo = await this.traduzirMetodoClasse(metodo, nomeModulo);
+            resultado += traducaoMetodo + '\n\n';
+        }
+        this.diminuirIndentacao();
+        resultado += this.adicionarIndentacao() + 'end';
+        this.moduloAtual = moduloAnterior;
+        return Promise.resolve(resultado);
+    }
+    /**
+     * Extrai nomes de campos do struct a partir do construtor da classe
+     */
+    async extrairCamposStruct(declaracao) {
+        const campos = new Set();
+        // Procurar pelo construtor
+        const construtor = declaracao.metodos.find(m => m.simbolo.lexema === 'construtor' || m.simbolo.lexema === 'inicializar');
+        if (!construtor) {
+            return [];
+        }
+        // Analisar corpo do construtor para encontrar atribuições a "isto.campo"
+        for (const declaracaoCorpo of construtor.funcao.corpo) {
+            this.extrairCamposDeDeclaracao(declaracaoCorpo, campos);
+        }
+        // Converter para atoms do Elixir
+        return Array.from(campos).map(c => `:${this.converterIdentificador(c)}`);
+    }
+    /**
+     * Extrai campos de uma declaração recursivamente
+     */
+    extrairCamposDeDeclaracao(declaracao, campos) {
+        // Se é uma expressão de atribuição com isto.campo
+        if (declaracao.constructor.name === 'Expressao' && declaracao.expressao) {
+            const expressao = declaracao.expressao;
+            // DefinirValor: usado para isto.campo = valor
+            if (expressao.constructor.name === 'DefinirValor') {
+                if (expressao.objeto && expressao.objeto.constructor.name === 'Isto') {
+                    campos.add(expressao.nome.lexema);
+                }
+            }
+            // Atribuir: pode ser usado para isto.campo = valor
+            if (expressao.constructor.name === 'Atribuir') {
+                // Verificar se o alvo é um acesso a propriedade de isto
+                if (expressao.alvo && expressao.alvo.constructor.name === 'AcessoPropriedade') {
+                    const acesso = expressao.alvo;
+                    if (acesso.objeto && acesso.objeto.constructor.name === 'Isto') {
+                        campos.add(acesso.nomePropriedade);
+                    }
+                }
+            }
+        }
+        // Se é um bloco, processar declarações internas
+        if (declaracao.constructor.name === 'Bloco') {
+            for (const decl of declaracao.declaracoes) {
+                this.extrairCamposDeDeclaracao(decl, campos);
+            }
+        }
+    }
+    /**
+     * Traduz um método de classe para função de módulo
+     */
+    async traduzirMetodoClasse(metodo, nomeModulo) {
+        const nomeMetodo = this.converterIdentificador(metodo.simbolo.lexema);
+        let resultado = this.adicionarIndentacao();
+        // Construtor vira função new/N
+        if (metodo.simbolo.lexema === 'construtor' || metodo.simbolo.lexema === 'inicializar') {
+            resultado += `def new(`;
+            const parametros = metodo.funcao.parametros.map(p => this.converterIdentificador(p.nome.lexema));
+            resultado += parametros.join(', ');
+            resultado += ') do\n';
+            this.aumentarIndentacao();
+            resultado += this.adicionarIndentacao();
+            resultado += `%${nomeModulo}{`;
+            // Extrair inicializações do construtor
+            const inicializacoes = await this.extrairInicializacoesStruct(metodo.funcao.corpo, nomeModulo);
+            resultado += inicializacoes;
+            resultado += '}\n';
+            this.diminuirIndentacao();
+            resultado += this.adicionarIndentacao() + 'end';
+        }
+        else {
+            // Métodos normais recebem o struct como primeiro parâmetro
+            resultado += `def ${nomeMetodo}(`;
+            const nomeParametroStruct = this.converterIdentificador(nomeModulo.toLowerCase());
+            this.nomeParametroStruct = nomeParametroStruct;
+            const parametros = [nomeParametroStruct].concat(metodo.funcao.parametros.map(p => this.converterIdentificador(p.nome.lexema)));
+            resultado += parametros.join(', ');
+            resultado += ') do\n';
+            this.aumentarIndentacao();
+            this.dentroDeMetodo = true;
+            for (const declaracaoCorpo of metodo.funcao.corpo) {
+                const traducao = await declaracaoCorpo.aceitar(this);
+                if (traducao) {
+                    resultado += traducao + '\n';
+                }
+            }
+            this.dentroDeMetodo = false;
+            this.nomeParametroStruct = null;
+            this.diminuirIndentacao();
+            resultado += this.adicionarIndentacao() + 'end';
+        }
+        return resultado;
+    }
+    /**
+     * Extrai inicializações de struct do corpo do construtor
+     */
+    async extrairInicializacoesStruct(corpo, nomeModulo) {
+        const inicializacoes = [];
+        for (const declaracao of corpo) {
+            if (declaracao.constructor.name === 'Expressao' && declaracao.expressao) {
+                const expressao = declaracao.expressao;
+                // DefinirValor: isto.campo = valor
+                if (expressao.constructor.name === 'DefinirValor') {
+                    if (expressao.objeto && expressao.objeto.constructor.name === 'Isto') {
+                        const campo = this.converterIdentificador(expressao.nome.lexema);
+                        const valor = await expressao.valor.aceitar(this);
+                        inicializacoes.push(`${campo}: ${valor}`);
+                    }
+                }
+                // Atribuir: pode ser isto.campo = valor (se alvo é AcessoPropriedade)
+                if (expressao.constructor.name === 'Atribuir') {
+                    if (expressao.alvo && expressao.alvo.constructor.name === 'AcessoPropriedade') {
+                        const acesso = expressao.alvo;
+                        if (acesso.objeto && acesso.objeto.constructor.name === 'Isto') {
+                            const campo = this.converterIdentificador(acesso.nomePropriedade);
+                            const valor = await expressao.valor.aceitar(this);
+                            inicializacoes.push(`${campo}: ${valor}`);
+                        }
+                    }
+                }
+            }
+        }
+        return inicializacoes.length > 0 ? inicializacoes.join(', ') : '';
+    }
+    async visitarDeclaracaoComentario(declaracao) {
+        const conteudo = Array.isArray(declaracao.conteudo)
+            ? declaracao.conteudo.join('\n# ')
+            : declaracao.conteudo;
+        return Promise.resolve(`${this.adicionarIndentacao()}# ${conteudo}`);
+    }
+    async visitarDeclaracaoConst(declaracao) {
+        // Em Elixir, constantes em módulos são atributos de módulo (@constante)
+        // Fora de módulos, são apenas bindings normais (imutáveis por padrão)
+        let resultado = this.adicionarIndentacao();
+        if (this.moduloAtual) {
+            // Dentro de módulo, usar atributo de módulo
+            const nomeAtributo = this.converterIdentificador(declaracao.simbolo.lexema);
+            resultado += `@${nomeAtributo} `;
+        }
+        else {
+            // Fora de módulo, binding normal (mantem nome original em maiúsculas)
+            resultado += declaracao.simbolo.lexema;
+            resultado += ' = ';
+        }
+        if (declaracao.inicializador) {
+            resultado += await declaracao.inicializador.aceitar(this);
+        }
+        else {
+            resultado += 'nil';
+        }
+        return Promise.resolve(resultado);
+    }
+    visitarDeclaracaoConstMultiplo(declaracao) {
+        throw new Error('Método não implementado: visitarDeclaracaoConstMultiplo');
+    }
+    async visitarDeclaracaoDeExpressao(declaracao) {
+        const resultado = this.adicionarIndentacao() + (await declaracao.expressao.aceitar(this));
+        return Promise.resolve(resultado);
+    }
+    async visitarDeclaracaoDefinicaoFuncao(declaracao) {
+        const nomeFuncao = this.converterIdentificador(declaracao.simbolo.lexema);
+        this.funcoesConhecidas.add(nomeFuncao);
+        let resultado = this.adicionarIndentacao();
+        resultado += `def ${nomeFuncao}(`;
+        // Parâmetros
+        const parametros = declaracao.funcao.parametros.map(p => this.converterIdentificador(p.nome.lexema));
+        resultado += parametros.join(', ');
+        resultado += ') do\n';
+        // Corpo
+        this.aumentarIndentacao();
+        for (const declaracaoCorpo of declaracao.funcao.corpo) {
+            const traducao = await declaracaoCorpo.aceitar(this);
+            if (traducao) {
+                resultado += traducao + '\n';
+            }
+        }
+        this.diminuirIndentacao();
+        resultado += this.adicionarIndentacao() + 'end';
+        return Promise.resolve(resultado);
+    }
+    async visitarDeclaracaoEnquanto(declaracao) {
+        // Enquanto em Elixir vira função recursiva
+        // Padrão: (fn -> loop = fn when cond -> corpo; loop.() end; loop = fn -> :ok end; loop.() end).()
+        let resultado = this.adicionarIndentacao();
+        resultado += '(fn ->\n';
+        this.aumentarIndentacao();
+        // Função recursiva com guard
+        resultado += this.adicionarIndentacao();
+        resultado += 'loop = fn when ';
+        resultado += await declaracao.condicao.aceitar(this);
+        resultado += ' ->\n';
+        this.aumentarIndentacao();
+        const traducaoCorpo = await declaracao.corpo.aceitar(this);
+        resultado += traducaoCorpo;
+        // Chamada recursiva
+        resultado += this.adicionarIndentacao() + 'loop.()\n';
+        this.diminuirIndentacao();
+        resultado += this.adicionarIndentacao() + 'end\n';
+        // Caso base
+        resultado += this.adicionarIndentacao() + 'loop = fn -> :ok end\n';
+        resultado += this.adicionarIndentacao() + 'loop.()\n';
+        this.diminuirIndentacao();
+        resultado += this.adicionarIndentacao() + 'end).()';
+        return Promise.resolve(resultado);
+    }
+    async visitarDeclaracaoEscolha(declaracao) {
+        let resultado = this.adicionarIndentacao();
+        resultado += 'case ';
+        resultado += await declaracao.identificadorOuLiteral.aceitar(this);
+        resultado += ' do\n';
+        this.aumentarIndentacao();
+        // Processar cada caminho
+        for (const caminho of declaracao.caminhos) {
+            for (const condicao of caminho.condicoes) {
+                resultado += this.adicionarIndentacao();
+                resultado += await condicao.aceitar(this);
+                resultado += ' ->\n';
+            }
+            this.aumentarIndentacao();
+            for (const decl of caminho.declaracoes) {
+                resultado += await decl.aceitar(this);
+                resultado += '\n';
+            }
+            this.diminuirIndentacao();
+        }
+        // Caminho padrão
+        if (declaracao.caminhoPadrao && declaracao.caminhoPadrao.declaracoes.length > 0) {
+            resultado += this.adicionarIndentacao() + '_ ->\n';
+            this.aumentarIndentacao();
+            for (const decl of declaracao.caminhoPadrao.declaracoes) {
+                resultado += await decl.aceitar(this);
+                resultado += '\n';
+            }
+            this.diminuirIndentacao();
+        }
+        this.diminuirIndentacao();
+        resultado += this.adicionarIndentacao() + 'end';
+        return Promise.resolve(resultado);
+    }
+    async visitarDeclaracaoEscreva(declaracao) {
+        let resultado = this.adicionarIndentacao();
+        resultado += 'IO.puts(';
+        if (declaracao.argumentos.length === 0) {
+            resultado += '""';
+        }
+        else if (declaracao.argumentos.length === 1) {
+            resultado += await declaracao.argumentos[0].aceitar(this);
+        }
+        else {
+            // Múltiplos argumentos - concatenar
+            const argumentos = [];
+            for (const arg of declaracao.argumentos) {
+                argumentos.push(await arg.aceitar(this));
+            }
+            resultado += argumentos.join(' <> ');
+        }
+        resultado += ')';
+        return Promise.resolve(resultado);
+    }
+    visitarDeclaracaoEscrevaMesmaLinha(declaracao) {
+        throw new Error('Método não implementado: visitarDeclaracaoEscrevaMesmaLinha');
+    }
+    async visitarDeclaracaoFazer(declaracao) {
+        // Fazer...enquanto é similar a enquanto, mas executa o corpo pelo menos uma vez
+        let resultado = this.adicionarIndentacao();
+        resultado += '(fn ->\n';
+        this.aumentarIndentacao();
+        resultado += this.adicionarIndentacao();
+        resultado += 'loop = fn ->\n';
+        this.aumentarIndentacao();
+        // Corpo
+        const traducaoCorpo = await declaracao.caminhoFazer.aceitar(this);
+        resultado += traducaoCorpo;
+        // Verificar condição e decidir se continua
+        resultado += this.adicionarIndentacao() + 'if ';
+        resultado += await declaracao.condicaoEnquanto.aceitar(this);
+        resultado += ' do\n';
+        this.aumentarIndentacao();
+        resultado += this.adicionarIndentacao() + 'loop.()\n';
+        this.diminuirIndentacao();
+        resultado += this.adicionarIndentacao() + 'else\n';
+        this.aumentarIndentacao();
+        resultado += this.adicionarIndentacao() + ':ok\n';
+        this.diminuirIndentacao();
+        resultado += this.adicionarIndentacao() + 'end\n';
+        this.diminuirIndentacao();
+        resultado += this.adicionarIndentacao() + 'end\n';
+        resultado += this.adicionarIndentacao() + 'loop.()\n';
+        this.diminuirIndentacao();
+        resultado += this.adicionarIndentacao() + 'end).()';
+        return Promise.resolve(resultado);
+    }
+    visitarDeclaracaoInicioAlgoritmo(declaracao) {
+        // Elixir não tem conceito de início de algoritmo
+        return Promise.resolve('');
+    }
+    async visitarDeclaracaoPara(declaracao) {
+        // Para loop vira função recursiva com inicializador, condição e incremento
+        let resultado = this.adicionarIndentacao();
+        resultado += '(fn ->\n';
+        this.aumentarIndentacao();
+        // Extrair variável e valor inicial
+        let nomeVar = '';
+        let valorInicial = '';
+        if (declaracao.inicializador) {
+            const init = Array.isArray(declaracao.inicializador)
+                ? declaracao.inicializador[0]
+                : declaracao.inicializador;
+            if (init.constructor.name === 'Var') {
+                nomeVar = this.converterIdentificador(init.simbolo.lexema);
+                if (init.inicializador) {
+                    valorInicial = await init.inicializador.aceitar(this);
+                }
+                else {
+                    valorInicial = '0';
+                }
+            }
+        }
+        // Função recursiva com parâmetro e guard
+        resultado += this.adicionarIndentacao();
+        resultado += `loop = fn ${nomeVar} when `;
+        resultado += await declaracao.condicao.aceitar(this);
+        resultado += ' ->\n';
+        this.aumentarIndentacao();
+        const traducaoCorpo = await declaracao.corpo.aceitar(this);
+        resultado += traducaoCorpo;
+        // Incremento e chamada recursiva
+        const incremento = await declaracao.incrementar.aceitar(this);
+        resultado += this.adicionarIndentacao() + `loop.(${incremento})\n`;
+        this.diminuirIndentacao();
+        resultado += this.adicionarIndentacao() + 'end\n';
+        // Caso base
+        resultado += this.adicionarIndentacao() + `loop = fn _ -> :ok end\n`;
+        resultado += this.adicionarIndentacao() + `loop.(${valorInicial})\n`;
+        this.diminuirIndentacao();
+        resultado += this.adicionarIndentacao() + 'end).()';
+        return Promise.resolve(resultado);
+    }
+    async visitarDeclaracaoParaCada(declaracao) {
+        let resultado = this.adicionarIndentacao();
+        resultado += 'Enum.each(';
+        resultado += await declaracao.vetorOuDicionario.aceitar(this);
+        resultado += ', fn ';
+        resultado += await declaracao.variavelIteracao.aceitar(this);
+        resultado += ' ->\n';
+        this.aumentarIndentacao();
+        const traducaoCorpo = await declaracao.corpo.aceitar(this);
+        resultado += traducaoCorpo;
+        this.diminuirIndentacao();
+        resultado += this.adicionarIndentacao() + 'end)';
+        return Promise.resolve(resultado);
+    }
+    async visitarDeclaracaoSe(declaracao) {
+        let resultado = this.adicionarIndentacao();
+        resultado += 'if ';
+        resultado += await declaracao.condicao.aceitar(this);
+        resultado += ' do\n';
+        this.aumentarIndentacao();
+        const traducaoEntao = await declaracao.caminhoEntao.aceitar(this);
+        resultado += traducaoEntao;
+        this.diminuirIndentacao();
+        if (declaracao.caminhoSenao) {
+            resultado += this.adicionarIndentacao() + 'else\n';
+            this.aumentarIndentacao();
+            const traducaoSenao = await declaracao.caminhoSenao.aceitar(this);
+            resultado += traducaoSenao;
+            this.diminuirIndentacao();
+        }
+        resultado += this.adicionarIndentacao() + 'end';
+        return Promise.resolve(resultado);
+    }
+    async visitarDeclaracaoTendoComo(declaracao) {
+        throw new Error('Método não implementado: visitarDeclaracaoTendoComo');
+    }
+    visitarDeclaracaoTente(declaracao) {
+        throw new Error('Método não implementado: visitarDeclaracaoTente');
+    }
+    visitarDeclaracaoTextoDocumentacao(declaracao) {
+        throw new Error('Método não implementado: visitarDeclaracaoTextoDocumentacao');
+    }
+    async visitarDeclaracaoVar(declaracao) {
+        let resultado = this.adicionarIndentacao();
+        resultado += this.converterIdentificador(declaracao.simbolo.lexema);
+        resultado += ' = ';
+        if (declaracao.inicializador) {
+            resultado += await declaracao.inicializador.aceitar(this);
+        }
+        else {
+            resultado += 'nil';
+        }
+        return Promise.resolve(resultado);
+    }
+    visitarDeclaracaoVarMultiplo(declaracao) {
+        throw new Error('Método não implementado: visitarDeclaracaoVarMultiplo');
+    }
+    // ========== EXPRESSÕES ==========
+    async visitarExpressaoDeAtribuicao(expressao) {
+        const alvo = await expressao.alvo.aceitar(this);
+        const valor = await expressao.valor.aceitar(this);
+        return Promise.resolve(`${alvo} = ${valor}`);
+    }
+    async visitarExpressaoAcessoIndiceVariavel(expressao) {
+        const objeto = await expressao.entidadeChamada.aceitar(this);
+        const indice = await expressao.indice.aceitar(this);
+        // Em Elixir, acesso por índice usa Enum.at/2
+        return Promise.resolve(`Enum.at(${objeto}, ${indice})`);
+    }
+    visitarExpressaoAcessoIntervaloVariavel(expressao) {
+        throw new Error('Método não implementado: visitarExpressaoAcessoIntervaloVariavel');
+    }
+    visitarExpressaoAcessoElementoMatriz(expressao) {
+        throw new Error('Método não implementado: visitarExpressaoAcessoElementoMatriz');
+    }
+    async visitarExpressaoAcessoMetodo(expressao) {
+        const objeto = await expressao.objeto.aceitar(this);
+        const metodo = this.converterIdentificador(expressao.nomeMetodo);
+        // AcessoMetodo é apenas a referência ao método, não a chamada
+        // A chamada é feita por visitarExpressaoDeChamada
+        return Promise.resolve(`${objeto}.${metodo}`);
+    }
+    /**
+     * Mapeia métodos built-in de Delégua para Elixir
+     */
+    mapearMetodoBuiltIn(metodo, objeto, argumentos) {
+        switch (metodo) {
+            // Array/List methods
+            case 'adicionar':
+            case 'empilhar':
+                return argumentos.length > 0 ? `[${argumentos[0]} | ${objeto}]` : `${objeto}`;
+            case 'tamanho':
+                return `length(${objeto})`;
+            case 'inclui':
+                return argumentos.length > 0 ? `Enum.member?(${objeto}, ${argumentos[0]})` : null;
+            case 'inverter':
+                return `Enum.reverse(${objeto})`;
+            case 'mapear':
+                return argumentos.length > 0 ? `Enum.map(${objeto}, ${argumentos[0]})` : null;
+            case 'filtrar':
+                return argumentos.length > 0 ? `Enum.filter(${objeto}, ${argumentos[0]})` : null;
+            case 'ordenar':
+                return `Enum.sort(${objeto})`;
+            case 'juntar':
+                return argumentos.length > 0 ? `Enum.join(${objeto}, ${argumentos[0]})` : `Enum.join(${objeto})`;
+            case 'fatiar':
+                if (argumentos.length >= 2) {
+                    return `Enum.slice(${objeto}, ${argumentos[0]}, ${argumentos[1]})`;
+                }
+                return null;
+            case 'remover':
+                return argumentos.length > 0 ? `List.delete(${objeto}, ${argumentos[0]})` : null;
+            case 'somar':
+                return `Enum.sum(${objeto})`;
+            // String methods
+            case 'maiusculo':
+                return `String.upcase(${objeto})`;
+            case 'minusculo':
+                return `String.downcase(${objeto})`;
+            case 'dividir':
+                return argumentos.length > 0 ? `String.split(${objeto}, ${argumentos[0]})` : null;
+            case 'substituir':
+                if (argumentos.length >= 2) {
+                    return `String.replace(${objeto}, ${argumentos[0]}, ${argumentos[1]})`;
+                }
+                return null;
+            case 'aparar':
+                return `String.trim(${objeto})`;
+            default:
+                return null;
+        }
+    }
+    /**
+     * Tenta extrair o nome do módulo de uma expressão de objeto
+     */
+    obterNomeModulo(objetoStr) {
+        // Se o objeto é uma variável simples, assumir que o módulo tem o mesmo nome em PascalCase
+        // Isso é uma heurística; em casos reais, precisaríamos de análise semântica
+        const match = objetoStr.match(/^([a-z_][a-z0-9_]*)$/);
+        if (match) {
+            return this.converterNomeModulo(match[1]);
+        }
+        return objetoStr;
+    }
+    async visitarExpressaoAcessoMetodoOuPropriedade(expressao) {
+        const objeto = await expressao.objeto.aceitar(this);
+        const simbolo = this.converterIdentificador(expressao.simbolo.lexema);
+        // AcessoMetodoOuPropriedade é apenas a referência, não a chamada
+        // A chamada com argumentos é feita por visitarExpressaoDeChamada
+        return Promise.resolve(`${objeto}.${simbolo}`);
+    }
+    async visitarExpressaoAcessoPropriedade(expressao) {
+        const objeto = await expressao.objeto.aceitar(this);
+        const propriedade = this.converterIdentificador(expressao.nomePropriedade);
+        return Promise.resolve(`${objeto}.${propriedade}`);
+    }
+    async visitarExpressaoAgrupamento(expressao) {
+        const conteudo = await expressao.expressao.aceitar(this);
+        return Promise.resolve(`(${conteudo})`);
+    }
+    visitarExpressaoArgumentoReferenciaFuncao(expressao) {
+        throw new Error('Método não implementado: visitarExpressaoArgumentoReferenciaFuncao');
+    }
+    visitarExpressaoAtribuicaoPorIndice(expressao) {
+        throw new Error('Método não implementado: visitarExpressaoAtribuicaoPorIndice');
+    }
+    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao) {
+        throw new Error('Método não implementado: visitarExpressaoAtribuicaoPorIndicesMatriz');
+    }
+    async visitarExpressaoBinaria(expressao) {
+        const esquerda = await expressao.esquerda.aceitar(this);
+        const direita = await expressao.direita.aceitar(this);
+        const operador = this.traduzirOperador(expressao.operador);
+        return Promise.resolve(`${esquerda} ${operador} ${direita}`);
+    }
+    async visitarExpressaoBloco(declaracao) {
+        let resultado = '';
+        for (const decl of declaracao.declaracoes) {
+            const traducao = await decl.aceitar(this);
+            if (traducao) {
+                resultado += traducao + '\n';
+            }
+        }
+        return Promise.resolve(resultado);
+    }
+    visitarExpressaoComentario(expressao) {
+        throw new Error('Método não implementado: visitarExpressaoComentario');
+    }
+    visitarExpressaoContinua(declaracao) {
+        throw new Error('Método não implementado: visitarExpressaoContinua');
+    }
+    async visitarExpressaoDeChamada(expressao) {
+        // Processar argumentos
+        const argumentos = [];
+        for (const arg of expressao.argumentos) {
+            const argTraduzido = await arg.aceitar(this);
+            if (argTraduzido && argTraduzido.trim() !== '') {
+                argumentos.push(argTraduzido);
+            }
+        }
+        // Verificar se é instanciação de módulo (classe)
+        if (expressao.entidadeChamada.constructor.name === 'Variavel') {
+            const nomeEntidade = expressao.entidadeChamada.simbolo.lexema;
+            if (this.modulosConhecidos.has(this.converterNomeModulo(nomeEntidade))) {
+                // Chamada de construtor de módulo
+                return Promise.resolve(`${this.converterNomeModulo(nomeEntidade)}.new(${argumentos.join(', ')})`);
+            }
+        }
+        // Verificar se é chamada de método (AcessoMetodo ou AcessoMetodoOuPropriedade)
+        if (expressao.entidadeChamada.constructor.name === 'AcessoMetodo') {
+            const acessoMetodo = expressao.entidadeChamada;
+            const objeto = await acessoMetodo.objeto.aceitar(this);
+            const metodo = this.converterIdentificador(acessoMetodo.nomeMetodo);
+            // Mapear métodos built-in
+            const metodoMapeado = this.mapearMetodoBuiltIn(metodo, objeto, argumentos);
+            if (metodoMapeado) {
+                return Promise.resolve(metodoMapeado);
+            }
+            // Método de módulo/struct - passar o struct como primeiro argumento
+            return Promise.resolve(`${this.obterNomeModulo(objeto)}.${metodo}(${objeto}${argumentos.length > 0 ? ', ' + argumentos.join(', ') : ''})`);
+        }
+        if (expressao.entidadeChamada.constructor.name === 'AcessoMetodoOuPropriedade') {
+            const acesso = expressao.entidadeChamada;
+            const objeto = await acesso.objeto.aceitar(this);
+            const simbolo = this.converterIdentificador(acesso.simbolo.lexema);
+            // Mapear métodos built-in
+            const metodoMapeado = this.mapearMetodoBuiltIn(simbolo, objeto, argumentos);
+            if (metodoMapeado) {
+                return Promise.resolve(metodoMapeado);
+            }
+            // Método de módulo/struct
+            return Promise.resolve(`${this.obterNomeModulo(objeto)}.${simbolo}(${objeto}${argumentos.length > 0 ? ', ' + argumentos.join(', ') : ''})`);
+        }
+        // Chamada normal de função
+        const entidadeChamada = await expressao.entidadeChamada.aceitar(this);
+        return Promise.resolve(`${entidadeChamada}(${argumentos.join(', ')})`);
+    }
+    visitarExpressaoDefinirValor(expressao) {
+        throw new Error('Método não implementado: visitarExpressaoDefinirValor');
+    }
+    async visitarExpressaoFuncaoConstruto(expressao) {
+        let resultado = 'fn ';
+        // Parâmetros
+        const parametros = expressao.parametros.map(p => this.converterIdentificador(p.nome.lexema));
+        resultado += parametros.join(', ');
+        resultado += ' ->';
+        // Corpo - se for uma única expressão, inline; se for bloco, multi-linha
+        if (expressao.corpo.length === 1) {
+            resultado += ' ';
+            const traducao = await expressao.corpo[0].aceitar(this);
+            resultado += traducao;
+        }
+        else {
+            resultado += '\n';
+            this.aumentarIndentacao();
+            for (const decl of expressao.corpo) {
+                const traducao = await decl.aceitar(this);
+                if (traducao) {
+                    resultado += traducao + '\n';
+                }
+            }
+            this.diminuirIndentacao();
+            resultado += this.adicionarIndentacao();
+        }
+        resultado += ' end';
+        return Promise.resolve(resultado);
+    }
+    async visitarExpressaoDeVariavel(expressao) {
+        return Promise.resolve(this.converterIdentificador(expressao.simbolo.lexema));
+    }
+    async visitarExpressaoDicionario(expressao) {
+        if (expressao.chaves.length === 0) {
+            return Promise.resolve('%{}');
+        }
+        const pares = [];
+        for (let i = 0; i < expressao.chaves.length; i++) {
+            const chave = await expressao.chaves[i].aceitar(this);
+            const valor = await expressao.valores[i].aceitar(this);
+            // Ignorar pares vazios (separadores)
+            if (chave && chave.trim() !== '' && valor && valor.trim() !== '') {
+                // Em Elixir, usa-se atoms (:chave) quando possível ou string => valor
+                // Por simplicidade, vamos usar sempre a sintaxe de string
+                pares.push(`${chave} => ${valor}`);
+            }
+        }
+        return Promise.resolve(`%{${pares.join(', ')}}`);
+    }
+    visitarExpressaoExpressaoRegular(expressao) {
+        throw new Error('Método não implementado: visitarExpressaoExpressaoRegular');
+    }
+    visitarExpressaoFalhar(expressao) {
+        throw new Error('Método não implementado: visitarExpressaoFalhar');
+    }
+    visitarExpressaoFimPara(declaracao) {
+        throw new Error('Método não implementado: visitarExpressaoFimPara');
+    }
+    visitarExpressaoFormatacaoEscrita(declaracao) {
+        throw new Error('Método não implementado: visitarExpressaoFormatacaoEscrita');
+    }
+    async visitarExpressaoIsto(expressao) {
+        // "isto" em Elixir é substituído pelo nome do parâmetro do struct
+        if (this.nomeParametroStruct) {
+            return Promise.resolve(this.nomeParametroStruct);
+        }
+        // Se não estamos em contexto de método, usar nome genérico
+        return Promise.resolve('self');
+    }
+    async visitarExpressaoLeia(expressao) {
+        let resultado = 'IO.gets(';
+        if (expressao.argumentos && expressao.argumentos.length > 0) {
+            resultado += await expressao.argumentos[0].aceitar(this);
+        }
+        else {
+            resultado += '""';
+        }
+        resultado += ') |> String.trim()';
+        return Promise.resolve(resultado);
+    }
+    async visitarExpressaoLiteral(expressao) {
+        const valor = expressao.valor;
+        // Null/nulo
+        if (valor === null || valor === undefined) {
+            return Promise.resolve('nil');
+        }
+        // Boolean
+        if (typeof valor === 'boolean') {
+            return Promise.resolve(valor ? 'true' : 'false');
+        }
+        // Number
+        if (typeof valor === 'number') {
+            return Promise.resolve(String(valor));
+        }
+        // String
+        if (typeof valor === 'string') {
+            // Elixir suporta interpolação com #{}
+            return Promise.resolve(`"${valor}"`);
+        }
+        return Promise.resolve(String(valor));
+    }
+    async visitarExpressaoLogica(expressao) {
+        const esquerda = await expressao.esquerda.aceitar(this);
+        const direita = await expressao.direita.aceitar(this);
+        const operador = this.traduzirOperador(expressao.operador);
+        return Promise.resolve(`${esquerda} ${operador} ${direita}`);
+    }
+    visitarExpressaoReferenciaFuncao(expressao) {
+        throw new Error('Método não implementado: visitarExpressaoReferenciaFuncao');
+    }
+    async visitarExpressaoRetornar(expressao) {
+        // Em Elixir, o retorno é implícito (última expressão)
+        // Mas podemos usar explicitamente para clareza ou retorno antecipado
+        let resultado = this.adicionarIndentacao();
+        if (expressao.valor) {
+            // Apenas retornar o valor, pois em Elixir a última expressão é o retorno
+            resultado += await expressao.valor.aceitar(this);
+        }
+        else {
+            resultado += 'nil';
+        }
+        return Promise.resolve(resultado);
+    }
+    visitarExpressaoSeparador(expressao) {
+        return Promise.resolve('');
+    }
+    visitarExpressaoSuper(expressao) {
+        throw new Error('Método não implementado: visitarExpressaoSuper');
+    }
+    visitarExpressaoSustar(declaracao) {
+        throw new Error('Método não implementado: visitarExpressaoSustar');
+    }
+    async visitarExpressaoTupla(expressao) {
+        // Tupla pode ter apenas um valor (expressao.valor) ou ser TuplaN com elementos
+        // Por enquanto, apenas retornar o valor se houver
+        if (expressao.valor !== undefined) {
+            return Promise.resolve(`{${expressao.valor}}`);
+        }
+        // Se não houver valor, tupla vazia
+        return Promise.resolve('{}');
+    }
+    async visitarExpressaoTuplaN(expressao) {
+        const valores = [];
+        for (const elemento of expressao.elementos) {
+            const valorTraduzido = await elemento.aceitar(this);
+            valores.push(valorTraduzido);
+        }
+        return Promise.resolve(`{${valores.join(', ')}}`);
+    }
+    visitarExpressaoTipoDe(expressao) {
+        throw new Error('Método não implementado: visitarExpressaoTipoDe');
+    }
+    async visitarExpressaoUnaria(expressao) {
+        const operando = await expressao.operando.aceitar(this);
+        const operador = this.traduzirOperador(expressao.operador);
+        // Elixir não tem ++ ou --, então operações de incremento/decremento precisam ser convertidas
+        if (expressao.operador.tipo === delegua_1.default.INCREMENTAR) {
+            return Promise.resolve(`${operando} + 1`);
+        }
+        if (expressao.operador.tipo === delegua_1.default.DECREMENTAR) {
+            return Promise.resolve(`${operando} - 1`);
+        }
+        // Operações unárias normais (-, !, ~)
+        if (expressao.incidenciaOperador === 'ANTES') {
+            return Promise.resolve(`${operador} ${operando}`);
+        }
+        else {
+            return Promise.resolve(`${operando} ${operador}`);
+        }
+    }
+    async visitarExpressaoVetor(expressao) {
+        if (expressao.valores.length === 0) {
+            return Promise.resolve('[]');
+        }
+        const valores = [];
+        for (const valor of expressao.valores) {
+            const valorTraduzido = await valor.aceitar(this);
+            // Ignorar separadores vazios
+            if (valorTraduzido && valorTraduzido.trim() !== '') {
+                valores.push(valorTraduzido);
+            }
+        }
+        return Promise.resolve(`[${valores.join(', ')}]`);
+    }
+}
+exports.TradutorElixir = TradutorElixir;
+
+},{"../tipos-de-simbolos/delegua":212}],234:[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.TradutorJavaScript = void 0;
 const construtos_1 = require("../construtos");
 const declaracoes_1 = require("../declaracoes");
@@ -39839,15 +40760,15 @@ class TradutorJavaScript {
 }
 exports.TradutorJavaScript = TradutorJavaScript;
 
-},{"../construtos":62,"../declaracoes":109,"../tipos-de-simbolos/delegua":212}],234:[function(require,module,exports){
+},{"../construtos":62,"../declaracoes":109,"../tipos-de-simbolos/delegua":212}],235:[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.TradutorMermaidJs = void 0;
-const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
 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.
@@ -39861,249 +40782,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}`;
-    }
-    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;
+    visitarDeclaracaoCabecalhoPrograma(declaracao) {
+        throw new Error('Método não implementado.');
     }
-    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';
@@ -40118,7 +40818,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);
                     }
                 }
@@ -40141,73 +40841,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);
     }
-    traduzirDeclaracaoEnquanto(declaracaoEnquanto) {
-        let texto = `Linha${declaracaoEnquanto.linha}(enquanto `;
-        const condicao = this.dicionarioConstrutos[declaracaoEnquanto.condicao.constructor.name](declaracaoEnquanto.condicao);
+    visitarDeclaracaoConstMultiplo(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarDeclaracaoDeExpressao(declaracao) {
+        // Verifica se é uma chamada de função
+        if (declaracao.expressao.constructor.name === '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;
+        return Promise.resolve(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,
-        };
-    }
-    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);
@@ -40215,122 +40943,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.');
     }
-    traduzirDeclaracaoPara(declaracaoPara) {
-        let texto = `Linha${declaracaoPara.linha}(para `;
-        if (declaracaoPara.inicializador) {
-            for (const declaracaoInicializadora of declaracaoPara.inicializador) {
+    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);
+    }
+    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);
@@ -40339,80 +41036,340 @@ class TradutorMermaidJs {
         this.anteriores.pop();
         this.anteriores.push(arestaCondicao);
         this.ultimaDicaVertice = 'Não';
-        return 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;
+        return Promise.resolve(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) {
+        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)}`;
-        }
-        textoInicial += ')';
-        return textoInicial;
+    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);
     }
-    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);
+    visitarDeclaracaoTente(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    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);
     }
-    traduzirDeclaracaoRetorna(declaracaoRetorna) {
-        let texto = `Linha${declaracaoRetorna.linha}(retorna`;
-        if (declaracaoRetorna.valor) {
-            texto += `: ${this.dicionarioConstrutos[declaracaoRetorna.valor.constructor.name](declaracaoRetorna.valor)}`;
+    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);
+    }
+    visitarExpressaoArgumentoReferenciaFuncao(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoAtribuicaoPorIndice(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    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.MENOR:
+                return Promise.resolve(`${operandoEsquerdo} for menor que ${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('');
+    }
+    visitarExpressaoContinua(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    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}`);
+    }
+    visitarExpressaoFuncaoConstruto(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    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);
+    }
+    visitarExpressaoExpressaoRegular(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoFalhar(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoFimPara(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoFormatacaoEscrita(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    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));
+        }
+    }
+    visitarExpressaoLogica(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoReferenciaFuncao(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    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(declaracaoRetorna, 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} `);
+    }
+    visitarExpressaoSuper(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoSustar(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoTupla(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoTuplaN(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    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.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}(${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';
@@ -40420,7 +41377,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) {
@@ -40463,7 +41420,7 @@ class TradutorMermaidJs {
 }
 exports.TradutorMermaidJs = TradutorMermaidJs;
 
-},{"../tipos-de-simbolos/delegua":212,"./mermaid":222}],235:[function(require,module,exports){
+},{"../tipos-de-simbolos/delegua":212,"./mermaid":222}],236:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorPortugolIpt = void 0;
@@ -40525,7 +41482,7 @@ class TradutorPortugolIpt {
 }
 exports.TradutorPortugolIpt = TradutorPortugolIpt;
 
-},{"../avaliador-sintatico/dialetos":17,"../lexador/dialetos":182}],236:[function(require,module,exports){
+},{"../avaliador-sintatico/dialetos":17,"../lexador/dialetos":182}],237:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -41211,7 +42168,7 @@ class TradutorPython {
 }
 exports.TradutorPython = TradutorPython;
 
-},{"../construtos":62,"../declaracoes":109,"../tipos-de-simbolos/delegua":212}],237:[function(require,module,exports){
+},{"../construtos":62,"../declaracoes":109,"../tipos-de-simbolos/delegua":212}],238:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorReversoJavaScript = void 0;
@@ -41606,7 +42563,7 @@ class TradutorReversoJavaScript {
 }
 exports.TradutorReversoJavaScript = TradutorReversoJavaScript;
 
-},{}],238:[function(require,module,exports){
+},{}],239:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorReversoPython = void 0;
@@ -41679,7 +42636,7 @@ class TradutorReversoPython {
 }
 exports.TradutorReversoPython = TradutorReversoPython;
 
-},{"./python/python3-lexer":227,"./python/python3-parser":228,"antlr4ts":356,"antlr4ts/tree/ParseTreeWalker":375}],239:[function(require,module,exports){
+},{"./python/python3-lexer":227,"./python/python3-parser":228,"antlr4ts":357,"antlr4ts/tree/ParseTreeWalker":376}],240:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -42273,7 +43230,7 @@ class TradutorReversoTenda {
 }
 exports.TradutorReversoTenda = TradutorReversoTenda;
 
-},{"../construtos":62,"../tipos-de-simbolos/tenda":219}],240:[function(require,module,exports){
+},{"../construtos":62,"../tipos-de-simbolos/tenda":219}],241:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -42961,7 +43918,7 @@ class TradutorRuby {
 }
 exports.TradutorRuby = TradutorRuby;
 
-},{"../construtos":62,"../declaracoes":109,"../tipos-de-simbolos/delegua":212}],241:[function(require,module,exports){
+},{"../construtos":62,"../declaracoes":109,"../tipos-de-simbolos/delegua":212}],242:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -42969,7 +43926,7 @@ exports.TradutorRuby = TradutorRuby;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],242:[function(require,module,exports){
+},{}],243:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -42977,7 +43934,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],243:[function(require,module,exports){
+},{}],244:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -43139,7 +44096,7 @@ __decorate([
 ], ANTLRInputStream.prototype, "toString", null);
 exports.ANTLRInputStream = ANTLRInputStream;
 
-},{"./Decorators":254,"./IntStream":260,"assert":397}],244:[function(require,module,exports){
+},{"./Decorators":255,"./IntStream":261,"assert":398}],245:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -43222,7 +44179,7 @@ __decorate([
 ], BailErrorStrategy.prototype, "sync", null);
 exports.BailErrorStrategy = BailErrorStrategy;
 
-},{"./Decorators":254,"./DefaultErrorStrategy":255,"./InputMismatchException":259,"./misc/ParseCancellationException":371}],245:[function(require,module,exports){
+},{"./Decorators":255,"./DefaultErrorStrategy":256,"./InputMismatchException":260,"./misc/ParseCancellationException":372}],246:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -43712,7 +44669,7 @@ BufferedTokenStream = __decorate([
 ], BufferedTokenStream);
 exports.BufferedTokenStream = BufferedTokenStream;
 
-},{"./CommonToken":250,"./Decorators":254,"./Lexer":262,"./Token":279,"./misc/Interval":366,"assert":397}],246:[function(require,module,exports){
+},{"./CommonToken":251,"./Decorators":255,"./Lexer":263,"./Token":280,"./misc/Interval":367,"assert":398}],247:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -43720,7 +44677,7 @@ exports.BufferedTokenStream = BufferedTokenStream;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],247:[function(require,module,exports){
+},{}],248:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -43854,7 +44811,7 @@ var CharStreams;
     // }
 })(CharStreams = exports.CharStreams || (exports.CharStreams = {}));
 
-},{"./CodePointBuffer":248,"./CodePointCharStream":249,"./IntStream":260}],248:[function(require,module,exports){
+},{"./CodePointBuffer":249,"./CodePointCharStream":250,"./IntStream":261}],249:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -44089,7 +45046,7 @@ exports.CodePointBuffer = CodePointBuffer;
     CodePointBuffer.Builder = Builder;
 })(CodePointBuffer = exports.CodePointBuffer || (exports.CodePointBuffer = {}));
 
-},{"./misc/Character":362,"assert":397}],249:[function(require,module,exports){
+},{"./misc/Character":363,"assert":398}],250:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -44239,7 +45196,7 @@ __decorate([
 ], CodePointCharStream.prototype, "getText", null);
 exports.CodePointCharStream = CodePointCharStream;
 
-},{"./Decorators":254,"./IntStream":260,"./misc/Interval":366,"assert":397}],250:[function(require,module,exports){
+},{"./Decorators":255,"./IntStream":261,"./misc/Interval":367,"assert":398}],251:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -44469,7 +45426,7 @@ CommonToken = __decorate([
 ], CommonToken);
 exports.CommonToken = CommonToken;
 
-},{"./Decorators":254,"./Token":279,"./misc/Interval":366}],251:[function(require,module,exports){
+},{"./Decorators":255,"./Token":280,"./misc/Interval":367}],252:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -44533,7 +45490,7 @@ exports.CommonTokenFactory = CommonTokenFactory;
     CommonTokenFactory.DEFAULT = new CommonTokenFactory();
 })(CommonTokenFactory = exports.CommonTokenFactory || (exports.CommonTokenFactory = {}));
 
-},{"./CommonToken":250,"./Decorators":254,"./misc/Interval":366}],252:[function(require,module,exports){
+},{"./CommonToken":251,"./Decorators":255,"./misc/Interval":367}],253:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -44660,7 +45617,7 @@ CommonTokenStream = __decorate([
 ], CommonTokenStream);
 exports.CommonTokenStream = CommonTokenStream;
 
-},{"./BufferedTokenStream":245,"./Decorators":254,"./Token":279}],253:[function(require,module,exports){
+},{"./BufferedTokenStream":246,"./Decorators":255,"./Token":280}],254:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -44694,7 +45651,7 @@ exports.ConsoleErrorListener = ConsoleErrorListener;
  */
 ConsoleErrorListener.INSTANCE = new ConsoleErrorListener();
 
-},{}],254:[function(require,module,exports){
+},{}],255:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -44721,7 +45678,7 @@ function SuppressWarnings(options) {
 }
 exports.SuppressWarnings = SuppressWarnings;
 
-},{}],255:[function(require,module,exports){
+},{}],256:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -45535,7 +46492,7 @@ __decorate([
 ], DefaultErrorStrategy.prototype, "consumeUntil", null);
 exports.DefaultErrorStrategy = DefaultErrorStrategy;
 
-},{"./Decorators":254,"./FailedPredicateException":258,"./InputMismatchException":259,"./NoViableAltException":266,"./Token":279,"./atn/ATNState":293,"./atn/ATNStateType":294,"./atn/PredictionContext":334,"./misc/IntervalSet":367}],256:[function(require,module,exports){
+},{"./Decorators":255,"./FailedPredicateException":259,"./InputMismatchException":260,"./NoViableAltException":267,"./Token":280,"./atn/ATNState":294,"./atn/ATNStateType":295,"./atn/PredictionContext":335,"./misc/IntervalSet":368}],257:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -45611,7 +46568,7 @@ var Dependents;
     Dependents[Dependents["FOLLOWING"] = 9] = "FOLLOWING";
 })(Dependents = exports.Dependents || (exports.Dependents = {}));
 
-},{}],257:[function(require,module,exports){
+},{}],258:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -45759,7 +46716,7 @@ __decorate([
 ], DiagnosticErrorListener.prototype, "getConflictingAlts", null);
 exports.DiagnosticErrorListener = DiagnosticErrorListener;
 
-},{"./Decorators":254,"./misc/BitSet":361,"./misc/Interval":366}],258:[function(require,module,exports){
+},{"./Decorators":255,"./misc/BitSet":362,"./misc/Interval":367}],259:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -45824,7 +46781,7 @@ FailedPredicateException = __decorate([
 ], FailedPredicateException);
 exports.FailedPredicateException = FailedPredicateException;
 
-},{"./Decorators":254,"./RecognitionException":273,"./atn/PredicateTransition":333}],259:[function(require,module,exports){
+},{"./Decorators":255,"./RecognitionException":274,"./atn/PredicateTransition":334}],260:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -45864,7 +46821,7 @@ InputMismatchException = __decorate([
 ], InputMismatchException);
 exports.InputMismatchException = InputMismatchException;
 
-},{"./Decorators":254,"./RecognitionException":273}],260:[function(require,module,exports){
+},{"./Decorators":255,"./RecognitionException":274}],261:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -45887,7 +46844,7 @@ var IntStream;
     IntStream.UNKNOWN_SOURCE_NAME = "<unknown>";
 })(IntStream = exports.IntStream || (exports.IntStream = {}));
 
-},{}],261:[function(require,module,exports){
+},{}],262:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -45934,7 +46891,7 @@ __decorate([
 ], InterpreterRuleContext.prototype, "ruleIndex", null);
 exports.InterpreterRuleContext = InterpreterRuleContext;
 
-},{"./Decorators":254,"./ParserRuleContext":270}],262:[function(require,module,exports){
+},{"./Decorators":255,"./ParserRuleContext":271}],263:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46270,7 +47227,7 @@ __decorate([
 ], Lexer.prototype, "charPositionInLine", null);
 exports.Lexer = Lexer;
 
-},{"./CommonTokenFactory":251,"./Decorators":254,"./IntStream":260,"./LexerNoViableAltException":264,"./Recognizer":274,"./Token":279,"./atn/LexerATNSimulator":312,"./misc/IntegerStack":365,"./misc/Interval":366}],263:[function(require,module,exports){
+},{"./CommonTokenFactory":252,"./Decorators":255,"./IntStream":261,"./LexerNoViableAltException":265,"./Recognizer":275,"./Token":280,"./atn/LexerATNSimulator":313,"./misc/IntegerStack":366,"./misc/Interval":367}],264:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46350,7 +47307,7 @@ LexerInterpreter = __decorate([
 ], LexerInterpreter);
 exports.LexerInterpreter = LexerInterpreter;
 
-},{"./Decorators":254,"./Lexer":262,"./atn/LexerATNSimulator":312}],264:[function(require,module,exports){
+},{"./Decorators":255,"./Lexer":263,"./atn/LexerATNSimulator":313}],265:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46407,7 +47364,7 @@ LexerNoViableAltException = __decorate([
 ], LexerNoViableAltException);
 exports.LexerNoViableAltException = LexerNoViableAltException;
 
-},{"./Decorators":254,"./RecognitionException":273,"./misc/Interval":366,"./misc/Utils":373}],265:[function(require,module,exports){
+},{"./Decorators":255,"./RecognitionException":274,"./misc/Interval":367,"./misc/Utils":374}],266:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46617,7 +47574,7 @@ ListTokenSource = __decorate([
 ], ListTokenSource);
 exports.ListTokenSource = ListTokenSource;
 
-},{"./CommonTokenFactory":251,"./Decorators":254,"./Token":279}],266:[function(require,module,exports){
+},{"./CommonTokenFactory":252,"./Decorators":255,"./Token":280}],267:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46672,7 +47629,7 @@ __decorate([
 ], NoViableAltException.prototype, "_startToken", void 0);
 exports.NoViableAltException = NoViableAltException;
 
-},{"./Decorators":254,"./Parser":267,"./RecognitionException":273}],267:[function(require,module,exports){
+},{"./Decorators":255,"./Parser":268,"./RecognitionException":274}],268:[function(require,module,exports){
 (function (process){(function (){
 "use strict";
 /*!
@@ -47518,7 +48475,7 @@ __decorate([
 exports.Parser = Parser;
 
 }).call(this)}).call(this,require('_process'))
-},{"./Decorators":254,"./DefaultErrorStrategy":255,"./Lexer":262,"./ProxyParserErrorListener":272,"./Recognizer":274,"./Token":279,"./atn/ATNDeserializationOptions":290,"./atn/ATNDeserializer":291,"./atn/ParseInfo":327,"./atn/ParserATNSimulator":328,"./atn/ProfilingATNSimulator":337,"./misc/IntegerStack":365,"./misc/Utils":373,"./tree/ErrorNode":374,"./tree/TerminalNode":377,"./tree/pattern/ParseTreePatternMatcher":382,"_process":456}],268:[function(require,module,exports){
+},{"./Decorators":255,"./DefaultErrorStrategy":256,"./Lexer":263,"./ProxyParserErrorListener":273,"./Recognizer":275,"./Token":280,"./atn/ATNDeserializationOptions":291,"./atn/ATNDeserializer":292,"./atn/ParseInfo":328,"./atn/ParserATNSimulator":329,"./atn/ProfilingATNSimulator":338,"./misc/IntegerStack":366,"./misc/Utils":374,"./tree/ErrorNode":375,"./tree/TerminalNode":378,"./tree/pattern/ParseTreePatternMatcher":383,"_process":457}],269:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -47526,7 +48483,7 @@ exports.Parser = Parser;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],269:[function(require,module,exports){
+},{}],270:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -47934,7 +48891,7 @@ ParserInterpreter = __decorate([
 ], ParserInterpreter);
 exports.ParserInterpreter = ParserInterpreter;
 
-},{"./Decorators":254,"./FailedPredicateException":258,"./InputMismatchException":259,"./InterpreterRuleContext":261,"./Parser":267,"./RecognitionException":273,"./Token":279,"./atn/ATNState":293,"./atn/ATNStateType":294,"./atn/LoopEndState":324,"./atn/ParserATNSimulator":328,"./atn/StarLoopEntryState":346,"./misc/BitSet":361}],270:[function(require,module,exports){
+},{"./Decorators":255,"./FailedPredicateException":259,"./InputMismatchException":260,"./InterpreterRuleContext":262,"./Parser":268,"./RecognitionException":274,"./Token":280,"./atn/ATNState":294,"./atn/ATNStateType":295,"./atn/LoopEndState":325,"./atn/ParserATNSimulator":329,"./atn/StarLoopEntryState":347,"./misc/BitSet":362}],271:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48235,7 +49192,7 @@ __decorate([
 ], ParserRuleContext.prototype, "sourceInterval", null);
 exports.ParserRuleContext = ParserRuleContext;
 
-},{"./Decorators":254,"./RuleContext":275,"./misc/Interval":366,"./tree/ErrorNode":374,"./tree/TerminalNode":377}],271:[function(require,module,exports){
+},{"./Decorators":255,"./RuleContext":276,"./misc/Interval":367,"./tree/ErrorNode":375,"./tree/TerminalNode":378}],272:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48285,7 +49242,7 @@ __decorate([
 ], ProxyErrorListener.prototype, "syntaxError", null);
 exports.ProxyErrorListener = ProxyErrorListener;
 
-},{"./Decorators":254}],272:[function(require,module,exports){
+},{"./Decorators":255}],273:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48344,7 +49301,7 @@ __decorate([
 ], ProxyParserErrorListener.prototype, "reportContextSensitivity", null);
 exports.ProxyParserErrorListener = ProxyParserErrorListener;
 
-},{"./Decorators":254,"./ProxyErrorListener":271}],273:[function(require,module,exports){
+},{"./Decorators":255,"./ProxyErrorListener":272}],274:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48449,7 +49406,7 @@ class RecognitionException extends Error {
 }
 exports.RecognitionException = RecognitionException;
 
-},{}],274:[function(require,module,exports){
+},{}],275:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48668,7 +49625,7 @@ __decorate([
 ], Recognizer.prototype, "getErrorListeners", null);
 exports.Recognizer = Recognizer;
 
-},{"./ConsoleErrorListener":253,"./Decorators":254,"./ProxyErrorListener":271,"./Token":279,"./misc/Utils":373}],275:[function(require,module,exports){
+},{"./ConsoleErrorListener":254,"./Decorators":255,"./ProxyErrorListener":272,"./Token":280,"./misc/Utils":374}],276:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48885,7 +49842,7 @@ __decorate([
 ], RuleContext.prototype, "toStringTree", null);
 exports.RuleContext = RuleContext;
 
-},{"./Decorators":254,"./ParserRuleContext":270,"./Recognizer":274,"./atn/ATN":287,"./misc/Interval":366,"./tree/RuleNode":376,"./tree/Trees":378}],276:[function(require,module,exports){
+},{"./Decorators":255,"./ParserRuleContext":271,"./Recognizer":275,"./atn/ATN":288,"./misc/Interval":367,"./tree/RuleNode":377,"./tree/Trees":379}],277:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48936,7 +49893,7 @@ __decorate([
 ], RuleContextWithAltNum.prototype, "altNumber", null);
 exports.RuleContextWithAltNum = RuleContextWithAltNum;
 
-},{"./Decorators":254,"./ParserRuleContext":270,"./atn/ATN":287}],277:[function(require,module,exports){
+},{"./Decorators":255,"./ParserRuleContext":271,"./atn/ATN":288}],278:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48959,7 +49916,7 @@ function RuleDependency(dependency) {
 }
 exports.RuleDependency = RuleDependency;
 
-},{}],278:[function(require,module,exports){
+},{}],279:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48978,7 +49935,7 @@ function RuleVersion(version) {
 }
 exports.RuleVersion = RuleVersion;
 
-},{}],279:[function(require,module,exports){
+},{}],280:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49018,7 +49975,7 @@ var Token;
     Token.MIN_USER_CHANNEL_VALUE = 2;
 })(Token = exports.Token || (exports.Token = {}));
 
-},{"./IntStream":260}],280:[function(require,module,exports){
+},{"./IntStream":261}],281:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49026,7 +49983,7 @@ var Token;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],281:[function(require,module,exports){
+},{}],282:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49034,7 +49991,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],282:[function(require,module,exports){
+},{}],283:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49042,7 +49999,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],283:[function(require,module,exports){
+},{}],284:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49550,7 +50507,7 @@ __decorate([
     Decorators_1.Override
 ], ReplaceOp.prototype, "toString", null);
 
-},{"./Decorators":254,"./Token":279,"./misc/Interval":366}],284:[function(require,module,exports){
+},{"./Decorators":255,"./Token":280,"./misc/Interval":367}],285:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49558,7 +50515,7 @@ __decorate([
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],285:[function(require,module,exports){
+},{}],286:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49678,7 +50635,7 @@ __decorate([
 ], VocabularyImpl, "EMPTY_VOCABULARY", void 0);
 exports.VocabularyImpl = VocabularyImpl;
 
-},{"./Decorators":254,"./Token":279}],286:[function(require,module,exports){
+},{"./Decorators":255,"./Token":280}],287:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49686,7 +50643,7 @@ exports.VocabularyImpl = VocabularyImpl;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],287:[function(require,module,exports){
+},{}],288:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49908,7 +50865,7 @@ exports.ATN = ATN;
 })(ATN = exports.ATN || (exports.ATN = {}));
 exports.ATN = ATN;
 
-},{"../Decorators":254,"../Token":279,"../dfa/DFA":352,"../misc/Array2DHashMap":357,"../misc/IntervalSet":367,"../misc/ObjectEqualityComparator":370,"./InvalidState":310,"./LL1Analyzer":311,"./PredictionContext":334,"assert":397}],288:[function(require,module,exports){
+},{"../Decorators":255,"../Token":280,"../dfa/DFA":353,"../misc/Array2DHashMap":358,"../misc/IntervalSet":368,"../misc/ObjectEqualityComparator":371,"./InvalidState":311,"./LL1Analyzer":312,"./PredictionContext":335,"assert":398}],289:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -50433,7 +51390,7 @@ ActionSemanticContextATNConfig = __decorate([
     __param(1, Decorators_1.NotNull), __param(2, Decorators_1.NotNull)
 ], ActionSemanticContextATNConfig);
 
-},{"../Decorators":254,"../misc/Array2DHashMap":357,"../misc/MurmurHash":369,"../misc/ObjectEqualityComparator":370,"./DecisionState":307,"./PredictionContext":334,"./SemanticContext":342,"assert":397}],289:[function(require,module,exports){
+},{"../Decorators":255,"../misc/Array2DHashMap":358,"../misc/MurmurHash":370,"../misc/ObjectEqualityComparator":371,"./DecisionState":308,"./PredictionContext":335,"./SemanticContext":343,"assert":398}],290:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -50880,7 +51837,7 @@ __decorate([
 ], ATNConfigSet.prototype, "hashCode", null);
 exports.ATNConfigSet = ATNConfigSet;
 
-},{"../Decorators":254,"../misc/Array2DHashMap":357,"../misc/Array2DHashSet":358,"../misc/ArrayEqualityComparator":359,"../misc/BitSet":361,"../misc/ObjectEqualityComparator":370,"../misc/Utils":373,"./ATN":287,"./ATNConfig":288,"./PredictionContext":334,"./PredictionContextCache":335,"./SemanticContext":342,"assert":397}],290:[function(require,module,exports){
+},{"../Decorators":255,"../misc/Array2DHashMap":358,"../misc/Array2DHashSet":359,"../misc/ArrayEqualityComparator":360,"../misc/BitSet":362,"../misc/ObjectEqualityComparator":371,"../misc/Utils":374,"./ATN":288,"./ATNConfig":289,"./PredictionContext":335,"./PredictionContextCache":336,"./SemanticContext":343,"assert":398}],291:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -50959,7 +51916,7 @@ __decorate([
 ], ATNDeserializationOptions, "defaultOptions", null);
 exports.ATNDeserializationOptions = ATNDeserializationOptions;
 
-},{"../Decorators":254}],291:[function(require,module,exports){
+},{"../Decorators":255}],292:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52046,7 +53003,7 @@ __decorate([
 ], ATNDeserializer.prototype, "edgeFactory", null);
 exports.ATNDeserializer = ATNDeserializer;
 
-},{"../Decorators":254,"../Token":279,"../dfa/DFA":352,"../misc/Array2DHashSet":358,"../misc/BitSet":361,"../misc/IntervalSet":367,"../misc/UUID":372,"./ATN":287,"./ATNDeserializationOptions":290,"./ATNStateType":294,"./ActionTransition":296,"./AtomTransition":298,"./BasicBlockStartState":299,"./BasicState":300,"./BlockEndState":301,"./BlockStartState":302,"./DecisionState":307,"./EpsilonTransition":308,"./InvalidState":310,"./LexerChannelAction":314,"./LexerCustomAction":315,"./LexerModeAction":317,"./LexerMoreAction":318,"./LexerPopModeAction":319,"./LexerPushModeAction":320,"./LexerSkipAction":321,"./LexerTypeAction":322,"./LoopEndState":324,"./NotSetTransition":325,"./ParserATNSimulator":328,"./PlusBlockStartState":329,"./PlusLoopbackState":330,"./PrecedencePredicateTransition":331,"./PredicateTransition":333,"./RangeTransition":338,"./RuleStartState":339,"./RuleStopState":340,"./RuleTransition":341,"./SetTransition":343,"./StarBlockStartState":345,"./StarLoopEntryState":346,"./StarLoopbackState":347,"./TokensStartState":348,"./WildcardTransition":350}],292:[function(require,module,exports){
+},{"../Decorators":255,"../Token":280,"../dfa/DFA":353,"../misc/Array2DHashSet":359,"../misc/BitSet":362,"../misc/IntervalSet":368,"../misc/UUID":373,"./ATN":288,"./ATNDeserializationOptions":291,"./ATNStateType":295,"./ActionTransition":297,"./AtomTransition":299,"./BasicBlockStartState":300,"./BasicState":301,"./BlockEndState":302,"./BlockStartState":303,"./DecisionState":308,"./EpsilonTransition":309,"./InvalidState":311,"./LexerChannelAction":315,"./LexerCustomAction":316,"./LexerModeAction":318,"./LexerMoreAction":319,"./LexerPopModeAction":320,"./LexerPushModeAction":321,"./LexerSkipAction":322,"./LexerTypeAction":323,"./LoopEndState":325,"./NotSetTransition":326,"./ParserATNSimulator":329,"./PlusBlockStartState":330,"./PlusLoopbackState":331,"./PrecedencePredicateTransition":332,"./PredicateTransition":334,"./RangeTransition":339,"./RuleStartState":340,"./RuleStopState":341,"./RuleTransition":342,"./SetTransition":344,"./StarBlockStartState":346,"./StarLoopEntryState":347,"./StarLoopbackState":348,"./TokensStartState":349,"./WildcardTransition":351}],293:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52110,7 +53067,7 @@ exports.ATNSimulator = ATNSimulator;
 })(ATNSimulator = exports.ATNSimulator || (exports.ATNSimulator = {}));
 exports.ATNSimulator = ATNSimulator;
 
-},{"../Decorators":254,"../dfa/DFAState":354,"./ATNConfigSet":289,"./PredictionContext":334}],293:[function(require,module,exports){
+},{"../Decorators":255,"../dfa/DFAState":355,"./ATNConfigSet":290,"./PredictionContext":335}],294:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52297,7 +53254,7 @@ exports.ATNState = ATNState;
     ATNState.INVALID_STATE_NUMBER = -1;
 })(ATNState = exports.ATNState || (exports.ATNState = {}));
 
-},{"../Decorators":254}],294:[function(require,module,exports){
+},{"../Decorators":255}],295:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52323,7 +53280,7 @@ var ATNStateType;
     ATNStateType[ATNStateType["LOOP_END"] = 12] = "LOOP_END";
 })(ATNStateType = exports.ATNStateType || (exports.ATNStateType = {}));
 
-},{}],295:[function(require,module,exports){
+},{}],296:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52343,7 +53300,7 @@ class AbstractPredicateTransition extends Transition_1.Transition {
 }
 exports.AbstractPredicateTransition = AbstractPredicateTransition;
 
-},{"./Transition":349}],296:[function(require,module,exports){
+},{"./Transition":350}],297:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52399,7 +53356,7 @@ ActionTransition = __decorate([
 ], ActionTransition);
 exports.ActionTransition = ActionTransition;
 
-},{"../Decorators":254,"./Transition":349}],297:[function(require,module,exports){
+},{"../Decorators":255,"./Transition":350}],298:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52486,7 +53443,7 @@ AmbiguityInfo = __decorate([
 ], AmbiguityInfo);
 exports.AmbiguityInfo = AmbiguityInfo;
 
-},{"../Decorators":254,"./DecisionEventInfo":305}],298:[function(require,module,exports){
+},{"../Decorators":255,"./DecisionEventInfo":306}],299:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52544,7 +53501,7 @@ AtomTransition = __decorate([
 ], AtomTransition);
 exports.AtomTransition = AtomTransition;
 
-},{"../Decorators":254,"../misc/IntervalSet":367,"./Transition":349}],299:[function(require,module,exports){
+},{"../Decorators":255,"../misc/IntervalSet":368,"./Transition":350}],300:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52576,7 +53533,7 @@ __decorate([
 ], BasicBlockStartState.prototype, "stateType", null);
 exports.BasicBlockStartState = BasicBlockStartState;
 
-},{"../Decorators":254,"./ATNStateType":294,"./BlockStartState":302}],300:[function(require,module,exports){
+},{"../Decorators":255,"./ATNStateType":295,"./BlockStartState":303}],301:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52608,7 +53565,7 @@ __decorate([
 ], BasicState.prototype, "stateType", null);
 exports.BasicState = BasicState;
 
-},{"../Decorators":254,"./ATNState":293,"./ATNStateType":294}],301:[function(require,module,exports){
+},{"../Decorators":255,"./ATNState":294,"./ATNStateType":295}],302:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52637,7 +53594,7 @@ __decorate([
 ], BlockEndState.prototype, "stateType", null);
 exports.BlockEndState = BlockEndState;
 
-},{"../Decorators":254,"./ATNState":293,"./ATNStateType":294}],302:[function(require,module,exports){
+},{"../Decorators":255,"./ATNState":294,"./ATNStateType":295}],303:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52651,7 +53608,7 @@ class BlockStartState extends DecisionState_1.DecisionState {
 }
 exports.BlockStartState = BlockStartState;
 
-},{"./DecisionState":307}],303:[function(require,module,exports){
+},{"./DecisionState":308}],304:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52721,7 +53678,7 @@ __decorate([
 ], ConflictInfo.prototype, "hashCode", null);
 exports.ConflictInfo = ConflictInfo;
 
-},{"../Decorators":254,"../misc/Utils":373}],304:[function(require,module,exports){
+},{"../Decorators":255,"../misc/Utils":374}],305:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52781,7 +53738,7 @@ ContextSensitivityInfo = __decorate([
 ], ContextSensitivityInfo);
 exports.ContextSensitivityInfo = ContextSensitivityInfo;
 
-},{"../Decorators":254,"./DecisionEventInfo":305}],305:[function(require,module,exports){
+},{"../Decorators":255,"./DecisionEventInfo":306}],306:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52833,7 +53790,7 @@ DecisionEventInfo = __decorate([
 ], DecisionEventInfo);
 exports.DecisionEventInfo = DecisionEventInfo;
 
-},{"../Decorators":254}],306:[function(require,module,exports){
+},{"../Decorators":255}],307:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53046,7 +54003,7 @@ __decorate([
 ], DecisionInfo.prototype, "toString", null);
 exports.DecisionInfo = DecisionInfo;
 
-},{"../Decorators":254}],307:[function(require,module,exports){
+},{"../Decorators":255}],308:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53066,7 +54023,7 @@ class DecisionState extends ATNState_1.ATNState {
 }
 exports.DecisionState = DecisionState;
 
-},{"./ATNState":293}],308:[function(require,module,exports){
+},{"./ATNState":294}],309:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53132,7 +54089,7 @@ EpsilonTransition = __decorate([
 ], EpsilonTransition);
 exports.EpsilonTransition = EpsilonTransition;
 
-},{"../Decorators":254,"./Transition":349}],309:[function(require,module,exports){
+},{"../Decorators":255,"./Transition":350}],310:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53185,7 +54142,7 @@ ErrorInfo = __decorate([
 ], ErrorInfo);
 exports.ErrorInfo = ErrorInfo;
 
-},{"../Decorators":254,"./DecisionEventInfo":305}],310:[function(require,module,exports){
+},{"../Decorators":255,"./DecisionEventInfo":306}],311:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53216,7 +54173,7 @@ __decorate([
 ], InvalidState.prototype, "stateType", null);
 exports.InvalidState = InvalidState;
 
-},{"../Decorators":254,"./ATNStateType":294,"./BasicState":300}],311:[function(require,module,exports){
+},{"../Decorators":255,"./ATNStateType":295,"./BasicState":301}],312:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53438,7 +54395,7 @@ LL1Analyzer = __decorate([
 ], LL1Analyzer);
 exports.LL1Analyzer = LL1Analyzer;
 
-},{"../Decorators":254,"../Token":279,"../misc/Array2DHashSet":358,"../misc/BitSet":361,"../misc/IntervalSet":367,"../misc/ObjectEqualityComparator":370,"./ATNConfig":288,"./AbstractPredicateTransition":295,"./NotSetTransition":325,"./PredictionContext":334,"./RuleStopState":340,"./RuleTransition":341,"./WildcardTransition":350}],312:[function(require,module,exports){
+},{"../Decorators":255,"../Token":280,"../misc/Array2DHashSet":359,"../misc/BitSet":362,"../misc/IntervalSet":368,"../misc/ObjectEqualityComparator":371,"./ATNConfig":289,"./AbstractPredicateTransition":296,"./NotSetTransition":326,"./PredictionContext":335,"./RuleStopState":341,"./RuleTransition":342,"./WildcardTransition":351}],313:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54155,7 +55112,7 @@ exports.LexerATNSimulator = LexerATNSimulator;
 })(LexerATNSimulator = exports.LexerATNSimulator || (exports.LexerATNSimulator = {}));
 exports.LexerATNSimulator = LexerATNSimulator;
 
-},{"../Decorators":254,"../IntStream":260,"../Lexer":262,"../LexerNoViableAltException":264,"../Token":279,"../dfa/AcceptStateInfo":351,"../dfa/DFAState":354,"../misc/Interval":366,"./ATN":287,"./ATNConfig":288,"./ATNConfigSet":289,"./ATNSimulator":292,"./LexerActionExecutor":313,"./OrderedATNConfigSet":326,"./PredictionContext":334,"./RuleStopState":340,"assert":397}],313:[function(require,module,exports){
+},{"../Decorators":255,"../IntStream":261,"../Lexer":263,"../LexerNoViableAltException":265,"../Token":280,"../dfa/AcceptStateInfo":352,"../dfa/DFAState":355,"../misc/Interval":367,"./ATN":288,"./ATNConfig":289,"./ATNConfigSet":290,"./ATNSimulator":293,"./LexerActionExecutor":314,"./OrderedATNConfigSet":327,"./PredictionContext":335,"./RuleStopState":341,"assert":398}],314:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54356,7 +55313,7 @@ LexerActionExecutor = __decorate([
 ], LexerActionExecutor);
 exports.LexerActionExecutor = LexerActionExecutor;
 
-},{"../Decorators":254,"../misc/ArrayEqualityComparator":359,"../misc/MurmurHash":369,"./LexerIndexedCustomAction":316}],314:[function(require,module,exports){
+},{"../Decorators":255,"../misc/ArrayEqualityComparator":360,"../misc/MurmurHash":370,"./LexerIndexedCustomAction":317}],315:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54461,7 +55418,7 @@ __decorate([
 ], LexerChannelAction.prototype, "toString", null);
 exports.LexerChannelAction = LexerChannelAction;
 
-},{"../Decorators":254,"../misc/MurmurHash":369}],315:[function(require,module,exports){
+},{"../Decorators":255,"../misc/MurmurHash":370}],316:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54590,7 +55547,7 @@ __decorate([
 ], LexerCustomAction.prototype, "equals", null);
 exports.LexerCustomAction = LexerCustomAction;
 
-},{"../Decorators":254,"../misc/MurmurHash":369}],316:[function(require,module,exports){
+},{"../Decorators":255,"../misc/MurmurHash":370}],317:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54725,7 +55682,7 @@ LexerIndexedCustomAction = __decorate([
 ], LexerIndexedCustomAction);
 exports.LexerIndexedCustomAction = LexerIndexedCustomAction;
 
-},{"../Decorators":254,"../misc/MurmurHash":369}],317:[function(require,module,exports){
+},{"../Decorators":255,"../misc/MurmurHash":370}],318:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54830,7 +55787,7 @@ __decorate([
 ], LexerModeAction.prototype, "toString", null);
 exports.LexerModeAction = LexerModeAction;
 
-},{"../Decorators":254,"../misc/MurmurHash":369}],318:[function(require,module,exports){
+},{"../Decorators":255,"../misc/MurmurHash":370}],319:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54926,7 +55883,7 @@ exports.LexerMoreAction = LexerMoreAction;
     LexerMoreAction.INSTANCE = new LexerMoreAction();
 })(LexerMoreAction = exports.LexerMoreAction || (exports.LexerMoreAction = {}));
 
-},{"../Decorators":254,"../misc/MurmurHash":369}],319:[function(require,module,exports){
+},{"../Decorators":255,"../misc/MurmurHash":370}],320:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55022,7 +55979,7 @@ exports.LexerPopModeAction = LexerPopModeAction;
     LexerPopModeAction.INSTANCE = new LexerPopModeAction();
 })(LexerPopModeAction = exports.LexerPopModeAction || (exports.LexerPopModeAction = {}));
 
-},{"../Decorators":254,"../misc/MurmurHash":369}],320:[function(require,module,exports){
+},{"../Decorators":255,"../misc/MurmurHash":370}],321:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55127,7 +56084,7 @@ __decorate([
 ], LexerPushModeAction.prototype, "toString", null);
 exports.LexerPushModeAction = LexerPushModeAction;
 
-},{"../Decorators":254,"../misc/MurmurHash":369}],321:[function(require,module,exports){
+},{"../Decorators":255,"../misc/MurmurHash":370}],322:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55223,7 +56180,7 @@ exports.LexerSkipAction = LexerSkipAction;
     LexerSkipAction.INSTANCE = new LexerSkipAction();
 })(LexerSkipAction = exports.LexerSkipAction || (exports.LexerSkipAction = {}));
 
-},{"../Decorators":254,"../misc/MurmurHash":369}],322:[function(require,module,exports){
+},{"../Decorators":255,"../misc/MurmurHash":370}],323:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55327,7 +56284,7 @@ __decorate([
 ], LexerTypeAction.prototype, "toString", null);
 exports.LexerTypeAction = LexerTypeAction;
 
-},{"../Decorators":254,"../misc/MurmurHash":369}],323:[function(require,module,exports){
+},{"../Decorators":255,"../misc/MurmurHash":370}],324:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55379,7 +56336,7 @@ LookaheadEventInfo = __decorate([
 ], LookaheadEventInfo);
 exports.LookaheadEventInfo = LookaheadEventInfo;
 
-},{"../Decorators":254,"./DecisionEventInfo":305}],324:[function(require,module,exports){
+},{"../Decorators":255,"./DecisionEventInfo":306}],325:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55408,7 +56365,7 @@ __decorate([
 ], LoopEndState.prototype, "stateType", null);
 exports.LoopEndState = LoopEndState;
 
-},{"../Decorators":254,"./ATNState":293,"./ATNStateType":294}],325:[function(require,module,exports){
+},{"../Decorators":255,"./ATNState":294,"./ATNStateType":295}],326:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55457,7 +56414,7 @@ NotSetTransition = __decorate([
 ], NotSetTransition);
 exports.NotSetTransition = NotSetTransition;
 
-},{"../Decorators":254,"./SetTransition":343}],326:[function(require,module,exports){
+},{"../Decorators":255,"./SetTransition":344}],327:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55512,7 +56469,7 @@ __decorate([
 ], OrderedATNConfigSet.prototype, "canMerge", null);
 exports.OrderedATNConfigSet = OrderedATNConfigSet;
 
-},{"../Decorators":254,"./ATNConfigSet":289}],327:[function(require,module,exports){
+},{"../Decorators":255,"./ATNConfigSet":290}],328:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55674,7 +56631,7 @@ ParseInfo = __decorate([
 ], ParseInfo);
 exports.ParseInfo = ParseInfo;
 
-},{"../Decorators":254}],328:[function(require,module,exports){
+},{"../Decorators":255}],329:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57947,7 +58904,7 @@ ParserATNSimulator = __decorate([
 ], ParserATNSimulator);
 exports.ParserATNSimulator = ParserATNSimulator;
 
-},{"../Decorators":254,"../IntStream":260,"../NoViableAltException":266,"../ParserRuleContext":270,"../Token":279,"../VocabularyImpl":285,"../dfa/AcceptStateInfo":351,"../dfa/DFAState":354,"../misc/Array2DHashSet":358,"../misc/Arrays":360,"../misc/BitSet":361,"../misc/IntegerList":364,"../misc/Interval":366,"../misc/ObjectEqualityComparator":370,"./ATN":287,"./ATNConfig":288,"./ATNConfigSet":289,"./ATNSimulator":292,"./ATNStateType":294,"./ActionTransition":296,"./AtomTransition":298,"./ConflictInfo":303,"./DecisionState":307,"./NotSetTransition":325,"./PredictionContext":334,"./PredictionContextCache":335,"./PredictionMode":336,"./RuleStopState":340,"./RuleTransition":341,"./SemanticContext":342,"./SetTransition":343,"./SimulatorState":344,"assert":397}],329:[function(require,module,exports){
+},{"../Decorators":255,"../IntStream":261,"../NoViableAltException":267,"../ParserRuleContext":271,"../Token":280,"../VocabularyImpl":286,"../dfa/AcceptStateInfo":352,"../dfa/DFAState":355,"../misc/Array2DHashSet":359,"../misc/Arrays":361,"../misc/BitSet":362,"../misc/IntegerList":365,"../misc/Interval":367,"../misc/ObjectEqualityComparator":371,"./ATN":288,"./ATNConfig":289,"./ATNConfigSet":290,"./ATNSimulator":293,"./ATNStateType":295,"./ActionTransition":297,"./AtomTransition":299,"./ConflictInfo":304,"./DecisionState":308,"./NotSetTransition":326,"./PredictionContext":335,"./PredictionContextCache":336,"./PredictionMode":337,"./RuleStopState":341,"./RuleTransition":342,"./SemanticContext":343,"./SetTransition":344,"./SimulatorState":345,"assert":398}],330:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57980,7 +58937,7 @@ __decorate([
 ], PlusBlockStartState.prototype, "stateType", null);
 exports.PlusBlockStartState = PlusBlockStartState;
 
-},{"../Decorators":254,"./ATNStateType":294,"./BlockStartState":302}],330:[function(require,module,exports){
+},{"../Decorators":255,"./ATNStateType":295,"./BlockStartState":303}],331:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -58011,7 +58968,7 @@ __decorate([
 ], PlusLoopbackState.prototype, "stateType", null);
 exports.PlusLoopbackState = PlusLoopbackState;
 
-},{"../Decorators":254,"./ATNStateType":294,"./DecisionState":307}],331:[function(require,module,exports){
+},{"../Decorators":255,"./ATNStateType":295,"./DecisionState":308}],332:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -58074,7 +59031,7 @@ PrecedencePredicateTransition = __decorate([
 ], PrecedencePredicateTransition);
 exports.PrecedencePredicateTransition = PrecedencePredicateTransition;
 
-},{"../Decorators":254,"./AbstractPredicateTransition":295,"./SemanticContext":342}],332:[function(require,module,exports){
+},{"../Decorators":255,"./AbstractPredicateTransition":296,"./SemanticContext":343}],333:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -58137,7 +59094,7 @@ PredicateEvalInfo = __decorate([
 ], PredicateEvalInfo);
 exports.PredicateEvalInfo = PredicateEvalInfo;
 
-},{"../Decorators":254,"./DecisionEventInfo":305}],333:[function(require,module,exports){
+},{"../Decorators":255,"./DecisionEventInfo":306}],334:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -58203,7 +59160,7 @@ PredicateTransition = __decorate([
 ], PredicateTransition);
 exports.PredicateTransition = PredicateTransition;
 
-},{"../Decorators":254,"./AbstractPredicateTransition":295,"./SemanticContext":342}],334:[function(require,module,exports){
+},{"../Decorators":255,"./AbstractPredicateTransition":296,"./SemanticContext":343}],335:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -58894,7 +59851,7 @@ exports.SingletonPredictionContext = SingletonPredictionContext;
     PredictionContext.IdentityEqualityComparator = IdentityEqualityComparator;
 })(PredictionContext = exports.PredictionContext || (exports.PredictionContext = {}));
 
-},{"../Decorators":254,"../misc/Array2DHashMap":357,"../misc/Array2DHashSet":358,"../misc/Arrays":360,"../misc/MurmurHash":369,"./PredictionContextCache":335,"assert":397}],335:[function(require,module,exports){
+},{"../Decorators":255,"../misc/Array2DHashMap":358,"../misc/Array2DHashSet":359,"../misc/Arrays":361,"../misc/MurmurHash":370,"./PredictionContextCache":336,"assert":398}],336:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59035,7 +59992,7 @@ PredictionContextCache.UNCACHED = new PredictionContextCache(false);
     PredictionContextCache.IdentityCommutativePredictionContextOperands = IdentityCommutativePredictionContextOperands;
 })(PredictionContextCache = exports.PredictionContextCache || (exports.PredictionContextCache = {}));
 
-},{"../Decorators":254,"../misc/Array2DHashMap":357,"../misc/ObjectEqualityComparator":370,"./PredictionContext":334,"assert":397}],336:[function(require,module,exports){
+},{"../Decorators":255,"../misc/Array2DHashMap":358,"../misc/ObjectEqualityComparator":371,"./PredictionContext":335,"assert":398}],337:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59196,7 +60153,7 @@ var PredictionMode;
     PredictionMode.allConfigsInRuleStopStates = allConfigsInRuleStopStates;
 })(PredictionMode = exports.PredictionMode || (exports.PredictionMode = {}));
 
-},{"../Decorators":254,"../misc/Array2DHashMap":357,"../misc/MurmurHash":369,"./RuleStopState":340}],337:[function(require,module,exports){
+},{"../Decorators":255,"../misc/Array2DHashMap":358,"../misc/MurmurHash":370,"./RuleStopState":341}],338:[function(require,module,exports){
 (function (process){(function (){
 "use strict";
 /*!
@@ -59465,7 +60422,7 @@ __decorate([
 exports.ProfilingATNSimulator = ProfilingATNSimulator;
 
 }).call(this)}).call(this,require('_process'))
-},{"../Decorators":254,"./ATN":287,"./ATNSimulator":292,"./AmbiguityInfo":297,"./ContextSensitivityInfo":304,"./DecisionInfo":306,"./ErrorInfo":309,"./LookaheadEventInfo":323,"./ParserATNSimulator":328,"./PredicateEvalInfo":332,"./SemanticContext":342,"./SimulatorState":344,"_process":456}],338:[function(require,module,exports){
+},{"../Decorators":255,"./ATN":288,"./ATNSimulator":293,"./AmbiguityInfo":298,"./ContextSensitivityInfo":305,"./DecisionInfo":307,"./ErrorInfo":310,"./LookaheadEventInfo":324,"./ParserATNSimulator":329,"./PredicateEvalInfo":333,"./SemanticContext":343,"./SimulatorState":345,"_process":457}],339:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59523,7 +60480,7 @@ RangeTransition = __decorate([
 ], RangeTransition);
 exports.RangeTransition = RangeTransition;
 
-},{"../Decorators":254,"../misc/IntervalSet":367,"./Transition":349}],339:[function(require,module,exports){
+},{"../Decorators":255,"../misc/IntervalSet":368,"./Transition":350}],340:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59556,7 +60513,7 @@ __decorate([
 ], RuleStartState.prototype, "stateType", null);
 exports.RuleStartState = RuleStartState;
 
-},{"../Decorators":254,"./ATNState":293,"./ATNStateType":294}],340:[function(require,module,exports){
+},{"../Decorators":255,"./ATNState":294,"./ATNStateType":295}],341:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59595,7 +60552,7 @@ __decorate([
 ], RuleStopState.prototype, "stateType", null);
 exports.RuleStopState = RuleStopState;
 
-},{"../Decorators":254,"./ATNState":293,"./ATNStateType":294}],341:[function(require,module,exports){
+},{"../Decorators":255,"./ATNState":294,"./ATNStateType":295}],342:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59651,7 +60608,7 @@ RuleTransition = __decorate([
 ], RuleTransition);
 exports.RuleTransition = RuleTransition;
 
-},{"../Decorators":254,"./Transition":349}],342:[function(require,module,exports){
+},{"../Decorators":255,"./Transition":350}],343:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60131,7 +61088,7 @@ exports.SemanticContext = SemanticContext;
     SemanticContext.OR = OR;
 })(SemanticContext = exports.SemanticContext || (exports.SemanticContext = {}));
 
-},{"../Decorators":254,"../misc/Array2DHashSet":358,"../misc/ArrayEqualityComparator":359,"../misc/MurmurHash":369,"../misc/ObjectEqualityComparator":370,"../misc/Utils":373}],343:[function(require,module,exports){
+},{"../Decorators":255,"../misc/Array2DHashSet":359,"../misc/ArrayEqualityComparator":360,"../misc/MurmurHash":370,"../misc/ObjectEqualityComparator":371,"../misc/Utils":374}],344:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60197,7 +61154,7 @@ SetTransition = __decorate([
 ], SetTransition);
 exports.SetTransition = SetTransition;
 
-},{"../Decorators":254,"../Token":279,"../misc/IntervalSet":367,"./Transition":349}],344:[function(require,module,exports){
+},{"../Decorators":255,"../Token":280,"../misc/IntervalSet":368,"./Transition":350}],345:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60233,7 +61190,7 @@ SimulatorState = __decorate([
 ], SimulatorState);
 exports.SimulatorState = SimulatorState;
 
-},{"../Decorators":254,"../ParserRuleContext":270}],345:[function(require,module,exports){
+},{"../Decorators":255,"../ParserRuleContext":271}],346:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60261,7 +61218,7 @@ __decorate([
 ], StarBlockStartState.prototype, "stateType", null);
 exports.StarBlockStartState = StarBlockStartState;
 
-},{"../Decorators":254,"./ATNStateType":294,"./BlockStartState":302}],346:[function(require,module,exports){
+},{"../Decorators":255,"./ATNStateType":295,"./BlockStartState":303}],347:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60318,7 +61275,7 @@ __decorate([
 ], StarLoopEntryState.prototype, "stateType", null);
 exports.StarLoopEntryState = StarLoopEntryState;
 
-},{"../Decorators":254,"../misc/BitSet":361,"./ATNStateType":294,"./DecisionState":307}],347:[function(require,module,exports){
+},{"../Decorators":255,"../misc/BitSet":362,"./ATNStateType":295,"./DecisionState":308}],348:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60349,7 +61306,7 @@ __decorate([
 ], StarLoopbackState.prototype, "stateType", null);
 exports.StarLoopbackState = StarLoopbackState;
 
-},{"../Decorators":254,"./ATNState":293,"./ATNStateType":294}],348:[function(require,module,exports){
+},{"../Decorators":255,"./ATNState":294,"./ATNStateType":295}],349:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60378,7 +61335,7 @@ __decorate([
 ], TokensStartState.prototype, "stateType", null);
 exports.TokensStartState = TokensStartState;
 
-},{"../Decorators":254,"./ATNStateType":294,"./DecisionState":307}],349:[function(require,module,exports){
+},{"../Decorators":255,"./ATNStateType":295,"./DecisionState":308}],350:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60452,7 +61409,7 @@ Transition = __decorate([
 ], Transition);
 exports.Transition = Transition;
 
-},{"../Decorators":254}],350:[function(require,module,exports){
+},{"../Decorators":255}],351:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60500,7 +61457,7 @@ WildcardTransition = __decorate([
 ], WildcardTransition);
 exports.WildcardTransition = WildcardTransition;
 
-},{"../Decorators":254,"./Transition":349}],351:[function(require,module,exports){
+},{"../Decorators":255,"./Transition":350}],352:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60542,7 +61499,7 @@ class AcceptStateInfo {
 }
 exports.AcceptStateInfo = AcceptStateInfo;
 
-},{}],352:[function(require,module,exports){
+},{}],353:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60717,7 +61674,7 @@ DFA = __decorate([
 ], DFA);
 exports.DFA = DFA;
 
-},{"../Decorators":254,"../VocabularyImpl":285,"../atn/ATNConfigSet":289,"../atn/StarLoopEntryState":346,"../misc/Array2DHashSet":358,"../misc/ObjectEqualityComparator":370,"./DFASerializer":353,"./DFAState":354,"./LexerDFASerializer":355}],353:[function(require,module,exports){
+},{"../Decorators":255,"../VocabularyImpl":286,"../atn/ATNConfigSet":290,"../atn/StarLoopEntryState":347,"../misc/Array2DHashSet":359,"../misc/ObjectEqualityComparator":371,"./DFASerializer":354,"./DFAState":355,"./LexerDFASerializer":356}],354:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60859,7 +61816,7 @@ __decorate([
 ], DFASerializer.prototype, "toString", null);
 exports.DFASerializer = DFASerializer;
 
-},{"../Decorators":254,"../Recognizer":274,"../VocabularyImpl":285,"../atn/ATNSimulator":292,"../atn/PredictionContext":334}],354:[function(require,module,exports){
+},{"../Decorators":255,"../Recognizer":275,"../VocabularyImpl":286,"../atn/ATNSimulator":293,"../atn/PredictionContext":335}],355:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -61090,7 +62047,7 @@ exports.DFAState = DFAState;
     DFAState.PredPrediction = PredPrediction;
 })(DFAState = exports.DFAState || (exports.DFAState = {}));
 
-},{"../Decorators":254,"../atn/ATN":287,"../atn/PredictionContext":334,"../misc/BitSet":361,"../misc/MurmurHash":369,"assert":397}],355:[function(require,module,exports){
+},{"../Decorators":255,"../atn/ATN":288,"../atn/PredictionContext":335,"../misc/BitSet":362,"../misc/MurmurHash":370,"assert":398}],356:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -61127,7 +62084,7 @@ LexerDFASerializer = __decorate([
 ], LexerDFASerializer);
 exports.LexerDFASerializer = LexerDFASerializer;
 
-},{"../Decorators":254,"../VocabularyImpl":285,"./DFASerializer":353}],356:[function(require,module,exports){
+},{"../Decorators":255,"../VocabularyImpl":286,"./DFASerializer":354}],357:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -61193,7 +62150,7 @@ __exportStar(require("./Vocabulary"), exports);
 __exportStar(require("./VocabularyImpl"), exports);
 __exportStar(require("./WritableToken"), exports);
 
-},{"./ANTLRErrorListener":241,"./ANTLRErrorStrategy":242,"./ANTLRInputStream":243,"./BailErrorStrategy":244,"./BufferedTokenStream":245,"./CharStream":246,"./CharStreams":247,"./CodePointBuffer":248,"./CodePointCharStream":249,"./CommonToken":250,"./CommonTokenFactory":251,"./CommonTokenStream":252,"./ConsoleErrorListener":253,"./DefaultErrorStrategy":255,"./Dependents":256,"./DiagnosticErrorListener":257,"./FailedPredicateException":258,"./InputMismatchException":259,"./IntStream":260,"./InterpreterRuleContext":261,"./Lexer":262,"./LexerInterpreter":263,"./LexerNoViableAltException":264,"./ListTokenSource":265,"./NoViableAltException":266,"./Parser":267,"./ParserErrorListener":268,"./ParserInterpreter":269,"./ParserRuleContext":270,"./ProxyErrorListener":271,"./ProxyParserErrorListener":272,"./RecognitionException":273,"./Recognizer":274,"./RuleContext":275,"./RuleContextWithAltNum":276,"./RuleDependency":277,"./RuleVersion":278,"./Token":279,"./TokenFactory":280,"./TokenSource":281,"./TokenStream":282,"./TokenStreamRewriter":283,"./Vocabulary":284,"./VocabularyImpl":285,"./WritableToken":286}],357:[function(require,module,exports){
+},{"./ANTLRErrorListener":242,"./ANTLRErrorStrategy":243,"./ANTLRInputStream":244,"./BailErrorStrategy":245,"./BufferedTokenStream":246,"./CharStream":247,"./CharStreams":248,"./CodePointBuffer":249,"./CodePointCharStream":250,"./CommonToken":251,"./CommonTokenFactory":252,"./CommonTokenStream":253,"./ConsoleErrorListener":254,"./DefaultErrorStrategy":256,"./Dependents":257,"./DiagnosticErrorListener":258,"./FailedPredicateException":259,"./InputMismatchException":260,"./IntStream":261,"./InterpreterRuleContext":262,"./Lexer":263,"./LexerInterpreter":264,"./LexerNoViableAltException":265,"./ListTokenSource":266,"./NoViableAltException":267,"./Parser":268,"./ParserErrorListener":269,"./ParserInterpreter":270,"./ParserRuleContext":271,"./ProxyErrorListener":272,"./ProxyParserErrorListener":273,"./RecognitionException":274,"./Recognizer":275,"./RuleContext":276,"./RuleContextWithAltNum":277,"./RuleDependency":278,"./RuleVersion":279,"./Token":280,"./TokenFactory":281,"./TokenSource":282,"./TokenStream":283,"./TokenStreamRewriter":284,"./Vocabulary":285,"./VocabularyImpl":286,"./WritableToken":287}],358:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -61276,7 +62233,7 @@ class Array2DHashMap {
 }
 exports.Array2DHashMap = Array2DHashMap;
 
-},{"./Array2DHashSet":358}],358:[function(require,module,exports){
+},{"./Array2DHashSet":359}],359:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -61643,7 +62600,7 @@ __decorate([
 ], Array2DHashSet.prototype, "createBuckets", null);
 exports.Array2DHashSet = Array2DHashSet;
 
-},{"../Decorators":254,"./DefaultEqualityComparator":363,"./MurmurHash":369,"assert":397}],359:[function(require,module,exports){
+},{"../Decorators":255,"./DefaultEqualityComparator":364,"./MurmurHash":370,"assert":398}],360:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -61715,7 +62672,7 @@ __decorate([
 ], ArrayEqualityComparator.prototype, "equals", null);
 exports.ArrayEqualityComparator = ArrayEqualityComparator;
 
-},{"../Decorators":254,"./MurmurHash":369,"./ObjectEqualityComparator":370}],360:[function(require,module,exports){
+},{"../Decorators":255,"./MurmurHash":370,"./ObjectEqualityComparator":371}],361:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -61785,7 +62742,7 @@ var Arrays;
     Arrays.toString = toString;
 })(Arrays = exports.Arrays || (exports.Arrays = {}));
 
-},{}],361:[function(require,module,exports){
+},{}],362:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -62457,7 +63414,7 @@ class BitSetIterator {
     [Symbol.iterator]() { return this; }
 }
 
-},{"./MurmurHash":369,"util":461}],362:[function(require,module,exports){
+},{"./MurmurHash":370,"util":462}],363:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -62478,7 +63435,7 @@ function isSupplementaryCodePoint(ch) {
 }
 exports.isSupplementaryCodePoint = isSupplementaryCodePoint;
 
-},{}],363:[function(require,module,exports){
+},{}],364:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -62549,7 +63506,7 @@ __decorate([
 ], DefaultEqualityComparator.prototype, "equals", null);
 exports.DefaultEqualityComparator = DefaultEqualityComparator;
 
-},{"../Decorators":254,"./MurmurHash":369,"./ObjectEqualityComparator":370}],364:[function(require,module,exports){
+},{"../Decorators":255,"./MurmurHash":370,"./ObjectEqualityComparator":371}],365:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -62843,7 +63800,7 @@ __decorate([
 ], IntegerList.prototype, "toString", null);
 exports.IntegerList = IntegerList;
 
-},{"../Decorators":254,"./Arrays":360}],365:[function(require,module,exports){
+},{"../Decorators":255,"./Arrays":361}],366:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -62873,7 +63830,7 @@ class IntegerStack extends IntegerList_1.IntegerList {
 }
 exports.IntegerStack = IntegerStack;
 
-},{"./IntegerList":364}],366:[function(require,module,exports){
+},{"./IntegerList":365}],367:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -63016,7 +63973,7 @@ __decorate([
 ], Interval.prototype, "toString", null);
 exports.Interval = Interval;
 
-},{"../Decorators":254}],367:[function(require,module,exports){
+},{"../Decorators":255}],368:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -63662,7 +64619,7 @@ __decorate([
 ], IntervalSet, "subtract", null);
 exports.IntervalSet = IntervalSet;
 
-},{"../Decorators":254,"../Lexer":262,"../Token":279,"./ArrayEqualityComparator":359,"./IntegerList":364,"./Interval":366,"./MurmurHash":369}],368:[function(require,module,exports){
+},{"../Decorators":255,"../Lexer":263,"../Token":280,"./ArrayEqualityComparator":360,"./IntegerList":365,"./Interval":367,"./MurmurHash":370}],369:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -63695,7 +64652,7 @@ class MultiMap extends Map {
 }
 exports.MultiMap = MultiMap;
 
-},{}],369:[function(require,module,exports){
+},{}],370:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -63810,7 +64767,7 @@ var MurmurHash;
     }
 })(MurmurHash = exports.MurmurHash || (exports.MurmurHash = {}));
 
-},{}],370:[function(require,module,exports){
+},{}],371:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -63869,7 +64826,7 @@ __decorate([
 ], ObjectEqualityComparator.prototype, "equals", null);
 exports.ObjectEqualityComparator = ObjectEqualityComparator;
 
-},{"../Decorators":254}],371:[function(require,module,exports){
+},{"../Decorators":255}],372:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -63898,7 +64855,7 @@ class ParseCancellationException extends Error {
 }
 exports.ParseCancellationException = ParseCancellationException;
 
-},{}],372:[function(require,module,exports){
+},{}],373:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -63952,7 +64909,7 @@ class UUID {
 }
 exports.UUID = UUID;
 
-},{"./MurmurHash":369}],373:[function(require,module,exports){
+},{"./MurmurHash":370}],374:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -64127,7 +65084,7 @@ exports.toCharArray = toCharArray;
 // 	return s;
 // }
 
-},{}],374:[function(require,module,exports){
+},{}],375:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -64163,7 +65120,7 @@ __decorate([
 ], ErrorNode.prototype, "accept", null);
 exports.ErrorNode = ErrorNode;
 
-},{"../Decorators":254,"./TerminalNode":377}],375:[function(require,module,exports){
+},{"../Decorators":255,"./TerminalNode":378}],376:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -64268,7 +65225,7 @@ exports.ParseTreeWalker = ParseTreeWalker;
     ParseTreeWalker.DEFAULT = new ParseTreeWalker();
 })(ParseTreeWalker = exports.ParseTreeWalker || (exports.ParseTreeWalker = {}));
 
-},{"./ErrorNode":374,"./RuleNode":376,"./TerminalNode":377}],376:[function(require,module,exports){
+},{"./ErrorNode":375,"./RuleNode":377,"./TerminalNode":378}],377:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -64280,7 +65237,7 @@ class RuleNode {
 }
 exports.RuleNode = RuleNode;
 
-},{}],377:[function(require,module,exports){
+},{}],378:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -64372,7 +65329,7 @@ __decorate([
 ], TerminalNode.prototype, "toString", null);
 exports.TerminalNode = TerminalNode;
 
-},{"../Decorators":254,"../Token":279,"../misc/Interval":366}],378:[function(require,module,exports){
+},{"../Decorators":255,"../Token":280,"../misc/Interval":367}],379:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -64616,7 +65573,7 @@ __decorate([
 ], Trees, "getRootOfSubtreeEnclosingRegion", null);
 exports.Trees = Trees;
 
-},{"../CommonToken":250,"../Decorators":254,"../Parser":267,"../ParserRuleContext":270,"../Token":279,"../atn/ATN":287,"../misc/Utils":373,"./ErrorNode":374,"./RuleNode":376,"./TerminalNode":377}],379:[function(require,module,exports){
+},{"../CommonToken":251,"../Decorators":255,"../Parser":268,"../ParserRuleContext":271,"../Token":280,"../atn/ATN":288,"../misc/Utils":374,"./ErrorNode":375,"./RuleNode":377,"./TerminalNode":378}],380:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -64640,7 +65597,7 @@ class Chunk {
 }
 exports.Chunk = Chunk;
 
-},{}],380:[function(require,module,exports){
+},{}],381:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -64820,7 +65777,7 @@ ParseTreeMatch = __decorate([
 ], ParseTreeMatch);
 exports.ParseTreeMatch = ParseTreeMatch;
 
-},{"../../Decorators":254}],381:[function(require,module,exports){
+},{"../../Decorators":255}],382:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -64978,7 +65935,7 @@ ParseTreePattern = __decorate([
 ], ParseTreePattern);
 exports.ParseTreePattern = ParseTreePattern;
 
-},{"../../Decorators":254,"../xpath/XPath":387}],382:[function(require,module,exports){
+},{"../../Decorators":255,"../xpath/XPath":388}],383:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65456,7 +66413,7 @@ exports.ParseTreePatternMatcher = ParseTreePatternMatcher;
     ParseTreePatternMatcher.StartRuleDoesNotConsumeFullPattern = StartRuleDoesNotConsumeFullPattern;
 })(ParseTreePatternMatcher = exports.ParseTreePatternMatcher || (exports.ParseTreePatternMatcher = {}));
 
-},{"../../BailErrorStrategy":244,"../../CharStreams":247,"../../CommonTokenStream":252,"../../Decorators":254,"../../ListTokenSource":265,"../../ParserInterpreter":269,"../../ParserRuleContext":270,"../../RecognitionException":273,"../../Token":279,"../../misc/MultiMap":368,"../../misc/ParseCancellationException":371,"../RuleNode":376,"../TerminalNode":377,"./ParseTreeMatch":380,"./ParseTreePattern":381,"./RuleTagToken":383,"./TagChunk":384,"./TextChunk":385,"./TokenTagToken":386}],383:[function(require,module,exports){
+},{"../../BailErrorStrategy":245,"../../CharStreams":248,"../../CommonTokenStream":253,"../../Decorators":255,"../../ListTokenSource":266,"../../ParserInterpreter":270,"../../ParserRuleContext":271,"../../RecognitionException":274,"../../Token":280,"../../misc/MultiMap":369,"../../misc/ParseCancellationException":372,"../RuleNode":377,"../TerminalNode":378,"./ParseTreeMatch":381,"./ParseTreePattern":382,"./RuleTagToken":384,"./TagChunk":385,"./TextChunk":386,"./TokenTagToken":387}],384:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65654,7 +66611,7 @@ RuleTagToken = __decorate([
 ], RuleTagToken);
 exports.RuleTagToken = RuleTagToken;
 
-},{"../../Decorators":254,"../../Token":279}],384:[function(require,module,exports){
+},{"../../Decorators":255,"../../Token":280}],385:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65741,7 +66698,7 @@ __decorate([
 ], TagChunk.prototype, "toString", null);
 exports.TagChunk = TagChunk;
 
-},{"../../Decorators":254,"./Chunk":379}],385:[function(require,module,exports){
+},{"../../Decorators":255,"./Chunk":380}],386:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65811,7 +66768,7 @@ TextChunk = __decorate([
 ], TextChunk);
 exports.TextChunk = TextChunk;
 
-},{"../../Decorators":254,"./Chunk":379}],386:[function(require,module,exports){
+},{"../../Decorators":255,"./Chunk":380}],387:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65906,7 +66863,7 @@ TokenTagToken = __decorate([
 ], TokenTagToken);
 exports.TokenTagToken = TokenTagToken;
 
-},{"../../CommonToken":250,"../../Decorators":254}],387:[function(require,module,exports){
+},{"../../CommonToken":251,"../../Decorators":255}],388:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -66103,7 +67060,7 @@ exports.XPath = XPath;
 XPath.WILDCARD = "*"; // word not operator/separator
 XPath.NOT = "!"; // word for invert operator
 
-},{"../../CharStreams":247,"../../CommonTokenStream":252,"../../LexerNoViableAltException":264,"../../ParserRuleContext":270,"../../Token":279,"./XPathLexer":389,"./XPathLexerErrorListener":390,"./XPathRuleAnywhereElement":391,"./XPathRuleElement":392,"./XPathTokenAnywhereElement":393,"./XPathTokenElement":394,"./XPathWildcardAnywhereElement":395,"./XPathWildcardElement":396}],388:[function(require,module,exports){
+},{"../../CharStreams":248,"../../CommonTokenStream":253,"../../LexerNoViableAltException":265,"../../ParserRuleContext":271,"../../Token":280,"./XPathLexer":390,"./XPathLexerErrorListener":391,"./XPathRuleAnywhereElement":392,"./XPathRuleElement":393,"./XPathTokenAnywhereElement":394,"./XPathTokenElement":395,"./XPathWildcardAnywhereElement":396,"./XPathWildcardElement":397}],389:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -66138,7 +67095,7 @@ __decorate([
 ], XPathElement.prototype, "toString", null);
 exports.XPathElement = XPathElement;
 
-},{"../../Decorators":254}],389:[function(require,module,exports){
+},{"../../Decorators":255}],390:[function(require,module,exports){
 "use strict";
 // Generated from XPathLexer.g4 by ANTLR 4.9.0-SNAPSHOT
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -66613,7 +67570,7 @@ XPathLexer._serializedATN = Utils.join([
     XPathLexer._serializedATNSegment1,
 ], "");
 
-},{"../../Lexer":262,"../../VocabularyImpl":285,"../../atn/ATNDeserializer":291,"../../atn/LexerATNSimulator":312,"../../misc/Utils":373}],390:[function(require,module,exports){
+},{"../../Lexer":263,"../../VocabularyImpl":286,"../../atn/ATNDeserializer":292,"../../atn/LexerATNSimulator":313,"../../misc/Utils":374}],391:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -66638,7 +67595,7 @@ __decorate([
 ], XPathLexerErrorListener.prototype, "syntaxError", null);
 exports.XPathLexerErrorListener = XPathLexerErrorListener;
 
-},{"../../Decorators":254}],391:[function(require,module,exports){
+},{"../../Decorators":255}],392:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -66672,7 +67629,7 @@ __decorate([
 ], XPathRuleAnywhereElement.prototype, "evaluate", null);
 exports.XPathRuleAnywhereElement = XPathRuleAnywhereElement;
 
-},{"../../Decorators":254,"../Trees":378,"./XPathElement":388}],392:[function(require,module,exports){
+},{"../../Decorators":255,"../Trees":379,"./XPathElement":389}],393:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -66715,7 +67672,7 @@ __decorate([
 ], XPathRuleElement.prototype, "evaluate", null);
 exports.XPathRuleElement = XPathRuleElement;
 
-},{"../../Decorators":254,"../../ParserRuleContext":270,"../Trees":378,"./XPathElement":388}],393:[function(require,module,exports){
+},{"../../Decorators":255,"../../ParserRuleContext":271,"../Trees":379,"./XPathElement":389}],394:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -66747,7 +67704,7 @@ __decorate([
 ], XPathTokenAnywhereElement.prototype, "evaluate", null);
 exports.XPathTokenAnywhereElement = XPathTokenAnywhereElement;
 
-},{"../../Decorators":254,"../Trees":378,"./XPathElement":388}],394:[function(require,module,exports){
+},{"../../Decorators":255,"../Trees":379,"./XPathElement":389}],395:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -66790,7 +67747,7 @@ __decorate([
 ], XPathTokenElement.prototype, "evaluate", null);
 exports.XPathTokenElement = XPathTokenElement;
 
-},{"../../Decorators":254,"../TerminalNode":377,"../Trees":378,"./XPathElement":388}],395:[function(require,module,exports){
+},{"../../Decorators":255,"../TerminalNode":378,"../Trees":379,"./XPathElement":389}],396:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -66826,7 +67783,7 @@ __decorate([
 ], XPathWildcardAnywhereElement.prototype, "evaluate", null);
 exports.XPathWildcardAnywhereElement = XPathWildcardAnywhereElement;
 
-},{"../../Decorators":254,"../Trees":378,"./XPath":387,"./XPathElement":388}],396:[function(require,module,exports){
+},{"../../Decorators":255,"../Trees":379,"./XPath":388,"./XPathElement":389}],397:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -66866,7 +67823,7 @@ __decorate([
 ], XPathWildcardElement.prototype, "evaluate", null);
 exports.XPathWildcardElement = XPathWildcardElement;
 
-},{"../../Decorators":254,"../Trees":378,"./XPath":387,"./XPathElement":388}],397:[function(require,module,exports){
+},{"../../Decorators":255,"../Trees":379,"./XPath":388,"./XPathElement":389}],398:[function(require,module,exports){
 (function (global){(function (){
 'use strict';
 
@@ -67376,7 +68333,7 @@ var objectKeys = Object.keys || function (obj) {
 };
 
 }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"object.assign/polyfill":454,"util/":400}],398:[function(require,module,exports){
+},{"object.assign/polyfill":455,"util/":401}],399:[function(require,module,exports){
 if (typeof Object.create === 'function') {
   // implementation from standard node.js 'util' module
   module.exports = function inherits(ctor, superCtor) {
@@ -67401,14 +68358,14 @@ if (typeof Object.create === 'function') {
   }
 }
 
-},{}],399:[function(require,module,exports){
+},{}],400:[function(require,module,exports){
 module.exports = function isBuffer(arg) {
   return arg && typeof arg === 'object'
     && typeof arg.copy === 'function'
     && typeof arg.fill === 'function'
     && typeof arg.readUInt8 === 'function';
 }
-},{}],400:[function(require,module,exports){
+},{}],401:[function(require,module,exports){
 (function (process,global){(function (){
 // Copyright Joyent, Inc. and other Node contributors.
 //
@@ -67998,7 +68955,7 @@ function hasOwnProperty(obj, prop) {
 }
 
 }).call(this)}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"./support/isBuffer":399,"_process":456,"inherits":398}],401:[function(require,module,exports){
+},{"./support/isBuffer":400,"_process":457,"inherits":399}],402:[function(require,module,exports){
 (function (global){(function (){
 'use strict';
 
@@ -68019,7 +68976,7 @@ module.exports = function availableTypedArrays() {
 };
 
 }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"possible-typed-array-names":455}],402:[function(require,module,exports){
+},{"possible-typed-array-names":456}],403:[function(require,module,exports){
 (function (process,global){(function (){
 module.exports = process.hrtime || hrtime
 
@@ -68050,7 +69007,7 @@ function hrtime(previousTimestamp){
   return [seconds,nanoseconds]
 }
 }).call(this)}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"_process":456}],403:[function(require,module,exports){
+},{"_process":457}],404:[function(require,module,exports){
 'use strict';
 
 var bind = require('function-bind');
@@ -68062,7 +69019,7 @@ var $reflectApply = require('./reflectApply');
 /** @type {import('./actualApply')} */
 module.exports = $reflectApply || bind.call($call, $apply);
 
-},{"./functionApply":405,"./functionCall":406,"./reflectApply":408,"function-bind":424}],404:[function(require,module,exports){
+},{"./functionApply":406,"./functionCall":407,"./reflectApply":409,"function-bind":425}],405:[function(require,module,exports){
 'use strict';
 
 var bind = require('function-bind');
@@ -68074,19 +69031,19 @@ module.exports = function applyBind() {
 	return actualApply(bind, $apply, arguments);
 };
 
-},{"./actualApply":403,"./functionApply":405,"function-bind":424}],405:[function(require,module,exports){
+},{"./actualApply":404,"./functionApply":406,"function-bind":425}],406:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./functionApply')} */
 module.exports = Function.prototype.apply;
 
-},{}],406:[function(require,module,exports){
+},{}],407:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./functionCall')} */
 module.exports = Function.prototype.call;
 
-},{}],407:[function(require,module,exports){
+},{}],408:[function(require,module,exports){
 'use strict';
 
 var bind = require('function-bind');
@@ -68103,13 +69060,13 @@ module.exports = function callBindBasic(args) {
 	return $actualApply(bind, $call, args);
 };
 
-},{"./actualApply":403,"./functionCall":406,"es-errors/type":419,"function-bind":424}],408:[function(require,module,exports){
+},{"./actualApply":404,"./functionCall":407,"es-errors/type":420,"function-bind":425}],409:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./reflectApply')} */
 module.exports = typeof Reflect !== 'undefined' && Reflect && Reflect.apply;
 
-},{}],409:[function(require,module,exports){
+},{}],410:[function(require,module,exports){
 'use strict';
 
 var setFunctionLength = require('set-function-length');
@@ -68135,7 +69092,7 @@ if ($defineProperty) {
 	module.exports.apply = applyBind;
 }
 
-},{"call-bind-apply-helpers":407,"call-bind-apply-helpers/applyBind":404,"es-define-property":413,"set-function-length":458}],410:[function(require,module,exports){
+},{"call-bind-apply-helpers":408,"call-bind-apply-helpers/applyBind":405,"es-define-property":414,"set-function-length":459}],411:[function(require,module,exports){
 'use strict';
 
 var GetIntrinsic = require('get-intrinsic');
@@ -68156,7 +69113,7 @@ module.exports = function callBoundIntrinsic(name, allowMissing) {
 	return intrinsic;
 };
 
-},{"call-bind-apply-helpers":407,"get-intrinsic":425}],411:[function(require,module,exports){
+},{"call-bind-apply-helpers":408,"get-intrinsic":426}],412:[function(require,module,exports){
 'use strict';
 
 var $defineProperty = require('es-define-property');
@@ -68214,7 +69171,7 @@ module.exports = function defineDataProperty(
 	}
 };
 
-},{"es-define-property":413,"es-errors/syntax":418,"es-errors/type":419,"gopd":430}],412:[function(require,module,exports){
+},{"es-define-property":414,"es-errors/syntax":419,"es-errors/type":420,"gopd":431}],413:[function(require,module,exports){
 'use strict';
 
 var callBind = require('call-bind-apply-helpers');
@@ -68246,7 +69203,7 @@ module.exports = desc && typeof desc.get === 'function'
 		}
 		: false;
 
-},{"call-bind-apply-helpers":407,"gopd":430}],413:[function(require,module,exports){
+},{"call-bind-apply-helpers":408,"gopd":431}],414:[function(require,module,exports){
 'use strict';
 
 /** @type {import('.')} */
@@ -68262,55 +69219,55 @@ if ($defineProperty) {
 
 module.exports = $defineProperty;
 
-},{}],414:[function(require,module,exports){
+},{}],415:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./eval')} */
 module.exports = EvalError;
 
-},{}],415:[function(require,module,exports){
+},{}],416:[function(require,module,exports){
 'use strict';
 
 /** @type {import('.')} */
 module.exports = Error;
 
-},{}],416:[function(require,module,exports){
+},{}],417:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./range')} */
 module.exports = RangeError;
 
-},{}],417:[function(require,module,exports){
+},{}],418:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./ref')} */
 module.exports = ReferenceError;
 
-},{}],418:[function(require,module,exports){
+},{}],419:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./syntax')} */
 module.exports = SyntaxError;
 
-},{}],419:[function(require,module,exports){
+},{}],420:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./type')} */
 module.exports = TypeError;
 
-},{}],420:[function(require,module,exports){
+},{}],421:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./uri')} */
 module.exports = URIError;
 
-},{}],421:[function(require,module,exports){
+},{}],422:[function(require,module,exports){
 'use strict';
 
 /** @type {import('.')} */
 module.exports = Object;
 
-},{}],422:[function(require,module,exports){
+},{}],423:[function(require,module,exports){
 'use strict';
 
 var isCallable = require('is-callable');
@@ -68381,7 +69338,7 @@ module.exports = function forEach(list, iterator, thisArg) {
     }
 };
 
-},{"is-callable":438}],423:[function(require,module,exports){
+},{"is-callable":439}],424:[function(require,module,exports){
 'use strict';
 
 /* eslint no-invalid-this: 1 */
@@ -68467,14 +69424,14 @@ module.exports = function bind(that) {
     return bound;
 };
 
-},{}],424:[function(require,module,exports){
+},{}],425:[function(require,module,exports){
 'use strict';
 
 var implementation = require('./implementation');
 
 module.exports = Function.prototype.bind || implementation;
 
-},{"./implementation":423}],425:[function(require,module,exports){
+},{"./implementation":424}],426:[function(require,module,exports){
 'use strict';
 
 var undefined;
@@ -68854,7 +69811,7 @@ module.exports = function GetIntrinsic(name, allowMissing) {
 	return value;
 };
 
-},{"call-bind-apply-helpers/functionApply":405,"call-bind-apply-helpers/functionCall":406,"es-define-property":413,"es-errors":415,"es-errors/eval":414,"es-errors/range":416,"es-errors/ref":417,"es-errors/syntax":418,"es-errors/type":419,"es-errors/uri":420,"es-object-atoms":421,"function-bind":424,"get-proto":428,"get-proto/Object.getPrototypeOf":426,"get-proto/Reflect.getPrototypeOf":427,"gopd":430,"has-symbols":432,"hasown":435,"math-intrinsics/abs":442,"math-intrinsics/floor":443,"math-intrinsics/max":445,"math-intrinsics/min":446,"math-intrinsics/pow":447,"math-intrinsics/round":448,"math-intrinsics/sign":449}],426:[function(require,module,exports){
+},{"call-bind-apply-helpers/functionApply":406,"call-bind-apply-helpers/functionCall":407,"es-define-property":414,"es-errors":416,"es-errors/eval":415,"es-errors/range":417,"es-errors/ref":418,"es-errors/syntax":419,"es-errors/type":420,"es-errors/uri":421,"es-object-atoms":422,"function-bind":425,"get-proto":429,"get-proto/Object.getPrototypeOf":427,"get-proto/Reflect.getPrototypeOf":428,"gopd":431,"has-symbols":433,"hasown":436,"math-intrinsics/abs":443,"math-intrinsics/floor":444,"math-intrinsics/max":446,"math-intrinsics/min":447,"math-intrinsics/pow":448,"math-intrinsics/round":449,"math-intrinsics/sign":450}],427:[function(require,module,exports){
 'use strict';
 
 var $Object = require('es-object-atoms');
@@ -68862,13 +69819,13 @@ var $Object = require('es-object-atoms');
 /** @type {import('./Object.getPrototypeOf')} */
 module.exports = $Object.getPrototypeOf || null;
 
-},{"es-object-atoms":421}],427:[function(require,module,exports){
+},{"es-object-atoms":422}],428:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./Reflect.getPrototypeOf')} */
 module.exports = (typeof Reflect !== 'undefined' && Reflect.getPrototypeOf) || null;
 
-},{}],428:[function(require,module,exports){
+},{}],429:[function(require,module,exports){
 'use strict';
 
 var reflectGetProto = require('./Reflect.getPrototypeOf');
@@ -68897,13 +69854,13 @@ module.exports = reflectGetProto
 			}
 			: null;
 
-},{"./Object.getPrototypeOf":426,"./Reflect.getPrototypeOf":427,"dunder-proto/get":412}],429:[function(require,module,exports){
+},{"./Object.getPrototypeOf":427,"./Reflect.getPrototypeOf":428,"dunder-proto/get":413}],430:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./gOPD')} */
 module.exports = Object.getOwnPropertyDescriptor;
 
-},{}],430:[function(require,module,exports){
+},{}],431:[function(require,module,exports){
 'use strict';
 
 /** @type {import('.')} */
@@ -68920,7 +69877,7 @@ if ($gOPD) {
 
 module.exports = $gOPD;
 
-},{"./gOPD":429}],431:[function(require,module,exports){
+},{"./gOPD":430}],432:[function(require,module,exports){
 'use strict';
 
 var $defineProperty = require('es-define-property');
@@ -68944,7 +69901,7 @@ hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBu
 
 module.exports = hasPropertyDescriptors;
 
-},{"es-define-property":413}],432:[function(require,module,exports){
+},{"es-define-property":414}],433:[function(require,module,exports){
 'use strict';
 
 var origSymbol = typeof Symbol !== 'undefined' && Symbol;
@@ -68960,7 +69917,7 @@ module.exports = function hasNativeSymbols() {
 	return hasSymbolSham();
 };
 
-},{"./shams":433}],433:[function(require,module,exports){
+},{"./shams":434}],434:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./shams')} */
@@ -69007,7 +69964,7 @@ module.exports = function hasSymbols() {
 	return true;
 };
 
-},{}],434:[function(require,module,exports){
+},{}],435:[function(require,module,exports){
 'use strict';
 
 var hasSymbols = require('has-symbols/shams');
@@ -69017,7 +69974,7 @@ module.exports = function hasToStringTagShams() {
 	return hasSymbols() && !!Symbol.toStringTag;
 };
 
-},{"has-symbols/shams":433}],435:[function(require,module,exports){
+},{"has-symbols/shams":434}],436:[function(require,module,exports){
 'use strict';
 
 var call = Function.prototype.call;
@@ -69027,7 +69984,7 @@ var bind = require('function-bind');
 /** @type {import('.')} */
 module.exports = bind.call(call, $hasOwn);
 
-},{"function-bind":424}],436:[function(require,module,exports){
+},{"function-bind":425}],437:[function(require,module,exports){
 if (typeof Object.create === 'function') {
   // implementation from standard node.js 'util' module
   module.exports = function inherits(ctor, superCtor) {
@@ -69056,7 +70013,7 @@ if (typeof Object.create === 'function') {
   }
 }
 
-},{}],437:[function(require,module,exports){
+},{}],438:[function(require,module,exports){
 'use strict';
 
 var hasToStringTag = require('has-tostringtag/shams')();
@@ -69102,7 +70059,7 @@ isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests
 /** @type {import('.')} */
 module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
 
-},{"call-bound":410,"has-tostringtag/shams":434}],438:[function(require,module,exports){
+},{"call-bound":411,"has-tostringtag/shams":435}],439:[function(require,module,exports){
 'use strict';
 
 var fnToStr = Function.prototype.toString;
@@ -69205,7 +70162,7 @@ module.exports = reflectApply
 		return tryFunctionObject(value);
 	};
 
-},{}],439:[function(require,module,exports){
+},{}],440:[function(require,module,exports){
 'use strict';
 
 var callBound = require('call-bound');
@@ -69254,7 +70211,7 @@ module.exports = function isGeneratorFunction(fn) {
 	return getProto(fn) === GeneratorFunction;
 };
 
-},{"call-bound":410,"get-proto":428,"has-tostringtag/shams":434,"safe-regex-test":457}],440:[function(require,module,exports){
+},{"call-bound":411,"get-proto":429,"has-tostringtag/shams":435,"safe-regex-test":458}],441:[function(require,module,exports){
 'use strict';
 
 var callBound = require('call-bound');
@@ -69325,7 +70282,7 @@ if (hasToStringTag) {
 
 module.exports = fn;
 
-},{"call-bound":410,"gopd":430,"has-tostringtag/shams":434,"hasown":435}],441:[function(require,module,exports){
+},{"call-bound":411,"gopd":431,"has-tostringtag/shams":435,"hasown":436}],442:[function(require,module,exports){
 'use strict';
 
 var whichTypedArray = require('which-typed-array');
@@ -69335,19 +70292,19 @@ module.exports = function isTypedArray(value) {
 	return !!whichTypedArray(value);
 };
 
-},{"which-typed-array":462}],442:[function(require,module,exports){
+},{"which-typed-array":463}],443:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./abs')} */
 module.exports = Math.abs;
 
-},{}],443:[function(require,module,exports){
+},{}],444:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./floor')} */
 module.exports = Math.floor;
 
-},{}],444:[function(require,module,exports){
+},{}],445:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./isNaN')} */
@@ -69355,31 +70312,31 @@ module.exports = Number.isNaN || function isNaN(a) {
 	return a !== a;
 };
 
-},{}],445:[function(require,module,exports){
+},{}],446:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./max')} */
 module.exports = Math.max;
 
-},{}],446:[function(require,module,exports){
+},{}],447:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./min')} */
 module.exports = Math.min;
 
-},{}],447:[function(require,module,exports){
+},{}],448:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./pow')} */
 module.exports = Math.pow;
 
-},{}],448:[function(require,module,exports){
+},{}],449:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./round')} */
 module.exports = Math.round;
 
-},{}],449:[function(require,module,exports){
+},{}],450:[function(require,module,exports){
 'use strict';
 
 var $isNaN = require('./isNaN');
@@ -69392,7 +70349,7 @@ module.exports = function sign(number) {
 	return number < 0 ? -1 : +1;
 };
 
-},{"./isNaN":444}],450:[function(require,module,exports){
+},{"./isNaN":445}],451:[function(require,module,exports){
 'use strict';
 
 var keysShim;
@@ -69516,7 +70473,7 @@ if (!Object.keys) {
 }
 module.exports = keysShim;
 
-},{"./isArguments":452}],451:[function(require,module,exports){
+},{"./isArguments":453}],452:[function(require,module,exports){
 'use strict';
 
 var slice = Array.prototype.slice;
@@ -69550,7 +70507,7 @@ keysShim.shim = function shimObjectKeys() {
 
 module.exports = keysShim;
 
-},{"./implementation":450,"./isArguments":452}],452:[function(require,module,exports){
+},{"./implementation":451,"./isArguments":453}],453:[function(require,module,exports){
 'use strict';
 
 var toStr = Object.prototype.toString;
@@ -69569,7 +70526,7 @@ module.exports = function isArguments(value) {
 	return isArgs;
 };
 
-},{}],453:[function(require,module,exports){
+},{}],454:[function(require,module,exports){
 'use strict';
 
 // modified from https://github.com/es-shims/es6-shim
@@ -69617,7 +70574,7 @@ module.exports = function assign(target, source1) {
 	return to; // step 4
 };
 
-},{"call-bound":410,"es-object-atoms":421,"has-symbols/shams":433,"object-keys":451}],454:[function(require,module,exports){
+},{"call-bound":411,"es-object-atoms":422,"has-symbols/shams":434,"object-keys":452}],455:[function(require,module,exports){
 'use strict';
 
 var implementation = require('./implementation');
@@ -69674,7 +70631,7 @@ module.exports = function getPolyfill() {
 	return Object.assign;
 };
 
-},{"./implementation":453}],455:[function(require,module,exports){
+},{"./implementation":454}],456:[function(require,module,exports){
 'use strict';
 
 /** @type {import('.')} */
@@ -69693,7 +70650,7 @@ module.exports = [
 	'BigUint64Array'
 ];
 
-},{}],456:[function(require,module,exports){
+},{}],457:[function(require,module,exports){
 // shim for using process in browser
 var process = module.exports = {};
 
@@ -69879,7 +70836,7 @@ process.chdir = function (dir) {
 };
 process.umask = function() { return 0; };
 
-},{}],457:[function(require,module,exports){
+},{}],458:[function(require,module,exports){
 'use strict';
 
 var callBound = require('call-bound');
@@ -69898,7 +70855,7 @@ module.exports = function regexTester(regex) {
 	};
 };
 
-},{"call-bound":410,"es-errors/type":419,"is-regex":440}],458:[function(require,module,exports){
+},{"call-bound":411,"es-errors/type":420,"is-regex":441}],459:[function(require,module,exports){
 'use strict';
 
 var GetIntrinsic = require('get-intrinsic');
@@ -69942,9 +70899,9 @@ module.exports = function setFunctionLength(fn, length) {
 	return fn;
 };
 
-},{"define-data-property":411,"es-errors/type":419,"get-intrinsic":425,"gopd":430,"has-property-descriptors":431}],459:[function(require,module,exports){
-arguments[4][399][0].apply(exports,arguments)
-},{"dup":399}],460:[function(require,module,exports){
+},{"define-data-property":412,"es-errors/type":420,"get-intrinsic":426,"gopd":431,"has-property-descriptors":432}],460:[function(require,module,exports){
+arguments[4][400][0].apply(exports,arguments)
+},{"dup":400}],461:[function(require,module,exports){
 // Currently in sync with Node.js lib/internal/util/types.js
 // https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9
 
@@ -70280,7 +71237,7 @@ exports.isAnyArrayBuffer = isAnyArrayBuffer;
   });
 });
 
-},{"is-arguments":437,"is-generator-function":439,"is-typed-array":441,"which-typed-array":462}],461:[function(require,module,exports){
+},{"is-arguments":438,"is-generator-function":440,"is-typed-array":442,"which-typed-array":463}],462:[function(require,module,exports){
 (function (process){(function (){
 // Copyright Joyent, Inc. and other Node contributors.
 //
@@ -70999,7 +71956,7 @@ function callbackify(original) {
 exports.callbackify = callbackify;
 
 }).call(this)}).call(this,require('_process'))
-},{"./support/isBuffer":459,"./support/types":460,"_process":456,"inherits":436}],462:[function(require,module,exports){
+},{"./support/isBuffer":460,"./support/types":461,"_process":457,"inherits":437}],463:[function(require,module,exports){
 (function (global){(function (){
 'use strict';
 
@@ -71120,5 +72077,5 @@ module.exports = function whichTypedArray(value) {
 };
 
 }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"available-typed-arrays":401,"call-bind":409,"call-bound":410,"for-each":422,"get-proto":428,"gopd":430,"has-tostringtag/shams":434}]},{},[134])(134)
+},{"available-typed-arrays":402,"call-bind":410,"call-bound":411,"for-each":423,"get-proto":429,"gopd":431,"has-tostringtag/shams":435}]},{},[134])(134)
 });