@designliquido/delegua 0.62.0 → 0.63.0

package/umd/delegua.js

@@ -2260,7 +2260,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
 }
 exports.AvaliadorSintatico = AvaliadorSintatico;
 
-},{"../bibliotecas/primitivas-dicionario":20,"../bibliotecas/primitivas-numero":21,"../bibliotecas/primitivas-texto":22,"../bibliotecas/primitivas-vetor":23,"../construtos":51,"../construtos/tuplas":68,"../declaracoes":96,"../inferenciador":116,"../informacao-elemento-sintatico":117,"../tipos-de-dados/delegua":185,"../tipos-de-simbolos/delegua":190,"./avaliador-sintatico-base":1,"./comum":3,"./elemento-montao-tipos":11,"./erro-avaliador-sintatico":12,"./informacao-escopo":14,"./montao-tipos":17,"./pilha-escopos":18,"browser-process-hrtime":371}],3:[function(require,module,exports){
+},{"../bibliotecas/primitivas-dicionario":20,"../bibliotecas/primitivas-numero":21,"../bibliotecas/primitivas-texto":22,"../bibliotecas/primitivas-vetor":23,"../construtos":51,"../construtos/tuplas":68,"../declaracoes":96,"../inferenciador":116,"../informacao-elemento-sintatico":117,"../tipos-de-dados/delegua":185,"../tipos-de-simbolos/delegua":190,"./avaliador-sintatico-base":1,"./comum":3,"./elemento-montao-tipos":11,"./erro-avaliador-sintatico":12,"./informacao-escopo":14,"./montao-tipos":17,"./pilha-escopos":18,"browser-process-hrtime":378}],3:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buscarRetornos = buscarRetornos;
@@ -4184,6 +4184,34 @@ class AvaliadorSintaticoPitugues {
         const textoFalha = this.consumir(pitugues_2.default.TEXTO, 'Esperado texto para explicar falha.');
         return new declaracoes_1.Falhar(simboloFalha, textoFalha.literal);
     }
+    /**
+     * Verifica se há pontos e vírgula no final de sentenças.
+     * Em Pituguês, ; só é permitido para separar múltiplos comandos na mesma linha,
+     * mas não no final de uma sentença/linha.
+     */
+    verificarPontosEVirgulasInvalidos() {
+        for (let i = 0; i < this.simbolos.length; i++) {
+            const simboloAtual = this.simbolos[i];
+            if (simboloAtual.tipo === pitugues_2.default.PONTO_E_VIRGULA) {
+                const proximoSimbolo = this.encontrarProximoSimboloNaoComentario(i + 1);
+                if (!proximoSimbolo || proximoSimbolo.linha > simboloAtual.linha) {
+                    this.erros.push(new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simboloAtual, 'Ponto e vírgula (;) não é permitido no final da sentença de código.'));
+                }
+            }
+        }
+    }
+    /**
+     * Encontra o próximo símbolo que não seja comentário.
+     * Isso é importante porque comentários não afetam a validade do ponto e vírgula.
+     */
+    encontrarProximoSimboloNaoComentario(inicio) {
+        for (let i = inicio; i < this.simbolos.length; i++) {
+            if (this.simbolos[i].tipo !== pitugues_2.default.COMENTARIO) {
+                return this.simbolos[i];
+            }
+        }
+        return null;
+    }
     /**
      * Consome o símbolo atual, verificando se é uma declaração de função, variável, classe
      * ou uma expressão.
@@ -4361,15 +4389,29 @@ class AvaliadorSintaticoPitugues {
         this.hashArquivo = hashArquivo || 0;
         this.simbolos = (retornoLexador === null || retornoLexador === void 0 ? void 0 : retornoLexador.simbolos) || [];
         this.localizacoes = (retornoLexador === null || retornoLexador === void 0 ? void 0 : retornoLexador.pragmas) || {};
+        this.verificarPontosEVirgulasInvalidos();
         let declaracoes = [];
         while (!this.estaNoFinal()) {
             const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
+            if (retornoDeclaracao === null) {
+                continue;
+            }
             if (Array.isArray(retornoDeclaracao)) {
                 declaracoes = declaracoes.concat(retornoDeclaracao);
             }
             else {
                 declaracoes.push(retornoDeclaracao);
             }
+            if (!this.estaNoFinal() && this.verificarTipoSimboloAtual(pitugues_2.default.PONTO_E_VIRGULA)) {
+                // Verificar se este ; está na mesma linha da declaração anterior
+                const declaracaoAnterior = declaracoes[declaracoes.length - 1];
+                const linhaDeclaraoAnterior = declaracaoAnterior.linha || 0;
+                const linhaPontoVirgula = this.simboloAtual().linha;
+                if (linhaPontoVirgula === linhaDeclaraoAnterior) {
+                    // Está na mesma linha, então é um separador válido
+                    this.avancarEDevolverAnterior();
+                }
+            }
         }
         if (this.performance) {
             const deltaAnalise = (0, browser_process_hrtime_1.default)(inicioAnalise);
@@ -4384,7 +4426,7 @@ class AvaliadorSintaticoPitugues {
 }
 exports.AvaliadorSintaticoPitugues = AvaliadorSintaticoPitugues;
 
-},{"../../bibliotecas/primitivas-dicionario":20,"../../bibliotecas/primitivas-numero":21,"../../bibliotecas/primitivas-texto":22,"../../bibliotecas/primitivas-vetor":23,"../../construtos":51,"../../declaracoes":96,"../../inferenciador":116,"../../informacao-elemento-sintatico":117,"../../lexador":177,"../../tipos-de-dados/dialetos/pitugues":186,"../../tipos-de-simbolos/pitugues":194,"../comum":3,"../erro-avaliador-sintatico":12,"../informacao-escopo":14,"../pilha-escopos":18,"browser-process-hrtime":371}],7:[function(require,module,exports){
+},{"../../bibliotecas/primitivas-dicionario":20,"../../bibliotecas/primitivas-numero":21,"../../bibliotecas/primitivas-texto":22,"../../bibliotecas/primitivas-vetor":23,"../../construtos":51,"../../declaracoes":96,"../../inferenciador":116,"../../informacao-elemento-sintatico":117,"../../lexador":177,"../../tipos-de-dados/dialetos/pitugues":186,"../../tipos-de-simbolos/pitugues":194,"../comum":3,"../erro-avaliador-sintatico":12,"../informacao-escopo":14,"../pilha-escopos":18,"browser-process-hrtime":378}],7:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -5273,7 +5315,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
 }
 exports.AvaliadorSintaticoPrisma = AvaliadorSintaticoPrisma;
 
-},{"../../bibliotecas/primitivas-dicionario":20,"../../bibliotecas/primitivas-numero":21,"../../bibliotecas/primitivas-texto":22,"../../bibliotecas/primitivas-vetor":23,"../../construtos":51,"../../declaracoes":96,"../../inferenciador":116,"../../informacao-elemento-sintatico":117,"../../lexador":177,"../../tipos-de-simbolos/prisma":196,"../avaliador-sintatico-base":1,"../comum":3,"../erro-avaliador-sintatico":12,"../informacao-escopo":14,"../pilha-escopos":18,"browser-process-hrtime":371}],9:[function(require,module,exports){
+},{"../../bibliotecas/primitivas-dicionario":20,"../../bibliotecas/primitivas-numero":21,"../../bibliotecas/primitivas-texto":22,"../../bibliotecas/primitivas-vetor":23,"../../construtos":51,"../../declaracoes":96,"../../inferenciador":116,"../../informacao-elemento-sintatico":117,"../../lexador":177,"../../tipos-de-simbolos/prisma":196,"../avaliador-sintatico-base":1,"../comum":3,"../erro-avaliador-sintatico":12,"../informacao-escopo":14,"../pilha-escopos":18,"browser-process-hrtime":378}],9:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -6259,7 +6301,7 @@ class AvaliadorSintaticoTenda extends avaliador_sintatico_base_1.AvaliadorSintat
 }
 exports.AvaliadorSintaticoTenda = AvaliadorSintaticoTenda;
 
-},{"../../bibliotecas/primitivas-dicionario":20,"../../bibliotecas/primitivas-numero":21,"../../bibliotecas/primitivas-texto":22,"../../bibliotecas/primitivas-vetor":23,"../../construtos":51,"../../construtos/tuplas":68,"../../declaracoes":96,"../../inferenciador":116,"../../informacao-elemento-sintatico":117,"../../lexador/simbolo":183,"../../tipos-de-dados/delegua":185,"../../tipos-de-simbolos/tenda":197,"../avaliador-sintatico-base":1,"./../erro-avaliador-sintatico":12,"./../informacao-escopo":14,"./../pilha-escopos":18,"browser-process-hrtime":371}],10:[function(require,module,exports){
+},{"../../bibliotecas/primitivas-dicionario":20,"../../bibliotecas/primitivas-numero":21,"../../bibliotecas/primitivas-texto":22,"../../bibliotecas/primitivas-vetor":23,"../../construtos":51,"../../construtos/tuplas":68,"../../declaracoes":96,"../../inferenciador":116,"../../informacao-elemento-sintatico":117,"../../lexador/simbolo":183,"../../tipos-de-dados/delegua":185,"../../tipos-de-simbolos/tenda":197,"../avaliador-sintatico-base":1,"./../erro-avaliador-sintatico":12,"./../informacao-escopo":14,"./../pilha-escopos":18,"browser-process-hrtime":378}],10:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -14741,7 +14783,7 @@ class InterpretadorBase {
 exports.InterpretadorBase = InterpretadorBase;
 
 }).call(this)}).call(this,require('_process'))
-},{"../avaliador-sintatico":13,"../bibliotecas/primitivas-dicionario":20,"../bibliotecas/primitivas-vetor":23,"../construtos":51,"../excecoes":110,"../inferenciador":116,"../lexador":177,"../quebras":184,"../tipos-de-dados/delegua":185,"../tipos-de-dados/primitivos":187,"../tipos-de-simbolos/delegua":190,"./espaco-memoria":144,"./estruturas":151,"./estruturas/metodo-primitiva":152,"./pilha-escopos-execucao":161,"_process":425,"browser-process-hrtime":371}],159:[function(require,module,exports){
+},{"../avaliador-sintatico":13,"../bibliotecas/primitivas-dicionario":20,"../bibliotecas/primitivas-vetor":23,"../construtos":51,"../excecoes":110,"../inferenciador":116,"../lexador":177,"../quebras":184,"../tipos-de-dados/delegua":185,"../tipos-de-dados/primitivos":187,"../tipos-de-simbolos/delegua":190,"./espaco-memoria":144,"./estruturas":151,"./estruturas/metodo-primitiva":152,"./pilha-escopos-execucao":161,"_process":432,"browser-process-hrtime":378}],159:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -16779,7 +16821,7 @@ class LexadorPitugues {
         this.performance = performance;
         this.simbolos = [];
         this.erros = [];
-        this.pragmas = {};
+        this.localizacoes = {};
         this.inicioSimbolo = 0;
         this.atual = 0;
         this.linha = 0;
@@ -16961,7 +17003,7 @@ class LexadorPitugues {
             espacos++;
             this.avancar();
         }
-        this.pragmas[this.linha + 1] = {
+        this.localizacoes[this.linha + 1] = {
             linha: this.linha + 1,
             espacosIndentacao: espacos,
         };
@@ -16987,12 +17029,13 @@ class LexadorPitugues {
         switch (caractere) {
             case ' ':
             case '\t':
-                this.avancar();
-                break;
             case '\r':
             case '\n':
             case '\0':
+                this.avancar();
+                break;
             case ';':
+                this.adicionarSimbolo(pitugues_2.default.PONTO_E_VIRGULA);
                 this.avancar();
                 break;
             case '=':
@@ -17178,7 +17221,7 @@ class LexadorPitugues {
         const inicioMapeamento = (0, browser_process_hrtime_1.default)();
         this.simbolos = [];
         this.erros = [];
-        this.pragmas = {};
+        this.localizacoes = {};
         this.inicioSimbolo = 0;
         this.atual = 0;
         this.linha = 0;
@@ -17198,13 +17241,13 @@ class LexadorPitugues {
         return {
             simbolos: this.simbolos,
             erros: this.erros,
-            pragmas: this.pragmas,
+            pragmas: this.localizacoes,
         };
     }
 }
 exports.LexadorPitugues = LexadorPitugues;
 
-},{"../../tipos-de-simbolos/pitugues":194,"../simbolo":183,"./palavras-reservadas/pitugues":173,"browser-process-hrtime":371}],167:[function(require,module,exports){
+},{"../../tipos-de-simbolos/pitugues":194,"../simbolo":183,"./palavras-reservadas/pitugues":173,"browser-process-hrtime":378}],167:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -17814,7 +17857,7 @@ class LexadorPrisma {
 }
 exports.LexadorPrisma = LexadorPrisma;
 
-},{"../../tipos-de-simbolos/prisma":196,"../simbolo":183,"./palavras-reservadas/prisma":175,"browser-process-hrtime":371}],169:[function(require,module,exports){
+},{"../../tipos-de-simbolos/prisma":196,"../simbolo":183,"./palavras-reservadas/prisma":175,"browser-process-hrtime":378}],169:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -18205,7 +18248,7 @@ class LexadorTenda {
 }
 exports.LexadorTenda = LexadorTenda;
 
-},{"../../tipos-de-simbolos/tenda":197,"../simbolo":183,"./palavras-reservadas/tenda":176,"browser-process-hrtime":371}],170:[function(require,module,exports){
+},{"../../tipos-de-simbolos/tenda":197,"../simbolo":183,"./palavras-reservadas/tenda":176,"browser-process-hrtime":378}],170:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -19164,7 +19207,7 @@ class Lexador {
 }
 exports.Lexador = Lexador;
 
-},{"../tipos-de-simbolos/delegua":190,"./palavras-reservadas":182,"./simbolo":183,"browser-process-hrtime":371}],181:[function(require,module,exports){
+},{"../tipos-de-simbolos/delegua":190,"./palavras-reservadas":182,"./simbolo":183,"browser-process-hrtime":378}],181:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -20226,6 +20269,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__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-javascript"), exports);
@@ -20236,7 +20281,138 @@ __exportStar(require("./tradutor-reverso-javascript"), exports);
 __exportStar(require("./tradutor-reverso-python"), exports);
 __exportStar(require("./tradutor-reverso-tenda"), exports);
 
-},{"./tradutor-assemblyscript":201,"./tradutor-calango":202,"./tradutor-javascript":203,"./tradutor-mermaidjs":204,"./tradutor-portugol-ipt":205,"./tradutor-python":206,"./tradutor-reverso-javascript":207,"./tradutor-reverso-python":208,"./tradutor-reverso-tenda":209}],199:[function(require,module,exports){
+},{"./tradutor-assembly-arm":206,"./tradutor-assembly-x64":207,"./tradutor-assemblyscript":208,"./tradutor-calango":209,"./tradutor-javascript":210,"./tradutor-mermaidjs":211,"./tradutor-portugol-ipt":212,"./tradutor-python":213,"./tradutor-reverso-javascript":214,"./tradutor-reverso-python":215,"./tradutor-reverso-tenda":216}],199:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArestaFluxograma = void 0;
+class ArestaFluxograma {
+    constructor(declaracao, texto) {
+        this.declaracao = declaracao;
+        this.texto = texto;
+    }
+}
+exports.ArestaFluxograma = ArestaFluxograma;
+
+},{}],200:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagramaClasse = void 0;
+class DiagramaClasse {
+    constructor(nome, superClasse) {
+        this.nome = nome;
+        this.superClasse = superClasse;
+        this.metodos = [];
+        this.propriedades = [];
+    }
+    paraTexto() {
+        let resultado = `    classe ${this.nome} {\n`;
+        // Adiciona propriedades (se houver)
+        for (const prop of this.propriedades) {
+            const tipo = prop.tipo ? `: ${prop.tipo}` : '';
+            resultado += `        +${prop.nome}${tipo}\n`;
+        }
+        // Adiciona métodos
+        for (const metodo of this.metodos) {
+            const params = metodo.parametros.join(', ');
+            const retorno = metodo.tipoRetorno ? `: ${metodo.tipoRetorno}` : '';
+            resultado += `        +${metodo.nome}(${params})${retorno}\n`;
+        }
+        resultado += `    }\n`;
+        // Adiciona herança se houver
+        if (this.superClasse) {
+            resultado += `    ${this.superClasse} <|-- ${this.nome}\n`;
+        }
+        return resultado;
+    }
+}
+exports.DiagramaClasse = DiagramaClasse;
+
+},{}],201:[function(require,module,exports){
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./aresta-fluxograma"), exports);
+__exportStar(require("./diagrama-classe"), exports);
+__exportStar(require("./subgrafo-classe"), exports);
+__exportStar(require("./vertice-fluxograma"), exports);
+
+},{"./aresta-fluxograma":199,"./diagrama-classe":200,"./subgrafo-classe":202,"./vertice-fluxograma":203}],202:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubgrafoClasse = void 0;
+class SubgrafoClasse {
+    constructor(nomeClasse, linha, superClasse) {
+        this.nomeClasse = nomeClasse;
+        this.linha = linha;
+        this.superClasse = superClasse;
+        this.vertices = [];
+        this.metodos = [];
+    }
+    paraTexto() {
+        let resultado = `    subgraph Classe_${this.nomeClasse}_${this.linha}["Classe: ${this.nomeClasse}`;
+        if (this.superClasse) {
+            resultado += ` (estende ${this.superClasse})`;
+        }
+        resultado += `"]\n`;
+        resultado += `        direction TB\n`;
+        // Nó de início da classe
+        resultado += `        ClasseInicio_${this.nomeClasse}_${this.linha}((Início da Classe))\n`;
+        // Adiciona os métodos como sub-subgrafos
+        for (const metodo of this.metodos) {
+            resultado += `        subgraph Metodo_${metodo.nome}_${this.nomeClasse}_${this.linha}["Método: ${metodo.nome}"]\n`;
+            resultado += `            direction TB\n`;
+            for (const vertice of metodo.vertices) {
+                // Adiciona indentação extra para vértices dentro do método
+                const textoVertice = vertice.paraTexto().replace(/^ {4}/, '            ');
+                resultado += textoVertice;
+            }
+            resultado += `        end\n`;
+        }
+        // Conecta o início da classe aos métodos
+        if (this.metodos.length > 0) {
+            const primeiroMetodo = this.metodos[0];
+            if (primeiroMetodo.vertices.length > 0) {
+                const primeiraAresta = primeiroMetodo.vertices[0].origem.texto;
+                resultado += `        ClasseInicio_${this.nomeClasse}_${this.linha} --> ${primeiraAresta}\n`;
+            }
+        }
+        resultado += `    end\n`;
+        return resultado;
+    }
+}
+exports.SubgrafoClasse = SubgrafoClasse;
+
+},{}],203:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerticeFluxograma = void 0;
+class VerticeFluxograma {
+    constructor(origem, destino, texto) {
+        this.origem = origem;
+        this.destino = destino;
+        this.texto = texto;
+    }
+    paraTexto() {
+        const seta = this.texto ? `-->|${this.texto}|` : '-->';
+        return `    ${this.origem.texto}${seta}${this.destino.texto};\n`;
+    }
+}
+exports.VerticeFluxograma = VerticeFluxograma;
+
+},{}],204:[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) {
@@ -21476,7 +21652,7 @@ __decorate([
     Decorators_1.Override
 ], Python3Lexer.prototype, "nextToken", null);
 
-},{"./python3-parser":200,"antlr4ts/CommonToken":219,"antlr4ts/Decorators":223,"antlr4ts/Lexer":231,"antlr4ts/Token":248,"antlr4ts/VocabularyImpl":254,"antlr4ts/atn/ATNDeserializer":260,"antlr4ts/atn/LexerATNSimulator":281,"antlr4ts/misc/Utils":342}],200:[function(require,module,exports){
+},{"./python3-parser":205,"antlr4ts/CommonToken":226,"antlr4ts/Decorators":230,"antlr4ts/Lexer":238,"antlr4ts/Token":255,"antlr4ts/VocabularyImpl":261,"antlr4ts/atn/ATNDeserializer":267,"antlr4ts/atn/LexerATNSimulator":288,"antlr4ts/misc/Utils":349}],205:[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) {
@@ -32723,7 +32899,1391 @@ class Yield_argContext extends ParserRuleContext_1.ParserRuleContext {
 }
 exports.Yield_argContext = Yield_argContext;
 
-},{"antlr4ts/FailedPredicateException":227,"antlr4ts/NoViableAltException":235,"antlr4ts/Parser":236,"antlr4ts/ParserRuleContext":239,"antlr4ts/RecognitionException":242,"antlr4ts/Token":248,"antlr4ts/VocabularyImpl":254,"antlr4ts/atn/ATN":256,"antlr4ts/atn/ATNDeserializer":260,"antlr4ts/atn/ParserATNSimulator":297,"antlr4ts/misc/Utils":342}],201:[function(require,module,exports){
+},{"antlr4ts/FailedPredicateException":234,"antlr4ts/NoViableAltException":242,"antlr4ts/Parser":243,"antlr4ts/ParserRuleContext":246,"antlr4ts/RecognitionException":249,"antlr4ts/Token":255,"antlr4ts/VocabularyImpl":261,"antlr4ts/atn/ATN":263,"antlr4ts/atn/ATNDeserializer":267,"antlr4ts/atn/ParserATNSimulator":304,"antlr4ts/misc/Utils":349}],206:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradutorAssemblyARM = void 0;
+const construtos_1 = require("../construtos");
+const declaracoes_1 = require("../declaracoes");
+class TradutorAssemblyARM {
+    constructor(alvo = 'linux-arm') {
+        this.alvo = alvo;
+        this.indentacao = 0;
+        this.contadorLabels = 0;
+        this.variaveis = new Map();
+        this.registradoresDisponiveis = ['r4', 'r5', 'r6', 'r7', 'r8', 'r9', 'r10'];
+        this.pilhaRegistradores = [];
+        this.bss = '.bss\n';
+        this.data = '.data\n';
+        this.dicionarioConstrutos = {
+            AcessoIndiceVariavel: this.traduzirAcessoIndiceVariavel.bind(this),
+            AcessoMetodoOuPropriedade: this.trazudirConstrutoAcessoMetodo.bind(this),
+            Agrupamento: this.traduzirConstrutoAgrupamento.bind(this),
+            AtribuicaoPorIndice: this.traduzirConstrutoAtribuicaoPorIndice.bind(this),
+            Atribuir: this.traduzirConstrutoAtribuir.bind(this),
+            Binario: this.traduzirConstrutoBinario.bind(this),
+            Chamada: this.traduzirConstrutoChamada.bind(this),
+            DefinirValor: this.traduzirConstrutoDefinirValor.bind(this),
+            FuncaoConstruto: this.traduzirFuncaoConstruto.bind(this),
+            Isto: () => 'this',
+            Literal: this.traduzirConstrutoLiteral.bind(this),
+            Logico: this.traduzirConstrutoLogico.bind(this),
+            TipoDe: this.traduzirConstrutoTipoDe.bind(this),
+            Unario: this.traduzirConstrutoUnario.bind(this),
+            Variavel: this.traduzirConstrutoVariavel.bind(this),
+            Vetor: this.traduzirConstrutoVetor.bind(this),
+        };
+        this.dicionarioDeclaracoes = {
+            Bloco: this.traduzirDeclaracaoBloco.bind(this),
+            Enquanto: this.traduzirDeclaracaoEnquanto.bind(this),
+            Continua: () => 'b .continue_label',
+            Escolha: this.traduzirDeclaracaoEscolha.bind(this),
+            Escreva: this.traduzirDeclaracaoEscreva.bind(this),
+            Expressao: this.traduzirDeclaracaoExpressao.bind(this),
+            Fazer: this.traduzirDeclaracaoFazer.bind(this),
+            Falhar: this.traduzirDeclaracaoFalhar.bind(this),
+            FuncaoDeclaracao: this.traduzirDeclaracaoFuncao.bind(this),
+            Importar: this.traduzirDeclaracaoImportar.bind(this),
+            Leia: this.traduzirDeclaracaoLeia.bind(this),
+            Para: this.traduzirDeclaracaoPara.bind(this),
+            ParaCada: this.traduzirDeclaracaoParaCada.bind(this),
+            Retorna: this.traduzirDeclaracaoRetorna.bind(this),
+            Se: this.traduzirDeclaracaoSe.bind(this),
+            Sustar: () => 'b .break_label',
+            Classe: this.traduzirDeclaracaoClasse.bind(this),
+            Tente: this.traduzirDeclaracaoTente.bind(this),
+            Const: this.traduzirDeclaracaoConst.bind(this),
+            Var: this.traduzirDeclaracaoVar.bind(this),
+        };
+        this.indentacao = 0;
+        // Seleciona o símbolo de entrada conforme a plataforma alvo.
+        // Para linux-arm: programa standalone com _start.
+        // Para android: ainda é um binário standalone, mas com rótulo Delegua_main
+        // para deixar claro que não é o _start do CRT padrão.
+        const entryLabel = this.alvo === 'android' ? 'Delegua_main' : '_start';
+        this.text = `
+.text
+.global ${entryLabel}
+
+${entryLabel}:`;
+    }
+    gerarDigitoAleatorio() {
+        let result = '';
+        const digits = '0123456789';
+        for (let i = 0; i < 5; i++) {
+            const randomIndex = Math.floor(Math.random() * digits.length);
+            result += digits.charAt(randomIndex);
+        }
+        return result;
+    }
+    gerarLabel() {
+        return `.L${this.contadorLabels++}`;
+    }
+    obterRegistrador() {
+        if (this.registradoresDisponiveis.length > 0) {
+            const reg = this.registradoresDisponiveis.pop();
+            this.pilhaRegistradores.push(reg);
+            return reg;
+        }
+        return 'r0'; // fallback
+    }
+    liberarRegistrador(reg) {
+        const index = this.pilhaRegistradores.indexOf(reg);
+        if (index > -1) {
+            this.pilhaRegistradores.splice(index, 1);
+            this.registradoresDisponiveis.push(reg);
+        }
+    }
+    // Implementação dos Construtos
+    traduzirAcessoIndiceVariavel(construto) {
+        var _a;
+        let nomeVar;
+        if (construto.entidadeChamada instanceof construtos_1.Variavel) {
+            nomeVar = (_a = construto.entidadeChamada.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        }
+        if (!nomeVar) {
+            nomeVar = 'unknown';
+        }
+        const indice = this.dicionarioConstrutos[construto.indice.constructor.name](construto.indice);
+        const reg = this.obterRegistrador();
+        this.text += `
+    ldr ${reg}, =${nomeVar}
+    ldr r0, =${indice}
+    lsl r0, r0, #2          @ multiply index by 4 (word size)
+    add ${reg}, ${reg}, r0
+    ldr r0, [${reg}]`;
+        this.liberarRegistrador(reg);
+        return 'r0';
+    }
+    trazudirConstrutoAcessoMetodo(construto) {
+        const objeto = this.dicionarioConstrutos[construto.objeto.constructor.name](construto.objeto);
+        return `${objeto}_${construto.nomeMetodo}`;
+    }
+    traduzirConstrutoAgrupamento(construto) {
+        return this.dicionarioConstrutos[construto.expressao.constructor.name](construto.expressao);
+    }
+    traduzirConstrutoAtribuicaoPorIndice(construto) {
+        var _a;
+        let nomeVar;
+        if (construto.objeto instanceof construtos_1.Variavel) {
+            nomeVar = (_a = construto.objeto.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        }
+        if (!nomeVar) {
+            nomeVar = 'unknown';
+        }
+        const indice = this.dicionarioConstrutos[construto.indice.constructor.name](construto.indice);
+        const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
+        const reg = this.obterRegistrador();
+        this.text += `
+    ldr ${reg}, =${nomeVar}
+    ldr r1, =${indice}
+    lsl r1, r1, #2          @ multiply by 4
+    add ${reg}, ${reg}, r1
+    ldr r1, =${valor}
+    str r1, [${reg}]`;
+        this.liberarRegistrador(reg);
+    }
+    traduzirConstrutoAtribuir(construto) {
+        var _a;
+        let nomeVar;
+        if (construto.alvo instanceof construtos_1.Variavel) {
+            nomeVar = (_a = construto.alvo.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        }
+        if (!nomeVar) {
+            return;
+        }
+        const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
+        if (!this.variaveis.has(nomeVar)) {
+            const varLabel = `var_${nomeVar}`;
+            this.bss += `    ${varLabel}: .space 4\n`;
+            this.variaveis.set(nomeVar, varLabel);
+        }
+        this.text += `
+    ldr r0, =${valor}
+    ldr r1, =${this.variaveis.get(nomeVar)}
+    str r0, [r1]`;
+    }
+    traduzirConstrutoBinario(construto) {
+        const esquerda = this.dicionarioConstrutos[construto.esquerda.constructor.name](construto.esquerda);
+        const direita = this.dicionarioConstrutos[construto.direita.constructor.name](construto.direita);
+        const operador = construto.operador.lexema;
+        const reg = this.obterRegistrador();
+        // Load left operand into r0
+        if (esquerda !== 'r0') {
+            this.text += `
+    ldr r0, =${esquerda}`;
+        }
+        // Load right operand into reg
+        this.text += `
+    ldr ${reg}, =${direita}`;
+        switch (operador) {
+            case '+':
+                this.text += `
+    add r0, r0, ${reg}`;
+                break;
+            case '-':
+                this.text += `
+    sub r0, r0, ${reg}`;
+                break;
+            case '*':
+                this.text += `
+    mul r0, r0, ${reg}`;
+                break;
+            case '/':
+                this.text += `
+    sdiv r0, r0, ${reg}`;
+                break;
+            case '%':
+                this.text += `
+    sdiv r1, r0, ${reg}
+    mul r1, r1, ${reg}
+    sub r0, r0, r1          @ r0 = r0 - (r0/reg)*reg`;
+                break;
+            case '<':
+                this.text += `
+    cmp r0, ${reg}
+    movlt r0, #1
+    movge r0, #0`;
+                break;
+            case '>':
+                this.text += `
+    cmp r0, ${reg}
+    movgt r0, #1
+    movle r0, #0`;
+                break;
+            case '<=':
+                this.text += `
+    cmp r0, ${reg}
+    movle r0, #1
+    movgt r0, #0`;
+                break;
+            case '>=':
+                this.text += `
+    cmp r0, ${reg}
+    movge r0, #1
+    movlt r0, #0`;
+                break;
+            case '==':
+            case '===':
+                this.text += `
+    cmp r0, ${reg}
+    moveq r0, #1
+    movne r0, #0`;
+                break;
+            case '!=':
+            case '!==':
+                this.text += `
+    cmp r0, ${reg}
+    movne r0, #1
+    moveq r0, #0`;
+                break;
+            default:
+                this.text += `
+    @ Operador ${operador} não implementado`;
+        }
+        this.liberarRegistrador(reg);
+        return 'r0';
+    }
+    traduzirConstrutoChamada(construto) {
+        var _a;
+        let nomeFuncao = 'funcao';
+        if (construto.entidadeChamada instanceof construtos_1.Variavel) {
+            nomeFuncao = ((_a = construto.entidadeChamada.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'funcao';
+        }
+        // ARM calling convention: r0-r3 for first 4 args, rest on stack
+        const registrosArgs = ['r0', 'r1', 'r2', 'r3'];
+        construto.argumentos.forEach((arg, index) => {
+            if (index < registrosArgs.length) {
+                const valorArg = this.dicionarioConstrutos[arg.constructor.name](arg);
+                if (valorArg !== registrosArgs[index]) {
+                    this.text += `
+    ldr ${registrosArgs[index]}, =${valorArg}`;
+                }
+            }
+            else {
+                // Push extra args on stack
+                const valorArg = this.dicionarioConstrutos[arg.constructor.name](arg);
+                this.text += `
+    ldr r0, =${valorArg}
+    push {r0}`;
+            }
+        });
+        this.text += `
+    bl ${nomeFuncao}`;
+    }
+    traduzirConstrutoDefinirValor(construto) {
+        const objeto = this.dicionarioConstrutos[construto.objeto.constructor.name](construto.objeto);
+        const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
+        this.text += `
+    ldr r0, =${valor}
+    ldr r1, =${objeto}
+    str r0, [r1]`;
+    }
+    traduzirFuncaoConstruto(construto) {
+        const labelFuncao = `func_${this.gerarDigitoAleatorio()}`;
+        this.text += `
+
+${labelFuncao}:
+    push {fp, lr}
+    mov fp, sp`;
+        // Traduzir corpo da função
+        if (construto.corpo && Array.isArray(construto.corpo)) {
+            construto.corpo.forEach((declaracao) => {
+                if (this.dicionarioDeclaracoes[declaracao.constructor.name]) {
+                    this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao);
+                }
+            });
+        }
+        this.text += `
+    mov sp, fp
+    pop {fp, pc}`;
+    }
+    traduzirConstrutoLiteral(construto) {
+        if (typeof construto.valor === 'string') {
+            return this.criaStringLiteral(construto);
+        }
+        return String(construto.valor);
+    }
+    traduzirConstrutoLogico(construto) {
+        const esquerda = this.dicionarioConstrutos[construto.esquerda.constructor.name](construto.esquerda);
+        const direita = this.dicionarioConstrutos[construto.direita.constructor.name](construto.direita);
+        const operador = construto.operador.lexema;
+        const labelVerdadeiro = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        this.text += `
+    ldr r0, =${esquerda}
+    cmp r0, #0`;
+        if (operador === 'e' || operador === '&&') {
+            this.text += `
+    beq ${labelFim}
+    ldr r0, =${direita}
+    cmp r0, #0
+    beq ${labelFim}
+${labelVerdadeiro}:
+    mov r0, #1
+${labelFim}:`;
+        }
+        else if (operador === 'ou' || operador === '||') {
+            this.text += `
+    bne ${labelVerdadeiro}
+    ldr r0, =${direita}
+    cmp r0, #0
+    bne ${labelVerdadeiro}
+    mov r0, #0
+    b ${labelFim}
+${labelVerdadeiro}:
+    mov r0, #1
+${labelFim}:`;
+        }
+        return 'r0';
+    }
+    traduzirConstrutoTipoDe(construto) {
+        const expressao = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
+        return expressao;
+    }
+    traduzirConstrutoUnario(construto) {
+        const operando = this.dicionarioConstrutos[construto.operando.constructor.name](construto.operando);
+        const operador = construto.operador.lexema;
+        this.text += `
+    ldr r0, =${operando}`;
+        if (operador === '-') {
+            this.text += `
+    neg r0, r0`;
+        }
+        else if (operador === '!' || operador === 'nao') {
+            this.text += `
+    cmp r0, #0
+    moveq r0, #1
+    movne r0, #0`;
+        }
+        return 'r0';
+    }
+    traduzirConstrutoVariavel(construto) {
+        var _a;
+        const nomeVar = (_a = construto.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        if (nomeVar && this.variaveis.has(nomeVar)) {
+            const varLabel = this.variaveis.get(nomeVar);
+            this.text += `
+    ldr r0, =${varLabel}
+    ldr r0, [r0]`;
+            return 'r0';
+        }
+        return nomeVar || 'unknown';
+    }
+    traduzirConstrutoVetor(construto) {
+        var _a;
+        const labelVetor = `vetor_${this.gerarDigitoAleatorio()}`;
+        const tamanho = ((_a = construto.valores) === null || _a === void 0 ? void 0 : _a.length) || 0;
+        this.bss += `    ${labelVetor}: .space ${tamanho * 4}\n`;
+        if (construto.valores && Array.isArray(construto.valores)) {
+            construto.valores.forEach((valor, index) => {
+                if (this.dicionarioConstrutos[valor.constructor.name]) {
+                    const valorTraduzido = this.dicionarioConstrutos[valor.constructor.name](valor);
+                    this.text += `
+    ldr r0, =${valorTraduzido}
+    ldr r1, =${labelVetor}
+    str r0, [r1, #${index * 4}]`;
+                }
+            });
+        }
+        return labelVetor;
+    }
+    // Implementação das Declarações
+    traduzirDeclaracaoBloco(declaracao) {
+        if (declaracao.declaracoes && Array.isArray(declaracao.declaracoes)) {
+            declaracao.declaracoes.forEach((decl) => {
+                if (this.dicionarioDeclaracoes[decl.constructor.name]) {
+                    this.dicionarioDeclaracoes[decl.constructor.name](decl);
+                }
+            });
+        }
+    }
+    traduzirDeclaracaoEnquanto(declaracao) {
+        const labelInicio = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        this.text += `
+${labelInicio}:`;
+        const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
+        this.text += `
+    cmp ${condicao}, #0
+    beq ${labelFim}`;
+        if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
+        }
+        this.text += `
+    b ${labelInicio}
+${labelFim}:`;
+    }
+    traduzirDeclaracaoEscolha(declaracao) {
+        const labelFim = this.gerarLabel();
+        const valorEscolha = this.dicionarioConstrutos[declaracao.identificadorOuLiteral.constructor.name](declaracao.identificadorOuLiteral);
+        if (declaracao.caminhos && Array.isArray(declaracao.caminhos)) {
+            declaracao.caminhos.forEach((caminho) => {
+                const labelProximo = this.gerarLabel();
+                if (caminho.condicoes && caminho.condicoes[0]) {
+                    const valorCaso = this.dicionarioConstrutos[caminho.condicoes[0].constructor.name](caminho.condicoes[0]);
+                    this.text += `
+    ldr r0, =${valorEscolha}
+    ldr r1, =${valorCaso}
+    cmp r0, r1
+    bne ${labelProximo}`;
+                    if (caminho.declaracoes && Array.isArray(caminho.declaracoes)) {
+                        caminho.declaracoes.forEach((decl) => {
+                            if (this.dicionarioDeclaracoes[decl.constructor.name]) {
+                                this.dicionarioDeclaracoes[decl.constructor.name](decl);
+                            }
+                        });
+                    }
+                    this.text += `
+    b ${labelFim}
+${labelProximo}:`;
+                }
+            });
+        }
+        this.text += `
+${labelFim}:`;
+    }
+    traduzirDeclaracaoExpressao(declaracao) {
+        if (declaracao.expressao && this.dicionarioConstrutos[declaracao.expressao.constructor.name]) {
+            this.dicionarioConstrutos[declaracao.expressao.constructor.name](declaracao.expressao);
+        }
+    }
+    traduzirDeclaracaoFazer(declaracao) {
+        const labelInicio = this.gerarLabel();
+        this.text += `
+${labelInicio}:`;
+        if (declaracao.caminhoFazer && declaracao.caminhoFazer.declaracoes) {
+            declaracao.caminhoFazer.declaracoes.forEach((decl) => {
+                if (this.dicionarioDeclaracoes[decl.constructor.name]) {
+                    this.dicionarioDeclaracoes[decl.constructor.name](decl);
+                }
+            });
+        }
+        if (declaracao.condicaoEnquanto) {
+            const condicao = this.dicionarioConstrutos[declaracao.condicaoEnquanto.constructor.name](declaracao.condicaoEnquanto);
+            this.text += `
+    cmp ${condicao}, #0
+    bne ${labelInicio}`;
+        }
+    }
+    traduzirDeclaracaoFalhar(declaracao) {
+        let mensagem = '"Erro"';
+        if (declaracao.explicacao && typeof declaracao.explicacao === 'object' && 'constructor' in declaracao.explicacao) {
+            const explicacao = declaracao.explicacao;
+            if (explicacao.constructor && this.dicionarioConstrutos[explicacao.constructor.name]) {
+                mensagem = this.dicionarioConstrutos[explicacao.constructor.name](explicacao);
+            }
+        }
+        this.text += `
+    @ Falhar com mensagem: ${mensagem}
+    mov r0, #1
+    mov r7, #1              @ sys_exit
+    swi 0`;
+    }
+    traduzirDeclaracaoFuncao(declaracao) {
+        var _a;
+        const nomeFuncao = ((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'funcao';
+        this.text += `
+
+${nomeFuncao}:
+    push {fp, lr}
+    mov fp, sp`;
+        if (declaracao.funcao && declaracao.funcao.corpo && Array.isArray(declaracao.funcao.corpo)) {
+            declaracao.funcao.corpo.forEach((decl) => {
+                if (this.dicionarioDeclaracoes[decl.constructor.name]) {
+                    this.dicionarioDeclaracoes[decl.constructor.name](decl);
+                }
+            });
+        }
+        this.text += `
+    mov sp, fp
+    pop {fp, pc}`;
+    }
+    traduzirDeclaracaoImportar(declaracao) {
+        this.text += `
+    @ Importar: ${declaracao.caminho || 'unknown'}`;
+    }
+    traduzirDeclaracaoLeia(declaracao) {
+        var _a;
+        let nomeVar;
+        if (declaracao.argumentos && declaracao.argumentos[0] && declaracao.argumentos[0] instanceof construtos_1.Variavel) {
+            nomeVar = (_a = declaracao.argumentos[0].simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        }
+        if (!nomeVar)
+            return;
+        if (!this.variaveis.has(nomeVar)) {
+            const varLabel = `var_${nomeVar}`;
+            this.bss += `    ${varLabel}: .space 256\n`;
+            this.variaveis.set(nomeVar, varLabel);
+        }
+        this.text += `
+    ldr r1, =${this.variaveis.get(nomeVar)}
+    mov r2, #256
+    mov r0, #0              @ stdin
+    mov r7, #3              @ sys_read
+    swi 0`;
+    }
+    traduzirDeclaracaoPara(declaracao) {
+        const labelInicio = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        if (declaracao.inicializador) {
+            const tipoInicializador = declaracao.inicializador.constructor.name;
+            if (this.dicionarioDeclaracoes[tipoInicializador]) {
+                this.dicionarioDeclaracoes[tipoInicializador](declaracao.inicializador);
+            }
+            else if (this.dicionarioConstrutos[tipoInicializador]) {
+                this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
+            }
+        }
+        this.text += `
+${labelInicio}:`;
+        if (declaracao.condicao) {
+            const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
+            this.text += `
+    cmp ${condicao}, #0
+    beq ${labelFim}`;
+        }
+        if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
+        }
+        if (declaracao.incrementar) {
+            if (this.dicionarioConstrutos[declaracao.incrementar.constructor.name]) {
+                this.dicionarioConstrutos[declaracao.incrementar.constructor.name](declaracao.incrementar);
+            }
+        }
+        this.text += `
+    b ${labelInicio}
+${labelFim}:`;
+    }
+    traduzirDeclaracaoParaCada(declaracao) {
+        var _a;
+        const labelInicio = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        let nomeVar;
+        if (declaracao.variavelIteracao instanceof construtos_1.Variavel) {
+            nomeVar = (_a = declaracao.variavelIteracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        }
+        const vetor = declaracao.vetorOuDicionario;
+        let tamanhoVetor = 0;
+        if (vetor instanceof construtos_1.Vetor) {
+            tamanhoVetor = vetor.tamanho || 0;
+        }
+        this.text += `
+    mov r4, #0              @ counter
+${labelInicio}:
+    cmp r4, #${tamanhoVetor}
+    bge ${labelFim}`;
+        if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
+        }
+        this.text += `
+    add r4, r4, #1
+    b ${labelInicio}
+${labelFim}:`;
+    }
+    traduzirDeclaracaoRetorna(declaracao) {
+        if (declaracao.valor) {
+            const valor = this.dicionarioConstrutos[declaracao.valor.constructor.name](declaracao.valor);
+            this.text += `
+    ldr r0, =${valor}`;
+        }
+        this.text += `
+    mov sp, fp
+    pop {fp, pc}`;
+    }
+    traduzirDeclaracaoSe(declaracao) {
+        const labelSenao = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
+        this.text += `
+    cmp ${condicao}, #0
+    beq ${labelSenao}`;
+        if (this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name](declaracao.caminhoEntao);
+        }
+        this.text += `
+    b ${labelFim}
+${labelSenao}:`;
+        if (declaracao.caminhoSenao && this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name](declaracao.caminhoSenao);
+        }
+        this.text += `
+${labelFim}:`;
+    }
+    traduzirDeclaracaoClasse(declaracao) {
+        var _a;
+        this.text += `
+    @ Classe: ${((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'unknown'}`;
+    }
+    traduzirDeclaracaoTente(declaracao) {
+        this.text += `
+    @ Tente-pegue`;
+        if (declaracao.caminhoTente && Array.isArray(declaracao.caminhoTente)) {
+            declaracao.caminhoTente.forEach((decl) => {
+                if (this.dicionarioDeclaracoes[decl.constructor.name]) {
+                    this.dicionarioDeclaracoes[decl.constructor.name](decl);
+                }
+            });
+        }
+    }
+    traduzirDeclaracaoConst(declaracao) {
+        var _a;
+        const nomeVar = (_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        if (!nomeVar)
+            return;
+        const valor = this.dicionarioConstrutos[declaracao.inicializador.constructor.name](declaracao.inicializador);
+        const varLabel = `const_${nomeVar}`;
+        this.data += `    ${varLabel}: .word ${valor}\n`;
+        this.variaveis.set(nomeVar, varLabel);
+    }
+    traduzirDeclaracaoVar(declaracao) {
+        var _a;
+        const nomeVar = (_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        if (!nomeVar)
+            return;
+        const varLabel = `var_${nomeVar}`;
+        this.bss += `    ${varLabel}: .space 4\n`;
+        this.variaveis.set(nomeVar, varLabel);
+        if (declaracao.inicializador && declaracao.inicializador.valor !== null) {
+            const tipoInicializador = declaracao.inicializador.constructor.name;
+            // Verificar se é um vetor
+            if (declaracao.inicializador instanceof construtos_1.Vetor) {
+                // Vetor precisa de tratamento especial
+                const labelVetor = this.traduzirConstrutoVetor(declaracao.inicializador);
+                // Associar o nome da variável com o label do vetor
+                this.variaveis.set(nomeVar, labelVetor);
+            }
+            else if (this.dicionarioConstrutos[tipoInicializador]) {
+                const valor = this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
+                this.text += `
+    ldr r0, =${valor}
+    ldr r1, =${varLabel}
+    str r0, [r1]`;
+            }
+        }
+    }
+    criaStringLiteral(literal) {
+        const varLiteral = `Delegua_${this.gerarDigitoAleatorio()}`;
+        this.data += `    ${varLiteral}: .asciz "${literal.valor}"\n`;
+        return varLiteral;
+    }
+    criaTamanhoNaMemoriaReferenteAVar(nomeStringLiteral) {
+        const varTamanho = `tam_${nomeStringLiteral}`;
+        // Em ARM, calculamos o tamanho de forma diferente
+        // Podemos usar uma diretiva ou calcular em tempo de execução
+        return varTamanho;
+    }
+    traduzirDeclaracaoEscreva(declaracaoEscreva) {
+        let tam_string_literal = '';
+        let nome_string_literal = '';
+        if (declaracaoEscreva.argumentos[0] instanceof construtos_1.Literal) {
+            nome_string_literal = this.criaStringLiteral(declaracaoEscreva.argumentos[0]);
+            const stringValue = declaracaoEscreva.argumentos[0].valor;
+            tam_string_literal = String(stringValue.length);
+        }
+        // Para ambos linux-arm e android, continuamos usando a convenção
+        // de syscall Linux ARM (write). Em Android típico, esse binário
+        // seria executado via adb/Termux, onde essa convenção ainda é válida.
+        this.text += `
+    ldr r1, =${nome_string_literal}
+    mov r2, #${tam_string_literal}
+    mov r0, #1              @ fd stdout
+    mov r7, #4              @ sys_write
+    swi 0`;
+    }
+    saidaSistema() {
+        // Mesmo comentário da função Escreva: usamos sys_exit Linux.
+        // Em um futuro modo Android "NDK/JNI", esta função deveria
+        // apenas retornar ao chamador em vez de fazer syscall direta.
+        this.text += `
+    mov r0, #1              @ exit status
+    mov r7, #1              @ sys_exit
+    swi 0`;
+    }
+    traduzir(declaracoes) {
+        let resultado = '';
+        this.declaracoesDeClasses = declaracoes.filter((declaracao) => declaracao instanceof declaracoes_1.Classe);
+        for (const declaracao of declaracoes) {
+            if (this.dicionarioDeclaracoes[declaracao.constructor.name]) {
+                this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao);
+            }
+        }
+        this.saidaSistema();
+        resultado += this.bss + '\n' + this.data + '\n' + this.text;
+        return resultado;
+    }
+}
+exports.TradutorAssemblyARM = TradutorAssemblyARM;
+
+},{"../construtos":51,"../declaracoes":96}],207:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradutorAssemblyX64 = void 0;
+const construtos_1 = require("../construtos");
+const declaracoes_1 = require("../declaracoes");
+class TradutorAssemblyX64 {
+    constructor(alvo = 'linux') {
+        this.alvo = alvo;
+        this.indentacao = 0;
+        this.contadorLabels = 0;
+        this.variaveis = new Map();
+        this.registradoresDisponiveis = ['rbx', 'r12', 'r13', 'r14', 'r15'];
+        this.pilhaRegistradores = [];
+        this.bss = 'section .bss\n';
+        this.data = 'section .data\n';
+        this.dicionarioConstrutos = {
+            AcessoIndiceVariavel: this.traduzirAcessoIndiceVariavel.bind(this),
+            AcessoMetodoOuPropriedade: this.trazudirConstrutoAcessoMetodo.bind(this),
+            Agrupamento: this.traduzirConstrutoAgrupamento.bind(this),
+            AtribuicaoPorIndice: this.traduzirConstrutoAtribuicaoPorIndice.bind(this),
+            Atribuir: this.traduzirConstrutoAtribuir.bind(this),
+            Binario: this.traduzirConstrutoBinario.bind(this),
+            Chamada: this.traduzirConstrutoChamada.bind(this),
+            DefinirValor: this.traduzirConstrutoDefinirValor.bind(this),
+            FuncaoConstruto: this.traduzirFuncaoConstruto.bind(this),
+            Isto: () => 'this',
+            Literal: this.traduzirConstrutoLiteral.bind(this),
+            Logico: this.traduzirConstrutoLogico.bind(this),
+            TipoDe: this.traduzirConstrutoTipoDe.bind(this),
+            Unario: this.traduzirConstrutoUnario.bind(this),
+            Variavel: this.traduzirConstrutoVariavel.bind(this),
+            Vetor: this.traduzirConstrutoVetor.bind(this),
+        };
+        this.dicionarioDeclaracoes = {
+            Bloco: this.traduzirDeclaracaoBloco.bind(this),
+            Enquanto: this.traduzirDeclaracaoEnquanto.bind(this),
+            Continua: () => 'continue',
+            Escolha: this.traduzirDeclaracaoEscolha.bind(this),
+            Expressao: this.traduzirDeclaracaoExpressao.bind(this),
+            Fazer: this.traduzirDeclaracaoFazer.bind(this),
+            Falhar: this.traduzirDeclaracaoFalhar.bind(this),
+            FuncaoDeclaracao: this.traduzirDeclaracaoFuncao.bind(this),
+            Importar: this.traduzirDeclaracaoImportar.bind(this),
+            Leia: this.traduzirDeclaracaoLeia.bind(this),
+            Para: this.traduzirDeclaracaoPara.bind(this),
+            ParaCada: this.traduzirDeclaracaoParaCada.bind(this),
+            Retorna: this.traduzirDeclaracaoRetorna.bind(this),
+            Se: this.traduzirDeclaracaoSe.bind(this),
+            Sustar: () => 'break',
+            Classe: this.traduzirDeclaracaoClasse.bind(this),
+            Tente: this.traduzirDeclaracaoTente.bind(this),
+            Const: this.traduzirDeclaracaoConst.bind(this),
+            Var: this.traduzirDeclaracaoVar.bind(this),
+            Escreva: this.traduzirDeclaracaoEscreva.bind(this),
+        };
+        this.indentacao = 0;
+        this.text = `
+section .text
+    ${this.alvo === 'linux' ? 'global _start' : 'global main'}
+${this.alvo === 'linux' ? '_start:' : 'main:'}`;
+        if (this.alvo === 'windows') {
+            this.text = `
+extern printf
+` + this.text;
+        }
+    }
+    gerarDigitoAleatorio() {
+        let result = '';
+        const digits = '0123456789';
+        for (let i = 0; i < 5; i++) {
+            const randomIndex = Math.floor(Math.random() * digits.length);
+            result += digits.charAt(randomIndex);
+        }
+        return result;
+    }
+    gerarLabel() {
+        return `L${this.contadorLabels++}`;
+    }
+    obterRegistrador() {
+        if (this.registradoresDisponiveis.length > 0) {
+            const reg = this.registradoresDisponiveis.pop();
+            this.pilhaRegistradores.push(reg);
+            return reg;
+        }
+        return 'rax'; // fallback
+    }
+    liberarRegistrador(reg) {
+        const index = this.pilhaRegistradores.indexOf(reg);
+        if (index > -1) {
+            this.pilhaRegistradores.splice(index, 1);
+            this.registradoresDisponiveis.push(reg);
+        }
+    }
+    // Implementação dos Construtos
+    traduzirAcessoIndiceVariavel(construto) {
+        var _a;
+        let nomeVar;
+        if (construto.entidadeChamada instanceof construtos_1.Variavel) {
+            nomeVar = (_a = construto.entidadeChamada.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        }
+        if (!nomeVar) {
+            nomeVar = 'unknown';
+        }
+        const indice = this.dicionarioConstrutos[construto.indice.constructor.name](construto.indice);
+        return `[${nomeVar} + ${indice} * 8]`;
+    }
+    trazudirConstrutoAcessoMetodo(construto) {
+        const objeto = this.dicionarioConstrutos[construto.objeto.constructor.name](construto.objeto);
+        return `${objeto}.${construto.nomeMetodo}`;
+    }
+    traduzirConstrutoAgrupamento(construto) {
+        return this.dicionarioConstrutos[construto.expressao.constructor.name](construto.expressao);
+    }
+    traduzirConstrutoAtribuicaoPorIndice(construto) {
+        var _a;
+        let nomeVar;
+        if (construto.objeto instanceof construtos_1.Variavel) {
+            nomeVar = (_a = construto.objeto.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        }
+        if (!nomeVar) {
+            nomeVar = 'unknown';
+        }
+        const indice = this.dicionarioConstrutos[construto.indice.constructor.name](construto.indice);
+        const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
+        this.text += `
+    mov rax, ${valor}
+    mov [${nomeVar} + ${indice} * 8], rax`;
+    }
+    traduzirConstrutoAtribuir(construto) {
+        var _a;
+        // Atribuir tem a estrutura: { alvo, valor }
+        let nomeVar;
+        if (construto.alvo instanceof construtos_1.Variavel) {
+            nomeVar = (_a = construto.alvo.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        }
+        if (!nomeVar) {
+            return;
+        }
+        const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
+        if (!this.variaveis.has(nomeVar)) {
+            const varLabel = `var_${nomeVar}`;
+            this.bss += `    ${varLabel} resq 1\n`;
+            this.variaveis.set(nomeVar, varLabel);
+        }
+        this.text += `
+    mov rax, ${valor}
+    mov [${this.variaveis.get(nomeVar)}], rax`;
+    }
+    traduzirConstrutoBinario(construto) {
+        const esquerda = this.dicionarioConstrutos[construto.esquerda.constructor.name](construto.esquerda);
+        const direita = this.dicionarioConstrutos[construto.direita.constructor.name](construto.direita);
+        const operador = construto.operador.lexema;
+        const reg = this.obterRegistrador();
+        this.text += `
+    mov rax, ${esquerda}
+    mov ${reg}, ${direita}`;
+        switch (operador) {
+            case '+':
+                this.text += `
+    add rax, ${reg}`;
+                break;
+            case '-':
+                this.text += `
+    sub rax, ${reg}`;
+                break;
+            case '*':
+                this.text += `
+    imul rax, ${reg}`;
+                break;
+            case '/':
+                this.text += `
+    xor rdx, rdx
+    idiv ${reg}`;
+                break;
+            case '%':
+                this.text += `
+    xor rdx, rdx
+    idiv ${reg}
+    mov rax, rdx`;
+                break;
+            default:
+                this.text += `
+    ; Operador ${operador} não implementado`;
+        }
+        this.liberarRegistrador(reg);
+        return 'rax';
+    }
+    traduzirConstrutoChamada(construto) {
+        var _a;
+        let nomeFuncao = 'funcao';
+        if (construto.entidadeChamada instanceof construtos_1.Variavel) {
+            nomeFuncao = ((_a = construto.entidadeChamada.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'funcao';
+        }
+        // Preparar argumentos (convenção de chamada System V AMD64)
+        const registrosArgs = this.alvo === 'linux'
+            ? ['rdi', 'rsi', 'rdx', 'rcx', 'r8', 'r9'] // System V AMD64 [web:8]
+            : ['rcx', 'rdx', 'r8', 'r9']; // Windows x64 [web:2]
+        construto.argumentos.forEach((arg, index) => {
+            if (index < registrosArgs.length) {
+                const valorArg = this.dicionarioConstrutos[arg.constructor.name](arg);
+                this.text += `
+    mov ${registrosArgs[index]}, ${valorArg}`;
+            }
+            else {
+                // TODO: push extra args on stack according to target ABI
+            }
+        });
+        this.text += `
+    call ${nomeFuncao}`;
+    }
+    traduzirConstrutoDefinirValor(construto) {
+        const objeto = this.dicionarioConstrutos[construto.objeto.constructor.name](construto.objeto);
+        const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
+        this.text += `
+    mov rax, ${valor}
+    mov [${objeto}], rax`;
+    }
+    traduzirFuncaoConstruto(construto) {
+        const labelFuncao = `func_${this.gerarDigitoAleatorio()}`;
+        this.text += `
+${labelFuncao}:
+    push rbp
+    mov rbp, rsp`;
+        // Traduzir corpo da função
+        if (construto.corpo && Array.isArray(construto.corpo)) {
+            construto.corpo.forEach((declaracao) => {
+                if (this.dicionarioDeclaracoes[declaracao.constructor.name]) {
+                    this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao);
+                }
+            });
+        }
+        this.text += `
+    pop rbp
+    ret`;
+    }
+    traduzirConstrutoLiteral(construto) {
+        if (typeof construto.valor === 'string') {
+            return this.criaStringLiteral(construto);
+        }
+        return String(construto.valor);
+    }
+    traduzirConstrutoLogico(construto) {
+        const esquerda = this.dicionarioConstrutos[construto.esquerda.constructor.name](construto.esquerda);
+        const direita = this.dicionarioConstrutos[construto.direita.constructor.name](construto.direita);
+        const operador = construto.operador.lexema;
+        const labelVerdadeiro = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        this.text += `
+    mov rax, ${esquerda}
+    cmp rax, 0`;
+        if (operador === 'e' || operador === '&&') {
+            this.text += `
+    je ${labelFim}
+    mov rax, ${direita}
+    cmp rax, 0
+    je ${labelFim}
+${labelVerdadeiro}:
+    mov rax, 1
+${labelFim}:`;
+        }
+        else if (operador === 'ou' || operador === '||') {
+            this.text += `
+    jne ${labelVerdadeiro}
+    mov rax, ${direita}
+    cmp rax, 0
+    jne ${labelVerdadeiro}
+    mov rax, 0
+    jmp ${labelFim}
+${labelVerdadeiro}:
+    mov rax, 1
+${labelFim}:`;
+        }
+        return 'rax';
+    }
+    traduzirConstrutoTipoDe(construto) {
+        // Simplificado - retorna tipo como número
+        const expressao = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
+        return expressao;
+    }
+    traduzirConstrutoUnario(construto) {
+        const operando = this.dicionarioConstrutos[construto.operando.constructor.name](construto.operando);
+        const operador = construto.operador.lexema;
+        this.text += `
+    mov rax, ${operando}`;
+        if (operador === '-') {
+            this.text += `
+    neg rax`;
+        }
+        else if (operador === '!' || operador === 'nao') {
+            this.text += `
+    cmp rax, 0
+    sete al
+    movzx rax, al`;
+        }
+        return 'rax';
+    }
+    traduzirConstrutoVariavel(construto) {
+        var _a;
+        const nomeVar = (_a = construto.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        if (nomeVar && this.variaveis.has(nomeVar)) {
+            return `[${this.variaveis.get(nomeVar)}]`;
+        }
+        return nomeVar || 'unknown';
+    }
+    traduzirConstrutoVetor(construto) {
+        var _a;
+        const labelVetor = `vetor_${this.gerarDigitoAleatorio()}`;
+        const tamanho = ((_a = construto.valores) === null || _a === void 0 ? void 0 : _a.length) || 0;
+        this.bss += `    ${labelVetor} resq ${tamanho}\n`;
+        if (construto.valores && Array.isArray(construto.valores)) {
+            construto.valores.forEach((valor, index) => {
+                if (this.dicionarioConstrutos[valor.constructor.name]) {
+                    const valorTraduzido = this.dicionarioConstrutos[valor.constructor.name](valor);
+                    this.text += `
+    mov rax, ${valorTraduzido}
+    mov [${labelVetor} + ${index * 8}], rax`;
+                }
+            });
+        }
+        return labelVetor;
+    }
+    // Implementação das Declarações
+    traduzirDeclaracaoBloco(declaracao) {
+        if (declaracao.declaracoes && Array.isArray(declaracao.declaracoes)) {
+            declaracao.declaracoes.forEach((decl) => {
+                if (this.dicionarioDeclaracoes[decl.constructor.name]) {
+                    this.dicionarioDeclaracoes[decl.constructor.name](decl);
+                }
+            });
+        }
+    }
+    traduzirDeclaracaoEnquanto(declaracao) {
+        const labelInicio = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        this.text += `
+${labelInicio}:`;
+        const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
+        this.text += `
+    cmp ${condicao}, 0
+    je ${labelFim}`;
+        if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
+        }
+        this.text += `
+    jmp ${labelInicio}
+${labelFim}:`;
+    }
+    traduzirDeclaracaoEscolha(declaracao) {
+        const labelFim = this.gerarLabel();
+        const valorEscolha = this.dicionarioConstrutos[declaracao.identificadorOuLiteral.constructor.name](declaracao.identificadorOuLiteral);
+        if (declaracao.caminhos && Array.isArray(declaracao.caminhos)) {
+            declaracao.caminhos.forEach((caminho) => {
+                const labelProximo = this.gerarLabel();
+                if (caminho.condicoes && caminho.condicoes[0]) {
+                    const valorCaso = this.dicionarioConstrutos[caminho.condicoes[0].constructor.name](caminho.condicoes[0]);
+                    this.text += `
+    mov rax, ${valorEscolha}
+    cmp rax, ${valorCaso}
+    jne ${labelProximo}`;
+                    if (caminho.declaracoes && Array.isArray(caminho.declaracoes)) {
+                        caminho.declaracoes.forEach((decl) => {
+                            if (this.dicionarioDeclaracoes[decl.constructor.name]) {
+                                this.dicionarioDeclaracoes[decl.constructor.name](decl);
+                            }
+                        });
+                    }
+                    this.text += `
+    jmp ${labelFim}
+${labelProximo}:`;
+                }
+            });
+        }
+        this.text += `
+${labelFim}:`;
+    }
+    traduzirDeclaracaoExpressao(declaracao) {
+        if (declaracao.expressao && this.dicionarioConstrutos[declaracao.expressao.constructor.name]) {
+            this.dicionarioConstrutos[declaracao.expressao.constructor.name](declaracao.expressao);
+        }
+    }
+    traduzirDeclaracaoFazer(declaracao) {
+        const labelInicio = this.gerarLabel();
+        this.text += `
+${labelInicio}:`;
+        // Em Delégua, fazer-enquanto tem caminhoFazer que é um Bloco
+        if (declaracao.caminhoFazer && declaracao.caminhoFazer.declaracoes) {
+            declaracao.caminhoFazer.declaracoes.forEach((decl) => {
+                if (this.dicionarioDeclaracoes[decl.constructor.name]) {
+                    this.dicionarioDeclaracoes[decl.constructor.name](decl);
+                }
+            });
+        }
+        if (declaracao.condicaoEnquanto) {
+            const condicao = this.dicionarioConstrutos[declaracao.condicaoEnquanto.constructor.name](declaracao.condicaoEnquanto);
+            this.text += `
+    cmp ${condicao}, 0
+    jne ${labelInicio}`;
+        }
+    }
+    traduzirDeclaracaoFalhar(declaracao) {
+        let mensagem = '"Erro"';
+        if (declaracao.explicacao && typeof declaracao.explicacao === 'object' && 'constructor' in declaracao.explicacao) {
+            const explicacao = declaracao.explicacao;
+            if (explicacao.constructor && this.dicionarioConstrutos[explicacao.constructor.name]) {
+                mensagem = this.dicionarioConstrutos[explicacao.constructor.name](explicacao);
+            }
+        }
+        if (this.alvo === 'linux') {
+            this.text += `
+        ; Falhar com mensagem: ${mensagem}
+        mov eax, 1
+        mov ebx, 1
+        int 0x80`;
+        }
+        else {
+            this.text += `
+        ; Falhar com mensagem: ${mensagem}
+        mov eax, 1
+        ret`;
+        }
+    }
+    traduzirDeclaracaoFuncao(declaracao) {
+        var _a;
+        const nomeFuncao = ((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'funcao';
+        this.text += `
+${nomeFuncao}:
+    push rbp
+    mov rbp, rsp`;
+        if (declaracao.funcao && declaracao.funcao.corpo && Array.isArray(declaracao.funcao.corpo)) {
+            declaracao.funcao.corpo.forEach((decl) => {
+                if (this.dicionarioDeclaracoes[decl.constructor.name]) {
+                    this.dicionarioDeclaracoes[decl.constructor.name](decl);
+                }
+            });
+        }
+        this.text += `
+    pop rbp
+    ret`;
+    }
+    traduzirDeclaracaoImportar(declaracao) {
+        // Importação é tratada em tempo de linkagem
+        this.text += `
+    ; Importar: ${declaracao.caminho || 'unknown'}`;
+    }
+    traduzirDeclaracaoLeia(declaracao) {
+        var _a;
+        let nomeVar;
+        if (declaracao.argumentos && declaracao.argumentos[0] && declaracao.argumentos[0] instanceof construtos_1.Variavel) {
+            nomeVar = (_a = declaracao.argumentos[0].simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        }
+        if (!nomeVar)
+            return;
+        if (!this.variaveis.has(nomeVar)) {
+            const varLabel = `var_${nomeVar}`;
+            this.bss += `    ${varLabel} resb 256\n`;
+            this.variaveis.set(nomeVar, varLabel);
+        }
+        this.text += `
+    mov eax, 3
+    mov ebx, 0
+    mov ecx, ${this.variaveis.get(nomeVar)}
+    mov edx, 256
+    int 0x80`;
+    }
+    traduzirDeclaracaoPara(declaracao) {
+        const labelInicio = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        // Inicializador pode ser uma declaração ou construto
+        if (declaracao.inicializador) {
+            const tipoInicializador = declaracao.inicializador.constructor.name;
+            if (this.dicionarioDeclaracoes[tipoInicializador]) {
+                this.dicionarioDeclaracoes[tipoInicializador](declaracao.inicializador);
+            }
+            else if (this.dicionarioConstrutos[tipoInicializador]) {
+                this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
+            }
+        }
+        this.text += `
+${labelInicio}:`;
+        if (declaracao.condicao) {
+            const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
+            this.text += `
+    cmp ${condicao}, 0
+    je ${labelFim}`;
+        }
+        if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
+        }
+        if (declaracao.incrementar) {
+            if (this.dicionarioConstrutos[declaracao.incrementar.constructor.name]) {
+                this.dicionarioConstrutos[declaracao.incrementar.constructor.name](declaracao.incrementar);
+            }
+        }
+        this.text += `
+    jmp ${labelInicio}
+${labelFim}:`;
+    }
+    traduzirDeclaracaoParaCada(declaracao) {
+        var _a;
+        const labelInicio = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        let nomeVar;
+        if (declaracao.variavelIteracao instanceof construtos_1.Variavel) {
+            nomeVar = (_a = declaracao.variavelIteracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        }
+        const vetor = declaracao.vetorOuDicionario;
+        let tamanhoVetor = 0;
+        if (vetor instanceof construtos_1.Vetor) {
+            tamanhoVetor = vetor.tamanho || 0;
+        }
+        this.text += `
+    xor rcx, rcx
+${labelInicio}:
+    cmp rcx, ${tamanhoVetor}
+    jge ${labelFim}`;
+        if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
+        }
+        this.text += `
+    inc rcx
+    jmp ${labelInicio}
+${labelFim}:`;
+    }
+    traduzirDeclaracaoRetorna(declaracao) {
+        if (declaracao.valor) {
+            const valor = this.dicionarioConstrutos[declaracao.valor.constructor.name](declaracao.valor);
+            this.text += `
+    mov rax, ${valor}`;
+        }
+        this.text += `
+    pop rbp
+    ret`;
+    }
+    traduzirDeclaracaoSe(declaracao) {
+        const labelSenao = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
+        this.text += `
+    cmp ${condicao}, 0
+    je ${labelSenao}`;
+        if (this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name](declaracao.caminhoEntao);
+        }
+        this.text += `
+    jmp ${labelFim}
+${labelSenao}:`;
+        if (declaracao.caminhoSenao && this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name](declaracao.caminhoSenao);
+        }
+        this.text += `
+${labelFim}:`;
+    }
+    traduzirDeclaracaoClasse(declaracao) {
+        var _a;
+        // Classes em assembly são complexas - implementação básica
+        this.text += `
+    ; Classe: ${((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'unknown'}`;
+    }
+    traduzirDeclaracaoTente(declaracao) {
+        // Try-catch em assembly requer handler complexo
+        this.text += `
+    ; Tente-pegue`;
+        if (declaracao.caminhoTente && Array.isArray(declaracao.caminhoTente)) {
+            declaracao.caminhoTente.forEach((decl) => {
+                if (this.dicionarioDeclaracoes[decl.constructor.name]) {
+                    this.dicionarioDeclaracoes[decl.constructor.name](decl);
+                }
+            });
+        }
+    }
+    traduzirDeclaracaoConst(declaracao) {
+        var _a;
+        const nomeVar = (_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        if (!nomeVar)
+            return;
+        const valor = this.dicionarioConstrutos[declaracao.inicializador.constructor.name](declaracao.inicializador);
+        const varLabel = `const_${nomeVar}`;
+        this.data += `    ${varLabel} dq ${valor}\n`;
+        this.variaveis.set(nomeVar, varLabel);
+    }
+    traduzirDeclaracaoVar(declaracao) {
+        var _a;
+        const nomeVar = (_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        if (!nomeVar)
+            return;
+        const varLabel = `var_${nomeVar}`;
+        this.bss += `    ${varLabel} resq 1\n`;
+        this.variaveis.set(nomeVar, varLabel);
+        if (declaracao.inicializador) {
+            const tipoInicializador = declaracao.inicializador.constructor.name;
+            // Verificar se é um vetor
+            if (declaracao.inicializador instanceof construtos_1.Vetor) {
+                // Vetor precisa de tratamento especial
+                const labelVetor = this.traduzirConstrutoVetor(declaracao.inicializador);
+                // Associar o nome da variável com o label do vetor
+                this.variaveis.set(nomeVar, labelVetor);
+            }
+            else if (this.dicionarioConstrutos[tipoInicializador]) {
+                const valor = this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
+                this.text += `
+    mov rax, ${valor}
+    mov [${varLabel}], rax`;
+            }
+        }
+    }
+    criaStringLiteral(literal) {
+        const varLiteral = `Delegua_${this.gerarDigitoAleatorio()}`;
+        this.data += `    ${varLiteral} db '${literal.valor}', 0\n`;
+        return varLiteral;
+    }
+    criaTamanhoNaMemoriaReferenteAVar(nomeStringLiteral) {
+        const varTamanho = `tam_${nomeStringLiteral}`;
+        this.data += `    ${varTamanho} equ $ - ${nomeStringLiteral}\n`;
+        return varTamanho;
+    }
+    traduzirDeclaracaoEscreva(declaracaoEscreva) {
+        let tam_string_literal = '';
+        let nome_string_literal = '';
+        if (declaracaoEscreva.argumentos[0] instanceof construtos_1.Literal) {
+            nome_string_literal = this.criaStringLiteral(declaracaoEscreva.argumentos[0]);
+            tam_string_literal = this.criaTamanhoNaMemoriaReferenteAVar(nome_string_literal);
+        }
+        if (this.alvo === 'linux') {
+            this.text += `
+    mov edx, ${tam_string_literal}
+    mov ecx, ${nome_string_literal}
+    mov ebx, 1        ; fd stdout
+    mov eax, 4        ; sys_write
+    int 0x80`;
+        }
+        else {
+            // Windows: prototype `extern printf` and follow Win64 calling convention
+            // RCX = format pointer; here we use the literal directly as a C string
+            this.text += `
+    lea rcx, [rel ${nome_string_literal}]
+    call printf`;
+        }
+    }
+    saidaSistema() {
+        if (this.alvo === 'linux') {
+            this.text += `
+        mov eax, 1        ; sys_exit
+        xor ebx, ebx      ; status 0
+        int 0x80`;
+        }
+        else {
+            // Windows: return from main with 0 in EAX
+            this.text += `
+        xor eax, eax
+        ret`;
+        }
+    }
+    traduzir(declaracoes) {
+        let resultado = '';
+        this.declaracoesDeClasses = declaracoes.filter((declaracao) => declaracao instanceof declaracoes_1.Classe);
+        for (const declaracao of declaracoes) {
+            if (this.dicionarioDeclaracoes[declaracao.constructor.name]) {
+                this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao);
+            }
+        }
+        this.saidaSistema();
+        resultado += this.bss + '\n' + this.data + '\n' + this.text;
+        return resultado;
+    }
+}
+exports.TradutorAssemblyX64 = TradutorAssemblyX64;
+
+},{"../construtos":51,"../declaracoes":96}],208:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -33358,7 +34918,7 @@ class TradutorAssemblyScript {
 }
 exports.TradutorAssemblyScript = TradutorAssemblyScript;
 
-},{"../construtos":51,"../declaracoes":96,"../tipos-de-simbolos/delegua":190}],202:[function(require,module,exports){
+},{"../construtos":51,"../declaracoes":96,"../tipos-de-simbolos/delegua":190}],209:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorCalango = void 0;
@@ -33420,7 +34980,7 @@ class TradutorCalango {
 }
 exports.TradutorCalango = TradutorCalango;
 
-},{"../avaliador-sintatico/dialetos/avaliador-sintatico-calango":4,"../lexador/dialetos":162}],203:[function(require,module,exports){
+},{"../avaliador-sintatico/dialetos/avaliador-sintatico-calango":4,"../lexador/dialetos":162}],210:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -34173,7 +35733,7 @@ class TradutorJavaScript {
 }
 exports.TradutorJavaScript = TradutorJavaScript;
 
-},{"../construtos":51,"../declaracoes":96,"../tipos-de-simbolos/delegua":190}],204:[function(require,module,exports){
+},{"../construtos":51,"../declaracoes":96,"../tipos-de-simbolos/delegua":190}],211:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -34181,23 +35741,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorMermaidJs = void 0;
 const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
-class ArestaFluxograma {
-    constructor(declaracao, texto) {
-        this.declaracao = declaracao;
-        this.texto = texto;
-    }
-}
-class VerticeFluxograma {
-    constructor(origem, destino, texto) {
-        this.origem = origem;
-        this.destino = destino;
-        this.texto = texto;
-    }
-    paraTexto() {
-        const seta = this.texto ? `-->|${this.texto}|` : '-->';
-        return `    ${this.origem.texto}${seta}${this.destino.texto};\n`;
-    }
-}
+const mermaid_1 = require("./mermaid");
 /**
  * [MermaidJs](https://mermaid.js.org/) é uma especificação que nos permite
  * criar fluxogramas através de uma notação por texto.
@@ -34224,7 +35768,8 @@ class TradutorMermaidJs {
             ComentarioComoConstruto: () => '',
             DefinirValor: this.traduzirConstrutoDefinirValor.bind(this),
             Dicionario: this.traduzirConstrutoDicionario.bind(this),
-            FuncaoConstruto: this.traduzirFuncaoConstruto.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),
@@ -34235,6 +35780,8 @@ class TradutorMermaidJs {
         };
         this.dicionarioDeclaracoes = {
             Bloco: this.traduzirDeclaracaoBloco.bind(this),
+            // Classe: this.traduzirDeclaracaoClasse.bind(this),
+            Classe: () => { throw new Error("Fluxogramas de classes ainda não é suportado."); },
             Comentario: () => '',
             Const: this.traduzirDeclaracaoConst.bind(this),
             Enquanto: this.traduzirDeclaracaoEnquanto.bind(this),
@@ -34242,6 +35789,8 @@ class TradutorMermaidJs {
             Expressao: this.traduzirDeclaracaoExpressao.bind(this),
             Escreva: this.traduzirDeclaracaoEscreva.bind(this),
             Fazer: this.traduzirDeclaracaoFazerEnquanto.bind(this),
+            // FuncaoDeclaracao: this.traduzirDeclaracaoFuncao.bind(this),
+            FuncaoDeclaracao: () => { throw new Error("Fluxogramas de funções ainda não é suportado."); },
             Para: this.traduzirDeclaracaoPara.bind(this),
             ParaCada: this.traduzirDeclaracaoParaCada.bind(this),
             Se: this.traduzirDeclaracaoSe.bind(this),
@@ -34315,7 +35864,19 @@ class TradutorMermaidJs {
         return texto;
     }
     traduzirFuncaoConstruto(funcaoConstruto) {
-        return `função`;
+        let vertices = [];
+        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);
+            }
+        }
+        /* if (this.anteriores.length > 0) {
+            vertices = vertices.concat(this.anteriores)
+        } */
+        return vertices;
     }
     traduzirConstrutoLeia(leia) {
         let texto = 'leia da entrada';
@@ -34375,7 +35936,7 @@ class TradutorMermaidJs {
                 textoVertice = String(this.ultimaDicaVertice);
                 this.ultimaDicaVertice = undefined;
             }
-            vertices.push(new VerticeFluxograma(anterior, aresta, textoVertice));
+            vertices.push(new mermaid_1.VerticeFluxograma(anterior, aresta, textoVertice));
         }
         return vertices;
     }
@@ -34387,10 +35948,45 @@ class TradutorMermaidJs {
         }
         return vertices;
     }
+    traduzirDeclaracaoClasse(declaracaoClasse) {
+        const nomeClasse = declaracaoClasse.simbolo.lexema;
+        const superClasse = declaracaoClasse.superClasse
+            ? declaracaoClasse.superClasse.nome.lexema
+            : undefined;
+        // Cria o diagrama de classe
+        const diagramaClasse = new mermaid_1.DiagramaClasse(nomeClasse, superClasse);
+        // Adiciona métodos ao diagrama
+        if (declaracaoClasse.metodos && declaracaoClasse.metodos.length > 0) {
+            for (const metodo of declaracaoClasse.metodos) {
+                const parametros = [];
+                if (metodo.funcao.parametros && metodo.funcao.parametros.length > 0) {
+                    for (const param of metodo.funcao.parametros) {
+                        const nomeParam = param.nome.lexema;
+                        const tipoParam = param.tipoDado || 'qualquer';
+                        parametros.push(`${nomeParam}: ${tipoParam}`);
+                    }
+                }
+                const tipoRetorno = metodo.funcao.tipo;
+                diagramaClasse.metodos.push({
+                    nome: metodo.simbolo.lexema,
+                    parametros,
+                    tipoRetorno
+                });
+            }
+        }
+        // Adiciona o diagrama à lista
+        this.diagramasClasses.push(diagramaClasse);
+        // No fluxograma principal, apenas mostra a definição da classe
+        const texto = `Linha${declaracaoClasse.linha}[Classe ${nomeClasse}${superClasse ? ` herda ${superClasse}` : ''}]`;
+        const aresta = new mermaid_1.ArestaFluxograma(declaracaoClasse, texto);
+        const vertices = this.logicaComumConexaoArestas(aresta);
+        this.anteriores.push(aresta);
+        return vertices;
+    }
     traduzirDeclaracaoConst(declaracaoConst) {
         let texto = `Linha${declaracaoConst.linha}(variável: ${declaracaoConst.simbolo.lexema}`;
         texto += this.logicaComumTraducaoVarEConst(declaracaoConst, texto);
-        const aresta = new ArestaFluxograma(declaracaoConst, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracaoConst, texto);
         const vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
         return vertices;
@@ -34399,14 +35995,14 @@ class TradutorMermaidJs {
         let texto = `Linha${declaracaoEnquanto.linha}(enquanto `;
         const condicao = this.dicionarioConstrutos[declaracaoEnquanto.condicao.constructor.name](declaracaoEnquanto.condicao);
         texto += condicao + ')';
-        const aresta = new ArestaFluxograma(declaracaoEnquanto, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracaoEnquanto, texto);
         let vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
         // Corpo, normalmente um `Bloco`.
         const verticesCorpo = this.dicionarioDeclaracoes[declaracaoEnquanto.corpo.constructor.name](declaracaoEnquanto.corpo);
         vertices = vertices.concat(verticesCorpo);
         const ultimaArestaCorpo = verticesCorpo[verticesCorpo.length - 1].destino;
-        const verticeLaco = new VerticeFluxograma(ultimaArestaCorpo, aresta);
+        const verticeLaco = new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, aresta);
         vertices.push(verticeLaco);
         return vertices;
     }
@@ -34425,7 +36021,7 @@ class TradutorMermaidJs {
             textoCaso = `caso ${textoIdentificadorOuLiteral} tenha qualquer outro valor:`;
         }
         let textoCaminho = `Linha${linha}(${textoCaso})`;
-        const arestaCondicaoCaminho = new ArestaFluxograma(declaracaoEscolha, textoCaminho);
+        const arestaCondicaoCaminho = new mermaid_1.ArestaFluxograma(declaracaoEscolha, textoCaminho);
         this.anteriores.push(arestaCondicaoCaminho);
         let verticesResolvidos = [];
         for (const declaracaoCaminho of caminhoEscolha.declaracoes) {
@@ -34444,7 +36040,7 @@ class TradutorMermaidJs {
         let texto = `Linha${declaracaoEscolha.linha}(escolha um caminho pelo valor de `;
         const textoIdentificadorOuLiteral = this.dicionarioConstrutos[declaracaoEscolha.identificadorOuLiteral.constructor.name](declaracaoEscolha.identificadorOuLiteral);
         texto += textoIdentificadorOuLiteral + ')';
-        const aresta = new ArestaFluxograma(declaracaoEscolha, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracaoEscolha, texto);
         let vertices = this.logicaComumConexaoArestas(aresta);
         const arestasCaminho = [];
         for (const caminho of declaracaoEscolha.caminhos) {
@@ -34454,7 +36050,7 @@ class TradutorMermaidJs {
             arestasCaminho.push(this.logicaComumCaminhoEscolha(declaracaoEscolha, declaracaoEscolha.caminhoPadrao, declaracaoEscolha.caminhoPadrao.declaracoes[0].linha - 1, textoIdentificadorOuLiteral, true));
         }
         for (const conjunto of Object.values(arestasCaminho)) {
-            const verticeEscolhaECaminho = new VerticeFluxograma(aresta, conjunto.caminho);
+            const verticeEscolhaECaminho = new mermaid_1.VerticeFluxograma(aresta, conjunto.caminho);
             vertices.push(verticeEscolhaECaminho);
             vertices = vertices.concat(conjunto.declaracoesCaminho);
             this.anteriores.push(conjunto.declaracoesCaminho[conjunto.declaracoesCaminho.length - 1].destino);
@@ -34469,7 +36065,7 @@ class TradutorMermaidJs {
         }
         texto = texto.slice(0, -2);
         texto += ')';
-        const aresta = new ArestaFluxograma(declaracaoEscreva, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracaoEscreva, texto);
         const vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
         return vertices;
@@ -34478,14 +36074,14 @@ class TradutorMermaidJs {
         let texto = `Linha${declaracaoExpressao.linha}(`;
         const textoConstruto = this.dicionarioConstrutos[declaracaoExpressao.expressao.constructor.name](declaracaoExpressao.expressao);
         texto += textoConstruto + ')';
-        const aresta = new ArestaFluxograma(declaracaoExpressao, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracaoExpressao, texto);
         const vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
         return vertices;
     }
     traduzirDeclaracaoFazerEnquanto(declaracaoFazerEnquanto) {
         const texto = `Linha${declaracaoFazerEnquanto.linha}(fazer)`;
-        const aresta = new ArestaFluxograma(declaracaoFazerEnquanto, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracaoFazerEnquanto, texto);
         let vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
         // Corpo, normalmente um `Bloco`.
@@ -34494,15 +36090,37 @@ class TradutorMermaidJs {
         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 ArestaFluxograma(declaracaoFazerEnquanto, textoEnquanto);
-        const verticeEnquanto = new VerticeFluxograma(ultimaArestaCorpo, arestaEnquanto);
+        const arestaEnquanto = new mermaid_1.ArestaFluxograma(declaracaoFazerEnquanto, textoEnquanto);
+        const verticeEnquanto = new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, arestaEnquanto);
         vertices.push(verticeEnquanto);
-        const verticeCondicaoComFazer = new VerticeFluxograma(arestaEnquanto, aresta);
+        const verticeCondicaoComFazer = new mermaid_1.VerticeFluxograma(arestaEnquanto, aresta);
         vertices.push(verticeCondicaoComFazer);
         this.anteriores.pop();
         this.anteriores.push(arestaEnquanto);
         return vertices;
     }
+    traduzirDeclaracaoFuncao(declaracaoFuncao) {
+        // Gera o corpo como vértices, mas não conecta nada ao fluxo principal
+        const verticesCorpo = this.traduzirFuncaoConstruto(declaracaoFuncao.funcao);
+        if (verticesCorpo.length === 0) {
+            return [];
+        }
+        // Descobre o texto dos nós do corpo
+        let textoSubgraph = `subgraph função ${declaracaoFuncao.simbolo.lexema}\n`;
+        for (const vertice of verticesCorpo) {
+            textoSubgraph += vertice.paraTexto();
+        }
+        textoSubgraph += `end;\n`;
+        // Armazena o subgraph para imprimir depois de graph TD;
+        this.subgrafosFuncoes.push(textoSubgraph);
+        // IMPORTANTE: não altera this.anteriores aqui, para a função
+        // não entrar no fluxo principal. O fluxo principal continua
+        // sendo só as declarações "top-level" (como a chamada em Linha4).
+        // Também não precisa devolver vértices, porque eles já
+        // foram adicionados em this.vertices pelos próprios tradutores
+        // das declarações do corpo (via dicionarioDeclaracoes).
+        return [];
+    }
     traduzirDeclaracaoPara(declaracaoPara) {
         let texto = `Linha${declaracaoPara.linha}(para `;
         if (declaracaoPara.inicializador) {
@@ -34515,13 +36133,13 @@ class TradutorMermaidJs {
             texto = texto.slice(0, -2);
         }
         texto += ')';
-        const aresta = new ArestaFluxograma(declaracaoPara, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracaoPara, 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 ArestaFluxograma(declaracaoPara, textoArestaCondicao);
+        const arestaCondicao = new mermaid_1.ArestaFluxograma(declaracaoPara, textoArestaCondicao);
         vertices = vertices.concat(this.logicaComumConexaoArestas(arestaCondicao));
         this.anteriores.push(arestaCondicao);
         this.ultimaDicaVertice = 'Sim';
@@ -34531,10 +36149,10 @@ class TradutorMermaidJs {
         // Incremento
         const ultimaArestaCorpo = verticesCorpo[verticesCorpo.length - 1].destino;
         const textoIncremento = this.dicionarioConstrutos[declaracaoPara.incrementar.constructor.name](declaracaoPara.incrementar);
-        const arestaIncremento = new ArestaFluxograma(declaracaoPara, `Linha${declaracaoPara.linha}Incremento(${textoIncremento})`);
-        const verticeIncremento = new VerticeFluxograma(ultimaArestaCorpo, arestaIncremento);
+        const arestaIncremento = new mermaid_1.ArestaFluxograma(declaracaoPara, `Linha${declaracaoPara.linha}Incremento(${textoIncremento})`);
+        const verticeIncremento = new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, arestaIncremento);
         vertices.push(verticeIncremento);
-        const verticeLaco = new VerticeFluxograma(arestaIncremento, arestaCondicao);
+        const verticeLaco = new mermaid_1.VerticeFluxograma(arestaIncremento, arestaCondicao);
         vertices.push(verticeLaco);
         // Configura a condição como anterior
         this.anteriores.pop();
@@ -34547,14 +36165,14 @@ class TradutorMermaidJs {
         let texto = `Linha${declaracaoParaCada.linha}(para cada ${textoVariavelIteracao} em `;
         const textoVariavelIterada = this.dicionarioConstrutos[declaracaoParaCada.vetorOuDicionario.constructor.name](declaracaoParaCada.vetorOuDicionario);
         texto += textoVariavelIterada + ')';
-        const aresta = new ArestaFluxograma(declaracaoParaCada, texto);
+        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 VerticeFluxograma(ultimaArestaCorpo, aresta));
+        vertices.push(new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, aresta));
         return vertices;
     }
     traduzirDeclaracaoSe(declaracaoSe) {
@@ -34562,7 +36180,7 @@ class TradutorMermaidJs {
         const condicao = this.dicionarioConstrutos[declaracaoSe.condicao.constructor.name](declaracaoSe.condicao);
         texto += condicao;
         texto += `}`;
-        const aresta = new ArestaFluxograma(declaracaoSe, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracaoSe, texto);
         let vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
         this.ultimaDicaVertice = 'Sim';
@@ -34572,8 +36190,8 @@ class TradutorMermaidJs {
         const ultimaArestaEntao = verticesEntao[verticesEntao.length - 1].destino;
         if (declaracaoSe.caminhoSenao) {
             this.anteriores = [];
-            const arestaSenao = new ArestaFluxograma(declaracaoSe, `Linha${declaracaoSe.caminhoSenao.linha}(senão)`);
-            vertices.push(new VerticeFluxograma(aresta, arestaSenao, 'Não'));
+            const arestaSenao = new mermaid_1.ArestaFluxograma(declaracaoSe, `Linha${declaracaoSe.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);
             vertices = vertices.concat(verticesSenao);
@@ -34591,7 +36209,7 @@ class TradutorMermaidJs {
     traduzirDeclaracaoVar(declaracaoVar) {
         let texto = `Linha${declaracaoVar.linha}(variável: ${declaracaoVar.simbolo.lexema}`;
         texto += this.logicaComumTraducaoVarEConst(declaracaoVar, texto);
-        const aresta = new ArestaFluxograma(declaracaoVar, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracaoVar, texto);
         const vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
         return vertices;
@@ -34600,9 +36218,15 @@ class TradutorMermaidJs {
         this.anteriores = [];
         this.vertices = [];
         let resultado = 'graph TD;\n';
+        this.subgrafosFuncoes = [];
         for (const declaracao of declaracoes) {
             this.vertices = this.vertices.concat(this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao));
         }
+        if (this.subgrafosFuncoes.length > 0) {
+            for (const sub of this.subgrafosFuncoes) {
+                resultado += sub;
+            }
+        }
         if (this.vertices.length === 0 && this.anteriores.length === 0) {
             resultado += `    Vazio;\n`;
         }
@@ -34627,7 +36251,7 @@ class TradutorMermaidJs {
 }
 exports.TradutorMermaidJs = TradutorMermaidJs;
 
-},{"../tipos-de-simbolos/delegua":190}],205:[function(require,module,exports){
+},{"../tipos-de-simbolos/delegua":190,"./mermaid":201}],212:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorPortugolIpt = void 0;
@@ -34689,7 +36313,7 @@ class TradutorPortugolIpt {
 }
 exports.TradutorPortugolIpt = TradutorPortugolIpt;
 
-},{"../avaliador-sintatico/dialetos":10,"../lexador/dialetos":162}],206:[function(require,module,exports){
+},{"../avaliador-sintatico/dialetos":10,"../lexador/dialetos":162}],213:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -35338,7 +36962,7 @@ class TradutorPython {
 }
 exports.TradutorPython = TradutorPython;
 
-},{"../construtos":51,"../declaracoes":96,"../tipos-de-simbolos/delegua":190}],207:[function(require,module,exports){
+},{"../construtos":51,"../declaracoes":96,"../tipos-de-simbolos/delegua":190}],214:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorReversoJavaScript = void 0;
@@ -35735,7 +37359,7 @@ class TradutorReversoJavaScript {
 }
 exports.TradutorReversoJavaScript = TradutorReversoJavaScript;
 
-},{}],208:[function(require,module,exports){
+},{}],215:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorReversoPython = void 0;
@@ -35808,7 +37432,7 @@ class TradutorReversoPython {
 }
 exports.TradutorReversoPython = TradutorReversoPython;
 
-},{"./python/python3-lexer":199,"./python/python3-parser":200,"antlr4ts":325,"antlr4ts/tree/ParseTreeWalker":344}],209:[function(require,module,exports){
+},{"./python/python3-lexer":204,"./python/python3-parser":205,"antlr4ts":332,"antlr4ts/tree/ParseTreeWalker":351}],216:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -36402,7 +38026,7 @@ class TradutorReversoTenda {
 }
 exports.TradutorReversoTenda = TradutorReversoTenda;
 
-},{"../construtos":51,"../tipos-de-simbolos/tenda":197}],210:[function(require,module,exports){
+},{"../construtos":51,"../tipos-de-simbolos/tenda":197}],217:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -36410,7 +38034,7 @@ exports.TradutorReversoTenda = TradutorReversoTenda;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],211:[function(require,module,exports){
+},{}],218:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -36418,7 +38042,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],212:[function(require,module,exports){
+},{}],219:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -36580,7 +38204,7 @@ __decorate([
 ], ANTLRInputStream.prototype, "toString", null);
 exports.ANTLRInputStream = ANTLRInputStream;
 
-},{"./Decorators":223,"./IntStream":229,"assert":366}],213:[function(require,module,exports){
+},{"./Decorators":230,"./IntStream":236,"assert":373}],220:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -36663,7 +38287,7 @@ __decorate([
 ], BailErrorStrategy.prototype, "sync", null);
 exports.BailErrorStrategy = BailErrorStrategy;
 
-},{"./Decorators":223,"./DefaultErrorStrategy":224,"./InputMismatchException":228,"./misc/ParseCancellationException":340}],214:[function(require,module,exports){
+},{"./Decorators":230,"./DefaultErrorStrategy":231,"./InputMismatchException":235,"./misc/ParseCancellationException":347}],221:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -37153,7 +38777,7 @@ BufferedTokenStream = __decorate([
 ], BufferedTokenStream);
 exports.BufferedTokenStream = BufferedTokenStream;
 
-},{"./CommonToken":219,"./Decorators":223,"./Lexer":231,"./Token":248,"./misc/Interval":335,"assert":366}],215:[function(require,module,exports){
+},{"./CommonToken":226,"./Decorators":230,"./Lexer":238,"./Token":255,"./misc/Interval":342,"assert":373}],222:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -37161,7 +38785,7 @@ exports.BufferedTokenStream = BufferedTokenStream;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],216:[function(require,module,exports){
+},{}],223:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -37295,7 +38919,7 @@ var CharStreams;
     // }
 })(CharStreams = exports.CharStreams || (exports.CharStreams = {}));
 
-},{"./CodePointBuffer":217,"./CodePointCharStream":218,"./IntStream":229}],217:[function(require,module,exports){
+},{"./CodePointBuffer":224,"./CodePointCharStream":225,"./IntStream":236}],224:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -37530,7 +39154,7 @@ exports.CodePointBuffer = CodePointBuffer;
     CodePointBuffer.Builder = Builder;
 })(CodePointBuffer = exports.CodePointBuffer || (exports.CodePointBuffer = {}));
 
-},{"./misc/Character":331,"assert":366}],218:[function(require,module,exports){
+},{"./misc/Character":338,"assert":373}],225:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -37680,7 +39304,7 @@ __decorate([
 ], CodePointCharStream.prototype, "getText", null);
 exports.CodePointCharStream = CodePointCharStream;
 
-},{"./Decorators":223,"./IntStream":229,"./misc/Interval":335,"assert":366}],219:[function(require,module,exports){
+},{"./Decorators":230,"./IntStream":236,"./misc/Interval":342,"assert":373}],226:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -37910,7 +39534,7 @@ CommonToken = __decorate([
 ], CommonToken);
 exports.CommonToken = CommonToken;
 
-},{"./Decorators":223,"./Token":248,"./misc/Interval":335}],220:[function(require,module,exports){
+},{"./Decorators":230,"./Token":255,"./misc/Interval":342}],227:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -37974,7 +39598,7 @@ exports.CommonTokenFactory = CommonTokenFactory;
     CommonTokenFactory.DEFAULT = new CommonTokenFactory();
 })(CommonTokenFactory = exports.CommonTokenFactory || (exports.CommonTokenFactory = {}));
 
-},{"./CommonToken":219,"./Decorators":223,"./misc/Interval":335}],221:[function(require,module,exports){
+},{"./CommonToken":226,"./Decorators":230,"./misc/Interval":342}],228:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -38101,7 +39725,7 @@ CommonTokenStream = __decorate([
 ], CommonTokenStream);
 exports.CommonTokenStream = CommonTokenStream;
 
-},{"./BufferedTokenStream":214,"./Decorators":223,"./Token":248}],222:[function(require,module,exports){
+},{"./BufferedTokenStream":221,"./Decorators":230,"./Token":255}],229:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -38135,7 +39759,7 @@ exports.ConsoleErrorListener = ConsoleErrorListener;
  */
 ConsoleErrorListener.INSTANCE = new ConsoleErrorListener();
 
-},{}],223:[function(require,module,exports){
+},{}],230:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -38162,7 +39786,7 @@ function SuppressWarnings(options) {
 }
 exports.SuppressWarnings = SuppressWarnings;
 
-},{}],224:[function(require,module,exports){
+},{}],231:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -38976,7 +40600,7 @@ __decorate([
 ], DefaultErrorStrategy.prototype, "consumeUntil", null);
 exports.DefaultErrorStrategy = DefaultErrorStrategy;
 
-},{"./Decorators":223,"./FailedPredicateException":227,"./InputMismatchException":228,"./NoViableAltException":235,"./Token":248,"./atn/ATNState":262,"./atn/ATNStateType":263,"./atn/PredictionContext":303,"./misc/IntervalSet":336}],225:[function(require,module,exports){
+},{"./Decorators":230,"./FailedPredicateException":234,"./InputMismatchException":235,"./NoViableAltException":242,"./Token":255,"./atn/ATNState":269,"./atn/ATNStateType":270,"./atn/PredictionContext":310,"./misc/IntervalSet":343}],232:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -39052,7 +40676,7 @@ var Dependents;
     Dependents[Dependents["FOLLOWING"] = 9] = "FOLLOWING";
 })(Dependents = exports.Dependents || (exports.Dependents = {}));
 
-},{}],226:[function(require,module,exports){
+},{}],233:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -39200,7 +40824,7 @@ __decorate([
 ], DiagnosticErrorListener.prototype, "getConflictingAlts", null);
 exports.DiagnosticErrorListener = DiagnosticErrorListener;
 
-},{"./Decorators":223,"./misc/BitSet":330,"./misc/Interval":335}],227:[function(require,module,exports){
+},{"./Decorators":230,"./misc/BitSet":337,"./misc/Interval":342}],234:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -39265,7 +40889,7 @@ FailedPredicateException = __decorate([
 ], FailedPredicateException);
 exports.FailedPredicateException = FailedPredicateException;
 
-},{"./Decorators":223,"./RecognitionException":242,"./atn/PredicateTransition":302}],228:[function(require,module,exports){
+},{"./Decorators":230,"./RecognitionException":249,"./atn/PredicateTransition":309}],235:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -39305,7 +40929,7 @@ InputMismatchException = __decorate([
 ], InputMismatchException);
 exports.InputMismatchException = InputMismatchException;
 
-},{"./Decorators":223,"./RecognitionException":242}],229:[function(require,module,exports){
+},{"./Decorators":230,"./RecognitionException":249}],236:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -39328,7 +40952,7 @@ var IntStream;
     IntStream.UNKNOWN_SOURCE_NAME = "<unknown>";
 })(IntStream = exports.IntStream || (exports.IntStream = {}));
 
-},{}],230:[function(require,module,exports){
+},{}],237:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -39375,7 +40999,7 @@ __decorate([
 ], InterpreterRuleContext.prototype, "ruleIndex", null);
 exports.InterpreterRuleContext = InterpreterRuleContext;
 
-},{"./Decorators":223,"./ParserRuleContext":239}],231:[function(require,module,exports){
+},{"./Decorators":230,"./ParserRuleContext":246}],238:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -39711,7 +41335,7 @@ __decorate([
 ], Lexer.prototype, "charPositionInLine", null);
 exports.Lexer = Lexer;
 
-},{"./CommonTokenFactory":220,"./Decorators":223,"./IntStream":229,"./LexerNoViableAltException":233,"./Recognizer":243,"./Token":248,"./atn/LexerATNSimulator":281,"./misc/IntegerStack":334,"./misc/Interval":335}],232:[function(require,module,exports){
+},{"./CommonTokenFactory":227,"./Decorators":230,"./IntStream":236,"./LexerNoViableAltException":240,"./Recognizer":250,"./Token":255,"./atn/LexerATNSimulator":288,"./misc/IntegerStack":341,"./misc/Interval":342}],239:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -39791,7 +41415,7 @@ LexerInterpreter = __decorate([
 ], LexerInterpreter);
 exports.LexerInterpreter = LexerInterpreter;
 
-},{"./Decorators":223,"./Lexer":231,"./atn/LexerATNSimulator":281}],233:[function(require,module,exports){
+},{"./Decorators":230,"./Lexer":238,"./atn/LexerATNSimulator":288}],240:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -39848,7 +41472,7 @@ LexerNoViableAltException = __decorate([
 ], LexerNoViableAltException);
 exports.LexerNoViableAltException = LexerNoViableAltException;
 
-},{"./Decorators":223,"./RecognitionException":242,"./misc/Interval":335,"./misc/Utils":342}],234:[function(require,module,exports){
+},{"./Decorators":230,"./RecognitionException":249,"./misc/Interval":342,"./misc/Utils":349}],241:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -40058,7 +41682,7 @@ ListTokenSource = __decorate([
 ], ListTokenSource);
 exports.ListTokenSource = ListTokenSource;
 
-},{"./CommonTokenFactory":220,"./Decorators":223,"./Token":248}],235:[function(require,module,exports){
+},{"./CommonTokenFactory":227,"./Decorators":230,"./Token":255}],242:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -40113,7 +41737,7 @@ __decorate([
 ], NoViableAltException.prototype, "_startToken", void 0);
 exports.NoViableAltException = NoViableAltException;
 
-},{"./Decorators":223,"./Parser":236,"./RecognitionException":242}],236:[function(require,module,exports){
+},{"./Decorators":230,"./Parser":243,"./RecognitionException":249}],243:[function(require,module,exports){
 (function (process){(function (){
 "use strict";
 /*!
@@ -40959,7 +42583,7 @@ __decorate([
 exports.Parser = Parser;
 
 }).call(this)}).call(this,require('_process'))
-},{"./Decorators":223,"./DefaultErrorStrategy":224,"./Lexer":231,"./ProxyParserErrorListener":241,"./Recognizer":243,"./Token":248,"./atn/ATNDeserializationOptions":259,"./atn/ATNDeserializer":260,"./atn/ParseInfo":296,"./atn/ParserATNSimulator":297,"./atn/ProfilingATNSimulator":306,"./misc/IntegerStack":334,"./misc/Utils":342,"./tree/ErrorNode":343,"./tree/TerminalNode":346,"./tree/pattern/ParseTreePatternMatcher":351,"_process":425}],237:[function(require,module,exports){
+},{"./Decorators":230,"./DefaultErrorStrategy":231,"./Lexer":238,"./ProxyParserErrorListener":248,"./Recognizer":250,"./Token":255,"./atn/ATNDeserializationOptions":266,"./atn/ATNDeserializer":267,"./atn/ParseInfo":303,"./atn/ParserATNSimulator":304,"./atn/ProfilingATNSimulator":313,"./misc/IntegerStack":341,"./misc/Utils":349,"./tree/ErrorNode":350,"./tree/TerminalNode":353,"./tree/pattern/ParseTreePatternMatcher":358,"_process":432}],244:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -40967,7 +42591,7 @@ exports.Parser = Parser;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],238:[function(require,module,exports){
+},{}],245:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -41375,7 +42999,7 @@ ParserInterpreter = __decorate([
 ], ParserInterpreter);
 exports.ParserInterpreter = ParserInterpreter;
 
-},{"./Decorators":223,"./FailedPredicateException":227,"./InputMismatchException":228,"./InterpreterRuleContext":230,"./Parser":236,"./RecognitionException":242,"./Token":248,"./atn/ATNState":262,"./atn/ATNStateType":263,"./atn/LoopEndState":293,"./atn/ParserATNSimulator":297,"./atn/StarLoopEntryState":315,"./misc/BitSet":330}],239:[function(require,module,exports){
+},{"./Decorators":230,"./FailedPredicateException":234,"./InputMismatchException":235,"./InterpreterRuleContext":237,"./Parser":243,"./RecognitionException":249,"./Token":255,"./atn/ATNState":269,"./atn/ATNStateType":270,"./atn/LoopEndState":300,"./atn/ParserATNSimulator":304,"./atn/StarLoopEntryState":322,"./misc/BitSet":337}],246:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -41676,7 +43300,7 @@ __decorate([
 ], ParserRuleContext.prototype, "sourceInterval", null);
 exports.ParserRuleContext = ParserRuleContext;
 
-},{"./Decorators":223,"./RuleContext":244,"./misc/Interval":335,"./tree/ErrorNode":343,"./tree/TerminalNode":346}],240:[function(require,module,exports){
+},{"./Decorators":230,"./RuleContext":251,"./misc/Interval":342,"./tree/ErrorNode":350,"./tree/TerminalNode":353}],247:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -41726,7 +43350,7 @@ __decorate([
 ], ProxyErrorListener.prototype, "syntaxError", null);
 exports.ProxyErrorListener = ProxyErrorListener;
 
-},{"./Decorators":223}],241:[function(require,module,exports){
+},{"./Decorators":230}],248:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -41785,7 +43409,7 @@ __decorate([
 ], ProxyParserErrorListener.prototype, "reportContextSensitivity", null);
 exports.ProxyParserErrorListener = ProxyParserErrorListener;
 
-},{"./Decorators":223,"./ProxyErrorListener":240}],242:[function(require,module,exports){
+},{"./Decorators":230,"./ProxyErrorListener":247}],249:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -41890,7 +43514,7 @@ class RecognitionException extends Error {
 }
 exports.RecognitionException = RecognitionException;
 
-},{}],243:[function(require,module,exports){
+},{}],250:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -42109,7 +43733,7 @@ __decorate([
 ], Recognizer.prototype, "getErrorListeners", null);
 exports.Recognizer = Recognizer;
 
-},{"./ConsoleErrorListener":222,"./Decorators":223,"./ProxyErrorListener":240,"./Token":248,"./misc/Utils":342}],244:[function(require,module,exports){
+},{"./ConsoleErrorListener":229,"./Decorators":230,"./ProxyErrorListener":247,"./Token":255,"./misc/Utils":349}],251:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -42326,7 +43950,7 @@ __decorate([
 ], RuleContext.prototype, "toStringTree", null);
 exports.RuleContext = RuleContext;
 
-},{"./Decorators":223,"./ParserRuleContext":239,"./Recognizer":243,"./atn/ATN":256,"./misc/Interval":335,"./tree/RuleNode":345,"./tree/Trees":347}],245:[function(require,module,exports){
+},{"./Decorators":230,"./ParserRuleContext":246,"./Recognizer":250,"./atn/ATN":263,"./misc/Interval":342,"./tree/RuleNode":352,"./tree/Trees":354}],252:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -42377,7 +44001,7 @@ __decorate([
 ], RuleContextWithAltNum.prototype, "altNumber", null);
 exports.RuleContextWithAltNum = RuleContextWithAltNum;
 
-},{"./Decorators":223,"./ParserRuleContext":239,"./atn/ATN":256}],246:[function(require,module,exports){
+},{"./Decorators":230,"./ParserRuleContext":246,"./atn/ATN":263}],253:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -42400,7 +44024,7 @@ function RuleDependency(dependency) {
 }
 exports.RuleDependency = RuleDependency;
 
-},{}],247:[function(require,module,exports){
+},{}],254:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -42419,7 +44043,7 @@ function RuleVersion(version) {
 }
 exports.RuleVersion = RuleVersion;
 
-},{}],248:[function(require,module,exports){
+},{}],255:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -42459,7 +44083,7 @@ var Token;
     Token.MIN_USER_CHANNEL_VALUE = 2;
 })(Token = exports.Token || (exports.Token = {}));
 
-},{"./IntStream":229}],249:[function(require,module,exports){
+},{"./IntStream":236}],256:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -42467,7 +44091,7 @@ var Token;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],250:[function(require,module,exports){
+},{}],257:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -42475,7 +44099,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],251:[function(require,module,exports){
+},{}],258:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -42483,7 +44107,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],252:[function(require,module,exports){
+},{}],259:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -42991,7 +44615,7 @@ __decorate([
     Decorators_1.Override
 ], ReplaceOp.prototype, "toString", null);
 
-},{"./Decorators":223,"./Token":248,"./misc/Interval":335}],253:[function(require,module,exports){
+},{"./Decorators":230,"./Token":255,"./misc/Interval":342}],260:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -42999,7 +44623,7 @@ __decorate([
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],254:[function(require,module,exports){
+},{}],261:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -43119,7 +44743,7 @@ __decorate([
 ], VocabularyImpl, "EMPTY_VOCABULARY", void 0);
 exports.VocabularyImpl = VocabularyImpl;
 
-},{"./Decorators":223,"./Token":248}],255:[function(require,module,exports){
+},{"./Decorators":230,"./Token":255}],262:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -43127,7 +44751,7 @@ exports.VocabularyImpl = VocabularyImpl;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],256:[function(require,module,exports){
+},{}],263:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -43349,7 +44973,7 @@ exports.ATN = ATN;
 })(ATN = exports.ATN || (exports.ATN = {}));
 exports.ATN = ATN;
 
-},{"../Decorators":223,"../Token":248,"../dfa/DFA":321,"../misc/Array2DHashMap":326,"../misc/IntervalSet":336,"../misc/ObjectEqualityComparator":339,"./InvalidState":279,"./LL1Analyzer":280,"./PredictionContext":303,"assert":366}],257:[function(require,module,exports){
+},{"../Decorators":230,"../Token":255,"../dfa/DFA":328,"../misc/Array2DHashMap":333,"../misc/IntervalSet":343,"../misc/ObjectEqualityComparator":346,"./InvalidState":286,"./LL1Analyzer":287,"./PredictionContext":310,"assert":373}],264:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -43874,7 +45498,7 @@ ActionSemanticContextATNConfig = __decorate([
     __param(1, Decorators_1.NotNull), __param(2, Decorators_1.NotNull)
 ], ActionSemanticContextATNConfig);
 
-},{"../Decorators":223,"../misc/Array2DHashMap":326,"../misc/MurmurHash":338,"../misc/ObjectEqualityComparator":339,"./DecisionState":276,"./PredictionContext":303,"./SemanticContext":311,"assert":366}],258:[function(require,module,exports){
+},{"../Decorators":230,"../misc/Array2DHashMap":333,"../misc/MurmurHash":345,"../misc/ObjectEqualityComparator":346,"./DecisionState":283,"./PredictionContext":310,"./SemanticContext":318,"assert":373}],265:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -44321,7 +45945,7 @@ __decorate([
 ], ATNConfigSet.prototype, "hashCode", null);
 exports.ATNConfigSet = ATNConfigSet;
 
-},{"../Decorators":223,"../misc/Array2DHashMap":326,"../misc/Array2DHashSet":327,"../misc/ArrayEqualityComparator":328,"../misc/BitSet":330,"../misc/ObjectEqualityComparator":339,"../misc/Utils":342,"./ATN":256,"./ATNConfig":257,"./PredictionContext":303,"./PredictionContextCache":304,"./SemanticContext":311,"assert":366}],259:[function(require,module,exports){
+},{"../Decorators":230,"../misc/Array2DHashMap":333,"../misc/Array2DHashSet":334,"../misc/ArrayEqualityComparator":335,"../misc/BitSet":337,"../misc/ObjectEqualityComparator":346,"../misc/Utils":349,"./ATN":263,"./ATNConfig":264,"./PredictionContext":310,"./PredictionContextCache":311,"./SemanticContext":318,"assert":373}],266:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -44400,7 +46024,7 @@ __decorate([
 ], ATNDeserializationOptions, "defaultOptions", null);
 exports.ATNDeserializationOptions = ATNDeserializationOptions;
 
-},{"../Decorators":223}],260:[function(require,module,exports){
+},{"../Decorators":230}],267:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -45487,7 +47111,7 @@ __decorate([
 ], ATNDeserializer.prototype, "edgeFactory", null);
 exports.ATNDeserializer = ATNDeserializer;
 
-},{"../Decorators":223,"../Token":248,"../dfa/DFA":321,"../misc/Array2DHashSet":327,"../misc/BitSet":330,"../misc/IntervalSet":336,"../misc/UUID":341,"./ATN":256,"./ATNDeserializationOptions":259,"./ATNStateType":263,"./ActionTransition":265,"./AtomTransition":267,"./BasicBlockStartState":268,"./BasicState":269,"./BlockEndState":270,"./BlockStartState":271,"./DecisionState":276,"./EpsilonTransition":277,"./InvalidState":279,"./LexerChannelAction":283,"./LexerCustomAction":284,"./LexerModeAction":286,"./LexerMoreAction":287,"./LexerPopModeAction":288,"./LexerPushModeAction":289,"./LexerSkipAction":290,"./LexerTypeAction":291,"./LoopEndState":293,"./NotSetTransition":294,"./ParserATNSimulator":297,"./PlusBlockStartState":298,"./PlusLoopbackState":299,"./PrecedencePredicateTransition":300,"./PredicateTransition":302,"./RangeTransition":307,"./RuleStartState":308,"./RuleStopState":309,"./RuleTransition":310,"./SetTransition":312,"./StarBlockStartState":314,"./StarLoopEntryState":315,"./StarLoopbackState":316,"./TokensStartState":317,"./WildcardTransition":319}],261:[function(require,module,exports){
+},{"../Decorators":230,"../Token":255,"../dfa/DFA":328,"../misc/Array2DHashSet":334,"../misc/BitSet":337,"../misc/IntervalSet":343,"../misc/UUID":348,"./ATN":263,"./ATNDeserializationOptions":266,"./ATNStateType":270,"./ActionTransition":272,"./AtomTransition":274,"./BasicBlockStartState":275,"./BasicState":276,"./BlockEndState":277,"./BlockStartState":278,"./DecisionState":283,"./EpsilonTransition":284,"./InvalidState":286,"./LexerChannelAction":290,"./LexerCustomAction":291,"./LexerModeAction":293,"./LexerMoreAction":294,"./LexerPopModeAction":295,"./LexerPushModeAction":296,"./LexerSkipAction":297,"./LexerTypeAction":298,"./LoopEndState":300,"./NotSetTransition":301,"./ParserATNSimulator":304,"./PlusBlockStartState":305,"./PlusLoopbackState":306,"./PrecedencePredicateTransition":307,"./PredicateTransition":309,"./RangeTransition":314,"./RuleStartState":315,"./RuleStopState":316,"./RuleTransition":317,"./SetTransition":319,"./StarBlockStartState":321,"./StarLoopEntryState":322,"./StarLoopbackState":323,"./TokensStartState":324,"./WildcardTransition":326}],268:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -45551,7 +47175,7 @@ exports.ATNSimulator = ATNSimulator;
 })(ATNSimulator = exports.ATNSimulator || (exports.ATNSimulator = {}));
 exports.ATNSimulator = ATNSimulator;
 
-},{"../Decorators":223,"../dfa/DFAState":323,"./ATNConfigSet":258,"./PredictionContext":303}],262:[function(require,module,exports){
+},{"../Decorators":230,"../dfa/DFAState":330,"./ATNConfigSet":265,"./PredictionContext":310}],269:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -45738,7 +47362,7 @@ exports.ATNState = ATNState;
     ATNState.INVALID_STATE_NUMBER = -1;
 })(ATNState = exports.ATNState || (exports.ATNState = {}));
 
-},{"../Decorators":223}],263:[function(require,module,exports){
+},{"../Decorators":230}],270:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -45764,7 +47388,7 @@ var ATNStateType;
     ATNStateType[ATNStateType["LOOP_END"] = 12] = "LOOP_END";
 })(ATNStateType = exports.ATNStateType || (exports.ATNStateType = {}));
 
-},{}],264:[function(require,module,exports){
+},{}],271:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -45784,7 +47408,7 @@ class AbstractPredicateTransition extends Transition_1.Transition {
 }
 exports.AbstractPredicateTransition = AbstractPredicateTransition;
 
-},{"./Transition":318}],265:[function(require,module,exports){
+},{"./Transition":325}],272:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -45840,7 +47464,7 @@ ActionTransition = __decorate([
 ], ActionTransition);
 exports.ActionTransition = ActionTransition;
 
-},{"../Decorators":223,"./Transition":318}],266:[function(require,module,exports){
+},{"../Decorators":230,"./Transition":325}],273:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -45927,7 +47551,7 @@ AmbiguityInfo = __decorate([
 ], AmbiguityInfo);
 exports.AmbiguityInfo = AmbiguityInfo;
 
-},{"../Decorators":223,"./DecisionEventInfo":274}],267:[function(require,module,exports){
+},{"../Decorators":230,"./DecisionEventInfo":281}],274:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -45985,7 +47609,7 @@ AtomTransition = __decorate([
 ], AtomTransition);
 exports.AtomTransition = AtomTransition;
 
-},{"../Decorators":223,"../misc/IntervalSet":336,"./Transition":318}],268:[function(require,module,exports){
+},{"../Decorators":230,"../misc/IntervalSet":343,"./Transition":325}],275:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46017,7 +47641,7 @@ __decorate([
 ], BasicBlockStartState.prototype, "stateType", null);
 exports.BasicBlockStartState = BasicBlockStartState;
 
-},{"../Decorators":223,"./ATNStateType":263,"./BlockStartState":271}],269:[function(require,module,exports){
+},{"../Decorators":230,"./ATNStateType":270,"./BlockStartState":278}],276:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46049,7 +47673,7 @@ __decorate([
 ], BasicState.prototype, "stateType", null);
 exports.BasicState = BasicState;
 
-},{"../Decorators":223,"./ATNState":262,"./ATNStateType":263}],270:[function(require,module,exports){
+},{"../Decorators":230,"./ATNState":269,"./ATNStateType":270}],277:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46078,7 +47702,7 @@ __decorate([
 ], BlockEndState.prototype, "stateType", null);
 exports.BlockEndState = BlockEndState;
 
-},{"../Decorators":223,"./ATNState":262,"./ATNStateType":263}],271:[function(require,module,exports){
+},{"../Decorators":230,"./ATNState":269,"./ATNStateType":270}],278:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46092,7 +47716,7 @@ class BlockStartState extends DecisionState_1.DecisionState {
 }
 exports.BlockStartState = BlockStartState;
 
-},{"./DecisionState":276}],272:[function(require,module,exports){
+},{"./DecisionState":283}],279:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46162,7 +47786,7 @@ __decorate([
 ], ConflictInfo.prototype, "hashCode", null);
 exports.ConflictInfo = ConflictInfo;
 
-},{"../Decorators":223,"../misc/Utils":342}],273:[function(require,module,exports){
+},{"../Decorators":230,"../misc/Utils":349}],280:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46222,7 +47846,7 @@ ContextSensitivityInfo = __decorate([
 ], ContextSensitivityInfo);
 exports.ContextSensitivityInfo = ContextSensitivityInfo;
 
-},{"../Decorators":223,"./DecisionEventInfo":274}],274:[function(require,module,exports){
+},{"../Decorators":230,"./DecisionEventInfo":281}],281:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46274,7 +47898,7 @@ DecisionEventInfo = __decorate([
 ], DecisionEventInfo);
 exports.DecisionEventInfo = DecisionEventInfo;
 
-},{"../Decorators":223}],275:[function(require,module,exports){
+},{"../Decorators":230}],282:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46487,7 +48111,7 @@ __decorate([
 ], DecisionInfo.prototype, "toString", null);
 exports.DecisionInfo = DecisionInfo;
 
-},{"../Decorators":223}],276:[function(require,module,exports){
+},{"../Decorators":230}],283:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46507,7 +48131,7 @@ class DecisionState extends ATNState_1.ATNState {
 }
 exports.DecisionState = DecisionState;
 
-},{"./ATNState":262}],277:[function(require,module,exports){
+},{"./ATNState":269}],284:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46573,7 +48197,7 @@ EpsilonTransition = __decorate([
 ], EpsilonTransition);
 exports.EpsilonTransition = EpsilonTransition;
 
-},{"../Decorators":223,"./Transition":318}],278:[function(require,module,exports){
+},{"../Decorators":230,"./Transition":325}],285:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46626,7 +48250,7 @@ ErrorInfo = __decorate([
 ], ErrorInfo);
 exports.ErrorInfo = ErrorInfo;
 
-},{"../Decorators":223,"./DecisionEventInfo":274}],279:[function(require,module,exports){
+},{"../Decorators":230,"./DecisionEventInfo":281}],286:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46657,7 +48281,7 @@ __decorate([
 ], InvalidState.prototype, "stateType", null);
 exports.InvalidState = InvalidState;
 
-},{"../Decorators":223,"./ATNStateType":263,"./BasicState":269}],280:[function(require,module,exports){
+},{"../Decorators":230,"./ATNStateType":270,"./BasicState":276}],287:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -46879,7 +48503,7 @@ LL1Analyzer = __decorate([
 ], LL1Analyzer);
 exports.LL1Analyzer = LL1Analyzer;
 
-},{"../Decorators":223,"../Token":248,"../misc/Array2DHashSet":327,"../misc/BitSet":330,"../misc/IntervalSet":336,"../misc/ObjectEqualityComparator":339,"./ATNConfig":257,"./AbstractPredicateTransition":264,"./NotSetTransition":294,"./PredictionContext":303,"./RuleStopState":309,"./RuleTransition":310,"./WildcardTransition":319}],281:[function(require,module,exports){
+},{"../Decorators":230,"../Token":255,"../misc/Array2DHashSet":334,"../misc/BitSet":337,"../misc/IntervalSet":343,"../misc/ObjectEqualityComparator":346,"./ATNConfig":264,"./AbstractPredicateTransition":271,"./NotSetTransition":301,"./PredictionContext":310,"./RuleStopState":316,"./RuleTransition":317,"./WildcardTransition":326}],288:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -47596,7 +49220,7 @@ exports.LexerATNSimulator = LexerATNSimulator;
 })(LexerATNSimulator = exports.LexerATNSimulator || (exports.LexerATNSimulator = {}));
 exports.LexerATNSimulator = LexerATNSimulator;
 
-},{"../Decorators":223,"../IntStream":229,"../Lexer":231,"../LexerNoViableAltException":233,"../Token":248,"../dfa/AcceptStateInfo":320,"../dfa/DFAState":323,"../misc/Interval":335,"./ATN":256,"./ATNConfig":257,"./ATNConfigSet":258,"./ATNSimulator":261,"./LexerActionExecutor":282,"./OrderedATNConfigSet":295,"./PredictionContext":303,"./RuleStopState":309,"assert":366}],282:[function(require,module,exports){
+},{"../Decorators":230,"../IntStream":236,"../Lexer":238,"../LexerNoViableAltException":240,"../Token":255,"../dfa/AcceptStateInfo":327,"../dfa/DFAState":330,"../misc/Interval":342,"./ATN":263,"./ATNConfig":264,"./ATNConfigSet":265,"./ATNSimulator":268,"./LexerActionExecutor":289,"./OrderedATNConfigSet":302,"./PredictionContext":310,"./RuleStopState":316,"assert":373}],289:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -47797,7 +49421,7 @@ LexerActionExecutor = __decorate([
 ], LexerActionExecutor);
 exports.LexerActionExecutor = LexerActionExecutor;
 
-},{"../Decorators":223,"../misc/ArrayEqualityComparator":328,"../misc/MurmurHash":338,"./LexerIndexedCustomAction":285}],283:[function(require,module,exports){
+},{"../Decorators":230,"../misc/ArrayEqualityComparator":335,"../misc/MurmurHash":345,"./LexerIndexedCustomAction":292}],290:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -47902,7 +49526,7 @@ __decorate([
 ], LexerChannelAction.prototype, "toString", null);
 exports.LexerChannelAction = LexerChannelAction;
 
-},{"../Decorators":223,"../misc/MurmurHash":338}],284:[function(require,module,exports){
+},{"../Decorators":230,"../misc/MurmurHash":345}],291:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48031,7 +49655,7 @@ __decorate([
 ], LexerCustomAction.prototype, "equals", null);
 exports.LexerCustomAction = LexerCustomAction;
 
-},{"../Decorators":223,"../misc/MurmurHash":338}],285:[function(require,module,exports){
+},{"../Decorators":230,"../misc/MurmurHash":345}],292:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48166,7 +49790,7 @@ LexerIndexedCustomAction = __decorate([
 ], LexerIndexedCustomAction);
 exports.LexerIndexedCustomAction = LexerIndexedCustomAction;
 
-},{"../Decorators":223,"../misc/MurmurHash":338}],286:[function(require,module,exports){
+},{"../Decorators":230,"../misc/MurmurHash":345}],293:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48271,7 +49895,7 @@ __decorate([
 ], LexerModeAction.prototype, "toString", null);
 exports.LexerModeAction = LexerModeAction;
 
-},{"../Decorators":223,"../misc/MurmurHash":338}],287:[function(require,module,exports){
+},{"../Decorators":230,"../misc/MurmurHash":345}],294:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48367,7 +49991,7 @@ exports.LexerMoreAction = LexerMoreAction;
     LexerMoreAction.INSTANCE = new LexerMoreAction();
 })(LexerMoreAction = exports.LexerMoreAction || (exports.LexerMoreAction = {}));
 
-},{"../Decorators":223,"../misc/MurmurHash":338}],288:[function(require,module,exports){
+},{"../Decorators":230,"../misc/MurmurHash":345}],295:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48463,7 +50087,7 @@ exports.LexerPopModeAction = LexerPopModeAction;
     LexerPopModeAction.INSTANCE = new LexerPopModeAction();
 })(LexerPopModeAction = exports.LexerPopModeAction || (exports.LexerPopModeAction = {}));
 
-},{"../Decorators":223,"../misc/MurmurHash":338}],289:[function(require,module,exports){
+},{"../Decorators":230,"../misc/MurmurHash":345}],296:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48568,7 +50192,7 @@ __decorate([
 ], LexerPushModeAction.prototype, "toString", null);
 exports.LexerPushModeAction = LexerPushModeAction;
 
-},{"../Decorators":223,"../misc/MurmurHash":338}],290:[function(require,module,exports){
+},{"../Decorators":230,"../misc/MurmurHash":345}],297:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48664,7 +50288,7 @@ exports.LexerSkipAction = LexerSkipAction;
     LexerSkipAction.INSTANCE = new LexerSkipAction();
 })(LexerSkipAction = exports.LexerSkipAction || (exports.LexerSkipAction = {}));
 
-},{"../Decorators":223,"../misc/MurmurHash":338}],291:[function(require,module,exports){
+},{"../Decorators":230,"../misc/MurmurHash":345}],298:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48768,7 +50392,7 @@ __decorate([
 ], LexerTypeAction.prototype, "toString", null);
 exports.LexerTypeAction = LexerTypeAction;
 
-},{"../Decorators":223,"../misc/MurmurHash":338}],292:[function(require,module,exports){
+},{"../Decorators":230,"../misc/MurmurHash":345}],299:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48820,7 +50444,7 @@ LookaheadEventInfo = __decorate([
 ], LookaheadEventInfo);
 exports.LookaheadEventInfo = LookaheadEventInfo;
 
-},{"../Decorators":223,"./DecisionEventInfo":274}],293:[function(require,module,exports){
+},{"../Decorators":230,"./DecisionEventInfo":281}],300:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48849,7 +50473,7 @@ __decorate([
 ], LoopEndState.prototype, "stateType", null);
 exports.LoopEndState = LoopEndState;
 
-},{"../Decorators":223,"./ATNState":262,"./ATNStateType":263}],294:[function(require,module,exports){
+},{"../Decorators":230,"./ATNState":269,"./ATNStateType":270}],301:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48898,7 +50522,7 @@ NotSetTransition = __decorate([
 ], NotSetTransition);
 exports.NotSetTransition = NotSetTransition;
 
-},{"../Decorators":223,"./SetTransition":312}],295:[function(require,module,exports){
+},{"../Decorators":230,"./SetTransition":319}],302:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48953,7 +50577,7 @@ __decorate([
 ], OrderedATNConfigSet.prototype, "canMerge", null);
 exports.OrderedATNConfigSet = OrderedATNConfigSet;
 
-},{"../Decorators":223,"./ATNConfigSet":258}],296:[function(require,module,exports){
+},{"../Decorators":230,"./ATNConfigSet":265}],303:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49115,7 +50739,7 @@ ParseInfo = __decorate([
 ], ParseInfo);
 exports.ParseInfo = ParseInfo;
 
-},{"../Decorators":223}],297:[function(require,module,exports){
+},{"../Decorators":230}],304:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -51388,7 +53012,7 @@ ParserATNSimulator = __decorate([
 ], ParserATNSimulator);
 exports.ParserATNSimulator = ParserATNSimulator;
 
-},{"../Decorators":223,"../IntStream":229,"../NoViableAltException":235,"../ParserRuleContext":239,"../Token":248,"../VocabularyImpl":254,"../dfa/AcceptStateInfo":320,"../dfa/DFAState":323,"../misc/Array2DHashSet":327,"../misc/Arrays":329,"../misc/BitSet":330,"../misc/IntegerList":333,"../misc/Interval":335,"../misc/ObjectEqualityComparator":339,"./ATN":256,"./ATNConfig":257,"./ATNConfigSet":258,"./ATNSimulator":261,"./ATNStateType":263,"./ActionTransition":265,"./AtomTransition":267,"./ConflictInfo":272,"./DecisionState":276,"./NotSetTransition":294,"./PredictionContext":303,"./PredictionContextCache":304,"./PredictionMode":305,"./RuleStopState":309,"./RuleTransition":310,"./SemanticContext":311,"./SetTransition":312,"./SimulatorState":313,"assert":366}],298:[function(require,module,exports){
+},{"../Decorators":230,"../IntStream":236,"../NoViableAltException":242,"../ParserRuleContext":246,"../Token":255,"../VocabularyImpl":261,"../dfa/AcceptStateInfo":327,"../dfa/DFAState":330,"../misc/Array2DHashSet":334,"../misc/Arrays":336,"../misc/BitSet":337,"../misc/IntegerList":340,"../misc/Interval":342,"../misc/ObjectEqualityComparator":346,"./ATN":263,"./ATNConfig":264,"./ATNConfigSet":265,"./ATNSimulator":268,"./ATNStateType":270,"./ActionTransition":272,"./AtomTransition":274,"./ConflictInfo":279,"./DecisionState":283,"./NotSetTransition":301,"./PredictionContext":310,"./PredictionContextCache":311,"./PredictionMode":312,"./RuleStopState":316,"./RuleTransition":317,"./SemanticContext":318,"./SetTransition":319,"./SimulatorState":320,"assert":373}],305:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -51421,7 +53045,7 @@ __decorate([
 ], PlusBlockStartState.prototype, "stateType", null);
 exports.PlusBlockStartState = PlusBlockStartState;
 
-},{"../Decorators":223,"./ATNStateType":263,"./BlockStartState":271}],299:[function(require,module,exports){
+},{"../Decorators":230,"./ATNStateType":270,"./BlockStartState":278}],306:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -51452,7 +53076,7 @@ __decorate([
 ], PlusLoopbackState.prototype, "stateType", null);
 exports.PlusLoopbackState = PlusLoopbackState;
 
-},{"../Decorators":223,"./ATNStateType":263,"./DecisionState":276}],300:[function(require,module,exports){
+},{"../Decorators":230,"./ATNStateType":270,"./DecisionState":283}],307:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -51515,7 +53139,7 @@ PrecedencePredicateTransition = __decorate([
 ], PrecedencePredicateTransition);
 exports.PrecedencePredicateTransition = PrecedencePredicateTransition;
 
-},{"../Decorators":223,"./AbstractPredicateTransition":264,"./SemanticContext":311}],301:[function(require,module,exports){
+},{"../Decorators":230,"./AbstractPredicateTransition":271,"./SemanticContext":318}],308:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -51578,7 +53202,7 @@ PredicateEvalInfo = __decorate([
 ], PredicateEvalInfo);
 exports.PredicateEvalInfo = PredicateEvalInfo;
 
-},{"../Decorators":223,"./DecisionEventInfo":274}],302:[function(require,module,exports){
+},{"../Decorators":230,"./DecisionEventInfo":281}],309:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -51644,7 +53268,7 @@ PredicateTransition = __decorate([
 ], PredicateTransition);
 exports.PredicateTransition = PredicateTransition;
 
-},{"../Decorators":223,"./AbstractPredicateTransition":264,"./SemanticContext":311}],303:[function(require,module,exports){
+},{"../Decorators":230,"./AbstractPredicateTransition":271,"./SemanticContext":318}],310:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52335,7 +53959,7 @@ exports.SingletonPredictionContext = SingletonPredictionContext;
     PredictionContext.IdentityEqualityComparator = IdentityEqualityComparator;
 })(PredictionContext = exports.PredictionContext || (exports.PredictionContext = {}));
 
-},{"../Decorators":223,"../misc/Array2DHashMap":326,"../misc/Array2DHashSet":327,"../misc/Arrays":329,"../misc/MurmurHash":338,"./PredictionContextCache":304,"assert":366}],304:[function(require,module,exports){
+},{"../Decorators":230,"../misc/Array2DHashMap":333,"../misc/Array2DHashSet":334,"../misc/Arrays":336,"../misc/MurmurHash":345,"./PredictionContextCache":311,"assert":373}],311:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52476,7 +54100,7 @@ PredictionContextCache.UNCACHED = new PredictionContextCache(false);
     PredictionContextCache.IdentityCommutativePredictionContextOperands = IdentityCommutativePredictionContextOperands;
 })(PredictionContextCache = exports.PredictionContextCache || (exports.PredictionContextCache = {}));
 
-},{"../Decorators":223,"../misc/Array2DHashMap":326,"../misc/ObjectEqualityComparator":339,"./PredictionContext":303,"assert":366}],305:[function(require,module,exports){
+},{"../Decorators":230,"../misc/Array2DHashMap":333,"../misc/ObjectEqualityComparator":346,"./PredictionContext":310,"assert":373}],312:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52637,7 +54261,7 @@ var PredictionMode;
     PredictionMode.allConfigsInRuleStopStates = allConfigsInRuleStopStates;
 })(PredictionMode = exports.PredictionMode || (exports.PredictionMode = {}));
 
-},{"../Decorators":223,"../misc/Array2DHashMap":326,"../misc/MurmurHash":338,"./RuleStopState":309}],306:[function(require,module,exports){
+},{"../Decorators":230,"../misc/Array2DHashMap":333,"../misc/MurmurHash":345,"./RuleStopState":316}],313:[function(require,module,exports){
 (function (process){(function (){
 "use strict";
 /*!
@@ -52906,7 +54530,7 @@ __decorate([
 exports.ProfilingATNSimulator = ProfilingATNSimulator;
 
 }).call(this)}).call(this,require('_process'))
-},{"../Decorators":223,"./ATN":256,"./ATNSimulator":261,"./AmbiguityInfo":266,"./ContextSensitivityInfo":273,"./DecisionInfo":275,"./ErrorInfo":278,"./LookaheadEventInfo":292,"./ParserATNSimulator":297,"./PredicateEvalInfo":301,"./SemanticContext":311,"./SimulatorState":313,"_process":425}],307:[function(require,module,exports){
+},{"../Decorators":230,"./ATN":263,"./ATNSimulator":268,"./AmbiguityInfo":273,"./ContextSensitivityInfo":280,"./DecisionInfo":282,"./ErrorInfo":285,"./LookaheadEventInfo":299,"./ParserATNSimulator":304,"./PredicateEvalInfo":308,"./SemanticContext":318,"./SimulatorState":320,"_process":432}],314:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52964,7 +54588,7 @@ RangeTransition = __decorate([
 ], RangeTransition);
 exports.RangeTransition = RangeTransition;
 
-},{"../Decorators":223,"../misc/IntervalSet":336,"./Transition":318}],308:[function(require,module,exports){
+},{"../Decorators":230,"../misc/IntervalSet":343,"./Transition":325}],315:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52997,7 +54621,7 @@ __decorate([
 ], RuleStartState.prototype, "stateType", null);
 exports.RuleStartState = RuleStartState;
 
-},{"../Decorators":223,"./ATNState":262,"./ATNStateType":263}],309:[function(require,module,exports){
+},{"../Decorators":230,"./ATNState":269,"./ATNStateType":270}],316:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53036,7 +54660,7 @@ __decorate([
 ], RuleStopState.prototype, "stateType", null);
 exports.RuleStopState = RuleStopState;
 
-},{"../Decorators":223,"./ATNState":262,"./ATNStateType":263}],310:[function(require,module,exports){
+},{"../Decorators":230,"./ATNState":269,"./ATNStateType":270}],317:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53092,7 +54716,7 @@ RuleTransition = __decorate([
 ], RuleTransition);
 exports.RuleTransition = RuleTransition;
 
-},{"../Decorators":223,"./Transition":318}],311:[function(require,module,exports){
+},{"../Decorators":230,"./Transition":325}],318:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53572,7 +55196,7 @@ exports.SemanticContext = SemanticContext;
     SemanticContext.OR = OR;
 })(SemanticContext = exports.SemanticContext || (exports.SemanticContext = {}));
 
-},{"../Decorators":223,"../misc/Array2DHashSet":327,"../misc/ArrayEqualityComparator":328,"../misc/MurmurHash":338,"../misc/ObjectEqualityComparator":339,"../misc/Utils":342}],312:[function(require,module,exports){
+},{"../Decorators":230,"../misc/Array2DHashSet":334,"../misc/ArrayEqualityComparator":335,"../misc/MurmurHash":345,"../misc/ObjectEqualityComparator":346,"../misc/Utils":349}],319:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53638,7 +55262,7 @@ SetTransition = __decorate([
 ], SetTransition);
 exports.SetTransition = SetTransition;
 
-},{"../Decorators":223,"../Token":248,"../misc/IntervalSet":336,"./Transition":318}],313:[function(require,module,exports){
+},{"../Decorators":230,"../Token":255,"../misc/IntervalSet":343,"./Transition":325}],320:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53674,7 +55298,7 @@ SimulatorState = __decorate([
 ], SimulatorState);
 exports.SimulatorState = SimulatorState;
 
-},{"../Decorators":223,"../ParserRuleContext":239}],314:[function(require,module,exports){
+},{"../Decorators":230,"../ParserRuleContext":246}],321:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53702,7 +55326,7 @@ __decorate([
 ], StarBlockStartState.prototype, "stateType", null);
 exports.StarBlockStartState = StarBlockStartState;
 
-},{"../Decorators":223,"./ATNStateType":263,"./BlockStartState":271}],315:[function(require,module,exports){
+},{"../Decorators":230,"./ATNStateType":270,"./BlockStartState":278}],322:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53759,7 +55383,7 @@ __decorate([
 ], StarLoopEntryState.prototype, "stateType", null);
 exports.StarLoopEntryState = StarLoopEntryState;
 
-},{"../Decorators":223,"../misc/BitSet":330,"./ATNStateType":263,"./DecisionState":276}],316:[function(require,module,exports){
+},{"../Decorators":230,"../misc/BitSet":337,"./ATNStateType":270,"./DecisionState":283}],323:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53790,7 +55414,7 @@ __decorate([
 ], StarLoopbackState.prototype, "stateType", null);
 exports.StarLoopbackState = StarLoopbackState;
 
-},{"../Decorators":223,"./ATNState":262,"./ATNStateType":263}],317:[function(require,module,exports){
+},{"../Decorators":230,"./ATNState":269,"./ATNStateType":270}],324:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53819,7 +55443,7 @@ __decorate([
 ], TokensStartState.prototype, "stateType", null);
 exports.TokensStartState = TokensStartState;
 
-},{"../Decorators":223,"./ATNStateType":263,"./DecisionState":276}],318:[function(require,module,exports){
+},{"../Decorators":230,"./ATNStateType":270,"./DecisionState":283}],325:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53893,7 +55517,7 @@ Transition = __decorate([
 ], Transition);
 exports.Transition = Transition;
 
-},{"../Decorators":223}],319:[function(require,module,exports){
+},{"../Decorators":230}],326:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53941,7 +55565,7 @@ WildcardTransition = __decorate([
 ], WildcardTransition);
 exports.WildcardTransition = WildcardTransition;
 
-},{"../Decorators":223,"./Transition":318}],320:[function(require,module,exports){
+},{"../Decorators":230,"./Transition":325}],327:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53983,7 +55607,7 @@ class AcceptStateInfo {
 }
 exports.AcceptStateInfo = AcceptStateInfo;
 
-},{}],321:[function(require,module,exports){
+},{}],328:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54158,7 +55782,7 @@ DFA = __decorate([
 ], DFA);
 exports.DFA = DFA;
 
-},{"../Decorators":223,"../VocabularyImpl":254,"../atn/ATNConfigSet":258,"../atn/StarLoopEntryState":315,"../misc/Array2DHashSet":327,"../misc/ObjectEqualityComparator":339,"./DFASerializer":322,"./DFAState":323,"./LexerDFASerializer":324}],322:[function(require,module,exports){
+},{"../Decorators":230,"../VocabularyImpl":261,"../atn/ATNConfigSet":265,"../atn/StarLoopEntryState":322,"../misc/Array2DHashSet":334,"../misc/ObjectEqualityComparator":346,"./DFASerializer":329,"./DFAState":330,"./LexerDFASerializer":331}],329:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54300,7 +55924,7 @@ __decorate([
 ], DFASerializer.prototype, "toString", null);
 exports.DFASerializer = DFASerializer;
 
-},{"../Decorators":223,"../Recognizer":243,"../VocabularyImpl":254,"../atn/ATNSimulator":261,"../atn/PredictionContext":303}],323:[function(require,module,exports){
+},{"../Decorators":230,"../Recognizer":250,"../VocabularyImpl":261,"../atn/ATNSimulator":268,"../atn/PredictionContext":310}],330:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54531,7 +56155,7 @@ exports.DFAState = DFAState;
     DFAState.PredPrediction = PredPrediction;
 })(DFAState = exports.DFAState || (exports.DFAState = {}));
 
-},{"../Decorators":223,"../atn/ATN":256,"../atn/PredictionContext":303,"../misc/BitSet":330,"../misc/MurmurHash":338,"assert":366}],324:[function(require,module,exports){
+},{"../Decorators":230,"../atn/ATN":263,"../atn/PredictionContext":310,"../misc/BitSet":337,"../misc/MurmurHash":345,"assert":373}],331:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54568,7 +56192,7 @@ LexerDFASerializer = __decorate([
 ], LexerDFASerializer);
 exports.LexerDFASerializer = LexerDFASerializer;
 
-},{"../Decorators":223,"../VocabularyImpl":254,"./DFASerializer":322}],325:[function(require,module,exports){
+},{"../Decorators":230,"../VocabularyImpl":261,"./DFASerializer":329}],332:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54634,7 +56258,7 @@ __exportStar(require("./Vocabulary"), exports);
 __exportStar(require("./VocabularyImpl"), exports);
 __exportStar(require("./WritableToken"), exports);
 
-},{"./ANTLRErrorListener":210,"./ANTLRErrorStrategy":211,"./ANTLRInputStream":212,"./BailErrorStrategy":213,"./BufferedTokenStream":214,"./CharStream":215,"./CharStreams":216,"./CodePointBuffer":217,"./CodePointCharStream":218,"./CommonToken":219,"./CommonTokenFactory":220,"./CommonTokenStream":221,"./ConsoleErrorListener":222,"./DefaultErrorStrategy":224,"./Dependents":225,"./DiagnosticErrorListener":226,"./FailedPredicateException":227,"./InputMismatchException":228,"./IntStream":229,"./InterpreterRuleContext":230,"./Lexer":231,"./LexerInterpreter":232,"./LexerNoViableAltException":233,"./ListTokenSource":234,"./NoViableAltException":235,"./Parser":236,"./ParserErrorListener":237,"./ParserInterpreter":238,"./ParserRuleContext":239,"./ProxyErrorListener":240,"./ProxyParserErrorListener":241,"./RecognitionException":242,"./Recognizer":243,"./RuleContext":244,"./RuleContextWithAltNum":245,"./RuleDependency":246,"./RuleVersion":247,"./Token":248,"./TokenFactory":249,"./TokenSource":250,"./TokenStream":251,"./TokenStreamRewriter":252,"./Vocabulary":253,"./VocabularyImpl":254,"./WritableToken":255}],326:[function(require,module,exports){
+},{"./ANTLRErrorListener":217,"./ANTLRErrorStrategy":218,"./ANTLRInputStream":219,"./BailErrorStrategy":220,"./BufferedTokenStream":221,"./CharStream":222,"./CharStreams":223,"./CodePointBuffer":224,"./CodePointCharStream":225,"./CommonToken":226,"./CommonTokenFactory":227,"./CommonTokenStream":228,"./ConsoleErrorListener":229,"./DefaultErrorStrategy":231,"./Dependents":232,"./DiagnosticErrorListener":233,"./FailedPredicateException":234,"./InputMismatchException":235,"./IntStream":236,"./InterpreterRuleContext":237,"./Lexer":238,"./LexerInterpreter":239,"./LexerNoViableAltException":240,"./ListTokenSource":241,"./NoViableAltException":242,"./Parser":243,"./ParserErrorListener":244,"./ParserInterpreter":245,"./ParserRuleContext":246,"./ProxyErrorListener":247,"./ProxyParserErrorListener":248,"./RecognitionException":249,"./Recognizer":250,"./RuleContext":251,"./RuleContextWithAltNum":252,"./RuleDependency":253,"./RuleVersion":254,"./Token":255,"./TokenFactory":256,"./TokenSource":257,"./TokenStream":258,"./TokenStreamRewriter":259,"./Vocabulary":260,"./VocabularyImpl":261,"./WritableToken":262}],333:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54717,7 +56341,7 @@ class Array2DHashMap {
 }
 exports.Array2DHashMap = Array2DHashMap;
 
-},{"./Array2DHashSet":327}],327:[function(require,module,exports){
+},{"./Array2DHashSet":334}],334:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55084,7 +56708,7 @@ __decorate([
 ], Array2DHashSet.prototype, "createBuckets", null);
 exports.Array2DHashSet = Array2DHashSet;
 
-},{"../Decorators":223,"./DefaultEqualityComparator":332,"./MurmurHash":338,"assert":366}],328:[function(require,module,exports){
+},{"../Decorators":230,"./DefaultEqualityComparator":339,"./MurmurHash":345,"assert":373}],335:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55156,7 +56780,7 @@ __decorate([
 ], ArrayEqualityComparator.prototype, "equals", null);
 exports.ArrayEqualityComparator = ArrayEqualityComparator;
 
-},{"../Decorators":223,"./MurmurHash":338,"./ObjectEqualityComparator":339}],329:[function(require,module,exports){
+},{"../Decorators":230,"./MurmurHash":345,"./ObjectEqualityComparator":346}],336:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55226,7 +56850,7 @@ var Arrays;
     Arrays.toString = toString;
 })(Arrays = exports.Arrays || (exports.Arrays = {}));
 
-},{}],330:[function(require,module,exports){
+},{}],337:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55898,7 +57522,7 @@ class BitSetIterator {
     [Symbol.iterator]() { return this; }
 }
 
-},{"./MurmurHash":338,"util":430}],331:[function(require,module,exports){
+},{"./MurmurHash":345,"util":437}],338:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55919,7 +57543,7 @@ function isSupplementaryCodePoint(ch) {
 }
 exports.isSupplementaryCodePoint = isSupplementaryCodePoint;
 
-},{}],332:[function(require,module,exports){
+},{}],339:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55990,7 +57614,7 @@ __decorate([
 ], DefaultEqualityComparator.prototype, "equals", null);
 exports.DefaultEqualityComparator = DefaultEqualityComparator;
 
-},{"../Decorators":223,"./MurmurHash":338,"./ObjectEqualityComparator":339}],333:[function(require,module,exports){
+},{"../Decorators":230,"./MurmurHash":345,"./ObjectEqualityComparator":346}],340:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -56284,7 +57908,7 @@ __decorate([
 ], IntegerList.prototype, "toString", null);
 exports.IntegerList = IntegerList;
 
-},{"../Decorators":223,"./Arrays":329}],334:[function(require,module,exports){
+},{"../Decorators":230,"./Arrays":336}],341:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -56314,7 +57938,7 @@ class IntegerStack extends IntegerList_1.IntegerList {
 }
 exports.IntegerStack = IntegerStack;
 
-},{"./IntegerList":333}],335:[function(require,module,exports){
+},{"./IntegerList":340}],342:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -56457,7 +58081,7 @@ __decorate([
 ], Interval.prototype, "toString", null);
 exports.Interval = Interval;
 
-},{"../Decorators":223}],336:[function(require,module,exports){
+},{"../Decorators":230}],343:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57103,7 +58727,7 @@ __decorate([
 ], IntervalSet, "subtract", null);
 exports.IntervalSet = IntervalSet;
 
-},{"../Decorators":223,"../Lexer":231,"../Token":248,"./ArrayEqualityComparator":328,"./IntegerList":333,"./Interval":335,"./MurmurHash":338}],337:[function(require,module,exports){
+},{"../Decorators":230,"../Lexer":238,"../Token":255,"./ArrayEqualityComparator":335,"./IntegerList":340,"./Interval":342,"./MurmurHash":345}],344:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57136,7 +58760,7 @@ class MultiMap extends Map {
 }
 exports.MultiMap = MultiMap;
 
-},{}],338:[function(require,module,exports){
+},{}],345:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57251,7 +58875,7 @@ var MurmurHash;
     }
 })(MurmurHash = exports.MurmurHash || (exports.MurmurHash = {}));
 
-},{}],339:[function(require,module,exports){
+},{}],346:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57310,7 +58934,7 @@ __decorate([
 ], ObjectEqualityComparator.prototype, "equals", null);
 exports.ObjectEqualityComparator = ObjectEqualityComparator;
 
-},{"../Decorators":223}],340:[function(require,module,exports){
+},{"../Decorators":230}],347:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57339,7 +58963,7 @@ class ParseCancellationException extends Error {
 }
 exports.ParseCancellationException = ParseCancellationException;
 
-},{}],341:[function(require,module,exports){
+},{}],348:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57393,7 +59017,7 @@ class UUID {
 }
 exports.UUID = UUID;
 
-},{"./MurmurHash":338}],342:[function(require,module,exports){
+},{"./MurmurHash":345}],349:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57568,7 +59192,7 @@ exports.toCharArray = toCharArray;
 // 	return s;
 // }
 
-},{}],343:[function(require,module,exports){
+},{}],350:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57604,7 +59228,7 @@ __decorate([
 ], ErrorNode.prototype, "accept", null);
 exports.ErrorNode = ErrorNode;
 
-},{"../Decorators":223,"./TerminalNode":346}],344:[function(require,module,exports){
+},{"../Decorators":230,"./TerminalNode":353}],351:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57709,7 +59333,7 @@ exports.ParseTreeWalker = ParseTreeWalker;
     ParseTreeWalker.DEFAULT = new ParseTreeWalker();
 })(ParseTreeWalker = exports.ParseTreeWalker || (exports.ParseTreeWalker = {}));
 
-},{"./ErrorNode":343,"./RuleNode":345,"./TerminalNode":346}],345:[function(require,module,exports){
+},{"./ErrorNode":350,"./RuleNode":352,"./TerminalNode":353}],352:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57721,7 +59345,7 @@ class RuleNode {
 }
 exports.RuleNode = RuleNode;
 
-},{}],346:[function(require,module,exports){
+},{}],353:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57813,7 +59437,7 @@ __decorate([
 ], TerminalNode.prototype, "toString", null);
 exports.TerminalNode = TerminalNode;
 
-},{"../Decorators":223,"../Token":248,"../misc/Interval":335}],347:[function(require,module,exports){
+},{"../Decorators":230,"../Token":255,"../misc/Interval":342}],354:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -58057,7 +59681,7 @@ __decorate([
 ], Trees, "getRootOfSubtreeEnclosingRegion", null);
 exports.Trees = Trees;
 
-},{"../CommonToken":219,"../Decorators":223,"../Parser":236,"../ParserRuleContext":239,"../Token":248,"../atn/ATN":256,"../misc/Utils":342,"./ErrorNode":343,"./RuleNode":345,"./TerminalNode":346}],348:[function(require,module,exports){
+},{"../CommonToken":226,"../Decorators":230,"../Parser":243,"../ParserRuleContext":246,"../Token":255,"../atn/ATN":263,"../misc/Utils":349,"./ErrorNode":350,"./RuleNode":352,"./TerminalNode":353}],355:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -58081,7 +59705,7 @@ class Chunk {
 }
 exports.Chunk = Chunk;
 
-},{}],349:[function(require,module,exports){
+},{}],356:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -58261,7 +59885,7 @@ ParseTreeMatch = __decorate([
 ], ParseTreeMatch);
 exports.ParseTreeMatch = ParseTreeMatch;
 
-},{"../../Decorators":223}],350:[function(require,module,exports){
+},{"../../Decorators":230}],357:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -58419,7 +60043,7 @@ ParseTreePattern = __decorate([
 ], ParseTreePattern);
 exports.ParseTreePattern = ParseTreePattern;
 
-},{"../../Decorators":223,"../xpath/XPath":356}],351:[function(require,module,exports){
+},{"../../Decorators":230,"../xpath/XPath":363}],358:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -58897,7 +60521,7 @@ exports.ParseTreePatternMatcher = ParseTreePatternMatcher;
     ParseTreePatternMatcher.StartRuleDoesNotConsumeFullPattern = StartRuleDoesNotConsumeFullPattern;
 })(ParseTreePatternMatcher = exports.ParseTreePatternMatcher || (exports.ParseTreePatternMatcher = {}));
 
-},{"../../BailErrorStrategy":213,"../../CharStreams":216,"../../CommonTokenStream":221,"../../Decorators":223,"../../ListTokenSource":234,"../../ParserInterpreter":238,"../../ParserRuleContext":239,"../../RecognitionException":242,"../../Token":248,"../../misc/MultiMap":337,"../../misc/ParseCancellationException":340,"../RuleNode":345,"../TerminalNode":346,"./ParseTreeMatch":349,"./ParseTreePattern":350,"./RuleTagToken":352,"./TagChunk":353,"./TextChunk":354,"./TokenTagToken":355}],352:[function(require,module,exports){
+},{"../../BailErrorStrategy":220,"../../CharStreams":223,"../../CommonTokenStream":228,"../../Decorators":230,"../../ListTokenSource":241,"../../ParserInterpreter":245,"../../ParserRuleContext":246,"../../RecognitionException":249,"../../Token":255,"../../misc/MultiMap":344,"../../misc/ParseCancellationException":347,"../RuleNode":352,"../TerminalNode":353,"./ParseTreeMatch":356,"./ParseTreePattern":357,"./RuleTagToken":359,"./TagChunk":360,"./TextChunk":361,"./TokenTagToken":362}],359:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59095,7 +60719,7 @@ RuleTagToken = __decorate([
 ], RuleTagToken);
 exports.RuleTagToken = RuleTagToken;
 
-},{"../../Decorators":223,"../../Token":248}],353:[function(require,module,exports){
+},{"../../Decorators":230,"../../Token":255}],360:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59182,7 +60806,7 @@ __decorate([
 ], TagChunk.prototype, "toString", null);
 exports.TagChunk = TagChunk;
 
-},{"../../Decorators":223,"./Chunk":348}],354:[function(require,module,exports){
+},{"../../Decorators":230,"./Chunk":355}],361:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59252,7 +60876,7 @@ TextChunk = __decorate([
 ], TextChunk);
 exports.TextChunk = TextChunk;
 
-},{"../../Decorators":223,"./Chunk":348}],355:[function(require,module,exports){
+},{"../../Decorators":230,"./Chunk":355}],362:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59347,7 +60971,7 @@ TokenTagToken = __decorate([
 ], TokenTagToken);
 exports.TokenTagToken = TokenTagToken;
 
-},{"../../CommonToken":219,"../../Decorators":223}],356:[function(require,module,exports){
+},{"../../CommonToken":226,"../../Decorators":230}],363:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59544,7 +61168,7 @@ exports.XPath = XPath;
 XPath.WILDCARD = "*"; // word not operator/separator
 XPath.NOT = "!"; // word for invert operator
 
-},{"../../CharStreams":216,"../../CommonTokenStream":221,"../../LexerNoViableAltException":233,"../../ParserRuleContext":239,"../../Token":248,"./XPathLexer":358,"./XPathLexerErrorListener":359,"./XPathRuleAnywhereElement":360,"./XPathRuleElement":361,"./XPathTokenAnywhereElement":362,"./XPathTokenElement":363,"./XPathWildcardAnywhereElement":364,"./XPathWildcardElement":365}],357:[function(require,module,exports){
+},{"../../CharStreams":223,"../../CommonTokenStream":228,"../../LexerNoViableAltException":240,"../../ParserRuleContext":246,"../../Token":255,"./XPathLexer":365,"./XPathLexerErrorListener":366,"./XPathRuleAnywhereElement":367,"./XPathRuleElement":368,"./XPathTokenAnywhereElement":369,"./XPathTokenElement":370,"./XPathWildcardAnywhereElement":371,"./XPathWildcardElement":372}],364:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59579,7 +61203,7 @@ __decorate([
 ], XPathElement.prototype, "toString", null);
 exports.XPathElement = XPathElement;
 
-},{"../../Decorators":223}],358:[function(require,module,exports){
+},{"../../Decorators":230}],365:[function(require,module,exports){
 "use strict";
 // Generated from XPathLexer.g4 by ANTLR 4.9.0-SNAPSHOT
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -60054,7 +61678,7 @@ XPathLexer._serializedATN = Utils.join([
     XPathLexer._serializedATNSegment1,
 ], "");
 
-},{"../../Lexer":231,"../../VocabularyImpl":254,"../../atn/ATNDeserializer":260,"../../atn/LexerATNSimulator":281,"../../misc/Utils":342}],359:[function(require,module,exports){
+},{"../../Lexer":238,"../../VocabularyImpl":261,"../../atn/ATNDeserializer":267,"../../atn/LexerATNSimulator":288,"../../misc/Utils":349}],366:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60079,7 +61703,7 @@ __decorate([
 ], XPathLexerErrorListener.prototype, "syntaxError", null);
 exports.XPathLexerErrorListener = XPathLexerErrorListener;
 
-},{"../../Decorators":223}],360:[function(require,module,exports){
+},{"../../Decorators":230}],367:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60113,7 +61737,7 @@ __decorate([
 ], XPathRuleAnywhereElement.prototype, "evaluate", null);
 exports.XPathRuleAnywhereElement = XPathRuleAnywhereElement;
 
-},{"../../Decorators":223,"../Trees":347,"./XPathElement":357}],361:[function(require,module,exports){
+},{"../../Decorators":230,"../Trees":354,"./XPathElement":364}],368:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60156,7 +61780,7 @@ __decorate([
 ], XPathRuleElement.prototype, "evaluate", null);
 exports.XPathRuleElement = XPathRuleElement;
 
-},{"../../Decorators":223,"../../ParserRuleContext":239,"../Trees":347,"./XPathElement":357}],362:[function(require,module,exports){
+},{"../../Decorators":230,"../../ParserRuleContext":246,"../Trees":354,"./XPathElement":364}],369:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60188,7 +61812,7 @@ __decorate([
 ], XPathTokenAnywhereElement.prototype, "evaluate", null);
 exports.XPathTokenAnywhereElement = XPathTokenAnywhereElement;
 
-},{"../../Decorators":223,"../Trees":347,"./XPathElement":357}],363:[function(require,module,exports){
+},{"../../Decorators":230,"../Trees":354,"./XPathElement":364}],370:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60231,7 +61855,7 @@ __decorate([
 ], XPathTokenElement.prototype, "evaluate", null);
 exports.XPathTokenElement = XPathTokenElement;
 
-},{"../../Decorators":223,"../TerminalNode":346,"../Trees":347,"./XPathElement":357}],364:[function(require,module,exports){
+},{"../../Decorators":230,"../TerminalNode":353,"../Trees":354,"./XPathElement":364}],371:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60267,7 +61891,7 @@ __decorate([
 ], XPathWildcardAnywhereElement.prototype, "evaluate", null);
 exports.XPathWildcardAnywhereElement = XPathWildcardAnywhereElement;
 
-},{"../../Decorators":223,"../Trees":347,"./XPath":356,"./XPathElement":357}],365:[function(require,module,exports){
+},{"../../Decorators":230,"../Trees":354,"./XPath":363,"./XPathElement":364}],372:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60307,7 +61931,7 @@ __decorate([
 ], XPathWildcardElement.prototype, "evaluate", null);
 exports.XPathWildcardElement = XPathWildcardElement;
 
-},{"../../Decorators":223,"../Trees":347,"./XPath":356,"./XPathElement":357}],366:[function(require,module,exports){
+},{"../../Decorators":230,"../Trees":354,"./XPath":363,"./XPathElement":364}],373:[function(require,module,exports){
 (function (global){(function (){
 'use strict';
 
@@ -60817,7 +62441,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":423,"util/":369}],367:[function(require,module,exports){
+},{"object.assign/polyfill":430,"util/":376}],374:[function(require,module,exports){
 if (typeof Object.create === 'function') {
   // implementation from standard node.js 'util' module
   module.exports = function inherits(ctor, superCtor) {
@@ -60842,14 +62466,14 @@ if (typeof Object.create === 'function') {
   }
 }
 
-},{}],368:[function(require,module,exports){
+},{}],375:[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';
 }
-},{}],369:[function(require,module,exports){
+},{}],376:[function(require,module,exports){
 (function (process,global){(function (){
 // Copyright Joyent, Inc. and other Node contributors.
 //
@@ -61439,7 +63063,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":368,"_process":425,"inherits":367}],370:[function(require,module,exports){
+},{"./support/isBuffer":375,"_process":432,"inherits":374}],377:[function(require,module,exports){
 (function (global){(function (){
 'use strict';
 
@@ -61460,7 +63084,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":424}],371:[function(require,module,exports){
+},{"possible-typed-array-names":431}],378:[function(require,module,exports){
 (function (process,global){(function (){
 module.exports = process.hrtime || hrtime
 
@@ -61491,7 +63115,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":425}],372:[function(require,module,exports){
+},{"_process":432}],379:[function(require,module,exports){
 'use strict';
 
 var bind = require('function-bind');
@@ -61503,7 +63127,7 @@ var $reflectApply = require('./reflectApply');
 /** @type {import('./actualApply')} */
 module.exports = $reflectApply || bind.call($call, $apply);
 
-},{"./functionApply":374,"./functionCall":375,"./reflectApply":377,"function-bind":393}],373:[function(require,module,exports){
+},{"./functionApply":381,"./functionCall":382,"./reflectApply":384,"function-bind":400}],380:[function(require,module,exports){
 'use strict';
 
 var bind = require('function-bind');
@@ -61515,19 +63139,19 @@ module.exports = function applyBind() {
 	return actualApply(bind, $apply, arguments);
 };
 
-},{"./actualApply":372,"./functionApply":374,"function-bind":393}],374:[function(require,module,exports){
+},{"./actualApply":379,"./functionApply":381,"function-bind":400}],381:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./functionApply')} */
 module.exports = Function.prototype.apply;
 
-},{}],375:[function(require,module,exports){
+},{}],382:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./functionCall')} */
 module.exports = Function.prototype.call;
 
-},{}],376:[function(require,module,exports){
+},{}],383:[function(require,module,exports){
 'use strict';
 
 var bind = require('function-bind');
@@ -61544,13 +63168,13 @@ module.exports = function callBindBasic(args) {
 	return $actualApply(bind, $call, args);
 };
 
-},{"./actualApply":372,"./functionCall":375,"es-errors/type":388,"function-bind":393}],377:[function(require,module,exports){
+},{"./actualApply":379,"./functionCall":382,"es-errors/type":395,"function-bind":400}],384:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./reflectApply')} */
 module.exports = typeof Reflect !== 'undefined' && Reflect && Reflect.apply;
 
-},{}],378:[function(require,module,exports){
+},{}],385:[function(require,module,exports){
 'use strict';
 
 var setFunctionLength = require('set-function-length');
@@ -61576,7 +63200,7 @@ if ($defineProperty) {
 	module.exports.apply = applyBind;
 }
 
-},{"call-bind-apply-helpers":376,"call-bind-apply-helpers/applyBind":373,"es-define-property":382,"set-function-length":427}],379:[function(require,module,exports){
+},{"call-bind-apply-helpers":383,"call-bind-apply-helpers/applyBind":380,"es-define-property":389,"set-function-length":434}],386:[function(require,module,exports){
 'use strict';
 
 var GetIntrinsic = require('get-intrinsic');
@@ -61597,7 +63221,7 @@ module.exports = function callBoundIntrinsic(name, allowMissing) {
 	return intrinsic;
 };
 
-},{"call-bind-apply-helpers":376,"get-intrinsic":394}],380:[function(require,module,exports){
+},{"call-bind-apply-helpers":383,"get-intrinsic":401}],387:[function(require,module,exports){
 'use strict';
 
 var $defineProperty = require('es-define-property');
@@ -61655,7 +63279,7 @@ module.exports = function defineDataProperty(
 	}
 };
 
-},{"es-define-property":382,"es-errors/syntax":387,"es-errors/type":388,"gopd":399}],381:[function(require,module,exports){
+},{"es-define-property":389,"es-errors/syntax":394,"es-errors/type":395,"gopd":406}],388:[function(require,module,exports){
 'use strict';
 
 var callBind = require('call-bind-apply-helpers');
@@ -61687,7 +63311,7 @@ module.exports = desc && typeof desc.get === 'function'
 		}
 		: false;
 
-},{"call-bind-apply-helpers":376,"gopd":399}],382:[function(require,module,exports){
+},{"call-bind-apply-helpers":383,"gopd":406}],389:[function(require,module,exports){
 'use strict';
 
 /** @type {import('.')} */
@@ -61703,55 +63327,55 @@ if ($defineProperty) {
 
 module.exports = $defineProperty;
 
-},{}],383:[function(require,module,exports){
+},{}],390:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./eval')} */
 module.exports = EvalError;
 
-},{}],384:[function(require,module,exports){
+},{}],391:[function(require,module,exports){
 'use strict';
 
 /** @type {import('.')} */
 module.exports = Error;
 
-},{}],385:[function(require,module,exports){
+},{}],392:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./range')} */
 module.exports = RangeError;
 
-},{}],386:[function(require,module,exports){
+},{}],393:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./ref')} */
 module.exports = ReferenceError;
 
-},{}],387:[function(require,module,exports){
+},{}],394:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./syntax')} */
 module.exports = SyntaxError;
 
-},{}],388:[function(require,module,exports){
+},{}],395:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./type')} */
 module.exports = TypeError;
 
-},{}],389:[function(require,module,exports){
+},{}],396:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./uri')} */
 module.exports = URIError;
 
-},{}],390:[function(require,module,exports){
+},{}],397:[function(require,module,exports){
 'use strict';
 
 /** @type {import('.')} */
 module.exports = Object;
 
-},{}],391:[function(require,module,exports){
+},{}],398:[function(require,module,exports){
 'use strict';
 
 var isCallable = require('is-callable');
@@ -61822,7 +63446,7 @@ module.exports = function forEach(list, iterator, thisArg) {
     }
 };
 
-},{"is-callable":407}],392:[function(require,module,exports){
+},{"is-callable":414}],399:[function(require,module,exports){
 'use strict';
 
 /* eslint no-invalid-this: 1 */
@@ -61908,14 +63532,14 @@ module.exports = function bind(that) {
     return bound;
 };
 
-},{}],393:[function(require,module,exports){
+},{}],400:[function(require,module,exports){
 'use strict';
 
 var implementation = require('./implementation');
 
 module.exports = Function.prototype.bind || implementation;
 
-},{"./implementation":392}],394:[function(require,module,exports){
+},{"./implementation":399}],401:[function(require,module,exports){
 'use strict';
 
 var undefined;
@@ -62295,7 +63919,7 @@ module.exports = function GetIntrinsic(name, allowMissing) {
 	return value;
 };
 
-},{"call-bind-apply-helpers/functionApply":374,"call-bind-apply-helpers/functionCall":375,"es-define-property":382,"es-errors":384,"es-errors/eval":383,"es-errors/range":385,"es-errors/ref":386,"es-errors/syntax":387,"es-errors/type":388,"es-errors/uri":389,"es-object-atoms":390,"function-bind":393,"get-proto":397,"get-proto/Object.getPrototypeOf":395,"get-proto/Reflect.getPrototypeOf":396,"gopd":399,"has-symbols":401,"hasown":404,"math-intrinsics/abs":411,"math-intrinsics/floor":412,"math-intrinsics/max":414,"math-intrinsics/min":415,"math-intrinsics/pow":416,"math-intrinsics/round":417,"math-intrinsics/sign":418}],395:[function(require,module,exports){
+},{"call-bind-apply-helpers/functionApply":381,"call-bind-apply-helpers/functionCall":382,"es-define-property":389,"es-errors":391,"es-errors/eval":390,"es-errors/range":392,"es-errors/ref":393,"es-errors/syntax":394,"es-errors/type":395,"es-errors/uri":396,"es-object-atoms":397,"function-bind":400,"get-proto":404,"get-proto/Object.getPrototypeOf":402,"get-proto/Reflect.getPrototypeOf":403,"gopd":406,"has-symbols":408,"hasown":411,"math-intrinsics/abs":418,"math-intrinsics/floor":419,"math-intrinsics/max":421,"math-intrinsics/min":422,"math-intrinsics/pow":423,"math-intrinsics/round":424,"math-intrinsics/sign":425}],402:[function(require,module,exports){
 'use strict';
 
 var $Object = require('es-object-atoms');
@@ -62303,13 +63927,13 @@ var $Object = require('es-object-atoms');
 /** @type {import('./Object.getPrototypeOf')} */
 module.exports = $Object.getPrototypeOf || null;
 
-},{"es-object-atoms":390}],396:[function(require,module,exports){
+},{"es-object-atoms":397}],403:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./Reflect.getPrototypeOf')} */
 module.exports = (typeof Reflect !== 'undefined' && Reflect.getPrototypeOf) || null;
 
-},{}],397:[function(require,module,exports){
+},{}],404:[function(require,module,exports){
 'use strict';
 
 var reflectGetProto = require('./Reflect.getPrototypeOf');
@@ -62338,13 +63962,13 @@ module.exports = reflectGetProto
 			}
 			: null;
 
-},{"./Object.getPrototypeOf":395,"./Reflect.getPrototypeOf":396,"dunder-proto/get":381}],398:[function(require,module,exports){
+},{"./Object.getPrototypeOf":402,"./Reflect.getPrototypeOf":403,"dunder-proto/get":388}],405:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./gOPD')} */
 module.exports = Object.getOwnPropertyDescriptor;
 
-},{}],399:[function(require,module,exports){
+},{}],406:[function(require,module,exports){
 'use strict';
 
 /** @type {import('.')} */
@@ -62361,7 +63985,7 @@ if ($gOPD) {
 
 module.exports = $gOPD;
 
-},{"./gOPD":398}],400:[function(require,module,exports){
+},{"./gOPD":405}],407:[function(require,module,exports){
 'use strict';
 
 var $defineProperty = require('es-define-property');
@@ -62385,7 +64009,7 @@ hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBu
 
 module.exports = hasPropertyDescriptors;
 
-},{"es-define-property":382}],401:[function(require,module,exports){
+},{"es-define-property":389}],408:[function(require,module,exports){
 'use strict';
 
 var origSymbol = typeof Symbol !== 'undefined' && Symbol;
@@ -62401,7 +64025,7 @@ module.exports = function hasNativeSymbols() {
 	return hasSymbolSham();
 };
 
-},{"./shams":402}],402:[function(require,module,exports){
+},{"./shams":409}],409:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./shams')} */
@@ -62448,7 +64072,7 @@ module.exports = function hasSymbols() {
 	return true;
 };
 
-},{}],403:[function(require,module,exports){
+},{}],410:[function(require,module,exports){
 'use strict';
 
 var hasSymbols = require('has-symbols/shams');
@@ -62458,7 +64082,7 @@ module.exports = function hasToStringTagShams() {
 	return hasSymbols() && !!Symbol.toStringTag;
 };
 
-},{"has-symbols/shams":402}],404:[function(require,module,exports){
+},{"has-symbols/shams":409}],411:[function(require,module,exports){
 'use strict';
 
 var call = Function.prototype.call;
@@ -62468,7 +64092,7 @@ var bind = require('function-bind');
 /** @type {import('.')} */
 module.exports = bind.call(call, $hasOwn);
 
-},{"function-bind":393}],405:[function(require,module,exports){
+},{"function-bind":400}],412:[function(require,module,exports){
 if (typeof Object.create === 'function') {
   // implementation from standard node.js 'util' module
   module.exports = function inherits(ctor, superCtor) {
@@ -62497,7 +64121,7 @@ if (typeof Object.create === 'function') {
   }
 }
 
-},{}],406:[function(require,module,exports){
+},{}],413:[function(require,module,exports){
 'use strict';
 
 var hasToStringTag = require('has-tostringtag/shams')();
@@ -62543,7 +64167,7 @@ isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests
 /** @type {import('.')} */
 module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
 
-},{"call-bound":379,"has-tostringtag/shams":403}],407:[function(require,module,exports){
+},{"call-bound":386,"has-tostringtag/shams":410}],414:[function(require,module,exports){
 'use strict';
 
 var fnToStr = Function.prototype.toString;
@@ -62646,7 +64270,7 @@ module.exports = reflectApply
 		return tryFunctionObject(value);
 	};
 
-},{}],408:[function(require,module,exports){
+},{}],415:[function(require,module,exports){
 'use strict';
 
 var callBound = require('call-bound');
@@ -62695,7 +64319,7 @@ module.exports = function isGeneratorFunction(fn) {
 	return getProto(fn) === GeneratorFunction;
 };
 
-},{"call-bound":379,"get-proto":397,"has-tostringtag/shams":403,"safe-regex-test":426}],409:[function(require,module,exports){
+},{"call-bound":386,"get-proto":404,"has-tostringtag/shams":410,"safe-regex-test":433}],416:[function(require,module,exports){
 'use strict';
 
 var callBound = require('call-bound');
@@ -62766,7 +64390,7 @@ if (hasToStringTag) {
 
 module.exports = fn;
 
-},{"call-bound":379,"gopd":399,"has-tostringtag/shams":403,"hasown":404}],410:[function(require,module,exports){
+},{"call-bound":386,"gopd":406,"has-tostringtag/shams":410,"hasown":411}],417:[function(require,module,exports){
 'use strict';
 
 var whichTypedArray = require('which-typed-array');
@@ -62776,19 +64400,19 @@ module.exports = function isTypedArray(value) {
 	return !!whichTypedArray(value);
 };
 
-},{"which-typed-array":431}],411:[function(require,module,exports){
+},{"which-typed-array":438}],418:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./abs')} */
 module.exports = Math.abs;
 
-},{}],412:[function(require,module,exports){
+},{}],419:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./floor')} */
 module.exports = Math.floor;
 
-},{}],413:[function(require,module,exports){
+},{}],420:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./isNaN')} */
@@ -62796,31 +64420,31 @@ module.exports = Number.isNaN || function isNaN(a) {
 	return a !== a;
 };
 
-},{}],414:[function(require,module,exports){
+},{}],421:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./max')} */
 module.exports = Math.max;
 
-},{}],415:[function(require,module,exports){
+},{}],422:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./min')} */
 module.exports = Math.min;
 
-},{}],416:[function(require,module,exports){
+},{}],423:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./pow')} */
 module.exports = Math.pow;
 
-},{}],417:[function(require,module,exports){
+},{}],424:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./round')} */
 module.exports = Math.round;
 
-},{}],418:[function(require,module,exports){
+},{}],425:[function(require,module,exports){
 'use strict';
 
 var $isNaN = require('./isNaN');
@@ -62833,7 +64457,7 @@ module.exports = function sign(number) {
 	return number < 0 ? -1 : +1;
 };
 
-},{"./isNaN":413}],419:[function(require,module,exports){
+},{"./isNaN":420}],426:[function(require,module,exports){
 'use strict';
 
 var keysShim;
@@ -62957,7 +64581,7 @@ if (!Object.keys) {
 }
 module.exports = keysShim;
 
-},{"./isArguments":421}],420:[function(require,module,exports){
+},{"./isArguments":428}],427:[function(require,module,exports){
 'use strict';
 
 var slice = Array.prototype.slice;
@@ -62991,7 +64615,7 @@ keysShim.shim = function shimObjectKeys() {
 
 module.exports = keysShim;
 
-},{"./implementation":419,"./isArguments":421}],421:[function(require,module,exports){
+},{"./implementation":426,"./isArguments":428}],428:[function(require,module,exports){
 'use strict';
 
 var toStr = Object.prototype.toString;
@@ -63010,7 +64634,7 @@ module.exports = function isArguments(value) {
 	return isArgs;
 };
 
-},{}],422:[function(require,module,exports){
+},{}],429:[function(require,module,exports){
 'use strict';
 
 // modified from https://github.com/es-shims/es6-shim
@@ -63058,7 +64682,7 @@ module.exports = function assign(target, source1) {
 	return to; // step 4
 };
 
-},{"call-bound":379,"es-object-atoms":390,"has-symbols/shams":402,"object-keys":420}],423:[function(require,module,exports){
+},{"call-bound":386,"es-object-atoms":397,"has-symbols/shams":409,"object-keys":427}],430:[function(require,module,exports){
 'use strict';
 
 var implementation = require('./implementation');
@@ -63115,7 +64739,7 @@ module.exports = function getPolyfill() {
 	return Object.assign;
 };
 
-},{"./implementation":422}],424:[function(require,module,exports){
+},{"./implementation":429}],431:[function(require,module,exports){
 'use strict';
 
 /** @type {import('.')} */
@@ -63134,7 +64758,7 @@ module.exports = [
 	'BigUint64Array'
 ];
 
-},{}],425:[function(require,module,exports){
+},{}],432:[function(require,module,exports){
 // shim for using process in browser
 var process = module.exports = {};
 
@@ -63320,7 +64944,7 @@ process.chdir = function (dir) {
 };
 process.umask = function() { return 0; };
 
-},{}],426:[function(require,module,exports){
+},{}],433:[function(require,module,exports){
 'use strict';
 
 var callBound = require('call-bound');
@@ -63339,7 +64963,7 @@ module.exports = function regexTester(regex) {
 	};
 };
 
-},{"call-bound":379,"es-errors/type":388,"is-regex":409}],427:[function(require,module,exports){
+},{"call-bound":386,"es-errors/type":395,"is-regex":416}],434:[function(require,module,exports){
 'use strict';
 
 var GetIntrinsic = require('get-intrinsic');
@@ -63383,9 +65007,9 @@ module.exports = function setFunctionLength(fn, length) {
 	return fn;
 };
 
-},{"define-data-property":380,"es-errors/type":388,"get-intrinsic":394,"gopd":399,"has-property-descriptors":400}],428:[function(require,module,exports){
-arguments[4][368][0].apply(exports,arguments)
-},{"dup":368}],429:[function(require,module,exports){
+},{"define-data-property":387,"es-errors/type":395,"get-intrinsic":401,"gopd":406,"has-property-descriptors":407}],435:[function(require,module,exports){
+arguments[4][375][0].apply(exports,arguments)
+},{"dup":375}],436:[function(require,module,exports){
 // Currently in sync with Node.js lib/internal/util/types.js
 // https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9
 
@@ -63721,7 +65345,7 @@ exports.isAnyArrayBuffer = isAnyArrayBuffer;
   });
 });
 
-},{"is-arguments":406,"is-generator-function":408,"is-typed-array":410,"which-typed-array":431}],430:[function(require,module,exports){
+},{"is-arguments":413,"is-generator-function":415,"is-typed-array":417,"which-typed-array":438}],437:[function(require,module,exports){
 (function (process){(function (){
 // Copyright Joyent, Inc. and other Node contributors.
 //
@@ -64440,7 +66064,7 @@ function callbackify(original) {
 exports.callbackify = callbackify;
 
 }).call(this)}).call(this,require('_process'))
-},{"./support/isBuffer":428,"./support/types":429,"_process":425,"inherits":405}],431:[function(require,module,exports){
+},{"./support/isBuffer":435,"./support/types":436,"_process":432,"inherits":412}],438:[function(require,module,exports){
 (function (global){(function (){
 'use strict';
 
@@ -64561,5 +66185,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":370,"call-bind":378,"call-bound":379,"for-each":391,"get-proto":397,"gopd":399,"has-tostringtag/shams":403}]},{},[115])(115)
+},{"available-typed-arrays":377,"call-bind":385,"call-bound":386,"for-each":398,"get-proto":404,"gopd":406,"has-tostringtag/shams":410}]},{},[115])(115)
 });