@designliquido/delegua 1.13.1 → 1.14.0

package/umd/delegua.js

@@ -4728,7 +4728,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
 }
 exports.AvaliadorSintatico = AvaliadorSintatico;
 
-},{"../bibliotecas/primitivas-dicionario":29,"../bibliotecas/primitivas-numero":30,"../bibliotecas/primitivas-texto":31,"../bibliotecas/primitivas-vetor":32,"../construtos":62,"../construtos/tuplas":80,"../declaracoes":110,"../inferenciador":137,"../informacao-elemento-sintatico":138,"../tipos-de-dados/delegua":217,"../tipos-de-simbolos/delegua":222,"./avaliador-sintatico-base":9,"./comum":11,"./elemento-montao-tipos":19,"./erro-avaliador-sintatico":20,"./informacao-escopo":22,"./montao-tipos":25,"./pilha-escopos":26,"browser-process-hrtime":413}],11:[function(require,module,exports){
+},{"../bibliotecas/primitivas-dicionario":29,"../bibliotecas/primitivas-numero":30,"../bibliotecas/primitivas-texto":31,"../bibliotecas/primitivas-vetor":32,"../construtos":62,"../construtos/tuplas":80,"../declaracoes":110,"../inferenciador":137,"../informacao-elemento-sintatico":138,"../tipos-de-dados/delegua":217,"../tipos-de-simbolos/delegua":222,"./avaliador-sintatico-base":9,"./comum":11,"./elemento-montao-tipos":19,"./erro-avaliador-sintatico":20,"./informacao-escopo":22,"./montao-tipos":25,"./pilha-escopos":26,"browser-process-hrtime":415}],11:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buscarRetornos = buscarRetornos;
@@ -7201,7 +7201,7 @@ class AvaliadorSintaticoPitugues {
 }
 exports.AvaliadorSintaticoPitugues = AvaliadorSintaticoPitugues;
 
-},{"../../bibliotecas/dialetos/pitugues/primitivas-tupla":28,"../../bibliotecas/primitivas-dicionario":29,"../../bibliotecas/primitivas-numero":30,"../../bibliotecas/primitivas-texto":31,"../../bibliotecas/primitivas-vetor":32,"../../construtos":62,"../../declaracoes":110,"../../inferenciador":137,"../../informacao-elemento-sintatico":138,"../../lexador":207,"../../lexador/micro-lexador-pitugues":212,"../../tipos-de-dados/dialetos/pitugues":218,"../../tipos-de-simbolos/pitugues":226,"../comum":11,"../erro-avaliador-sintatico":20,"../informacao-escopo":22,"../pilha-escopos":26,"./micro-avaliador-sintatico-pitugues":18,"browser-process-hrtime":413}],14:[function(require,module,exports){
+},{"../../bibliotecas/dialetos/pitugues/primitivas-tupla":28,"../../bibliotecas/primitivas-dicionario":29,"../../bibliotecas/primitivas-numero":30,"../../bibliotecas/primitivas-texto":31,"../../bibliotecas/primitivas-vetor":32,"../../construtos":62,"../../declaracoes":110,"../../inferenciador":137,"../../informacao-elemento-sintatico":138,"../../lexador":207,"../../lexador/micro-lexador-pitugues":212,"../../tipos-de-dados/dialetos/pitugues":218,"../../tipos-de-simbolos/pitugues":226,"../comum":11,"../erro-avaliador-sintatico":20,"../informacao-escopo":22,"../pilha-escopos":26,"./micro-avaliador-sintatico-pitugues":18,"browser-process-hrtime":415}],14:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -8124,7 +8124,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
 }
 exports.AvaliadorSintaticoPrisma = AvaliadorSintaticoPrisma;
 
-},{"../../bibliotecas/primitivas-dicionario":29,"../../bibliotecas/primitivas-numero":30,"../../bibliotecas/primitivas-texto":31,"../../bibliotecas/primitivas-vetor":32,"../../construtos":62,"../../declaracoes":110,"../../inferenciador":137,"../../informacao-elemento-sintatico":138,"../../lexador":207,"../../tipos-de-simbolos/prisma":228,"../avaliador-sintatico-base":9,"../comum":11,"../informacao-escopo":22,"../pilha-escopos":26,"browser-process-hrtime":413}],16:[function(require,module,exports){
+},{"../../bibliotecas/primitivas-dicionario":29,"../../bibliotecas/primitivas-numero":30,"../../bibliotecas/primitivas-texto":31,"../../bibliotecas/primitivas-vetor":32,"../../construtos":62,"../../declaracoes":110,"../../inferenciador":137,"../../informacao-elemento-sintatico":138,"../../lexador":207,"../../tipos-de-simbolos/prisma":228,"../avaliador-sintatico-base":9,"../comum":11,"../informacao-escopo":22,"../pilha-escopos":26,"browser-process-hrtime":415}],16:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -9106,7 +9106,7 @@ class AvaliadorSintaticoTenda extends avaliador_sintatico_base_1.AvaliadorSintat
 }
 exports.AvaliadorSintaticoTenda = AvaliadorSintaticoTenda;
 
-},{"../../bibliotecas/primitivas-dicionario":29,"../../bibliotecas/primitivas-numero":30,"../../bibliotecas/primitivas-texto":31,"../../bibliotecas/primitivas-vetor":32,"../../construtos":62,"../../construtos/tuplas":80,"../../declaracoes":110,"../../inferenciador":137,"../../informacao-elemento-sintatico":138,"../../lexador/simbolo":215,"../../tipos-de-dados/delegua":217,"../../tipos-de-simbolos/tenda":229,"../avaliador-sintatico-base":9,"./../erro-avaliador-sintatico":20,"./../informacao-escopo":22,"./../pilha-escopos":26,"browser-process-hrtime":413}],17:[function(require,module,exports){
+},{"../../bibliotecas/primitivas-dicionario":29,"../../bibliotecas/primitivas-numero":30,"../../bibliotecas/primitivas-texto":31,"../../bibliotecas/primitivas-vetor":32,"../../construtos":62,"../../construtos/tuplas":80,"../../declaracoes":110,"../../inferenciador":137,"../../informacao-elemento-sintatico":138,"../../lexador/simbolo":215,"../../tipos-de-dados/delegua":217,"../../tipos-de-simbolos/tenda":229,"../avaliador-sintatico-base":9,"./../erro-avaliador-sintatico":20,"./../informacao-escopo":22,"./../pilha-escopos":26,"browser-process-hrtime":415}],17:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -13795,6 +13795,7 @@ exports.Variavel = Variavel;
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vetor = void 0;
+const comentario_como_construto_1 = require("./comentario-como-construto");
 const separador_1 = require("./separador");
 class Vetor {
     constructor(hashArquivo, linha, valores, tipo) {
@@ -13808,7 +13809,7 @@ class Vetor {
      * (Separador, comentários) que podem aparecer entre os elementos.
      */
     get elementos() {
-        return this.valores.filter((v) => v.constructor !== separador_1.Separador);
+        return this.valores.filter((v) => v.constructor !== separador_1.Separador && v.constructor !== comentario_como_construto_1.ComentarioComoConstruto);
     }
     get tamanho() {
         return this.elementos.length;
@@ -13825,7 +13826,7 @@ class Vetor {
 }
 exports.Vetor = Vetor;
 
-},{"./separador":73}],91:[function(require,module,exports){
+},{"./comentario-como-construto":47,"./separador":73}],91:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ajuda = void 0;
@@ -20660,10 +20661,10 @@ class InterpretadorBase {
     }
     async visitarExpressaoVetor(expressao) {
         const valores = [];
-        for (let i = 0; i < expressao.valores.length; i++) {
-            valores.push(this.resolverValor(await this.avaliar(expressao.valores[i])));
+        for (let i = 0; i < expressao.elementos.length; i++) {
+            valores.push(this.resolverValor(await this.avaliar(expressao.elementos[i])));
         }
-        return valores.filter((v) => v !== null && v !== undefined);
+        return valores;
     }
     visitarExpressaoSuper(expressao) {
         const objeto = this.pilhaEscoposExecucao.obterVariavelPorNome('isto');
@@ -21045,7 +21046,7 @@ class InterpretadorBase {
 exports.InterpretadorBase = InterpretadorBase;
 
 }).call(this)}).call(this,require('_process'),require("timers").setImmediate)
-},{"../avaliador-sintatico":21,"../bibliotecas/primitivas-dicionario":29,"../bibliotecas/primitivas-vetor":32,"../construtos":62,"../excecoes":131,"../inferenciador":137,"../lexador":207,"../quebras":216,"../tipos-de-dados/delegua":217,"../tipos-de-dados/primitivos":219,"../tipos-de-simbolos/delegua":222,"./espaco-memoria":171,"./estruturas":179,"./estruturas/metodo-primitiva":181,"./pilha-escopos-execucao":191,"_process":467,"browser-process-hrtime":413,"timers":470}],189:[function(require,module,exports){
+},{"../avaliador-sintatico":21,"../bibliotecas/primitivas-dicionario":29,"../bibliotecas/primitivas-vetor":32,"../construtos":62,"../excecoes":131,"../inferenciador":137,"../lexador":207,"../quebras":216,"../tipos-de-dados/delegua":217,"../tipos-de-dados/primitivos":219,"../tipos-de-simbolos/delegua":222,"./espaco-memoria":171,"./estruturas":179,"./estruturas/metodo-primitiva":181,"./pilha-escopos-execucao":191,"_process":469,"browser-process-hrtime":415,"timers":472}],189:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -23875,7 +23876,7 @@ class LexadorPitugues {
 }
 exports.LexadorPitugues = LexadorPitugues;
 
-},{"../../tipos-de-simbolos/pitugues":226,"../simbolo":215,"./palavras-reservadas/pitugues":203,"browser-process-hrtime":413}],197:[function(require,module,exports){
+},{"../../tipos-de-simbolos/pitugues":226,"../simbolo":215,"./palavras-reservadas/pitugues":203,"browser-process-hrtime":415}],197:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -24515,7 +24516,7 @@ class LexadorPrisma {
 }
 exports.LexadorPrisma = LexadorPrisma;
 
-},{"../../tipos-de-simbolos/prisma":228,"../simbolo":215,"./palavras-reservadas/prisma":205,"browser-process-hrtime":413}],199:[function(require,module,exports){
+},{"../../tipos-de-simbolos/prisma":228,"../simbolo":215,"./palavras-reservadas/prisma":205,"browser-process-hrtime":415}],199:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -24909,7 +24910,7 @@ class LexadorTenda {
 }
 exports.LexadorTenda = LexadorTenda;
 
-},{"../../tipos-de-simbolos/tenda":229,"../simbolo":215,"./palavras-reservadas/tenda":206,"browser-process-hrtime":413}],200:[function(require,module,exports){
+},{"../../tipos-de-simbolos/tenda":229,"../simbolo":215,"./palavras-reservadas/tenda":206,"browser-process-hrtime":415}],200:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -26026,7 +26027,7 @@ class Lexador {
 }
 exports.Lexador = Lexador;
 
-},{"../tipos-de-simbolos/delegua":222,"./palavras-reservadas":214,"./simbolo":215,"browser-process-hrtime":413}],211:[function(require,module,exports){
+},{"../tipos-de-simbolos/delegua":222,"./palavras-reservadas":214,"./simbolo":215,"browser-process-hrtime":415}],211:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -27550,6 +27551,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./tradutor-assembly-arm"), exports);
+__exportStar(require("./tradutor-assembly-risc-v"), exports);
+__exportStar(require("./tradutor-webassembly"), exports);
 __exportStar(require("./tradutor-assembly-x64"), exports);
 __exportStar(require("./tradutor-assemblyscript"), exports);
 __exportStar(require("./tradutor-calango"), exports);
@@ -27563,7 +27566,7 @@ __exportStar(require("./tradutor-reverso-python"), exports);
 __exportStar(require("./tradutor-reverso-tenda"), exports);
 __exportStar(require("./tradutor-ruby"), exports);
 
-},{"./tradutor-assembly-arm":239,"./tradutor-assembly-x64":240,"./tradutor-assemblyscript":241,"./tradutor-calango":242,"./tradutor-elixir":243,"./tradutor-javascript":244,"./tradutor-mermaidjs":245,"./tradutor-portugol-ipt":246,"./tradutor-python":247,"./tradutor-reverso-javascript":248,"./tradutor-reverso-python":249,"./tradutor-reverso-tenda":250,"./tradutor-ruby":251}],231:[function(require,module,exports){
+},{"./tradutor-assembly-arm":239,"./tradutor-assembly-risc-v":240,"./tradutor-assembly-x64":241,"./tradutor-assemblyscript":242,"./tradutor-calango":243,"./tradutor-elixir":244,"./tradutor-javascript":245,"./tradutor-mermaidjs":246,"./tradutor-portugol-ipt":247,"./tradutor-python":248,"./tradutor-reverso-javascript":249,"./tradutor-reverso-python":250,"./tradutor-reverso-tenda":251,"./tradutor-ruby":252,"./tradutor-webassembly":253}],231:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArestaFluxograma = void 0;
@@ -28933,7 +28936,7 @@ __decorate([
     Decorators_1.Override
 ], Python3Lexer.prototype, "nextToken", null);
 
-},{"./python3-parser":238,"antlr4ts/CommonToken":261,"antlr4ts/Decorators":265,"antlr4ts/Lexer":273,"antlr4ts/Token":290,"antlr4ts/VocabularyImpl":296,"antlr4ts/atn/ATNDeserializer":302,"antlr4ts/atn/LexerATNSimulator":323,"antlr4ts/misc/Utils":384}],238:[function(require,module,exports){
+},{"./python3-parser":238,"antlr4ts/CommonToken":263,"antlr4ts/Decorators":267,"antlr4ts/Lexer":275,"antlr4ts/Token":292,"antlr4ts/VocabularyImpl":298,"antlr4ts/atn/ATNDeserializer":304,"antlr4ts/atn/LexerATNSimulator":325,"antlr4ts/misc/Utils":386}],238:[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) {
@@ -40180,7 +40183,7 @@ class Yield_argContext extends ParserRuleContext_1.ParserRuleContext {
 }
 exports.Yield_argContext = Yield_argContext;
 
-},{"antlr4ts/FailedPredicateException":269,"antlr4ts/NoViableAltException":277,"antlr4ts/Parser":278,"antlr4ts/ParserRuleContext":281,"antlr4ts/RecognitionException":284,"antlr4ts/Token":290,"antlr4ts/VocabularyImpl":296,"antlr4ts/atn/ATN":298,"antlr4ts/atn/ATNDeserializer":302,"antlr4ts/atn/ParserATNSimulator":339,"antlr4ts/misc/Utils":384}],239:[function(require,module,exports){
+},{"antlr4ts/FailedPredicateException":271,"antlr4ts/NoViableAltException":279,"antlr4ts/Parser":280,"antlr4ts/ParserRuleContext":283,"antlr4ts/RecognitionException":286,"antlr4ts/Token":292,"antlr4ts/VocabularyImpl":298,"antlr4ts/atn/ATN":300,"antlr4ts/atn/ATNDeserializer":304,"antlr4ts/atn/ParserATNSimulator":341,"antlr4ts/misc/Utils":386}],239:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorAssemblyARM = void 0;
@@ -40907,6 +40910,692 @@ exports.TradutorAssemblyARM = TradutorAssemblyARM;
 },{"../construtos":62,"../declaracoes":110}],240:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradutorAssemblyRISCV = void 0;
+const construtos_1 = require("../construtos");
+const declaracoes_1 = require("../declaracoes");
+class TradutorAssemblyRISCV {
+    constructor(alvo = 'linux-rv64') {
+        this.alvo = alvo;
+        this.indentacao = 0;
+        this.contadorLabels = 0;
+        this.variaveis = new Map();
+        // s2-s9 são callee-saved — seguros para usar como scratch entre chamadas
+        this.registradoresDisponiveis = ['s2', 's3', 's4', 's5', 's6', 's7', 's8', 's9'];
+        this.pilhaRegistradores = [];
+        this.bss = '.bss\n';
+        this.data = '.data\n';
+        this.dicionarioConstrutos = {
+            AcessoIndiceVariavel: this.traduzirAcessoIndiceVariavel.bind(this),
+            AcessoMetodoOuPropriedade: this.traduzirConstrutoAcessoMetodo.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: () => 'j .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: () => 'j .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;
+        this.text = `
+.text
+.global _start
+
+_start:`;
+    }
+    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 'a0'; // fallback
+    }
+    liberarRegistrador(reg) {
+        const index = this.pilhaRegistradores.indexOf(reg);
+        if (index > -1) {
+            this.pilhaRegistradores.splice(index, 1);
+            this.registradoresDisponiveis.push(reg);
+        }
+    }
+    // Emite a instrução de carga correta para o registrador destino.
+    // RISC-V não tem um `ldr reg, =value` polimórfico como ARM —
+    // usa `li` para inteiros e `la` para endereços de símbolos.
+    emitirCarga(registrador, valor) {
+        if (valor === registrador)
+            return;
+        if (valor === 'null') {
+            this.text += `\n    li ${registrador}, 0`;
+        }
+        else if (/^-?\d+$/.test(valor) || valor === 'true' || valor === 'false') {
+            const numVal = valor === 'true' ? '1' : valor === 'false' ? '0' : valor;
+            this.text += `\n    li ${registrador}, ${numVal}`;
+        }
+        else if (/^-?\d+\.\d+$/.test(valor)) {
+            // Ponto flutuante: armazenar em .data e carregar endereço.
+            // Operações FPU não são suportadas por esta implementação básica.
+            const floatLabel = `float_${this.gerarDigitoAleatorio()}`;
+            this.data += `    ${floatLabel}: .double ${valor}\n`;
+            this.text += `\n    la ${registrador}, ${floatLabel}`;
+        }
+        else {
+            this.text += `\n    la ${registrador}, ${valor}`;
+        }
+    }
+    // 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 += `\n    la ${reg}, ${nomeVar}`;
+        this.emitirCarga('a0', indice);
+        this.text += `
+    slli a0, a0, 3          # multiplicar índice por 8 (palavra de 64 bits)
+    add ${reg}, ${reg}, a0
+    ld a0, 0(${reg})`;
+        this.liberarRegistrador(reg);
+        return 'a0';
+    }
+    traduzirConstrutoAcessoMetodo(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 += `\n    la ${reg}, ${nomeVar}`;
+        this.emitirCarga('a1', indice);
+        this.text += `
+    slli a1, a1, 3          # multiplicar índice por 8
+    add ${reg}, ${reg}, a1`;
+        this.emitirCarga('a1', valor);
+        this.text += `\n    sd a1, 0(${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 8\n`;
+            this.variaveis.set(nomeVar, varLabel);
+        }
+        this.emitirCarga('a0', valor);
+        this.text += `
+    la a1, ${this.variaveis.get(nomeVar)}
+    sd a0, 0(a1)`;
+    }
+    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();
+        // Carregar operando esquerdo em a0
+        if (esquerda !== 'a0') {
+            this.emitirCarga('a0', esquerda);
+        }
+        // Carregar operando direito no registrador scratch
+        this.emitirCarga(reg, direita);
+        switch (operador) {
+            case '+':
+                this.text += `\n    add a0, a0, ${reg}`;
+                break;
+            case '-':
+                this.text += `\n    sub a0, a0, ${reg}`;
+                break;
+            case '*':
+                this.text += `\n    mul a0, a0, ${reg}`;
+                break;
+            case '/':
+                this.text += `\n    div a0, a0, ${reg}`;
+                break;
+            case '%':
+                // `rem` é instrução única na extensão M (universal em rv64 Linux)
+                this.text += `\n    rem a0, a0, ${reg}`;
+                break;
+            case '<':
+                // slt: a0 = 1 se a0 < reg
+                this.text += `\n    slt a0, a0, ${reg}`;
+                break;
+            case '>':
+                // slt com operandos trocados: a0 = 1 se reg < a0, i.e., a0 > reg
+                this.text += `\n    slt a0, ${reg}, a0`;
+                break;
+            case '<=':
+                // NOT(a0 > reg) = NOT(reg < a0)
+                this.text += `\n    slt a0, ${reg}, a0\n    xori a0, a0, 1`;
+                break;
+            case '>=':
+                // NOT(a0 < reg)
+                this.text += `\n    slt a0, a0, ${reg}\n    xori a0, a0, 1`;
+                break;
+            case '==':
+            case '===':
+                // sub + seqz: a0 = 1 se a0 - reg == 0
+                this.text += `\n    sub a0, a0, ${reg}\n    seqz a0, a0`;
+                break;
+            case '!=':
+            case '!==':
+                // sub + snez: a0 = 1 se a0 - reg != 0
+                this.text += `\n    sub a0, a0, ${reg}\n    snez a0, a0`;
+                break;
+            default:
+                this.text += `\n    # Operador ${operador} não implementado`;
+        }
+        this.liberarRegistrador(reg);
+        return 'a0';
+    }
+    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';
+        }
+        // Convenção RISC-V: a0-a7 para até 8 argumentos
+        const registrosArgs = ['a0', 'a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7'];
+        construto.argumentos.forEach((arg, index) => {
+            if (index < registrosArgs.length) {
+                const valorArg = this.dicionarioConstrutos[arg.constructor.name](arg);
+                if (valorArg !== registrosArgs[index]) {
+                    this.emitirCarga(registrosArgs[index], valorArg);
+                }
+            }
+        });
+        this.text += `\n    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.emitirCarga('a0', valor);
+        this.text += `
+    la a1, ${objeto}
+    sd a0, 0(a1)`;
+    }
+    traduzirFuncaoConstruto(construto) {
+        const labelFuncao = `func_${this.gerarDigitoAleatorio()}`;
+        this.text += `
+
+${labelFuncao}:
+    addi sp, sp, -16
+    sd   ra, 8(sp)
+    sd   s0, 0(sp)
+    addi s0, sp, 16`;
+        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 += `
+    ld   ra, 8(sp)
+    ld   s0, 0(sp)
+    addi sp, sp, 16
+    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.emitirCarga('a0', esquerda);
+        if (operador === 'e' || operador === '&&') {
+            this.text += `\n    beqz a0, ${labelFim}`;
+            this.emitirCarga('a0', direita);
+            this.text += `
+    beqz a0, ${labelFim}
+${labelVerdadeiro}:
+    li a0, 1
+${labelFim}:`;
+        }
+        else if (operador === 'ou' || operador === '||') {
+            this.text += `\n    bnez a0, ${labelVerdadeiro}`;
+            this.emitirCarga('a0', direita);
+            this.text += `
+    bnez a0, ${labelVerdadeiro}
+    li a0, 0
+    j ${labelFim}
+${labelVerdadeiro}:
+    li a0, 1
+${labelFim}:`;
+        }
+        return 'a0';
+    }
+    traduzirConstrutoTipoDe(construto) {
+        return this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
+    }
+    traduzirConstrutoUnario(construto) {
+        const operando = this.dicionarioConstrutos[construto.operando.constructor.name](construto.operando);
+        const operador = construto.operador.lexema;
+        this.emitirCarga('a0', operando);
+        if (operador === '-') {
+            this.text += `\n    neg a0, a0`;
+        }
+        else if (operador === '!' || operador === 'nao') {
+            // seqz: a0 = 1 se a0 == 0, else 0
+            this.text += `\n    seqz a0, a0`;
+        }
+        return 'a0';
+    }
+    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 += `
+    la a0, ${varLabel}
+    ld a0, 0(a0)`;
+            return 'a0';
+        }
+        return nomeVar || 'unknown';
+    }
+    traduzirConstrutoVetor(construto) {
+        const labelVetor = `vetor_${this.gerarDigitoAleatorio()}`;
+        // `elementos` filtra nós sintáticos (Separador, ComentarioComoConstruto)
+        const elementos = construto.elementos;
+        // Cada elemento ocupa 8 bytes em rv64
+        this.bss += `    ${labelVetor}: .space ${elementos.length * 8}\n`;
+        elementos.forEach((valor, index) => {
+            if (this.dicionarioConstrutos[valor.constructor.name]) {
+                const valorTraduzido = this.dicionarioConstrutos[valor.constructor.name](valor);
+                this.emitirCarga('a0', valorTraduzido);
+                this.text += `
+    la a1, ${labelVetor}
+    sd a0, ${index * 8}(a1)`;
+            }
+        });
+        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 += `\n${labelInicio}:`;
+        const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
+        if (condicao !== 'a0') {
+            this.emitirCarga('a0', condicao);
+        }
+        this.text += `\n    beqz a0, ${labelFim}`;
+        if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
+        }
+        this.text += `
+    j ${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.emitirCarga('a0', valorEscolha);
+                    this.emitirCarga('a1', valorCaso);
+                    this.text += `\n    bne a0, a1, ${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 += `
+    j ${labelFim}
+${labelProximo}:`;
+                }
+            });
+        }
+        this.text += `\n${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 += `\n${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);
+            if (condicao !== 'a0') {
+                this.emitirCarga('a0', condicao);
+            }
+            this.text += `\n    bnez a0, ${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}
+    li a0, 1
+    li a7, 93               # sys_exit
+    ecall`;
+    }
+    traduzirDeclaracaoFuncao(declaracao) {
+        var _a;
+        const nomeFuncao = ((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'funcao';
+        this.text += `
+
+${nomeFuncao}:
+    addi sp, sp, -16
+    sd   ra, 8(sp)
+    sd   s0, 0(sp)
+    addi s0, sp, 16`;
+        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 += `
+    ld   ra, 8(sp)
+    ld   s0, 0(sp)
+    addi sp, sp, 16
+    ret`;
+    }
+    traduzirDeclaracaoImportar(declaracao) {
+        this.text += `\n    # 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 += `
+    li a0, 0                # fd stdin
+    la a1, ${this.variaveis.get(nomeVar)}
+    li a2, 256
+    li a7, 63               # sys_read
+    ecall`;
+    }
+    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 += `\n${labelInicio}:`;
+        if (declaracao.condicao) {
+            const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
+            if (condicao !== 'a0') {
+                this.emitirCarga('a0', condicao);
+            }
+            this.text += `\n    beqz a0, ${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 += `
+    j ${labelInicio}
+${labelFim}:`;
+    }
+    traduzirDeclaracaoParaCada(declaracao) {
+        const labelInicio = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        const vetor = declaracao.vetorOuDicionario;
+        let tamanhoVetor = 0;
+        if (vetor instanceof construtos_1.Vetor) {
+            tamanhoVetor = vetor.tamanho || 0;
+        }
+        // t0: contador; t1: limite (caller-saved, seguros aqui)
+        this.text += `
+    li t0, 0                # contador
+    li t1, ${tamanhoVetor}
+${labelInicio}:
+    bge t0, t1, ${labelFim}`;
+        if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
+        }
+        this.text += `
+    addi t0, t0, 1
+    j ${labelInicio}
+${labelFim}:`;
+    }
+    traduzirDeclaracaoRetorna(declaracao) {
+        if (declaracao.valor) {
+            const valor = this.dicionarioConstrutos[declaracao.valor.constructor.name](declaracao.valor);
+            this.emitirCarga('a0', valor);
+        }
+        this.text += `
+    ld   ra, 8(sp)
+    ld   s0, 0(sp)
+    addi sp, sp, 16
+    ret`;
+    }
+    traduzirDeclaracaoSe(declaracao) {
+        const labelSenao = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
+        if (condicao !== 'a0') {
+            this.emitirCarga('a0', condicao);
+        }
+        this.text += `\n    beqz a0, ${labelSenao}`;
+        if (this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name](declaracao.caminhoEntao);
+        }
+        this.text += `
+    j ${labelFim}
+${labelSenao}:`;
+        if (declaracao.caminhoSenao &&
+            this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name](declaracao.caminhoSenao);
+        }
+        this.text += `\n${labelFim}:`;
+    }
+    traduzirDeclaracaoClasse(declaracao) {
+        var _a;
+        this.text += `\n    # Classe: ${((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'unknown'}`;
+    }
+    traduzirDeclaracaoTente(declaracao) {
+        this.text += `\n    # 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}: .dword ${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 8\n`;
+        this.variaveis.set(nomeVar, varLabel);
+        if (declaracao.inicializador && declaracao.inicializador.valor !== null) {
+            const tipoInicializador = declaracao.inicializador.constructor.name;
+            if (declaracao.inicializador instanceof construtos_1.Vetor) {
+                const labelVetor = this.traduzirConstrutoVetor(declaracao.inicializador);
+                this.variaveis.set(nomeVar, labelVetor);
+            }
+            else if (this.dicionarioConstrutos[tipoInicializador]) {
+                const valor = this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
+                this.emitirCarga('a0', valor);
+                this.text += `
+    la a1, ${varLabel}
+    sd a0, 0(a1)`;
+            }
+        }
+    }
+    criaStringLiteral(literal) {
+        const varLiteral = `Delegua_${this.gerarDigitoAleatorio()}`;
+        this.data += `    ${varLiteral}: .asciz "${literal.valor}"\n`;
+        return varLiteral;
+    }
+    criaTamanhoNaMemoriaReferenteAVar(nomeStringLiteral) {
+        return `tam_${nomeStringLiteral}`;
+    }
+    traduzirDeclaracaoEscreva(declaracaoEscreva) {
+        let nomeStringLiteral = '';
+        let tamanhoString = '';
+        if (declaracaoEscreva.argumentos[0] instanceof construtos_1.Literal) {
+            nomeStringLiteral = this.criaStringLiteral(declaracaoEscreva.argumentos[0]);
+            const stringValue = declaracaoEscreva.argumentos[0].valor;
+            tamanhoString = String(stringValue.length);
+        }
+        // sys_write(fd=1, buf, count): a7=64, a0=fd, a1=buf, a2=count
+        this.text += `
+    la a1, ${nomeStringLiteral}
+    li a2, ${tamanhoString}
+    li a0, 1                # fd stdout
+    li a7, 64               # sys_write
+    ecall`;
+    }
+    saidaSistema() {
+        this.text += `
+    li a0, 0                # código de saída
+    li a7, 93               # sys_exit
+    ecall`;
+    }
+    traduzir(declaracoes) {
+        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();
+        return this.bss + '\n' + this.data + '\n' + this.text;
+    }
+}
+exports.TradutorAssemblyRISCV = TradutorAssemblyRISCV;
+
+},{"../construtos":62,"../declaracoes":110}],241:[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");
@@ -40918,6 +41607,9 @@ class TradutorAssemblyX64 {
         this.variaveis = new Map();
         this.registradoresDisponiveis = ['rbx', 'r12', 'r13', 'r14', 'r15'];
         this.pilhaRegistradores = [];
+        this.helperPrintIntEmitido = false;
+        this.fmtIntWindowsEmitido = false;
+        this.helpers = '';
         this.bss = 'section .bss\n';
         this.data = 'section .data\n';
         this.dicionarioConstrutos = {
@@ -40961,15 +41653,15 @@ class TradutorAssemblyX64 {
             Escreva: this.traduzirDeclaracaoEscreva.bind(this),
         };
         this.indentacao = 0;
-        this.text = `
+        this.textoSaida = `
 section .text
     ${this.alvo === 'linux' ? 'global _start' : 'global main'}
 ${this.alvo === 'linux' ? '_start:' : 'main:'}`;
         if (this.alvo === 'windows') {
-            this.text =
+            this.textoSaida =
                 `
 extern printf
-` + this.text;
+` + this.textoSaida;
         }
     }
     gerarDigitoAleatorio() {
@@ -41030,7 +41722,7 @@ extern printf
         }
         const indice = this.dicionarioConstrutos[construto.indice.constructor.name](construto.indice);
         const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
-        this.text += `
+        this.textoSaida += `
     mov rax, ${valor}
     mov [${nomeVar} + ${indice} * 8], rax`;
     }
@@ -41050,7 +41742,7 @@ extern printf
             this.bss += `    ${varLabel} resq 1\n`;
             this.variaveis.set(nomeVar, varLabel);
         }
-        this.text += `
+        this.textoSaida += `
     mov rax, ${valor}
     mov [${this.variaveis.get(nomeVar)}], rax`;
     }
@@ -41058,39 +41750,75 @@ extern printf
         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 += `
+        const registrador = this.obterRegistrador();
+        this.textoSaida += `
     mov rax, ${esquerda}
-    mov ${reg}, ${direita}`;
+    mov ${registrador}, ${direita}`;
         switch (operador) {
             case '+':
-                this.text += `
-    add rax, ${reg}`;
+                this.textoSaida += `
+    add rax, ${registrador}`;
                 break;
             case '-':
-                this.text += `
-    sub rax, ${reg}`;
+                this.textoSaida += `
+    sub rax, ${registrador}`;
                 break;
             case '*':
-                this.text += `
-    imul rax, ${reg}`;
+                this.textoSaida += `
+    imul rax, ${registrador}`;
                 break;
             case '/':
-                this.text += `
+                this.textoSaida += `
     xor rdx, rdx
-    idiv ${reg}`;
+    idiv ${registrador}`;
                 break;
             case '%':
-                this.text += `
+                this.textoSaida += `
     xor rdx, rdx
-    idiv ${reg}
+    idiv ${registrador}
     mov rax, rdx`;
                 break;
+            case '<':
+                this.textoSaida += `
+    cmp rax, ${registrador}
+    setl al
+    movzx rax, al`;
+                break;
+            case '>':
+                this.textoSaida += `
+    cmp rax, ${registrador}
+    setg al
+    movzx rax, al`;
+                break;
+            case '<=':
+                this.textoSaida += `
+    cmp rax, ${registrador}
+    setle al
+    movzx rax, al`;
+                break;
+            case '>=':
+                this.textoSaida += `
+    cmp rax, ${registrador}
+    setge al
+    movzx rax, al`;
+                break;
+            case '==':
+                this.textoSaida += `
+    cmp rax, ${registrador}
+    sete al
+    movzx rax, al`;
+                break;
+            case '!=':
+                this.textoSaida += `
+    cmp rax, ${registrador}
+    setne al
+    movzx rax, al`;
+                break;
             default:
-                this.text += `
+                this.textoSaida += `
     ; Operador ${operador} não implementado`;
         }
-        this.liberarRegistrador(reg);
+        this.liberarRegistrador(registrador);
         return 'rax';
     }
     traduzirConstrutoChamada(construto) {
@@ -41106,26 +41834,26 @@ extern printf
         construto.argumentos.forEach((arg, index) => {
             if (index < registrosArgs.length) {
                 const valorArg = this.dicionarioConstrutos[arg.constructor.name](arg);
-                this.text += `
+                this.textoSaida += `
     mov ${registrosArgs[index]}, ${valorArg}`;
             }
             else {
                 // TODO: push extra args on stack according to target ABI
             }
         });
-        this.text += `
+        this.textoSaida += `
     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 += `
+        this.textoSaida += `
     mov rax, ${valor}
     mov [${objeto}], rax`;
     }
     traduzirFuncaoConstruto(construto) {
         const labelFuncao = `func_${this.gerarDigitoAleatorio()}`;
-        this.text += `
+        this.textoSaida += `
 ${labelFuncao}:
     push rbp
     mov rbp, rsp`;
@@ -41137,7 +41865,7 @@ ${labelFuncao}:
                 }
             });
         }
-        this.text += `
+        this.textoSaida += `
     pop rbp
     ret`;
     }
@@ -41153,11 +41881,11 @@ ${labelFuncao}:
         const operador = construto.operador.lexema;
         const labelVerdadeiro = this.gerarLabel();
         const labelFim = this.gerarLabel();
-        this.text += `
+        this.textoSaida += `
     mov rax, ${esquerda}
     cmp rax, 0`;
         if (operador === 'e' || operador === '&&') {
-            this.text += `
+            this.textoSaida += `
     je ${labelFim}
     mov rax, ${direita}
     cmp rax, 0
@@ -41167,7 +41895,7 @@ ${labelVerdadeiro}:
 ${labelFim}:`;
         }
         else if (operador === 'ou' || operador === '||') {
-            this.text += `
+            this.textoSaida += `
     jne ${labelVerdadeiro}
     mov rax, ${direita}
     cmp rax, 0
@@ -41188,17 +41916,27 @@ ${labelFim}:`;
     traduzirConstrutoUnario(construto) {
         const operando = this.dicionarioConstrutos[construto.operando.constructor.name](construto.operando);
         const operador = construto.operador.lexema;
-        this.text += `
+        this.textoSaida += `
     mov rax, ${operando}`;
         if (operador === '-') {
-            this.text += `
+            this.textoSaida += `
     neg rax`;
         }
         else if (operador === '!' || operador === 'nao') {
-            this.text += `
+            this.textoSaida += `
     cmp rax, 0
     sete al
     movzx rax, al`;
+        }
+        else if (operador === '++') {
+            this.textoSaida += `
+    inc rax
+    mov ${operando}, rax`;
+        }
+        else if (operador === '--') {
+            this.textoSaida += `
+    dec rax
+    mov ${operando}, rax`;
         }
         return 'rax';
     }
@@ -41212,27 +41950,27 @@ ${labelFim}:`;
     }
     traduzirConstrutoVetor(construto) {
         var _a;
-        const labelVetor = `vetor_${this.gerarDigitoAleatorio()}`;
+        const rotuloVetor = `vetor_${this.gerarDigitoAleatorio()}`;
         const tamanho = ((_a = construto.valores) === null || _a === void 0 ? void 0 : _a.length) || 0;
-        this.bss += `    ${labelVetor} resq ${tamanho}\n`;
+        this.bss += `    ${rotuloVetor} 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 += `
+                    this.textoSaida += `
     mov rax, ${valorTraduzido}
-    mov [${labelVetor} + ${index * 8}], rax`;
+    mov [${rotuloVetor} + ${index * 8}], rax`;
                 }
             });
         }
-        return labelVetor;
+        return rotuloVetor;
     }
     // 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);
+            declaracao.declaracoes.forEach((declaracao) => {
+                if (this.dicionarioDeclaracoes[declaracao.constructor.name]) {
+                    this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao);
                 }
             });
         }
@@ -41240,16 +41978,16 @@ ${labelFim}:`;
     traduzirDeclaracaoEnquanto(declaracao) {
         const labelInicio = this.gerarLabel();
         const labelFim = this.gerarLabel();
-        this.text += `
+        this.textoSaida += `
 ${labelInicio}:`;
         const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
-        this.text += `
+        this.textoSaida += `
     cmp ${condicao}, 0
     je ${labelFim}`;
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
         }
-        this.text += `
+        this.textoSaida += `
     jmp ${labelInicio}
 ${labelFim}:`;
     }
@@ -41261,24 +41999,24 @@ ${labelFim}:`;
                 const labelProximo = this.gerarLabel();
                 if (caminho.condicoes && caminho.condicoes[0]) {
                     const valorCaso = this.dicionarioConstrutos[caminho.condicoes[0].constructor.name](caminho.condicoes[0]);
-                    this.text += `
+                    this.textoSaida += `
     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);
+                        caminho.declaracoes.forEach((declaracao) => {
+                            if (this.dicionarioDeclaracoes[declaracao.constructor.name]) {
+                                this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao);
                             }
                         });
                     }
-                    this.text += `
+                    this.textoSaida += `
     jmp ${labelFim}
 ${labelProximo}:`;
                 }
             });
         }
-        this.text += `
+        this.textoSaida += `
 ${labelFim}:`;
     }
     traduzirDeclaracaoExpressao(declaracao) {
@@ -41289,19 +42027,19 @@ ${labelFim}:`;
     }
     traduzirDeclaracaoFazer(declaracao) {
         const labelInicio = this.gerarLabel();
-        this.text += `
+        this.textoSaida += `
 ${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);
+            declaracao.caminhoFazer.declaracoes.forEach((declaracao) => {
+                if (this.dicionarioDeclaracoes[declaracao.constructor.name]) {
+                    this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao);
                 }
             });
         }
         if (declaracao.condicaoEnquanto) {
             const condicao = this.dicionarioConstrutos[declaracao.condicaoEnquanto.constructor.name](declaracao.condicaoEnquanto);
-            this.text += `
+            this.textoSaida += `
     cmp ${condicao}, 0
     jne ${labelInicio}`;
         }
@@ -41317,14 +42055,14 @@ ${labelInicio}:`;
             }
         }
         if (this.alvo === 'linux') {
-            this.text += `
+            this.textoSaida += `
         ; Falhar com mensagem: ${mensagem}
         mov eax, 1
         mov ebx, 1
         int 0x80`;
         }
         else {
-            this.text += `
+            this.textoSaida += `
         ; Falhar com mensagem: ${mensagem}
         mov eax, 1
         ret`;
@@ -41333,7 +42071,7 @@ ${labelInicio}:`;
     traduzirDeclaracaoFuncao(declaracao) {
         var _a;
         const nomeFuncao = ((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'funcao';
-        this.text += `
+        this.textoSaida += `
 ${nomeFuncao}:
     push rbp
     mov rbp, rsp`;
@@ -41346,13 +42084,13 @@ ${nomeFuncao}:
                 }
             });
         }
-        this.text += `
+        this.textoSaida += `
     pop rbp
     ret`;
     }
     traduzirDeclaracaoImportar(declaracao) {
         // Importação é tratada em tempo de linkagem
-        this.text += `
+        this.textoSaida += `
     ; Importar: ${declaracao.caminho || 'unknown'}`;
     }
     traduzirDeclaracaoLeia(declaracao) {
@@ -41370,7 +42108,7 @@ ${nomeFuncao}:
             this.bss += `    ${varLabel} resb 256\n`;
             this.variaveis.set(nomeVar, varLabel);
         }
-        this.text += `
+        this.textoSaida += `
     mov eax, 3
     mov ebx, 0
     mov ecx, ${this.variaveis.get(nomeVar)}
@@ -41380,21 +42118,31 @@ ${nomeFuncao}:
     traduzirDeclaracaoPara(declaracao) {
         const labelInicio = this.gerarLabel();
         const labelFim = this.gerarLabel();
-        // Inicializador pode ser uma declaração ou construto
+        // Inicializador pode ser um array de declarações, uma declaração ou um construto
         if (declaracao.inicializador) {
-            const tipoInicializador = declaracao.inicializador.constructor.name;
-            if (this.dicionarioDeclaracoes[tipoInicializador]) {
-                this.dicionarioDeclaracoes[tipoInicializador](declaracao.inicializador);
+            if (Array.isArray(declaracao.inicializador)) {
+                for (const decl of declaracao.inicializador) {
+                    const tipo = decl.constructor.name;
+                    if (this.dicionarioDeclaracoes[tipo]) {
+                        this.dicionarioDeclaracoes[tipo](decl);
+                    }
+                }
             }
-            else if (this.dicionarioConstrutos[tipoInicializador]) {
-                this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
+            else {
+                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 += `
+        this.textoSaida += `
 ${labelInicio}:`;
         if (declaracao.condicao) {
             const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
-            this.text += `
+            this.textoSaida += `
     cmp ${condicao}, 0
     je ${labelFim}`;
         }
@@ -41406,14 +42154,14 @@ ${labelInicio}:`;
                 this.dicionarioConstrutos[declaracao.incrementar.constructor.name](declaracao.incrementar);
             }
         }
-        this.text += `
+        this.textoSaida += `
     jmp ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoParaCada(declaracao) {
         var _a;
-        const labelInicio = this.gerarLabel();
-        const labelFim = this.gerarLabel();
+        const rotuloInicio = this.gerarLabel();
+        const rotuloFim = this.gerarLabel();
         let nomeVar;
         if (declaracao.variavelIteracao instanceof construtos_1.Variavel) {
             nomeVar = (_a = declaracao.variavelIteracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
@@ -41423,63 +42171,63 @@ ${labelFim}:`;
         if (vetor instanceof construtos_1.Vetor) {
             tamanhoVetor = vetor.tamanho || 0;
         }
-        this.text += `
+        this.textoSaida += `
     xor rcx, rcx
-${labelInicio}:
+${rotuloInicio}:
     cmp rcx, ${tamanhoVetor}
-    jge ${labelFim}`;
+    jge ${rotuloFim}`;
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
         }
-        this.text += `
+        this.textoSaida += `
     inc rcx
-    jmp ${labelInicio}
-${labelFim}:`;
+    jmp ${rotuloInicio}
+${rotuloFim}:`;
     }
     traduzirDeclaracaoRetorna(declaracao) {
         if (declaracao.valor) {
             const valor = this.dicionarioConstrutos[declaracao.valor.constructor.name](declaracao.valor);
-            this.text += `
+            this.textoSaida += `
     mov rax, ${valor}`;
         }
-        this.text += `
+        this.textoSaida += `
     pop rbp
     ret`;
     }
     traduzirDeclaracaoSe(declaracao) {
-        const labelSenao = this.gerarLabel();
-        const labelFim = this.gerarLabel();
+        const rotuloSenao = this.gerarLabel();
+        const rotuloFim = this.gerarLabel();
         const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
-        this.text += `
+        this.textoSaida += `
     cmp ${condicao}, 0
-    je ${labelSenao}`;
+    je ${rotuloSenao}`;
         if (this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name](declaracao.caminhoEntao);
         }
-        this.text += `
-    jmp ${labelFim}
-${labelSenao}:`;
+        this.textoSaida += `
+    jmp ${rotuloFim}
+${rotuloSenao}:`;
         if (declaracao.caminhoSenao &&
             this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name](declaracao.caminhoSenao);
         }
-        this.text += `
-${labelFim}:`;
+        this.textoSaida += `
+${rotuloFim}:`;
     }
     traduzirDeclaracaoClasse(declaracao) {
         var _a;
         // Classes em assembly são complexas - implementação básica
-        this.text += `
+        this.textoSaida += `
     ; Classe: ${((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'unknown'}`;
     }
     traduzirDeclaracaoTente(declaracao) {
         // Try-catch em assembly requer handler complexo
-        this.text += `
+        this.textoSaida += `
     ; 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);
+            declaracao.caminhoTente.forEach((declaracao) => {
+                if (this.dicionarioDeclaracoes[declaracao.constructor.name]) {
+                    this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao);
                 }
             });
         }
@@ -41513,7 +42261,7 @@ ${labelFim}:`;
             }
             else if (this.dicionarioConstrutos[tipoInicializador]) {
                 const valor = this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
-                this.text += `
+                this.textoSaida += `
     mov rax, ${valor}
     mov [${varLabel}], rax`;
             }
@@ -41529,39 +42277,89 @@ ${labelFim}:`;
         this.data += `    ${varTamanho} equ $ - ${nomeStringLiteral}\n`;
         return varTamanho;
     }
+    emitirHelperPrintInt() {
+        if (this.helperPrintIntEmitido)
+            return;
+        this.helperPrintIntEmitido = true;
+        this.bss += `    __print_buf resb 24\n`;
+        this.helpers += `
+__delegua_print_int:
+    push rbx
+    push rcx
+    push rdx
+    push rsi
+    mov rcx, 10
+    lea rsi, [__print_buf + 22]
+    mov byte [rsi], 10
+.print_digitloop:
+    xor rdx, rdx
+    div rcx
+    add dl, '0'
+    dec rsi
+    mov [rsi], dl
+    test rax, rax
+    jnz .print_digitloop
+    lea rdx, [__print_buf + 23]
+    sub rdx, rsi
+    mov ecx, esi
+    mov ebx, 1
+    mov eax, 4
+    int 0x80
+    pop rsi
+    pop rdx
+    pop rcx
+    pop rbx
+    ret`;
+    }
     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 += `
+        const arg = declaracaoEscreva.argumentos[0];
+        if (arg instanceof construtos_1.Literal) {
+            const nome_string_literal = this.criaStringLiteral(arg);
+            const tam_string_literal = this.criaTamanhoNaMemoriaReferenteAVar(nome_string_literal);
+            if (this.alvo === 'linux') {
+                this.textoSaida += `
     mov edx, ${tam_string_literal}
     mov ecx, ${nome_string_literal}
     mov ebx, 1        ; fd stdout
     mov eax, 4        ; sys_write
     int 0x80`;
+            }
+            else {
+                this.textoSaida += `
+    lea rcx, [rel ${nome_string_literal}]
+    call printf`;
+            }
         }
         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}]
+            const valor = this.dicionarioConstrutos[arg.constructor.name](arg);
+            if (this.alvo === 'linux') {
+                this.emitirHelperPrintInt();
+                this.textoSaida += `
+    mov rax, ${valor}
+    call __delegua_print_int`;
+            }
+            else {
+                if (!this.fmtIntWindowsEmitido) {
+                    this.data += `    __fmt_int db '%d', 10, 0\n`;
+                    this.fmtIntWindowsEmitido = true;
+                }
+                this.textoSaida += `
+    mov rdx, ${valor}
+    lea rcx, [rel __fmt_int]
     call printf`;
+            }
         }
     }
     saidaSistema() {
         if (this.alvo === 'linux') {
-            this.text += `
+            this.textoSaida += `
         mov eax, 1        ; sys_exit
         xor ebx, ebx      ; status 0
         int 0x80`;
         }
         else {
             // Windows: return from main with 0 in EAX
-            this.text += `
+            this.textoSaida += `
         xor eax, eax
         ret`;
         }
@@ -41575,13 +42373,14 @@ ${labelFim}:`;
             }
         }
         this.saidaSistema();
-        resultado += this.bss + '\n' + this.data + '\n' + this.text;
+        this.textoSaida += this.helpers;
+        resultado += this.bss + '\n' + this.data + '\n' + this.textoSaida;
         return resultado;
     }
 }
 exports.TradutorAssemblyX64 = TradutorAssemblyX64;
 
-},{"../construtos":62,"../declaracoes":110}],241:[function(require,module,exports){
+},{"../construtos":62,"../declaracoes":110}],242:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -42349,7 +43148,7 @@ class TradutorAssemblyScript {
         let resultado = '';
         this.indentacao += 4;
         resultado += ' '.repeat(this.indentacao);
-        for (let condicao of caminho.condicoes) {
+        for (let condicao of (caminho.condicoes || [])) {
             resultado +=
                 'case ' + this.dicionarioConstrutos[condicao.constructor.name](condicao) + ':\n';
             resultado += ' '.repeat(this.indentacao);
@@ -42725,7 +43524,7 @@ class TradutorAssemblyScript {
 }
 exports.TradutorAssemblyScript = TradutorAssemblyScript;
 
-},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":222}],242:[function(require,module,exports){
+},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":222}],243:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorCalango = void 0;
@@ -42780,7 +43579,7 @@ class TradutorCalango {
 }
 exports.TradutorCalango = TradutorCalango;
 
-},{}],243:[function(require,module,exports){
+},{}],244:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -43709,7 +44508,7 @@ class TradutorElixir {
 }
 exports.TradutorElixir = TradutorElixir;
 
-},{"../tipos-de-simbolos/delegua":222}],244:[function(require,module,exports){
+},{"../tipos-de-simbolos/delegua":222}],245:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -44504,7 +45303,7 @@ class TradutorJavaScript {
 }
 exports.TradutorJavaScript = TradutorJavaScript;
 
-},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":222}],245:[function(require,module,exports){
+},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":222}],246:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -45328,7 +46127,7 @@ class TradutorMermaidJs {
 }
 exports.TradutorMermaidJs = TradutorMermaidJs;
 
-},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":222,"./mermaid":232}],246:[function(require,module,exports){
+},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":222,"./mermaid":232}],247:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorPortugolIpt = void 0;
@@ -45390,7 +46189,7 @@ class TradutorPortugolIpt {
 }
 exports.TradutorPortugolIpt = TradutorPortugolIpt;
 
-},{"../avaliador-sintatico/dialetos":17,"../lexador/dialetos":192}],247:[function(require,module,exports){
+},{"../avaliador-sintatico/dialetos":17,"../lexador/dialetos":192}],248:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -46076,7 +46875,7 @@ class TradutorPython {
 }
 exports.TradutorPython = TradutorPython;
 
-},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":222}],248:[function(require,module,exports){
+},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":222}],249:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorReversoJavaScript = void 0;
@@ -46471,7 +47270,7 @@ class TradutorReversoJavaScript {
 }
 exports.TradutorReversoJavaScript = TradutorReversoJavaScript;
 
-},{}],249:[function(require,module,exports){
+},{}],250:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorReversoPython = void 0;
@@ -46544,7 +47343,7 @@ class TradutorReversoPython {
 }
 exports.TradutorReversoPython = TradutorReversoPython;
 
-},{"./python/python3-lexer":237,"./python/python3-parser":238,"antlr4ts":367,"antlr4ts/tree/ParseTreeWalker":386}],250:[function(require,module,exports){
+},{"./python/python3-lexer":237,"./python/python3-parser":238,"antlr4ts":369,"antlr4ts/tree/ParseTreeWalker":388}],251:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -47138,7 +47937,7 @@ class TradutorReversoTenda {
 }
 exports.TradutorReversoTenda = TradutorReversoTenda;
 
-},{"../construtos":62,"../tipos-de-simbolos/tenda":229}],251:[function(require,module,exports){
+},{"../construtos":62,"../tipos-de-simbolos/tenda":229}],252:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -47826,7 +48625,903 @@ class TradutorRuby {
 }
 exports.TradutorRuby = TradutorRuby;
 
-},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":222}],252:[function(require,module,exports){
+},{"../construtos":62,"../declaracoes":110,"../tipos-de-simbolos/delegua":222}],253:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradutorWebAssembly = void 0;
+const construtos_1 = require("../construtos");
+const declaracoes_1 = require("../declaracoes");
+class TradutorWebAssembly {
+    constructor() {
+        // ── Seções do módulo WAT ───────────────────────────────────────────────
+        /** Segmentos de dados estáticos para strings literais */
+        this.segmentosTexto = [];
+        /** Próximo byte livre na memória linear para strings */
+        this.deslocamentoTexto = 0;
+        /** Texto WAT completo de cada função declarada pelo usuário */
+        this.funcoesCompletas = [];
+        /** Declarações WAT de variáveis globais `(global ...)` */
+        this.declaracoesGlobais = [];
+        // ── Contexto da função sendo traduzida no momento ──────────────────────
+        /** Instruções WAT emitidas no corpo da função corrente */
+        this.corpoDaFuncaoAtual = '';
+        /** Declarações `(param ...)` e `(local ...)` da função corrente */
+        this.declaracoesLocaisAtual = '';
+        /** Nomes de locais/params já declarados (evita duplicatas) */
+        this.locaisDeclaradosAtual = new Set();
+        /** Estamos dentro do corpo de uma função nomeada? */
+        this.dentroFuncao = false;
+        /** A função corrente possui ao menos um `retorna` com valor? */
+        this.funcaoTemRetorno = false;
+        // ── Mapa de variáveis ─────────────────────────────────────────────────
+        /** Nome Delégua → metadados WAT */
+        this.variaveis = new Map();
+        // ── Controle de fluxo (break/continue) ───────────────────────────────
+        /** Pilha de rótulos de laço para `sustar`/`continua` */
+        this.pilhaDeControle = [];
+        // ── Geração de rótulos ────────────────────────────────────────────────
+        this.contadorRotulos = 0;
+        // =========================================================================
+        // Dicionário de construtos (expressões)
+        // =========================================================================
+        this.dicionarioConstrutos = {
+            AcessoIndiceVariavel: this.traduzirAcessoIndiceVariavel.bind(this),
+            AcessoMetodoOuPropriedade: this.traduzirAcessoMetodo.bind(this),
+            Agrupamento: this.traduzirAgrupamento.bind(this),
+            AtribuicaoPorIndice: this.traduzirAtribuicaoPorIndice.bind(this),
+            Atribuir: this.traduzirAtribuir.bind(this),
+            Binario: this.traduzirBinario.bind(this),
+            Chamada: this.traduzirChamada.bind(this),
+            DefinirValor: this.traduzirDefinirValor.bind(this),
+            FuncaoConstruto: this.traduzirFuncaoConstruto.bind(this),
+            Literal: this.traduzirLiteral.bind(this),
+            Logico: this.traduzirLogico.bind(this),
+            TipoDe: this.traduzirTipoDe.bind(this),
+            Unario: this.traduzirUnario.bind(this),
+            Variavel: this.traduzirVariavel.bind(this),
+            Vetor: this.traduzirVetor.bind(this),
+        };
+        // =========================================================================
+        // Dicionário de declarações (instruções)
+        // =========================================================================
+        this.dicionarioDeclaracoes = {
+            Bloco: this.traduzirBloco.bind(this),
+            Classe: this.traduzirClasse.bind(this),
+            Const: this.traduzirConst.bind(this),
+            Continua: this.traduzirContinua.bind(this),
+            Enquanto: this.traduzirEnquanto.bind(this),
+            Escolha: this.traduzirEscolha.bind(this),
+            Escreva: this.traduzirEscreva.bind(this),
+            EscrevaMesmaLinha: this.traduzirEscreva.bind(this),
+            Expressao: this.traduzirExpressao.bind(this),
+            Falhar: this.traduzirFalhar.bind(this),
+            Fazer: this.traduzirFazer.bind(this),
+            FuncaoDeclaracao: this.traduzirFuncaoDeclaracao.bind(this),
+            Importar: this.traduzirImportar.bind(this),
+            Para: this.traduzirPara.bind(this),
+            ParaCada: this.traduzirParaCada.bind(this),
+            Retorna: this.traduzirRetorna.bind(this),
+            Se: this.traduzirSe.bind(this),
+            Sustar: this.traduzirSustar.bind(this),
+            Tente: this.traduzirTente.bind(this),
+            Var: this.traduzirVar.bind(this),
+        };
+    }
+    // =========================================================================
+    // Helpers internos
+    // =========================================================================
+    gerarRotulo() {
+        return `$L${this.contadorRotulos++}`;
+    }
+    /** Emite uma instrução indentada no corpo da função corrente. */
+    emitir(instrucao) {
+        this.corpoDaFuncaoAtual += `    ${instrucao}\n`;
+    }
+    /**
+     * Converte uma string JavaScript para bytes UTF-8.
+     * Usa `encodeURIComponent` para extrair os bytes — funciona em qualquer ambiente JS
+     * sem depender de APIs específicas de Node.js (Buffer) ou browser (TextEncoder).
+     */
+    stringParaBytesUtf8(valor) {
+        const encoded = encodeURIComponent(valor);
+        const bytes = [];
+        for (let i = 0; i < encoded.length;) {
+            if (encoded[i] === '%') {
+                bytes.push(parseInt(encoded.slice(i + 1, i + 3), 16));
+                i += 3;
+            }
+            else {
+                bytes.push(encoded.charCodeAt(i));
+                i++;
+            }
+        }
+        return bytes;
+    }
+    /**
+     * Converte uma string JavaScript para o formato de literal de string WAT.
+     * Bytes não-ASCII e caracteres especiais são hex-escapados como `\xx`.
+     * Retorna o literal pronto para uso em `(data ...)` e o comprimento em bytes UTF-8.
+     */
+    escaparStringWat(valor) {
+        const bytes = this.stringParaBytesUtf8(valor);
+        let watLiteral = '';
+        for (const byte of bytes) {
+            if (byte === 0x22) {
+                watLiteral += '\\"'; // aspas duplas
+            }
+            else if (byte === 0x5c) {
+                watLiteral += '\\\\'; // contrabarra
+            }
+            else if (byte >= 0x20 && byte <= 0x7e) {
+                watLiteral += String.fromCharCode(byte); // ASCII imprimível
+            }
+            else {
+                watLiteral += `\\${byte.toString(16).padStart(2, '0')}`; // \xx
+            }
+        }
+        return { watLiteral, byteLen: bytes.length };
+    }
+    /**
+     * Internaliza uma string literal na memória linear estática.
+     * Strings idênticas são deduplicadas.
+     * O comprimento armazenado é o comprimento em bytes UTF-8, não em caracteres.
+     */
+    internalizarTexto(valor) {
+        const existente = this.segmentosTexto.find((s) => s.conteudo === valor);
+        if (existente) {
+            return { offset: existente.deslocamento, len: existente.tamanho };
+        }
+        const { byteLen } = this.escaparStringWat(valor);
+        const offset = this.deslocamentoTexto;
+        this.segmentosTexto.push({ deslocamento: offset, conteudo: valor, tamanho: byteLen });
+        this.deslocamentoTexto += byteLen;
+        return { offset, len: byteLen };
+    }
+    /**
+     * Infere o tipo WAT de um construto.
+     * Strings → i32 (ponteiro). Tudo mais → i64 (padrão, inclusive booleanos).
+     */
+    inferirTipo(construto) {
+        if (construto instanceof construtos_1.Literal && typeof construto.valor === 'string')
+            return 'i32';
+        return 'i64';
+    }
+    /**
+     * Declara um parâmetro ou variável local para a função corrente.
+     * `ehParam = true` emite `(param ...)`, senão `(local ...)`.
+     */
+    declararParamLocal(nome, tipo, ehParam) {
+        if (this.locaisDeclaradosAtual.has(nome))
+            return;
+        this.locaisDeclaradosAtual.add(nome);
+        const watNome = `$${nome}`;
+        const diretiva = ehParam ? 'param' : 'local';
+        this.declaracoesLocaisAtual += ` (${diretiva} ${watNome} ${tipo})`;
+        this.variaveis.set(nome, { watNome, tipo, escopo: 'local' });
+    }
+    /** Salva o contexto da função corrente e inicializa um novo. */
+    salvarEIniciarContextoFuncao() {
+        const snapshot = {
+            corpoDaFuncaoAtual: this.corpoDaFuncaoAtual,
+            declaracoesLocaisAtual: this.declaracoesLocaisAtual,
+            locaisDeclaradosAtual: this.locaisDeclaradosAtual,
+            dentroFuncao: this.dentroFuncao,
+            funcaoTemRetorno: this.funcaoTemRetorno,
+            variaveis: new Map(this.variaveis),
+        };
+        this.corpoDaFuncaoAtual = '';
+        this.declaracoesLocaisAtual = '';
+        this.locaisDeclaradosAtual = new Set();
+        this.dentroFuncao = true;
+        this.funcaoTemRetorno = false;
+        // Remove locais do mapa — globais permanecem
+        for (const [nome, meta] of this.variaveis) {
+            if (meta.escopo === 'local')
+                this.variaveis.delete(nome);
+        }
+        return snapshot;
+    }
+    /** Restaura o contexto de função a partir de um snapshot. */
+    restaurarContextoFuncao(snapshot) {
+        this.corpoDaFuncaoAtual = snapshot.corpoDaFuncaoAtual;
+        this.declaracoesLocaisAtual = snapshot.declaracoesLocaisAtual;
+        this.locaisDeclaradosAtual = snapshot.locaisDeclaradosAtual;
+        this.dentroFuncao = snapshot.dentroFuncao;
+        this.funcaoTemRetorno = snapshot.funcaoTemRetorno;
+        this.variaveis = snapshot.variaveis;
+    }
+    /**
+     * Garante que uma variável existe no escopo correto.
+     * Retorna o nome WAT da variável (e.g. `$x`).
+     */
+    garantirVariavel(nome, tipo = 'i64') {
+        if (this.variaveis.has(nome)) {
+            return this.variaveis.get(nome).watNome;
+        }
+        if (this.dentroFuncao) {
+            this.declararParamLocal(nome, tipo, false);
+            return `$${nome}`;
+        }
+        // Global
+        const watNome = `$${nome}`;
+        this.declaracoesGlobais.push(`  (global ${watNome} (mut ${tipo}) (${tipo}.const 0))`);
+        this.variaveis.set(nome, { watNome, tipo, escopo: 'global' });
+        return watNome;
+    }
+    // =========================================================================
+    // Dispatch helpers
+    // =========================================================================
+    traduzirConstruto(construto) {
+        const handler = this.dicionarioConstrutos[construto.constructor.name];
+        if (handler)
+            return handler(construto);
+        return `(i64.const 0) ;; construto não suportado: ${construto.constructor.name}`;
+    }
+    traduzirDeclaracaoInterna(declaracao) {
+        const handler = this.dicionarioDeclaracoes[declaracao.constructor.name];
+        if (handler)
+            handler(declaracao);
+        else
+            this.emitir(`;; declaração não suportada: ${declaracao.constructor.name}`);
+    }
+    // =========================================================================
+    // Construtos
+    // =========================================================================
+    traduzirLiteral(construto) {
+        if (typeof construto.valor === 'boolean') {
+            return `(i64.const ${construto.valor ? 1 : 0})`;
+        }
+        if (typeof construto.valor === 'string') {
+            // Retorna apenas o ponteiro; `escreva` usa internalizarTexto diretamente
+            // para obter o comprimento também.
+            const { offset } = this.internalizarTexto(construto.valor);
+            return `(i32.const ${offset})`;
+        }
+        if (typeof construto.valor === 'bigint') {
+            return `(i64.const ${construto.valor})`;
+        }
+        // Número: trunca para i64
+        return `(i64.const ${Math.trunc(Number(construto.valor))})`;
+    }
+    traduzirVariavel(construto) {
+        var _a;
+        const nome = (_a = construto.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        if (!nome)
+            return '(i64.const 0)';
+        const meta = this.variaveis.get(nome);
+        if (!meta)
+            return `(i64.const 0) ;; variável desconhecida: ${nome}`;
+        const instrucao = meta.escopo === 'local' ? 'local.get' : 'global.get';
+        return `(${instrucao} ${meta.watNome})`;
+    }
+    traduzirAtribuir(construto) {
+        var _a;
+        let nome;
+        if (construto.alvo instanceof construtos_1.Variavel) {
+            nome = (_a = construto.alvo.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        }
+        if (!nome)
+            return '(i64.const 0)';
+        const tipoInferido = this.inferirTipo(construto.valor);
+        const watNome = this.garantirVariavel(nome, tipoInferido);
+        const valor = this.traduzirConstruto(construto.valor);
+        const meta = this.variaveis.get(nome);
+        const instrucao = meta.escopo === 'local' ? 'local.set' : 'global.set';
+        return `(${instrucao} ${watNome} ${valor})`;
+    }
+    traduzirBinario(construto) {
+        const esq = this.traduzirConstruto(construto.esquerda);
+        const dir = this.traduzirConstruto(construto.direita);
+        const op = construto.operador.lexema;
+        switch (op) {
+            case '+': return `(i64.add ${esq} ${dir})`;
+            case '-': return `(i64.sub ${esq} ${dir})`;
+            case '*': return `(i64.mul ${esq} ${dir})`;
+            case '/': return `(i64.div_s ${esq} ${dir})`;
+            case '%': return `(i64.rem_s ${esq} ${dir})`;
+            case '<': return `(i64.extend_i32_s (i64.lt_s ${esq} ${dir}))`;
+            case '>': return `(i64.extend_i32_s (i64.gt_s ${esq} ${dir}))`;
+            case '<=': return `(i64.extend_i32_s (i64.le_s ${esq} ${dir}))`;
+            case '>=': return `(i64.extend_i32_s (i64.ge_s ${esq} ${dir}))`;
+            case '==':
+            case '===': return `(i64.extend_i32_s (i64.eq ${esq} ${dir}))`;
+            case '!=':
+            case '!==': return `(i64.extend_i32_s (i64.ne ${esq} ${dir}))`;
+            default:
+                return `(i64.const 0) ;; operador não suportado: ${op}`;
+        }
+    }
+    traduzirLogico(construto) {
+        const esq = this.traduzirConstruto(construto.esquerda);
+        const dir = this.traduzirConstruto(construto.direita);
+        const op = construto.operador.lexema;
+        // Ambos os lados avaliados (sem curto-circuito na v1).
+        // Converte i64 → i32 (ne 0), aplica i32.and / i32.or, estende de volta.
+        const esqBool = `(i32.ne (i32.const 0) (i32.wrap_i64 ${esq}))`;
+        const dirBool = `(i32.ne (i32.const 0) (i32.wrap_i64 ${dir}))`;
+        if (op === 'e' || op === '&&') {
+            return `(i64.extend_i32_s (i32.and ${esqBool} ${dirBool}))`;
+        }
+        if (op === 'ou' || op === '||') {
+            return `(i64.extend_i32_s (i32.or ${esqBool} ${dirBool}))`;
+        }
+        return `(i64.const 0) ;; operador lógico não suportado: ${op}`;
+    }
+    traduzirUnario(construto) {
+        var _a;
+        const op = construto.operador.lexema;
+        const operando = this.traduzirConstruto(construto.operando);
+        if (op === '-') {
+            return `(i64.sub (i64.const 0) ${operando})`;
+        }
+        if (op === '!' || op === 'nao') {
+            return `(i64.extend_i32_s (i64.eqz ${operando}))`;
+        }
+        if (op === '++' || op === '--') {
+            // Apenas pré-incremento/decremento de variável simples na v1
+            let nome;
+            if (construto.operando instanceof construtos_1.Variavel) {
+                nome = (_a = construto.operando.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+            }
+            if (!nome)
+                return operando;
+            const meta = this.variaveis.get(nome);
+            if (!meta)
+                return operando;
+            const instrSet = meta.escopo === 'local' ? 'local.set' : 'global.set';
+            const instrGet = meta.escopo === 'local' ? 'local.get' : 'global.get';
+            const delta = op === '++' ? 1 : -1;
+            const novoValor = `(i64.add ${operando} (i64.const ${delta}))`;
+            // Retorna uma sequência: set + get (usando local.tee para locais, ou set;get para globais)
+            if (meta.escopo === 'local') {
+                return `(local.tee ${meta.watNome} ${novoValor})`;
+            }
+            // Para globais não existe tee; emitimos o set e retornamos o get
+            this.emitir(`(${instrSet} ${meta.watNome} ${novoValor})`);
+            return `(${instrGet} ${meta.watNome})`;
+        }
+        return operando;
+    }
+    traduzirAgrupamento(construto) {
+        return this.traduzirConstruto(construto.expressao);
+    }
+    traduzirChamada(construto) {
+        var _a;
+        let nomeFuncao = 'desconhecida';
+        if (construto.entidadeChamada instanceof construtos_1.Variavel) {
+            nomeFuncao = ((_a = construto.entidadeChamada.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'desconhecida';
+        }
+        const args = construto.argumentos
+            .map((arg) => this.traduzirConstruto(arg))
+            .join(' ');
+        return `(call $${nomeFuncao}${args ? ' ' + args : ''})`;
+    }
+    traduzirAcessoIndiceVariavel(construto) {
+        var _a;
+        let baseExpr = '(i32.const 0)';
+        if (construto.entidadeChamada instanceof construtos_1.Variavel) {
+            const nome = (_a = construto.entidadeChamada.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+            const meta = nome ? this.variaveis.get(nome) : undefined;
+            if (meta) {
+                const instrGet = meta.escopo === 'local' ? 'local.get' : 'global.get';
+                baseExpr = `(${instrGet} ${meta.watNome})`;
+            }
+        }
+        const indice = this.traduzirConstruto(construto.indice);
+        // base + indice * 8  (cada elemento i64 ocupa 8 bytes)
+        const offset = `(i32.add ${baseExpr} (i32.wrap_i64 (i64.mul ${indice} (i64.const 8))))`;
+        return `(i64.load ${offset})`;
+    }
+    traduzirAtribuicaoPorIndice(construto) {
+        var _a;
+        let baseExpr = '(i32.const 0)';
+        if (construto.objeto instanceof construtos_1.Variavel) {
+            const nome = (_a = construto.objeto.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+            const meta = nome ? this.variaveis.get(nome) : undefined;
+            if (meta) {
+                const instrGet = meta.escopo === 'local' ? 'local.get' : 'global.get';
+                baseExpr = `(${instrGet} ${meta.watNome})`;
+            }
+        }
+        const indice = this.traduzirConstruto(construto.indice);
+        const valor = this.traduzirConstruto(construto.valor);
+        const offset = `(i32.add ${baseExpr} (i32.wrap_i64 (i64.mul ${indice} (i64.const 8))))`;
+        return `(i64.store ${offset} ${valor})`;
+    }
+    traduzirVetor(construto) {
+        var _a, _b;
+        // Aloca espaço na memória linear para N × 8 bytes.
+        // Os valores são emitidos como instruções de store na função corrente.
+        const n = (_b = (_a = construto.valores) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+        const offset = this.deslocamentoTexto;
+        // Reserva n * 8 bytes (sem conteúdo estático; preenchido em tempo de execução)
+        this.deslocamentoTexto += n * 8;
+        if (construto.valores) {
+            for (let i = 0; i < n; i++) {
+                const valor = this.traduzirConstruto(construto.valores[i]);
+                const enderecoElem = `(i32.const ${offset + i * 8})`;
+                this.emitir(`(i64.store ${enderecoElem} ${valor})`);
+            }
+        }
+        return `(i32.const ${offset})`;
+    }
+    traduzirDefinirValor(construto) {
+        // Acesso a propriedade de objeto — simplificado na v1
+        const valor = this.traduzirConstruto(construto.valor);
+        return `${valor} ;; definir valor não totalmente suportado na v1`;
+    }
+    traduzirFuncaoConstruto(construto) {
+        var _a;
+        // Função anônima: emite como função nomeada com rótulo gerado
+        const rotulo = `__anonima_${this.contadorRotulos++}`;
+        const snapshot = this.salvarEIniciarContextoFuncao();
+        for (const decl of (_a = construto.corpo) !== null && _a !== void 0 ? _a : []) {
+            this.traduzirDeclaracaoInterna(decl);
+        }
+        this.emitir('(i64.const 0)');
+        const funcWat = `  (func $${rotulo}${this.declaracoesLocaisAtual} (result i64)\n` +
+            this.corpoDaFuncaoAtual +
+            `  )`;
+        this.funcoesCompletas.push(funcWat);
+        this.restaurarContextoFuncao(snapshot);
+        return `(i32.const 0) ;; referência à função anônima $${rotulo}`;
+    }
+    traduzirAcessoMetodo(_construto) {
+        return '(i64.const 0) ;; acesso a método não suportado na v1';
+    }
+    traduzirTipoDe(construto) {
+        return this.traduzirConstruto(construto.valor);
+    }
+    // =========================================================================
+    // Declarações
+    // =========================================================================
+    traduzirVar(declaracao) {
+        var _a;
+        const nome = (_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        if (!nome)
+            return;
+        if (declaracao.inicializador instanceof construtos_1.Vetor) {
+            // Vetor: aloca em memória e guarda o ponteiro i32 na variável
+            if (this.dentroFuncao) {
+                this.declararParamLocal(nome, 'i32', false);
+            }
+            else {
+                this.declaracoesGlobais.push(`  (global $${nome} (mut i32) (i32.const 0))`);
+                this.variaveis.set(nome, { watNome: `$${nome}`, tipo: 'i32', escopo: 'global' });
+            }
+            const ponteiro = this.traduzirVetor(declaracao.inicializador);
+            const meta = this.variaveis.get(nome);
+            const instrSet = meta.escopo === 'local' ? 'local.set' : 'global.set';
+            this.emitir(`(${instrSet} $${nome} ${ponteiro})`);
+            return;
+        }
+        const tipo = declaracao.inicializador ? this.inferirTipo(declaracao.inicializador) : 'i64';
+        if (this.dentroFuncao) {
+            this.declararParamLocal(nome, tipo, false);
+            if (declaracao.inicializador) {
+                const valor = this.traduzirConstruto(declaracao.inicializador);
+                this.emitir(`(local.set $${nome} ${valor})`);
+            }
+        }
+        else {
+            // Globais WAT só aceitam const-exprs como inicializadores.
+            // Literais → inicializador imediato; expressões complexas → init 0 + global.set em $principal.
+            if (declaracao.inicializador instanceof construtos_1.Literal) {
+                const init = this.traduzirGlobalInit(declaracao.inicializador, tipo);
+                this.declaracoesGlobais.push(`  (global $${nome} (mut ${tipo}) ${init})`);
+                this.variaveis.set(nome, { watNome: `$${nome}`, tipo, escopo: 'global' });
+            }
+            else {
+                this.declaracoesGlobais.push(`  (global $${nome} (mut ${tipo}) (${tipo}.const 0))`);
+                this.variaveis.set(nome, { watNome: `$${nome}`, tipo, escopo: 'global' });
+                if (declaracao.inicializador) {
+                    const valor = this.traduzirConstruto(declaracao.inicializador);
+                    this.emitir(`(global.set $${nome} ${valor})`);
+                }
+            }
+        }
+    }
+    traduzirConst(declaracao) {
+        var _a;
+        const nome = (_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        if (!nome)
+            return;
+        const tipo = this.inferirTipo(declaracao.inicializador);
+        if (this.dentroFuncao) {
+            // Dentro de função: trata como local (sem imutabilidade real em WAT)
+            this.declararParamLocal(nome, tipo, false);
+            const valor = this.traduzirConstruto(declaracao.inicializador);
+            this.emitir(`(local.set $${nome} ${valor})`);
+        }
+        else {
+            // Constante global: sem `mut`; apenas literais são válidos como init
+            if (declaracao.inicializador instanceof construtos_1.Literal) {
+                const init = this.traduzirGlobalInit(declaracao.inicializador, tipo);
+                this.declaracoesGlobais.push(`  (global $${nome} ${tipo} ${init})`);
+            }
+            else {
+                // Expressão complexa: global imutável não pode ser sobrescrita em WAT.
+                // Tratamos como mutável para permitir inicialização tardia.
+                this.declaracoesGlobais.push(`  (global $${nome} (mut ${tipo}) (${tipo}.const 0))`);
+                const valor = this.traduzirConstruto(declaracao.inicializador);
+                this.emitir(`(global.set $${nome} ${valor})`);
+            }
+            this.variaveis.set(nome, { watNome: `$${nome}`, tipo, escopo: 'global' });
+        }
+    }
+    /**
+     * Traduz um literal para um WAT const-expr válido como inicializador de global.
+     * Apenas literais são aceitos como inicializadores de globais em WAT.
+     */
+    traduzirGlobalInit(construto, tipo) {
+        if (typeof construto.valor === 'boolean')
+            return `(i64.const ${construto.valor ? 1 : 0})`;
+        if (typeof construto.valor === 'string') {
+            const { offset } = this.internalizarTexto(construto.valor);
+            return `(i32.const ${offset})`;
+        }
+        if (typeof construto.valor === 'bigint')
+            return `(i64.const ${construto.valor})`;
+        return `(${tipo}.const ${Math.trunc(Number(construto.valor))})`;
+    }
+    traduzirSe(declaracao) {
+        const condicao = this.traduzirConstruto(declaracao.condicao);
+        this.emitir(`(if`);
+        this.emitir(`  (i32.wrap_i64 ${condicao})`);
+        this.emitir(`  (then`);
+        if (this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name]) {
+            const corpoPrevio = this.corpoDaFuncaoAtual;
+            this.corpoDaFuncaoAtual = '';
+            this.traduzirDeclaracaoInterna(declaracao.caminhoEntao);
+            const corpoEntao = this.corpoDaFuncaoAtual
+                .split('\n')
+                .map((l) => `  ${l}`)
+                .join('\n');
+            this.corpoDaFuncaoAtual = corpoPrevio + corpoEntao;
+        }
+        this.emitir(`  )`);
+        if (declaracao.caminhoSenao) {
+            this.emitir(`  (else`);
+            const corpoPrevio = this.corpoDaFuncaoAtual;
+            this.corpoDaFuncaoAtual = '';
+            this.traduzirDeclaracaoInterna(declaracao.caminhoSenao);
+            const corpoSenao = this.corpoDaFuncaoAtual
+                .split('\n')
+                .map((l) => `  ${l}`)
+                .join('\n');
+            this.corpoDaFuncaoAtual = corpoPrevio + corpoSenao;
+            this.emitir(`  )`);
+        }
+        this.emitir(`)`);
+    }
+    traduzirEnquanto(declaracao) {
+        const labelSaida = this.gerarRotulo();
+        const labelLaco = this.gerarRotulo();
+        this.pilhaDeControle.push({ labelSaida, labelLaco });
+        const condicao = this.traduzirConstruto(declaracao.condicao);
+        this.emitir(`(block ${labelSaida}`);
+        this.emitir(`  (loop ${labelLaco}`);
+        this.emitir(`    (br_if ${labelSaida}`);
+        this.emitir(`      (i32.eqz (i32.wrap_i64 ${condicao}))`);
+        this.emitir(`    )`);
+        this.traduzirDeclaracaoInterna(declaracao.corpo);
+        this.emitir(`    (br ${labelLaco})`);
+        this.emitir(`  )`);
+        this.emitir(`)`);
+        this.pilhaDeControle.pop();
+    }
+    traduzirPara(declaracao) {
+        // Inicializador
+        if (declaracao.inicializador) {
+            if (Array.isArray(declaracao.inicializador)) {
+                for (const decl of declaracao.inicializador) {
+                    this.traduzirDeclaracaoInterna(decl);
+                }
+            }
+            else {
+                this.traduzirDeclaracaoInterna(declaracao.inicializador);
+            }
+        }
+        const labelSaida = this.gerarRotulo();
+        const labelLaco = this.gerarRotulo();
+        this.pilhaDeControle.push({ labelSaida, labelLaco });
+        const condicao = declaracao.condicao
+            ? this.traduzirConstruto(declaracao.condicao)
+            : '(i64.const 1)';
+        this.emitir(`(block ${labelSaida}`);
+        this.emitir(`  (loop ${labelLaco}`);
+        this.emitir(`    (br_if ${labelSaida}`);
+        this.emitir(`      (i32.eqz (i32.wrap_i64 ${condicao}))`);
+        this.emitir(`    )`);
+        if (declaracao.corpo) {
+            this.traduzirDeclaracaoInterna(declaracao.corpo);
+        }
+        if (declaracao.incrementar) {
+            const inc = this.traduzirConstruto(declaracao.incrementar);
+            this.emitir(`(drop ${inc})`);
+        }
+        this.emitir(`    (br ${labelLaco})`);
+        this.emitir(`  )`);
+        this.emitir(`)`);
+        this.pilhaDeControle.pop();
+    }
+    traduzirFazer(declaracao) {
+        var _a;
+        const labelSaida = this.gerarRotulo();
+        const labelLaco = this.gerarRotulo();
+        this.pilhaDeControle.push({ labelSaida, labelLaco });
+        this.emitir(`(block ${labelSaida}`);
+        this.emitir(`  (loop ${labelLaco}`);
+        if ((_a = declaracao.caminhoFazer) === null || _a === void 0 ? void 0 : _a.declaracoes) {
+            for (const decl of declaracao.caminhoFazer.declaracoes) {
+                this.traduzirDeclaracaoInterna(decl);
+            }
+        }
+        if (declaracao.condicaoEnquanto) {
+            const condicao = this.traduzirConstruto(declaracao.condicaoEnquanto);
+            // Repete se a condição for verdadeira
+            this.emitir(`    (br_if ${labelLaco}`);
+            this.emitir(`      (i32.wrap_i64 ${condicao})`);
+            this.emitir(`    )`);
+        }
+        this.emitir(`  )`);
+        this.emitir(`)`);
+        this.pilhaDeControle.pop();
+    }
+    traduzirEscolha(declaracao) {
+        const rotuloEscolha = `__escolha_${this.contadorRotulos++}`;
+        const tipo = 'i64';
+        // Declara local temporário para o valor do escolha
+        this.declararParamLocal(rotuloEscolha, tipo, false);
+        const sujeito = this.traduzirConstruto(declaracao.identificadorOuLiteral);
+        this.emitir(`(local.set $${rotuloEscolha} ${sujeito})`);
+        // Gera cadeia de if/else aninhados
+        this.emitirCadeiaEscolha(rotuloEscolha, declaracao.caminhos, declaracao.caminhoPadrao);
+    }
+    emitirCadeiaEscolha(rotuloEscolha, caminhos, caminhoPadrao, indice = 0) {
+        var _a, _b;
+        if (indice >= caminhos.length) {
+            // Emite o caminho padrão (senao) se existir
+            if (caminhoPadrao) {
+                for (const decl of (_a = caminhoPadrao.declaracoes) !== null && _a !== void 0 ? _a : []) {
+                    this.traduzirDeclaracaoInterna(decl);
+                }
+            }
+            return;
+        }
+        const caminho = caminhos[indice];
+        if (!caminho.condicoes || caminho.condicoes.length === 0) {
+            this.emitirCadeiaEscolha(rotuloEscolha, caminhos, caminhoPadrao, indice + 1);
+            return;
+        }
+        // Condição: qualquer das condicoes casa com o valor do escolha
+        const primeiraCond = `(i64.eq (local.get $${rotuloEscolha}) ${this.traduzirConstruto(caminho.condicoes[0])})`;
+        let condicaoFinal = primeiraCond;
+        for (let i = 1; i < caminho.condicoes.length; i++) {
+            const outraCond = `(i64.eq (local.get $${rotuloEscolha}) ${this.traduzirConstruto(caminho.condicoes[i])})`;
+            condicaoFinal = `(i32.or ${condicaoFinal} ${outraCond})`;
+        }
+        this.emitir(`(if`);
+        this.emitir(`  ${condicaoFinal}`);
+        this.emitir(`  (then`);
+        for (const decl of (_b = caminho.declaracoes) !== null && _b !== void 0 ? _b : []) {
+            this.traduzirDeclaracaoInterna(decl);
+        }
+        this.emitir(`  )`);
+        const temProximo = indice + 1 < caminhos.length || caminhoPadrao != null;
+        if (temProximo) {
+            this.emitir(`  (else`);
+            this.emitirCadeiaEscolha(rotuloEscolha, caminhos, caminhoPadrao, indice + 1);
+            this.emitir(`  )`);
+        }
+        this.emitir(`)`);
+    }
+    traduzirBloco(declaracao) {
+        var _a;
+        for (const decl of (_a = declaracao.declaracoes) !== null && _a !== void 0 ? _a : []) {
+            this.traduzirDeclaracaoInterna(decl);
+        }
+    }
+    traduzirExpressao(declaracao) {
+        if (!declaracao.expressao)
+            return;
+        const expr = this.traduzirConstruto(declaracao.expressao);
+        // Atribuições e stores não deixam valor na pilha; outros sim → drop
+        const deixaValor = !(declaracao.expressao instanceof construtos_1.Atribuir) &&
+            !(declaracao.expressao instanceof construtos_1.AtribuicaoPorIndice);
+        if (deixaValor) {
+            this.emitir(`(drop ${expr})`);
+        }
+        else {
+            this.emitir(expr);
+        }
+    }
+    traduzirEscreva(declaracao) {
+        for (const arg of declaracao.argumentos) {
+            if (arg instanceof construtos_1.Literal && typeof arg.valor === 'string') {
+                const { offset, len } = this.internalizarTexto(arg.valor);
+                this.emitir(`(call $__escreva_texto (i32.const ${offset}) (i32.const ${len}))`);
+            }
+            else {
+                const expr = this.traduzirConstruto(arg);
+                this.emitir(`(call $__escreva_inteiro ${expr})`);
+            }
+        }
+    }
+    traduzirRetorna(declaracao) {
+        this.funcaoTemRetorno = true;
+        if (declaracao.valor) {
+            const valor = this.traduzirConstruto(declaracao.valor);
+            this.emitir(`(return ${valor})`);
+        }
+        else {
+            this.emitir(`(return (i64.const 0))`);
+        }
+    }
+    traduzirSustar(_declaracao) {
+        const topo = this.pilhaDeControle[this.pilhaDeControle.length - 1];
+        if (topo) {
+            this.emitir(`(br ${topo.labelSaida})`);
+        }
+    }
+    traduzirContinua(_declaracao) {
+        const topo = this.pilhaDeControle[this.pilhaDeControle.length - 1];
+        if (topo) {
+            this.emitir(`(br ${topo.labelLaco})`);
+        }
+    }
+    traduzirFuncaoDeclaracao(declaracao) {
+        var _a, _b, _c, _d, _e, _f;
+        const nome = (_b = (_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) !== null && _b !== void 0 ? _b : `__func_${this.contadorRotulos++}`;
+        const snapshot = this.salvarEIniciarContextoFuncao();
+        // Declara parâmetros
+        for (const param of (_d = (_c = declaracao.funcao) === null || _c === void 0 ? void 0 : _c.parametros) !== null && _d !== void 0 ? _d : []) {
+            this.declararParamLocal(param.nome.lexema, 'i64', true);
+        }
+        // Traduz corpo
+        for (const decl of (_f = (_e = declaracao.funcao) === null || _e === void 0 ? void 0 : _e.corpo) !== null && _f !== void 0 ? _f : []) {
+            this.traduzirDeclaracaoInterna(decl);
+        }
+        // Retorno implícito 0 (garante stack completo)
+        this.emitir('(i64.const 0)');
+        const ehPrincipal = nome === 'principal';
+        const exportar = ehPrincipal ? ' (export "principal")' : '';
+        const funcWat = `  (func $${nome}${exportar}${this.declaracoesLocaisAtual} (result i64)\n` +
+            this.corpoDaFuncaoAtual +
+            `  )`;
+        this.funcoesCompletas.push(funcWat);
+        this.restaurarContextoFuncao(snapshot);
+    }
+    traduzirFalhar(declaracao) {
+        // `unreachable` = trap incondicional em WebAssembly
+        let msg = '';
+        if (declaracao.explicacao) {
+            try {
+                msg = ` ;; ${this.traduzirConstruto(declaracao.explicacao)}`;
+            }
+            catch (_a) {
+                // ignore
+            }
+        }
+        this.emitir(`(unreachable)${msg}`);
+    }
+    traduzirImportar(_declaracao) {
+        this.emitir(`;; importar não suportado em WebAssembly nativo`);
+    }
+    traduzirTente(declaracao) {
+        var _a;
+        this.emitir(`;; tente/pegue: tratamento de exceções é v2`);
+        for (const decl of (_a = declaracao.caminhoTente) !== null && _a !== void 0 ? _a : []) {
+            this.traduzirDeclaracaoInterna(decl);
+        }
+    }
+    traduzirClasse(_declaracao) {
+        this.emitir(`;; classe: não suportada na v1`);
+    }
+    traduzirParaCada(declaracao) {
+        this.emitir(`;; para cada: requer suporte a iteráveis (v2)`);
+        if (declaracao.corpo) {
+            this.traduzirDeclaracaoInterna(declaracao.corpo);
+        }
+    }
+    // =========================================================================
+    // Método principal
+    // =========================================================================
+    /**
+     * Traduz uma lista de declarações Delégua para um módulo WAT.
+     * Retorna a string completa do módulo.
+     */
+    traduzir(declaracoes) {
+        // Verifica se o usuário declarou explicitamente `funcao principal()`
+        const principalDeclarado = declaracoes.some((d) => { var _a; return d instanceof declaracoes_1.FuncaoDeclaracao && ((_a = d.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) === 'principal'; });
+        // Processa todas as declarações de nível superior
+        for (const declaracao of declaracoes) {
+            this.traduzirDeclaracaoInterna(declaracao);
+        }
+        // Se o usuário não declarou principal(), envolve os stmts de topo em $principal
+        if (!principalDeclarado) {
+            const corpoTopo = this.corpoDaFuncaoAtual;
+            const locaisDeclarados = this.declaracoesLocaisAtual;
+            const funcPrincipal = `  (func $principal (export "principal")${locaisDeclarados} (result i64)\n` +
+                corpoTopo +
+                `    (i64.const 0)\n` +
+                `  )`;
+            this.funcoesCompletas.push(funcPrincipal);
+        }
+        // ── Monta as seções do módulo ────────────────────────────────────────
+        const linhasImports = [
+            `  (import "delegua" "escreva_texto"   (func $__escreva_texto   (param i32 i32)))`,
+            `  (import "delegua" "escreva_inteiro" (func $__escreva_inteiro (param i64)))`,
+        ];
+        const linhaMemoria = `  (memory (export "memory") 1)`;
+        const linhasDados = this.segmentosTexto.map((s) => {
+            const { watLiteral } = this.escaparStringWat(s.conteudo);
+            return `  (data (i32.const ${s.deslocamento}) "${watLiteral}")`;
+        });
+        const partes = [
+            '(module',
+            ...linhasImports,
+            '',
+            linhaMemoria,
+        ];
+        if (linhasDados.length > 0) {
+            partes.push('');
+            partes.push(...linhasDados);
+        }
+        if (this.declaracoesGlobais.length > 0) {
+            partes.push('');
+            partes.push(...this.declaracoesGlobais);
+        }
+        if (this.funcoesCompletas.length > 0) {
+            partes.push('');
+            partes.push(...this.funcoesCompletas);
+        }
+        partes.push(')');
+        return partes.join('\n');
+    }
+    // =========================================================================
+    // Arquivo host JavaScript
+    // =========================================================================
+    /**
+     * Gera um arquivo `.mjs` host para executar o módulo WASM no Node.js.
+     * Fornece os imports necessários (`delegua.escreva_texto`, `delegua.escreva_inteiro`).
+     */
+    gerarArquivoHost() {
+        return `// Gerado por Delégua -> WebAssembly
+// Uso: node delegua-host.mjs <arquivo.wasm>
+import { readFileSync } from 'fs';
+
+const args = process.argv.slice(2);
+const wasmPath = args[0] ?? 'saida.wasm';
+
+let memoryExport;
+
+const importObject = {
+    delegua: {
+        /** Imprime texto a partir de um ponteiro e comprimento na memória linear. */
+        escreva_texto(ptr, len) {
+            const bytes = new Uint8Array(memoryExport.buffer, ptr, len);
+            process.stdout.write(new TextDecoder('utf-8').decode(bytes));
+        },
+        /** Imprime um inteiro de 64 bits (recebido como BigInt no JS). */
+        escreva_inteiro(valor) {
+            process.stdout.write(String(valor));
+        },
+    }
+};
+
+const wasmBuffer = readFileSync(wasmPath);
+const { instance } = await WebAssembly.instantiate(wasmBuffer, importObject);
+memoryExport = instance.exports.memory;
+
+const codigoSaida = Number(instance.exports.principal());
+process.exit(codigoSaida);
+`;
+    }
+}
+exports.TradutorWebAssembly = TradutorWebAssembly;
+
+},{"../construtos":62,"../declaracoes":110}],254:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -47834,7 +49529,7 @@ exports.TradutorRuby = TradutorRuby;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],253:[function(require,module,exports){
+},{}],255:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -47842,7 +49537,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],254:[function(require,module,exports){
+},{}],256:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48004,7 +49699,7 @@ __decorate([
 ], ANTLRInputStream.prototype, "toString", null);
 exports.ANTLRInputStream = ANTLRInputStream;
 
-},{"./Decorators":265,"./IntStream":271,"assert":408}],255:[function(require,module,exports){
+},{"./Decorators":267,"./IntStream":273,"assert":410}],257:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48087,7 +49782,7 @@ __decorate([
 ], BailErrorStrategy.prototype, "sync", null);
 exports.BailErrorStrategy = BailErrorStrategy;
 
-},{"./Decorators":265,"./DefaultErrorStrategy":266,"./InputMismatchException":270,"./misc/ParseCancellationException":382}],256:[function(require,module,exports){
+},{"./Decorators":267,"./DefaultErrorStrategy":268,"./InputMismatchException":272,"./misc/ParseCancellationException":384}],258:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48577,7 +50272,7 @@ BufferedTokenStream = __decorate([
 ], BufferedTokenStream);
 exports.BufferedTokenStream = BufferedTokenStream;
 
-},{"./CommonToken":261,"./Decorators":265,"./Lexer":273,"./Token":290,"./misc/Interval":377,"assert":408}],257:[function(require,module,exports){
+},{"./CommonToken":263,"./Decorators":267,"./Lexer":275,"./Token":292,"./misc/Interval":379,"assert":410}],259:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48585,7 +50280,7 @@ exports.BufferedTokenStream = BufferedTokenStream;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],258:[function(require,module,exports){
+},{}],260:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48719,7 +50414,7 @@ var CharStreams;
     // }
 })(CharStreams = exports.CharStreams || (exports.CharStreams = {}));
 
-},{"./CodePointBuffer":259,"./CodePointCharStream":260,"./IntStream":271}],259:[function(require,module,exports){
+},{"./CodePointBuffer":261,"./CodePointCharStream":262,"./IntStream":273}],261:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -48954,7 +50649,7 @@ exports.CodePointBuffer = CodePointBuffer;
     CodePointBuffer.Builder = Builder;
 })(CodePointBuffer = exports.CodePointBuffer || (exports.CodePointBuffer = {}));
 
-},{"./misc/Character":373,"assert":408}],260:[function(require,module,exports){
+},{"./misc/Character":375,"assert":410}],262:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49104,7 +50799,7 @@ __decorate([
 ], CodePointCharStream.prototype, "getText", null);
 exports.CodePointCharStream = CodePointCharStream;
 
-},{"./Decorators":265,"./IntStream":271,"./misc/Interval":377,"assert":408}],261:[function(require,module,exports){
+},{"./Decorators":267,"./IntStream":273,"./misc/Interval":379,"assert":410}],263:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49334,7 +51029,7 @@ CommonToken = __decorate([
 ], CommonToken);
 exports.CommonToken = CommonToken;
 
-},{"./Decorators":265,"./Token":290,"./misc/Interval":377}],262:[function(require,module,exports){
+},{"./Decorators":267,"./Token":292,"./misc/Interval":379}],264:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49398,7 +51093,7 @@ exports.CommonTokenFactory = CommonTokenFactory;
     CommonTokenFactory.DEFAULT = new CommonTokenFactory();
 })(CommonTokenFactory = exports.CommonTokenFactory || (exports.CommonTokenFactory = {}));
 
-},{"./CommonToken":261,"./Decorators":265,"./misc/Interval":377}],263:[function(require,module,exports){
+},{"./CommonToken":263,"./Decorators":267,"./misc/Interval":379}],265:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49525,7 +51220,7 @@ CommonTokenStream = __decorate([
 ], CommonTokenStream);
 exports.CommonTokenStream = CommonTokenStream;
 
-},{"./BufferedTokenStream":256,"./Decorators":265,"./Token":290}],264:[function(require,module,exports){
+},{"./BufferedTokenStream":258,"./Decorators":267,"./Token":292}],266:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49559,7 +51254,7 @@ exports.ConsoleErrorListener = ConsoleErrorListener;
  */
 ConsoleErrorListener.INSTANCE = new ConsoleErrorListener();
 
-},{}],265:[function(require,module,exports){
+},{}],267:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -49586,7 +51281,7 @@ function SuppressWarnings(options) {
 }
 exports.SuppressWarnings = SuppressWarnings;
 
-},{}],266:[function(require,module,exports){
+},{}],268:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -50400,7 +52095,7 @@ __decorate([
 ], DefaultErrorStrategy.prototype, "consumeUntil", null);
 exports.DefaultErrorStrategy = DefaultErrorStrategy;
 
-},{"./Decorators":265,"./FailedPredicateException":269,"./InputMismatchException":270,"./NoViableAltException":277,"./Token":290,"./atn/ATNState":304,"./atn/ATNStateType":305,"./atn/PredictionContext":345,"./misc/IntervalSet":378}],267:[function(require,module,exports){
+},{"./Decorators":267,"./FailedPredicateException":271,"./InputMismatchException":272,"./NoViableAltException":279,"./Token":292,"./atn/ATNState":306,"./atn/ATNStateType":307,"./atn/PredictionContext":347,"./misc/IntervalSet":380}],269:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -50476,7 +52171,7 @@ var Dependents;
     Dependents[Dependents["FOLLOWING"] = 9] = "FOLLOWING";
 })(Dependents = exports.Dependents || (exports.Dependents = {}));
 
-},{}],268:[function(require,module,exports){
+},{}],270:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -50624,7 +52319,7 @@ __decorate([
 ], DiagnosticErrorListener.prototype, "getConflictingAlts", null);
 exports.DiagnosticErrorListener = DiagnosticErrorListener;
 
-},{"./Decorators":265,"./misc/BitSet":372,"./misc/Interval":377}],269:[function(require,module,exports){
+},{"./Decorators":267,"./misc/BitSet":374,"./misc/Interval":379}],271:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -50689,7 +52384,7 @@ FailedPredicateException = __decorate([
 ], FailedPredicateException);
 exports.FailedPredicateException = FailedPredicateException;
 
-},{"./Decorators":265,"./RecognitionException":284,"./atn/PredicateTransition":344}],270:[function(require,module,exports){
+},{"./Decorators":267,"./RecognitionException":286,"./atn/PredicateTransition":346}],272:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -50729,7 +52424,7 @@ InputMismatchException = __decorate([
 ], InputMismatchException);
 exports.InputMismatchException = InputMismatchException;
 
-},{"./Decorators":265,"./RecognitionException":284}],271:[function(require,module,exports){
+},{"./Decorators":267,"./RecognitionException":286}],273:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -50752,7 +52447,7 @@ var IntStream;
     IntStream.UNKNOWN_SOURCE_NAME = "<unknown>";
 })(IntStream = exports.IntStream || (exports.IntStream = {}));
 
-},{}],272:[function(require,module,exports){
+},{}],274:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -50799,7 +52494,7 @@ __decorate([
 ], InterpreterRuleContext.prototype, "ruleIndex", null);
 exports.InterpreterRuleContext = InterpreterRuleContext;
 
-},{"./Decorators":265,"./ParserRuleContext":281}],273:[function(require,module,exports){
+},{"./Decorators":267,"./ParserRuleContext":283}],275:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -51135,7 +52830,7 @@ __decorate([
 ], Lexer.prototype, "charPositionInLine", null);
 exports.Lexer = Lexer;
 
-},{"./CommonTokenFactory":262,"./Decorators":265,"./IntStream":271,"./LexerNoViableAltException":275,"./Recognizer":285,"./Token":290,"./atn/LexerATNSimulator":323,"./misc/IntegerStack":376,"./misc/Interval":377}],274:[function(require,module,exports){
+},{"./CommonTokenFactory":264,"./Decorators":267,"./IntStream":273,"./LexerNoViableAltException":277,"./Recognizer":287,"./Token":292,"./atn/LexerATNSimulator":325,"./misc/IntegerStack":378,"./misc/Interval":379}],276:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -51215,7 +52910,7 @@ LexerInterpreter = __decorate([
 ], LexerInterpreter);
 exports.LexerInterpreter = LexerInterpreter;
 
-},{"./Decorators":265,"./Lexer":273,"./atn/LexerATNSimulator":323}],275:[function(require,module,exports){
+},{"./Decorators":267,"./Lexer":275,"./atn/LexerATNSimulator":325}],277:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -51272,7 +52967,7 @@ LexerNoViableAltException = __decorate([
 ], LexerNoViableAltException);
 exports.LexerNoViableAltException = LexerNoViableAltException;
 
-},{"./Decorators":265,"./RecognitionException":284,"./misc/Interval":377,"./misc/Utils":384}],276:[function(require,module,exports){
+},{"./Decorators":267,"./RecognitionException":286,"./misc/Interval":379,"./misc/Utils":386}],278:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -51482,7 +53177,7 @@ ListTokenSource = __decorate([
 ], ListTokenSource);
 exports.ListTokenSource = ListTokenSource;
 
-},{"./CommonTokenFactory":262,"./Decorators":265,"./Token":290}],277:[function(require,module,exports){
+},{"./CommonTokenFactory":264,"./Decorators":267,"./Token":292}],279:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -51537,7 +53232,7 @@ __decorate([
 ], NoViableAltException.prototype, "_startToken", void 0);
 exports.NoViableAltException = NoViableAltException;
 
-},{"./Decorators":265,"./Parser":278,"./RecognitionException":284}],278:[function(require,module,exports){
+},{"./Decorators":267,"./Parser":280,"./RecognitionException":286}],280:[function(require,module,exports){
 (function (process){(function (){
 "use strict";
 /*!
@@ -52383,7 +54078,7 @@ __decorate([
 exports.Parser = Parser;
 
 }).call(this)}).call(this,require('_process'))
-},{"./Decorators":265,"./DefaultErrorStrategy":266,"./Lexer":273,"./ProxyParserErrorListener":283,"./Recognizer":285,"./Token":290,"./atn/ATNDeserializationOptions":301,"./atn/ATNDeserializer":302,"./atn/ParseInfo":338,"./atn/ParserATNSimulator":339,"./atn/ProfilingATNSimulator":348,"./misc/IntegerStack":376,"./misc/Utils":384,"./tree/ErrorNode":385,"./tree/TerminalNode":388,"./tree/pattern/ParseTreePatternMatcher":393,"_process":467}],279:[function(require,module,exports){
+},{"./Decorators":267,"./DefaultErrorStrategy":268,"./Lexer":275,"./ProxyParserErrorListener":285,"./Recognizer":287,"./Token":292,"./atn/ATNDeserializationOptions":303,"./atn/ATNDeserializer":304,"./atn/ParseInfo":340,"./atn/ParserATNSimulator":341,"./atn/ProfilingATNSimulator":350,"./misc/IntegerStack":378,"./misc/Utils":386,"./tree/ErrorNode":387,"./tree/TerminalNode":390,"./tree/pattern/ParseTreePatternMatcher":395,"_process":469}],281:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52391,7 +54086,7 @@ exports.Parser = Parser;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],280:[function(require,module,exports){
+},{}],282:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -52799,7 +54494,7 @@ ParserInterpreter = __decorate([
 ], ParserInterpreter);
 exports.ParserInterpreter = ParserInterpreter;
 
-},{"./Decorators":265,"./FailedPredicateException":269,"./InputMismatchException":270,"./InterpreterRuleContext":272,"./Parser":278,"./RecognitionException":284,"./Token":290,"./atn/ATNState":304,"./atn/ATNStateType":305,"./atn/LoopEndState":335,"./atn/ParserATNSimulator":339,"./atn/StarLoopEntryState":357,"./misc/BitSet":372}],281:[function(require,module,exports){
+},{"./Decorators":267,"./FailedPredicateException":271,"./InputMismatchException":272,"./InterpreterRuleContext":274,"./Parser":280,"./RecognitionException":286,"./Token":292,"./atn/ATNState":306,"./atn/ATNStateType":307,"./atn/LoopEndState":337,"./atn/ParserATNSimulator":341,"./atn/StarLoopEntryState":359,"./misc/BitSet":374}],283:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53100,7 +54795,7 @@ __decorate([
 ], ParserRuleContext.prototype, "sourceInterval", null);
 exports.ParserRuleContext = ParserRuleContext;
 
-},{"./Decorators":265,"./RuleContext":286,"./misc/Interval":377,"./tree/ErrorNode":385,"./tree/TerminalNode":388}],282:[function(require,module,exports){
+},{"./Decorators":267,"./RuleContext":288,"./misc/Interval":379,"./tree/ErrorNode":387,"./tree/TerminalNode":390}],284:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53150,7 +54845,7 @@ __decorate([
 ], ProxyErrorListener.prototype, "syntaxError", null);
 exports.ProxyErrorListener = ProxyErrorListener;
 
-},{"./Decorators":265}],283:[function(require,module,exports){
+},{"./Decorators":267}],285:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53209,7 +54904,7 @@ __decorate([
 ], ProxyParserErrorListener.prototype, "reportContextSensitivity", null);
 exports.ProxyParserErrorListener = ProxyParserErrorListener;
 
-},{"./Decorators":265,"./ProxyErrorListener":282}],284:[function(require,module,exports){
+},{"./Decorators":267,"./ProxyErrorListener":284}],286:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53314,7 +55009,7 @@ class RecognitionException extends Error {
 }
 exports.RecognitionException = RecognitionException;
 
-},{}],285:[function(require,module,exports){
+},{}],287:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53533,7 +55228,7 @@ __decorate([
 ], Recognizer.prototype, "getErrorListeners", null);
 exports.Recognizer = Recognizer;
 
-},{"./ConsoleErrorListener":264,"./Decorators":265,"./ProxyErrorListener":282,"./Token":290,"./misc/Utils":384}],286:[function(require,module,exports){
+},{"./ConsoleErrorListener":266,"./Decorators":267,"./ProxyErrorListener":284,"./Token":292,"./misc/Utils":386}],288:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53750,7 +55445,7 @@ __decorate([
 ], RuleContext.prototype, "toStringTree", null);
 exports.RuleContext = RuleContext;
 
-},{"./Decorators":265,"./ParserRuleContext":281,"./Recognizer":285,"./atn/ATN":298,"./misc/Interval":377,"./tree/RuleNode":387,"./tree/Trees":389}],287:[function(require,module,exports){
+},{"./Decorators":267,"./ParserRuleContext":283,"./Recognizer":287,"./atn/ATN":300,"./misc/Interval":379,"./tree/RuleNode":389,"./tree/Trees":391}],289:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53801,7 +55496,7 @@ __decorate([
 ], RuleContextWithAltNum.prototype, "altNumber", null);
 exports.RuleContextWithAltNum = RuleContextWithAltNum;
 
-},{"./Decorators":265,"./ParserRuleContext":281,"./atn/ATN":298}],288:[function(require,module,exports){
+},{"./Decorators":267,"./ParserRuleContext":283,"./atn/ATN":300}],290:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53824,7 +55519,7 @@ function RuleDependency(dependency) {
 }
 exports.RuleDependency = RuleDependency;
 
-},{}],289:[function(require,module,exports){
+},{}],291:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53843,7 +55538,7 @@ function RuleVersion(version) {
 }
 exports.RuleVersion = RuleVersion;
 
-},{}],290:[function(require,module,exports){
+},{}],292:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53883,7 +55578,7 @@ var Token;
     Token.MIN_USER_CHANNEL_VALUE = 2;
 })(Token = exports.Token || (exports.Token = {}));
 
-},{"./IntStream":271}],291:[function(require,module,exports){
+},{"./IntStream":273}],293:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53891,7 +55586,7 @@ var Token;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],292:[function(require,module,exports){
+},{}],294:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53899,7 +55594,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],293:[function(require,module,exports){
+},{}],295:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -53907,7 +55602,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],294:[function(require,module,exports){
+},{}],296:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54415,7 +56110,7 @@ __decorate([
     Decorators_1.Override
 ], ReplaceOp.prototype, "toString", null);
 
-},{"./Decorators":265,"./Token":290,"./misc/Interval":377}],295:[function(require,module,exports){
+},{"./Decorators":267,"./Token":292,"./misc/Interval":379}],297:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54423,7 +56118,7 @@ __decorate([
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],296:[function(require,module,exports){
+},{}],298:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54543,7 +56238,7 @@ __decorate([
 ], VocabularyImpl, "EMPTY_VOCABULARY", void 0);
 exports.VocabularyImpl = VocabularyImpl;
 
-},{"./Decorators":265,"./Token":290}],297:[function(require,module,exports){
+},{"./Decorators":267,"./Token":292}],299:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54551,7 +56246,7 @@ exports.VocabularyImpl = VocabularyImpl;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],298:[function(require,module,exports){
+},{}],300:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -54773,7 +56468,7 @@ exports.ATN = ATN;
 })(ATN = exports.ATN || (exports.ATN = {}));
 exports.ATN = ATN;
 
-},{"../Decorators":265,"../Token":290,"../dfa/DFA":363,"../misc/Array2DHashMap":368,"../misc/IntervalSet":378,"../misc/ObjectEqualityComparator":381,"./InvalidState":321,"./LL1Analyzer":322,"./PredictionContext":345,"assert":408}],299:[function(require,module,exports){
+},{"../Decorators":267,"../Token":292,"../dfa/DFA":365,"../misc/Array2DHashMap":370,"../misc/IntervalSet":380,"../misc/ObjectEqualityComparator":383,"./InvalidState":323,"./LL1Analyzer":324,"./PredictionContext":347,"assert":410}],301:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55298,7 +56993,7 @@ ActionSemanticContextATNConfig = __decorate([
     __param(1, Decorators_1.NotNull), __param(2, Decorators_1.NotNull)
 ], ActionSemanticContextATNConfig);
 
-},{"../Decorators":265,"../misc/Array2DHashMap":368,"../misc/MurmurHash":380,"../misc/ObjectEqualityComparator":381,"./DecisionState":318,"./PredictionContext":345,"./SemanticContext":353,"assert":408}],300:[function(require,module,exports){
+},{"../Decorators":267,"../misc/Array2DHashMap":370,"../misc/MurmurHash":382,"../misc/ObjectEqualityComparator":383,"./DecisionState":320,"./PredictionContext":347,"./SemanticContext":355,"assert":410}],302:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55745,7 +57440,7 @@ __decorate([
 ], ATNConfigSet.prototype, "hashCode", null);
 exports.ATNConfigSet = ATNConfigSet;
 
-},{"../Decorators":265,"../misc/Array2DHashMap":368,"../misc/Array2DHashSet":369,"../misc/ArrayEqualityComparator":370,"../misc/BitSet":372,"../misc/ObjectEqualityComparator":381,"../misc/Utils":384,"./ATN":298,"./ATNConfig":299,"./PredictionContext":345,"./PredictionContextCache":346,"./SemanticContext":353,"assert":408}],301:[function(require,module,exports){
+},{"../Decorators":267,"../misc/Array2DHashMap":370,"../misc/Array2DHashSet":371,"../misc/ArrayEqualityComparator":372,"../misc/BitSet":374,"../misc/ObjectEqualityComparator":383,"../misc/Utils":386,"./ATN":300,"./ATNConfig":301,"./PredictionContext":347,"./PredictionContextCache":348,"./SemanticContext":355,"assert":410}],303:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -55824,7 +57519,7 @@ __decorate([
 ], ATNDeserializationOptions, "defaultOptions", null);
 exports.ATNDeserializationOptions = ATNDeserializationOptions;
 
-},{"../Decorators":265}],302:[function(require,module,exports){
+},{"../Decorators":267}],304:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -56911,7 +58606,7 @@ __decorate([
 ], ATNDeserializer.prototype, "edgeFactory", null);
 exports.ATNDeserializer = ATNDeserializer;
 
-},{"../Decorators":265,"../Token":290,"../dfa/DFA":363,"../misc/Array2DHashSet":369,"../misc/BitSet":372,"../misc/IntervalSet":378,"../misc/UUID":383,"./ATN":298,"./ATNDeserializationOptions":301,"./ATNStateType":305,"./ActionTransition":307,"./AtomTransition":309,"./BasicBlockStartState":310,"./BasicState":311,"./BlockEndState":312,"./BlockStartState":313,"./DecisionState":318,"./EpsilonTransition":319,"./InvalidState":321,"./LexerChannelAction":325,"./LexerCustomAction":326,"./LexerModeAction":328,"./LexerMoreAction":329,"./LexerPopModeAction":330,"./LexerPushModeAction":331,"./LexerSkipAction":332,"./LexerTypeAction":333,"./LoopEndState":335,"./NotSetTransition":336,"./ParserATNSimulator":339,"./PlusBlockStartState":340,"./PlusLoopbackState":341,"./PrecedencePredicateTransition":342,"./PredicateTransition":344,"./RangeTransition":349,"./RuleStartState":350,"./RuleStopState":351,"./RuleTransition":352,"./SetTransition":354,"./StarBlockStartState":356,"./StarLoopEntryState":357,"./StarLoopbackState":358,"./TokensStartState":359,"./WildcardTransition":361}],303:[function(require,module,exports){
+},{"../Decorators":267,"../Token":292,"../dfa/DFA":365,"../misc/Array2DHashSet":371,"../misc/BitSet":374,"../misc/IntervalSet":380,"../misc/UUID":385,"./ATN":300,"./ATNDeserializationOptions":303,"./ATNStateType":307,"./ActionTransition":309,"./AtomTransition":311,"./BasicBlockStartState":312,"./BasicState":313,"./BlockEndState":314,"./BlockStartState":315,"./DecisionState":320,"./EpsilonTransition":321,"./InvalidState":323,"./LexerChannelAction":327,"./LexerCustomAction":328,"./LexerModeAction":330,"./LexerMoreAction":331,"./LexerPopModeAction":332,"./LexerPushModeAction":333,"./LexerSkipAction":334,"./LexerTypeAction":335,"./LoopEndState":337,"./NotSetTransition":338,"./ParserATNSimulator":341,"./PlusBlockStartState":342,"./PlusLoopbackState":343,"./PrecedencePredicateTransition":344,"./PredicateTransition":346,"./RangeTransition":351,"./RuleStartState":352,"./RuleStopState":353,"./RuleTransition":354,"./SetTransition":356,"./StarBlockStartState":358,"./StarLoopEntryState":359,"./StarLoopbackState":360,"./TokensStartState":361,"./WildcardTransition":363}],305:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -56975,7 +58670,7 @@ exports.ATNSimulator = ATNSimulator;
 })(ATNSimulator = exports.ATNSimulator || (exports.ATNSimulator = {}));
 exports.ATNSimulator = ATNSimulator;
 
-},{"../Decorators":265,"../dfa/DFAState":365,"./ATNConfigSet":300,"./PredictionContext":345}],304:[function(require,module,exports){
+},{"../Decorators":267,"../dfa/DFAState":367,"./ATNConfigSet":302,"./PredictionContext":347}],306:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57162,7 +58857,7 @@ exports.ATNState = ATNState;
     ATNState.INVALID_STATE_NUMBER = -1;
 })(ATNState = exports.ATNState || (exports.ATNState = {}));
 
-},{"../Decorators":265}],305:[function(require,module,exports){
+},{"../Decorators":267}],307:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57188,7 +58883,7 @@ var ATNStateType;
     ATNStateType[ATNStateType["LOOP_END"] = 12] = "LOOP_END";
 })(ATNStateType = exports.ATNStateType || (exports.ATNStateType = {}));
 
-},{}],306:[function(require,module,exports){
+},{}],308:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57208,7 +58903,7 @@ class AbstractPredicateTransition extends Transition_1.Transition {
 }
 exports.AbstractPredicateTransition = AbstractPredicateTransition;
 
-},{"./Transition":360}],307:[function(require,module,exports){
+},{"./Transition":362}],309:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57264,7 +58959,7 @@ ActionTransition = __decorate([
 ], ActionTransition);
 exports.ActionTransition = ActionTransition;
 
-},{"../Decorators":265,"./Transition":360}],308:[function(require,module,exports){
+},{"../Decorators":267,"./Transition":362}],310:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57351,7 +59046,7 @@ AmbiguityInfo = __decorate([
 ], AmbiguityInfo);
 exports.AmbiguityInfo = AmbiguityInfo;
 
-},{"../Decorators":265,"./DecisionEventInfo":316}],309:[function(require,module,exports){
+},{"../Decorators":267,"./DecisionEventInfo":318}],311:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57409,7 +59104,7 @@ AtomTransition = __decorate([
 ], AtomTransition);
 exports.AtomTransition = AtomTransition;
 
-},{"../Decorators":265,"../misc/IntervalSet":378,"./Transition":360}],310:[function(require,module,exports){
+},{"../Decorators":267,"../misc/IntervalSet":380,"./Transition":362}],312:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57441,7 +59136,7 @@ __decorate([
 ], BasicBlockStartState.prototype, "stateType", null);
 exports.BasicBlockStartState = BasicBlockStartState;
 
-},{"../Decorators":265,"./ATNStateType":305,"./BlockStartState":313}],311:[function(require,module,exports){
+},{"../Decorators":267,"./ATNStateType":307,"./BlockStartState":315}],313:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57473,7 +59168,7 @@ __decorate([
 ], BasicState.prototype, "stateType", null);
 exports.BasicState = BasicState;
 
-},{"../Decorators":265,"./ATNState":304,"./ATNStateType":305}],312:[function(require,module,exports){
+},{"../Decorators":267,"./ATNState":306,"./ATNStateType":307}],314:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57502,7 +59197,7 @@ __decorate([
 ], BlockEndState.prototype, "stateType", null);
 exports.BlockEndState = BlockEndState;
 
-},{"../Decorators":265,"./ATNState":304,"./ATNStateType":305}],313:[function(require,module,exports){
+},{"../Decorators":267,"./ATNState":306,"./ATNStateType":307}],315:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57516,7 +59211,7 @@ class BlockStartState extends DecisionState_1.DecisionState {
 }
 exports.BlockStartState = BlockStartState;
 
-},{"./DecisionState":318}],314:[function(require,module,exports){
+},{"./DecisionState":320}],316:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57586,7 +59281,7 @@ __decorate([
 ], ConflictInfo.prototype, "hashCode", null);
 exports.ConflictInfo = ConflictInfo;
 
-},{"../Decorators":265,"../misc/Utils":384}],315:[function(require,module,exports){
+},{"../Decorators":267,"../misc/Utils":386}],317:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57646,7 +59341,7 @@ ContextSensitivityInfo = __decorate([
 ], ContextSensitivityInfo);
 exports.ContextSensitivityInfo = ContextSensitivityInfo;
 
-},{"../Decorators":265,"./DecisionEventInfo":316}],316:[function(require,module,exports){
+},{"../Decorators":267,"./DecisionEventInfo":318}],318:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57698,7 +59393,7 @@ DecisionEventInfo = __decorate([
 ], DecisionEventInfo);
 exports.DecisionEventInfo = DecisionEventInfo;
 
-},{"../Decorators":265}],317:[function(require,module,exports){
+},{"../Decorators":267}],319:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57911,7 +59606,7 @@ __decorate([
 ], DecisionInfo.prototype, "toString", null);
 exports.DecisionInfo = DecisionInfo;
 
-},{"../Decorators":265}],318:[function(require,module,exports){
+},{"../Decorators":267}],320:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57931,7 +59626,7 @@ class DecisionState extends ATNState_1.ATNState {
 }
 exports.DecisionState = DecisionState;
 
-},{"./ATNState":304}],319:[function(require,module,exports){
+},{"./ATNState":306}],321:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -57997,7 +59692,7 @@ EpsilonTransition = __decorate([
 ], EpsilonTransition);
 exports.EpsilonTransition = EpsilonTransition;
 
-},{"../Decorators":265,"./Transition":360}],320:[function(require,module,exports){
+},{"../Decorators":267,"./Transition":362}],322:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -58050,7 +59745,7 @@ ErrorInfo = __decorate([
 ], ErrorInfo);
 exports.ErrorInfo = ErrorInfo;
 
-},{"../Decorators":265,"./DecisionEventInfo":316}],321:[function(require,module,exports){
+},{"../Decorators":267,"./DecisionEventInfo":318}],323:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -58081,7 +59776,7 @@ __decorate([
 ], InvalidState.prototype, "stateType", null);
 exports.InvalidState = InvalidState;
 
-},{"../Decorators":265,"./ATNStateType":305,"./BasicState":311}],322:[function(require,module,exports){
+},{"../Decorators":267,"./ATNStateType":307,"./BasicState":313}],324:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -58303,7 +59998,7 @@ LL1Analyzer = __decorate([
 ], LL1Analyzer);
 exports.LL1Analyzer = LL1Analyzer;
 
-},{"../Decorators":265,"../Token":290,"../misc/Array2DHashSet":369,"../misc/BitSet":372,"../misc/IntervalSet":378,"../misc/ObjectEqualityComparator":381,"./ATNConfig":299,"./AbstractPredicateTransition":306,"./NotSetTransition":336,"./PredictionContext":345,"./RuleStopState":351,"./RuleTransition":352,"./WildcardTransition":361}],323:[function(require,module,exports){
+},{"../Decorators":267,"../Token":292,"../misc/Array2DHashSet":371,"../misc/BitSet":374,"../misc/IntervalSet":380,"../misc/ObjectEqualityComparator":383,"./ATNConfig":301,"./AbstractPredicateTransition":308,"./NotSetTransition":338,"./PredictionContext":347,"./RuleStopState":353,"./RuleTransition":354,"./WildcardTransition":363}],325:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59020,7 +60715,7 @@ exports.LexerATNSimulator = LexerATNSimulator;
 })(LexerATNSimulator = exports.LexerATNSimulator || (exports.LexerATNSimulator = {}));
 exports.LexerATNSimulator = LexerATNSimulator;
 
-},{"../Decorators":265,"../IntStream":271,"../Lexer":273,"../LexerNoViableAltException":275,"../Token":290,"../dfa/AcceptStateInfo":362,"../dfa/DFAState":365,"../misc/Interval":377,"./ATN":298,"./ATNConfig":299,"./ATNConfigSet":300,"./ATNSimulator":303,"./LexerActionExecutor":324,"./OrderedATNConfigSet":337,"./PredictionContext":345,"./RuleStopState":351,"assert":408}],324:[function(require,module,exports){
+},{"../Decorators":267,"../IntStream":273,"../Lexer":275,"../LexerNoViableAltException":277,"../Token":292,"../dfa/AcceptStateInfo":364,"../dfa/DFAState":367,"../misc/Interval":379,"./ATN":300,"./ATNConfig":301,"./ATNConfigSet":302,"./ATNSimulator":305,"./LexerActionExecutor":326,"./OrderedATNConfigSet":339,"./PredictionContext":347,"./RuleStopState":353,"assert":410}],326:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59221,7 +60916,7 @@ LexerActionExecutor = __decorate([
 ], LexerActionExecutor);
 exports.LexerActionExecutor = LexerActionExecutor;
 
-},{"../Decorators":265,"../misc/ArrayEqualityComparator":370,"../misc/MurmurHash":380,"./LexerIndexedCustomAction":327}],325:[function(require,module,exports){
+},{"../Decorators":267,"../misc/ArrayEqualityComparator":372,"../misc/MurmurHash":382,"./LexerIndexedCustomAction":329}],327:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59326,7 +61021,7 @@ __decorate([
 ], LexerChannelAction.prototype, "toString", null);
 exports.LexerChannelAction = LexerChannelAction;
 
-},{"../Decorators":265,"../misc/MurmurHash":380}],326:[function(require,module,exports){
+},{"../Decorators":267,"../misc/MurmurHash":382}],328:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59455,7 +61150,7 @@ __decorate([
 ], LexerCustomAction.prototype, "equals", null);
 exports.LexerCustomAction = LexerCustomAction;
 
-},{"../Decorators":265,"../misc/MurmurHash":380}],327:[function(require,module,exports){
+},{"../Decorators":267,"../misc/MurmurHash":382}],329:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59590,7 +61285,7 @@ LexerIndexedCustomAction = __decorate([
 ], LexerIndexedCustomAction);
 exports.LexerIndexedCustomAction = LexerIndexedCustomAction;
 
-},{"../Decorators":265,"../misc/MurmurHash":380}],328:[function(require,module,exports){
+},{"../Decorators":267,"../misc/MurmurHash":382}],330:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59695,7 +61390,7 @@ __decorate([
 ], LexerModeAction.prototype, "toString", null);
 exports.LexerModeAction = LexerModeAction;
 
-},{"../Decorators":265,"../misc/MurmurHash":380}],329:[function(require,module,exports){
+},{"../Decorators":267,"../misc/MurmurHash":382}],331:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59791,7 +61486,7 @@ exports.LexerMoreAction = LexerMoreAction;
     LexerMoreAction.INSTANCE = new LexerMoreAction();
 })(LexerMoreAction = exports.LexerMoreAction || (exports.LexerMoreAction = {}));
 
-},{"../Decorators":265,"../misc/MurmurHash":380}],330:[function(require,module,exports){
+},{"../Decorators":267,"../misc/MurmurHash":382}],332:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59887,7 +61582,7 @@ exports.LexerPopModeAction = LexerPopModeAction;
     LexerPopModeAction.INSTANCE = new LexerPopModeAction();
 })(LexerPopModeAction = exports.LexerPopModeAction || (exports.LexerPopModeAction = {}));
 
-},{"../Decorators":265,"../misc/MurmurHash":380}],331:[function(require,module,exports){
+},{"../Decorators":267,"../misc/MurmurHash":382}],333:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -59992,7 +61687,7 @@ __decorate([
 ], LexerPushModeAction.prototype, "toString", null);
 exports.LexerPushModeAction = LexerPushModeAction;
 
-},{"../Decorators":265,"../misc/MurmurHash":380}],332:[function(require,module,exports){
+},{"../Decorators":267,"../misc/MurmurHash":382}],334:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60088,7 +61783,7 @@ exports.LexerSkipAction = LexerSkipAction;
     LexerSkipAction.INSTANCE = new LexerSkipAction();
 })(LexerSkipAction = exports.LexerSkipAction || (exports.LexerSkipAction = {}));
 
-},{"../Decorators":265,"../misc/MurmurHash":380}],333:[function(require,module,exports){
+},{"../Decorators":267,"../misc/MurmurHash":382}],335:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60192,7 +61887,7 @@ __decorate([
 ], LexerTypeAction.prototype, "toString", null);
 exports.LexerTypeAction = LexerTypeAction;
 
-},{"../Decorators":265,"../misc/MurmurHash":380}],334:[function(require,module,exports){
+},{"../Decorators":267,"../misc/MurmurHash":382}],336:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60244,7 +61939,7 @@ LookaheadEventInfo = __decorate([
 ], LookaheadEventInfo);
 exports.LookaheadEventInfo = LookaheadEventInfo;
 
-},{"../Decorators":265,"./DecisionEventInfo":316}],335:[function(require,module,exports){
+},{"../Decorators":267,"./DecisionEventInfo":318}],337:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60273,7 +61968,7 @@ __decorate([
 ], LoopEndState.prototype, "stateType", null);
 exports.LoopEndState = LoopEndState;
 
-},{"../Decorators":265,"./ATNState":304,"./ATNStateType":305}],336:[function(require,module,exports){
+},{"../Decorators":267,"./ATNState":306,"./ATNStateType":307}],338:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60322,7 +62017,7 @@ NotSetTransition = __decorate([
 ], NotSetTransition);
 exports.NotSetTransition = NotSetTransition;
 
-},{"../Decorators":265,"./SetTransition":354}],337:[function(require,module,exports){
+},{"../Decorators":267,"./SetTransition":356}],339:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60377,7 +62072,7 @@ __decorate([
 ], OrderedATNConfigSet.prototype, "canMerge", null);
 exports.OrderedATNConfigSet = OrderedATNConfigSet;
 
-},{"../Decorators":265,"./ATNConfigSet":300}],338:[function(require,module,exports){
+},{"../Decorators":267,"./ATNConfigSet":302}],340:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -60539,7 +62234,7 @@ ParseInfo = __decorate([
 ], ParseInfo);
 exports.ParseInfo = ParseInfo;
 
-},{"../Decorators":265}],339:[function(require,module,exports){
+},{"../Decorators":267}],341:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -62812,7 +64507,7 @@ ParserATNSimulator = __decorate([
 ], ParserATNSimulator);
 exports.ParserATNSimulator = ParserATNSimulator;
 
-},{"../Decorators":265,"../IntStream":271,"../NoViableAltException":277,"../ParserRuleContext":281,"../Token":290,"../VocabularyImpl":296,"../dfa/AcceptStateInfo":362,"../dfa/DFAState":365,"../misc/Array2DHashSet":369,"../misc/Arrays":371,"../misc/BitSet":372,"../misc/IntegerList":375,"../misc/Interval":377,"../misc/ObjectEqualityComparator":381,"./ATN":298,"./ATNConfig":299,"./ATNConfigSet":300,"./ATNSimulator":303,"./ATNStateType":305,"./ActionTransition":307,"./AtomTransition":309,"./ConflictInfo":314,"./DecisionState":318,"./NotSetTransition":336,"./PredictionContext":345,"./PredictionContextCache":346,"./PredictionMode":347,"./RuleStopState":351,"./RuleTransition":352,"./SemanticContext":353,"./SetTransition":354,"./SimulatorState":355,"assert":408}],340:[function(require,module,exports){
+},{"../Decorators":267,"../IntStream":273,"../NoViableAltException":279,"../ParserRuleContext":283,"../Token":292,"../VocabularyImpl":298,"../dfa/AcceptStateInfo":364,"../dfa/DFAState":367,"../misc/Array2DHashSet":371,"../misc/Arrays":373,"../misc/BitSet":374,"../misc/IntegerList":377,"../misc/Interval":379,"../misc/ObjectEqualityComparator":383,"./ATN":300,"./ATNConfig":301,"./ATNConfigSet":302,"./ATNSimulator":305,"./ATNStateType":307,"./ActionTransition":309,"./AtomTransition":311,"./ConflictInfo":316,"./DecisionState":320,"./NotSetTransition":338,"./PredictionContext":347,"./PredictionContextCache":348,"./PredictionMode":349,"./RuleStopState":353,"./RuleTransition":354,"./SemanticContext":355,"./SetTransition":356,"./SimulatorState":357,"assert":410}],342:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -62845,7 +64540,7 @@ __decorate([
 ], PlusBlockStartState.prototype, "stateType", null);
 exports.PlusBlockStartState = PlusBlockStartState;
 
-},{"../Decorators":265,"./ATNStateType":305,"./BlockStartState":313}],341:[function(require,module,exports){
+},{"../Decorators":267,"./ATNStateType":307,"./BlockStartState":315}],343:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -62876,7 +64571,7 @@ __decorate([
 ], PlusLoopbackState.prototype, "stateType", null);
 exports.PlusLoopbackState = PlusLoopbackState;
 
-},{"../Decorators":265,"./ATNStateType":305,"./DecisionState":318}],342:[function(require,module,exports){
+},{"../Decorators":267,"./ATNStateType":307,"./DecisionState":320}],344:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -62939,7 +64634,7 @@ PrecedencePredicateTransition = __decorate([
 ], PrecedencePredicateTransition);
 exports.PrecedencePredicateTransition = PrecedencePredicateTransition;
 
-},{"../Decorators":265,"./AbstractPredicateTransition":306,"./SemanticContext":353}],343:[function(require,module,exports){
+},{"../Decorators":267,"./AbstractPredicateTransition":308,"./SemanticContext":355}],345:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -63002,7 +64697,7 @@ PredicateEvalInfo = __decorate([
 ], PredicateEvalInfo);
 exports.PredicateEvalInfo = PredicateEvalInfo;
 
-},{"../Decorators":265,"./DecisionEventInfo":316}],344:[function(require,module,exports){
+},{"../Decorators":267,"./DecisionEventInfo":318}],346:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -63068,7 +64763,7 @@ PredicateTransition = __decorate([
 ], PredicateTransition);
 exports.PredicateTransition = PredicateTransition;
 
-},{"../Decorators":265,"./AbstractPredicateTransition":306,"./SemanticContext":353}],345:[function(require,module,exports){
+},{"../Decorators":267,"./AbstractPredicateTransition":308,"./SemanticContext":355}],347:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -63759,7 +65454,7 @@ exports.SingletonPredictionContext = SingletonPredictionContext;
     PredictionContext.IdentityEqualityComparator = IdentityEqualityComparator;
 })(PredictionContext = exports.PredictionContext || (exports.PredictionContext = {}));
 
-},{"../Decorators":265,"../misc/Array2DHashMap":368,"../misc/Array2DHashSet":369,"../misc/Arrays":371,"../misc/MurmurHash":380,"./PredictionContextCache":346,"assert":408}],346:[function(require,module,exports){
+},{"../Decorators":267,"../misc/Array2DHashMap":370,"../misc/Array2DHashSet":371,"../misc/Arrays":373,"../misc/MurmurHash":382,"./PredictionContextCache":348,"assert":410}],348:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -63900,7 +65595,7 @@ PredictionContextCache.UNCACHED = new PredictionContextCache(false);
     PredictionContextCache.IdentityCommutativePredictionContextOperands = IdentityCommutativePredictionContextOperands;
 })(PredictionContextCache = exports.PredictionContextCache || (exports.PredictionContextCache = {}));
 
-},{"../Decorators":265,"../misc/Array2DHashMap":368,"../misc/ObjectEqualityComparator":381,"./PredictionContext":345,"assert":408}],347:[function(require,module,exports){
+},{"../Decorators":267,"../misc/Array2DHashMap":370,"../misc/ObjectEqualityComparator":383,"./PredictionContext":347,"assert":410}],349:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -64061,7 +65756,7 @@ var PredictionMode;
     PredictionMode.allConfigsInRuleStopStates = allConfigsInRuleStopStates;
 })(PredictionMode = exports.PredictionMode || (exports.PredictionMode = {}));
 
-},{"../Decorators":265,"../misc/Array2DHashMap":368,"../misc/MurmurHash":380,"./RuleStopState":351}],348:[function(require,module,exports){
+},{"../Decorators":267,"../misc/Array2DHashMap":370,"../misc/MurmurHash":382,"./RuleStopState":353}],350:[function(require,module,exports){
 (function (process){(function (){
 "use strict";
 /*!
@@ -64330,7 +66025,7 @@ __decorate([
 exports.ProfilingATNSimulator = ProfilingATNSimulator;
 
 }).call(this)}).call(this,require('_process'))
-},{"../Decorators":265,"./ATN":298,"./ATNSimulator":303,"./AmbiguityInfo":308,"./ContextSensitivityInfo":315,"./DecisionInfo":317,"./ErrorInfo":320,"./LookaheadEventInfo":334,"./ParserATNSimulator":339,"./PredicateEvalInfo":343,"./SemanticContext":353,"./SimulatorState":355,"_process":467}],349:[function(require,module,exports){
+},{"../Decorators":267,"./ATN":300,"./ATNSimulator":305,"./AmbiguityInfo":310,"./ContextSensitivityInfo":317,"./DecisionInfo":319,"./ErrorInfo":322,"./LookaheadEventInfo":336,"./ParserATNSimulator":341,"./PredicateEvalInfo":345,"./SemanticContext":355,"./SimulatorState":357,"_process":469}],351:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -64388,7 +66083,7 @@ RangeTransition = __decorate([
 ], RangeTransition);
 exports.RangeTransition = RangeTransition;
 
-},{"../Decorators":265,"../misc/IntervalSet":378,"./Transition":360}],350:[function(require,module,exports){
+},{"../Decorators":267,"../misc/IntervalSet":380,"./Transition":362}],352:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -64421,7 +66116,7 @@ __decorate([
 ], RuleStartState.prototype, "stateType", null);
 exports.RuleStartState = RuleStartState;
 
-},{"../Decorators":265,"./ATNState":304,"./ATNStateType":305}],351:[function(require,module,exports){
+},{"../Decorators":267,"./ATNState":306,"./ATNStateType":307}],353:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -64460,7 +66155,7 @@ __decorate([
 ], RuleStopState.prototype, "stateType", null);
 exports.RuleStopState = RuleStopState;
 
-},{"../Decorators":265,"./ATNState":304,"./ATNStateType":305}],352:[function(require,module,exports){
+},{"../Decorators":267,"./ATNState":306,"./ATNStateType":307}],354:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -64516,7 +66211,7 @@ RuleTransition = __decorate([
 ], RuleTransition);
 exports.RuleTransition = RuleTransition;
 
-},{"../Decorators":265,"./Transition":360}],353:[function(require,module,exports){
+},{"../Decorators":267,"./Transition":362}],355:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -64996,7 +66691,7 @@ exports.SemanticContext = SemanticContext;
     SemanticContext.OR = OR;
 })(SemanticContext = exports.SemanticContext || (exports.SemanticContext = {}));
 
-},{"../Decorators":265,"../misc/Array2DHashSet":369,"../misc/ArrayEqualityComparator":370,"../misc/MurmurHash":380,"../misc/ObjectEqualityComparator":381,"../misc/Utils":384}],354:[function(require,module,exports){
+},{"../Decorators":267,"../misc/Array2DHashSet":371,"../misc/ArrayEqualityComparator":372,"../misc/MurmurHash":382,"../misc/ObjectEqualityComparator":383,"../misc/Utils":386}],356:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65062,7 +66757,7 @@ SetTransition = __decorate([
 ], SetTransition);
 exports.SetTransition = SetTransition;
 
-},{"../Decorators":265,"../Token":290,"../misc/IntervalSet":378,"./Transition":360}],355:[function(require,module,exports){
+},{"../Decorators":267,"../Token":292,"../misc/IntervalSet":380,"./Transition":362}],357:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65098,7 +66793,7 @@ SimulatorState = __decorate([
 ], SimulatorState);
 exports.SimulatorState = SimulatorState;
 
-},{"../Decorators":265,"../ParserRuleContext":281}],356:[function(require,module,exports){
+},{"../Decorators":267,"../ParserRuleContext":283}],358:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65126,7 +66821,7 @@ __decorate([
 ], StarBlockStartState.prototype, "stateType", null);
 exports.StarBlockStartState = StarBlockStartState;
 
-},{"../Decorators":265,"./ATNStateType":305,"./BlockStartState":313}],357:[function(require,module,exports){
+},{"../Decorators":267,"./ATNStateType":307,"./BlockStartState":315}],359:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65183,7 +66878,7 @@ __decorate([
 ], StarLoopEntryState.prototype, "stateType", null);
 exports.StarLoopEntryState = StarLoopEntryState;
 
-},{"../Decorators":265,"../misc/BitSet":372,"./ATNStateType":305,"./DecisionState":318}],358:[function(require,module,exports){
+},{"../Decorators":267,"../misc/BitSet":374,"./ATNStateType":307,"./DecisionState":320}],360:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65214,7 +66909,7 @@ __decorate([
 ], StarLoopbackState.prototype, "stateType", null);
 exports.StarLoopbackState = StarLoopbackState;
 
-},{"../Decorators":265,"./ATNState":304,"./ATNStateType":305}],359:[function(require,module,exports){
+},{"../Decorators":267,"./ATNState":306,"./ATNStateType":307}],361:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65243,7 +66938,7 @@ __decorate([
 ], TokensStartState.prototype, "stateType", null);
 exports.TokensStartState = TokensStartState;
 
-},{"../Decorators":265,"./ATNStateType":305,"./DecisionState":318}],360:[function(require,module,exports){
+},{"../Decorators":267,"./ATNStateType":307,"./DecisionState":320}],362:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65317,7 +67012,7 @@ Transition = __decorate([
 ], Transition);
 exports.Transition = Transition;
 
-},{"../Decorators":265}],361:[function(require,module,exports){
+},{"../Decorators":267}],363:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65365,7 +67060,7 @@ WildcardTransition = __decorate([
 ], WildcardTransition);
 exports.WildcardTransition = WildcardTransition;
 
-},{"../Decorators":265,"./Transition":360}],362:[function(require,module,exports){
+},{"../Decorators":267,"./Transition":362}],364:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65407,7 +67102,7 @@ class AcceptStateInfo {
 }
 exports.AcceptStateInfo = AcceptStateInfo;
 
-},{}],363:[function(require,module,exports){
+},{}],365:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65582,7 +67277,7 @@ DFA = __decorate([
 ], DFA);
 exports.DFA = DFA;
 
-},{"../Decorators":265,"../VocabularyImpl":296,"../atn/ATNConfigSet":300,"../atn/StarLoopEntryState":357,"../misc/Array2DHashSet":369,"../misc/ObjectEqualityComparator":381,"./DFASerializer":364,"./DFAState":365,"./LexerDFASerializer":366}],364:[function(require,module,exports){
+},{"../Decorators":267,"../VocabularyImpl":298,"../atn/ATNConfigSet":302,"../atn/StarLoopEntryState":359,"../misc/Array2DHashSet":371,"../misc/ObjectEqualityComparator":383,"./DFASerializer":366,"./DFAState":367,"./LexerDFASerializer":368}],366:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65724,7 +67419,7 @@ __decorate([
 ], DFASerializer.prototype, "toString", null);
 exports.DFASerializer = DFASerializer;
 
-},{"../Decorators":265,"../Recognizer":285,"../VocabularyImpl":296,"../atn/ATNSimulator":303,"../atn/PredictionContext":345}],365:[function(require,module,exports){
+},{"../Decorators":267,"../Recognizer":287,"../VocabularyImpl":298,"../atn/ATNSimulator":305,"../atn/PredictionContext":347}],367:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65955,7 +67650,7 @@ exports.DFAState = DFAState;
     DFAState.PredPrediction = PredPrediction;
 })(DFAState = exports.DFAState || (exports.DFAState = {}));
 
-},{"../Decorators":265,"../atn/ATN":298,"../atn/PredictionContext":345,"../misc/BitSet":372,"../misc/MurmurHash":380,"assert":408}],366:[function(require,module,exports){
+},{"../Decorators":267,"../atn/ATN":300,"../atn/PredictionContext":347,"../misc/BitSet":374,"../misc/MurmurHash":382,"assert":410}],368:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -65992,7 +67687,7 @@ LexerDFASerializer = __decorate([
 ], LexerDFASerializer);
 exports.LexerDFASerializer = LexerDFASerializer;
 
-},{"../Decorators":265,"../VocabularyImpl":296,"./DFASerializer":364}],367:[function(require,module,exports){
+},{"../Decorators":267,"../VocabularyImpl":298,"./DFASerializer":366}],369:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -66058,7 +67753,7 @@ __exportStar(require("./Vocabulary"), exports);
 __exportStar(require("./VocabularyImpl"), exports);
 __exportStar(require("./WritableToken"), exports);
 
-},{"./ANTLRErrorListener":252,"./ANTLRErrorStrategy":253,"./ANTLRInputStream":254,"./BailErrorStrategy":255,"./BufferedTokenStream":256,"./CharStream":257,"./CharStreams":258,"./CodePointBuffer":259,"./CodePointCharStream":260,"./CommonToken":261,"./CommonTokenFactory":262,"./CommonTokenStream":263,"./ConsoleErrorListener":264,"./DefaultErrorStrategy":266,"./Dependents":267,"./DiagnosticErrorListener":268,"./FailedPredicateException":269,"./InputMismatchException":270,"./IntStream":271,"./InterpreterRuleContext":272,"./Lexer":273,"./LexerInterpreter":274,"./LexerNoViableAltException":275,"./ListTokenSource":276,"./NoViableAltException":277,"./Parser":278,"./ParserErrorListener":279,"./ParserInterpreter":280,"./ParserRuleContext":281,"./ProxyErrorListener":282,"./ProxyParserErrorListener":283,"./RecognitionException":284,"./Recognizer":285,"./RuleContext":286,"./RuleContextWithAltNum":287,"./RuleDependency":288,"./RuleVersion":289,"./Token":290,"./TokenFactory":291,"./TokenSource":292,"./TokenStream":293,"./TokenStreamRewriter":294,"./Vocabulary":295,"./VocabularyImpl":296,"./WritableToken":297}],368:[function(require,module,exports){
+},{"./ANTLRErrorListener":254,"./ANTLRErrorStrategy":255,"./ANTLRInputStream":256,"./BailErrorStrategy":257,"./BufferedTokenStream":258,"./CharStream":259,"./CharStreams":260,"./CodePointBuffer":261,"./CodePointCharStream":262,"./CommonToken":263,"./CommonTokenFactory":264,"./CommonTokenStream":265,"./ConsoleErrorListener":266,"./DefaultErrorStrategy":268,"./Dependents":269,"./DiagnosticErrorListener":270,"./FailedPredicateException":271,"./InputMismatchException":272,"./IntStream":273,"./InterpreterRuleContext":274,"./Lexer":275,"./LexerInterpreter":276,"./LexerNoViableAltException":277,"./ListTokenSource":278,"./NoViableAltException":279,"./Parser":280,"./ParserErrorListener":281,"./ParserInterpreter":282,"./ParserRuleContext":283,"./ProxyErrorListener":284,"./ProxyParserErrorListener":285,"./RecognitionException":286,"./Recognizer":287,"./RuleContext":288,"./RuleContextWithAltNum":289,"./RuleDependency":290,"./RuleVersion":291,"./Token":292,"./TokenFactory":293,"./TokenSource":294,"./TokenStream":295,"./TokenStreamRewriter":296,"./Vocabulary":297,"./VocabularyImpl":298,"./WritableToken":299}],370:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -66141,7 +67836,7 @@ class Array2DHashMap {
 }
 exports.Array2DHashMap = Array2DHashMap;
 
-},{"./Array2DHashSet":369}],369:[function(require,module,exports){
+},{"./Array2DHashSet":371}],371:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -66508,7 +68203,7 @@ __decorate([
 ], Array2DHashSet.prototype, "createBuckets", null);
 exports.Array2DHashSet = Array2DHashSet;
 
-},{"../Decorators":265,"./DefaultEqualityComparator":374,"./MurmurHash":380,"assert":408}],370:[function(require,module,exports){
+},{"../Decorators":267,"./DefaultEqualityComparator":376,"./MurmurHash":382,"assert":410}],372:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -66580,7 +68275,7 @@ __decorate([
 ], ArrayEqualityComparator.prototype, "equals", null);
 exports.ArrayEqualityComparator = ArrayEqualityComparator;
 
-},{"../Decorators":265,"./MurmurHash":380,"./ObjectEqualityComparator":381}],371:[function(require,module,exports){
+},{"../Decorators":267,"./MurmurHash":382,"./ObjectEqualityComparator":383}],373:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -66650,7 +68345,7 @@ var Arrays;
     Arrays.toString = toString;
 })(Arrays = exports.Arrays || (exports.Arrays = {}));
 
-},{}],372:[function(require,module,exports){
+},{}],374:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -67322,7 +69017,7 @@ class BitSetIterator {
     [Symbol.iterator]() { return this; }
 }
 
-},{"./MurmurHash":380,"util":473}],373:[function(require,module,exports){
+},{"./MurmurHash":382,"util":475}],375:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -67343,7 +69038,7 @@ function isSupplementaryCodePoint(ch) {
 }
 exports.isSupplementaryCodePoint = isSupplementaryCodePoint;
 
-},{}],374:[function(require,module,exports){
+},{}],376:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -67414,7 +69109,7 @@ __decorate([
 ], DefaultEqualityComparator.prototype, "equals", null);
 exports.DefaultEqualityComparator = DefaultEqualityComparator;
 
-},{"../Decorators":265,"./MurmurHash":380,"./ObjectEqualityComparator":381}],375:[function(require,module,exports){
+},{"../Decorators":267,"./MurmurHash":382,"./ObjectEqualityComparator":383}],377:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -67708,7 +69403,7 @@ __decorate([
 ], IntegerList.prototype, "toString", null);
 exports.IntegerList = IntegerList;
 
-},{"../Decorators":265,"./Arrays":371}],376:[function(require,module,exports){
+},{"../Decorators":267,"./Arrays":373}],378:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -67738,7 +69433,7 @@ class IntegerStack extends IntegerList_1.IntegerList {
 }
 exports.IntegerStack = IntegerStack;
 
-},{"./IntegerList":375}],377:[function(require,module,exports){
+},{"./IntegerList":377}],379:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -67881,7 +69576,7 @@ __decorate([
 ], Interval.prototype, "toString", null);
 exports.Interval = Interval;
 
-},{"../Decorators":265}],378:[function(require,module,exports){
+},{"../Decorators":267}],380:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -68527,7 +70222,7 @@ __decorate([
 ], IntervalSet, "subtract", null);
 exports.IntervalSet = IntervalSet;
 
-},{"../Decorators":265,"../Lexer":273,"../Token":290,"./ArrayEqualityComparator":370,"./IntegerList":375,"./Interval":377,"./MurmurHash":380}],379:[function(require,module,exports){
+},{"../Decorators":267,"../Lexer":275,"../Token":292,"./ArrayEqualityComparator":372,"./IntegerList":377,"./Interval":379,"./MurmurHash":382}],381:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -68560,7 +70255,7 @@ class MultiMap extends Map {
 }
 exports.MultiMap = MultiMap;
 
-},{}],380:[function(require,module,exports){
+},{}],382:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -68675,7 +70370,7 @@ var MurmurHash;
     }
 })(MurmurHash = exports.MurmurHash || (exports.MurmurHash = {}));
 
-},{}],381:[function(require,module,exports){
+},{}],383:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -68734,7 +70429,7 @@ __decorate([
 ], ObjectEqualityComparator.prototype, "equals", null);
 exports.ObjectEqualityComparator = ObjectEqualityComparator;
 
-},{"../Decorators":265}],382:[function(require,module,exports){
+},{"../Decorators":267}],384:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -68763,7 +70458,7 @@ class ParseCancellationException extends Error {
 }
 exports.ParseCancellationException = ParseCancellationException;
 
-},{}],383:[function(require,module,exports){
+},{}],385:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -68817,7 +70512,7 @@ class UUID {
 }
 exports.UUID = UUID;
 
-},{"./MurmurHash":380}],384:[function(require,module,exports){
+},{"./MurmurHash":382}],386:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -68992,7 +70687,7 @@ exports.toCharArray = toCharArray;
 // 	return s;
 // }
 
-},{}],385:[function(require,module,exports){
+},{}],387:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -69028,7 +70723,7 @@ __decorate([
 ], ErrorNode.prototype, "accept", null);
 exports.ErrorNode = ErrorNode;
 
-},{"../Decorators":265,"./TerminalNode":388}],386:[function(require,module,exports){
+},{"../Decorators":267,"./TerminalNode":390}],388:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -69133,7 +70828,7 @@ exports.ParseTreeWalker = ParseTreeWalker;
     ParseTreeWalker.DEFAULT = new ParseTreeWalker();
 })(ParseTreeWalker = exports.ParseTreeWalker || (exports.ParseTreeWalker = {}));
 
-},{"./ErrorNode":385,"./RuleNode":387,"./TerminalNode":388}],387:[function(require,module,exports){
+},{"./ErrorNode":387,"./RuleNode":389,"./TerminalNode":390}],389:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -69145,7 +70840,7 @@ class RuleNode {
 }
 exports.RuleNode = RuleNode;
 
-},{}],388:[function(require,module,exports){
+},{}],390:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -69237,7 +70932,7 @@ __decorate([
 ], TerminalNode.prototype, "toString", null);
 exports.TerminalNode = TerminalNode;
 
-},{"../Decorators":265,"../Token":290,"../misc/Interval":377}],389:[function(require,module,exports){
+},{"../Decorators":267,"../Token":292,"../misc/Interval":379}],391:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -69481,7 +71176,7 @@ __decorate([
 ], Trees, "getRootOfSubtreeEnclosingRegion", null);
 exports.Trees = Trees;
 
-},{"../CommonToken":261,"../Decorators":265,"../Parser":278,"../ParserRuleContext":281,"../Token":290,"../atn/ATN":298,"../misc/Utils":384,"./ErrorNode":385,"./RuleNode":387,"./TerminalNode":388}],390:[function(require,module,exports){
+},{"../CommonToken":263,"../Decorators":267,"../Parser":280,"../ParserRuleContext":283,"../Token":292,"../atn/ATN":300,"../misc/Utils":386,"./ErrorNode":387,"./RuleNode":389,"./TerminalNode":390}],392:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -69505,7 +71200,7 @@ class Chunk {
 }
 exports.Chunk = Chunk;
 
-},{}],391:[function(require,module,exports){
+},{}],393:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -69685,7 +71380,7 @@ ParseTreeMatch = __decorate([
 ], ParseTreeMatch);
 exports.ParseTreeMatch = ParseTreeMatch;
 
-},{"../../Decorators":265}],392:[function(require,module,exports){
+},{"../../Decorators":267}],394:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -69843,7 +71538,7 @@ ParseTreePattern = __decorate([
 ], ParseTreePattern);
 exports.ParseTreePattern = ParseTreePattern;
 
-},{"../../Decorators":265,"../xpath/XPath":398}],393:[function(require,module,exports){
+},{"../../Decorators":267,"../xpath/XPath":400}],395:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -70321,7 +72016,7 @@ exports.ParseTreePatternMatcher = ParseTreePatternMatcher;
     ParseTreePatternMatcher.StartRuleDoesNotConsumeFullPattern = StartRuleDoesNotConsumeFullPattern;
 })(ParseTreePatternMatcher = exports.ParseTreePatternMatcher || (exports.ParseTreePatternMatcher = {}));
 
-},{"../../BailErrorStrategy":255,"../../CharStreams":258,"../../CommonTokenStream":263,"../../Decorators":265,"../../ListTokenSource":276,"../../ParserInterpreter":280,"../../ParserRuleContext":281,"../../RecognitionException":284,"../../Token":290,"../../misc/MultiMap":379,"../../misc/ParseCancellationException":382,"../RuleNode":387,"../TerminalNode":388,"./ParseTreeMatch":391,"./ParseTreePattern":392,"./RuleTagToken":394,"./TagChunk":395,"./TextChunk":396,"./TokenTagToken":397}],394:[function(require,module,exports){
+},{"../../BailErrorStrategy":257,"../../CharStreams":260,"../../CommonTokenStream":265,"../../Decorators":267,"../../ListTokenSource":278,"../../ParserInterpreter":282,"../../ParserRuleContext":283,"../../RecognitionException":286,"../../Token":292,"../../misc/MultiMap":381,"../../misc/ParseCancellationException":384,"../RuleNode":389,"../TerminalNode":390,"./ParseTreeMatch":393,"./ParseTreePattern":394,"./RuleTagToken":396,"./TagChunk":397,"./TextChunk":398,"./TokenTagToken":399}],396:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -70519,7 +72214,7 @@ RuleTagToken = __decorate([
 ], RuleTagToken);
 exports.RuleTagToken = RuleTagToken;
 
-},{"../../Decorators":265,"../../Token":290}],395:[function(require,module,exports){
+},{"../../Decorators":267,"../../Token":292}],397:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -70606,7 +72301,7 @@ __decorate([
 ], TagChunk.prototype, "toString", null);
 exports.TagChunk = TagChunk;
 
-},{"../../Decorators":265,"./Chunk":390}],396:[function(require,module,exports){
+},{"../../Decorators":267,"./Chunk":392}],398:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -70676,7 +72371,7 @@ TextChunk = __decorate([
 ], TextChunk);
 exports.TextChunk = TextChunk;
 
-},{"../../Decorators":265,"./Chunk":390}],397:[function(require,module,exports){
+},{"../../Decorators":267,"./Chunk":392}],399:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -70771,7 +72466,7 @@ TokenTagToken = __decorate([
 ], TokenTagToken);
 exports.TokenTagToken = TokenTagToken;
 
-},{"../../CommonToken":261,"../../Decorators":265}],398:[function(require,module,exports){
+},{"../../CommonToken":263,"../../Decorators":267}],400:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -70968,7 +72663,7 @@ exports.XPath = XPath;
 XPath.WILDCARD = "*"; // word not operator/separator
 XPath.NOT = "!"; // word for invert operator
 
-},{"../../CharStreams":258,"../../CommonTokenStream":263,"../../LexerNoViableAltException":275,"../../ParserRuleContext":281,"../../Token":290,"./XPathLexer":400,"./XPathLexerErrorListener":401,"./XPathRuleAnywhereElement":402,"./XPathRuleElement":403,"./XPathTokenAnywhereElement":404,"./XPathTokenElement":405,"./XPathWildcardAnywhereElement":406,"./XPathWildcardElement":407}],399:[function(require,module,exports){
+},{"../../CharStreams":260,"../../CommonTokenStream":265,"../../LexerNoViableAltException":277,"../../ParserRuleContext":283,"../../Token":292,"./XPathLexer":402,"./XPathLexerErrorListener":403,"./XPathRuleAnywhereElement":404,"./XPathRuleElement":405,"./XPathTokenAnywhereElement":406,"./XPathTokenElement":407,"./XPathWildcardAnywhereElement":408,"./XPathWildcardElement":409}],401:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -71003,7 +72698,7 @@ __decorate([
 ], XPathElement.prototype, "toString", null);
 exports.XPathElement = XPathElement;
 
-},{"../../Decorators":265}],400:[function(require,module,exports){
+},{"../../Decorators":267}],402:[function(require,module,exports){
 "use strict";
 // Generated from XPathLexer.g4 by ANTLR 4.9.0-SNAPSHOT
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -71478,7 +73173,7 @@ XPathLexer._serializedATN = Utils.join([
     XPathLexer._serializedATNSegment1,
 ], "");
 
-},{"../../Lexer":273,"../../VocabularyImpl":296,"../../atn/ATNDeserializer":302,"../../atn/LexerATNSimulator":323,"../../misc/Utils":384}],401:[function(require,module,exports){
+},{"../../Lexer":275,"../../VocabularyImpl":298,"../../atn/ATNDeserializer":304,"../../atn/LexerATNSimulator":325,"../../misc/Utils":386}],403:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -71503,7 +73198,7 @@ __decorate([
 ], XPathLexerErrorListener.prototype, "syntaxError", null);
 exports.XPathLexerErrorListener = XPathLexerErrorListener;
 
-},{"../../Decorators":265}],402:[function(require,module,exports){
+},{"../../Decorators":267}],404:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -71537,7 +73232,7 @@ __decorate([
 ], XPathRuleAnywhereElement.prototype, "evaluate", null);
 exports.XPathRuleAnywhereElement = XPathRuleAnywhereElement;
 
-},{"../../Decorators":265,"../Trees":389,"./XPathElement":399}],403:[function(require,module,exports){
+},{"../../Decorators":267,"../Trees":391,"./XPathElement":401}],405:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -71580,7 +73275,7 @@ __decorate([
 ], XPathRuleElement.prototype, "evaluate", null);
 exports.XPathRuleElement = XPathRuleElement;
 
-},{"../../Decorators":265,"../../ParserRuleContext":281,"../Trees":389,"./XPathElement":399}],404:[function(require,module,exports){
+},{"../../Decorators":267,"../../ParserRuleContext":283,"../Trees":391,"./XPathElement":401}],406:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -71612,7 +73307,7 @@ __decorate([
 ], XPathTokenAnywhereElement.prototype, "evaluate", null);
 exports.XPathTokenAnywhereElement = XPathTokenAnywhereElement;
 
-},{"../../Decorators":265,"../Trees":389,"./XPathElement":399}],405:[function(require,module,exports){
+},{"../../Decorators":267,"../Trees":391,"./XPathElement":401}],407:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -71655,7 +73350,7 @@ __decorate([
 ], XPathTokenElement.prototype, "evaluate", null);
 exports.XPathTokenElement = XPathTokenElement;
 
-},{"../../Decorators":265,"../TerminalNode":388,"../Trees":389,"./XPathElement":399}],406:[function(require,module,exports){
+},{"../../Decorators":267,"../TerminalNode":390,"../Trees":391,"./XPathElement":401}],408:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -71691,7 +73386,7 @@ __decorate([
 ], XPathWildcardAnywhereElement.prototype, "evaluate", null);
 exports.XPathWildcardAnywhereElement = XPathWildcardAnywhereElement;
 
-},{"../../Decorators":265,"../Trees":389,"./XPath":398,"./XPathElement":399}],407:[function(require,module,exports){
+},{"../../Decorators":267,"../Trees":391,"./XPath":400,"./XPathElement":401}],409:[function(require,module,exports){
 "use strict";
 /*!
  * Copyright 2016 The ANTLR Project. All rights reserved.
@@ -71731,7 +73426,7 @@ __decorate([
 ], XPathWildcardElement.prototype, "evaluate", null);
 exports.XPathWildcardElement = XPathWildcardElement;
 
-},{"../../Decorators":265,"../Trees":389,"./XPath":398,"./XPathElement":399}],408:[function(require,module,exports){
+},{"../../Decorators":267,"../Trees":391,"./XPath":400,"./XPathElement":401}],410:[function(require,module,exports){
 (function (global){(function (){
 'use strict';
 
@@ -72241,7 +73936,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":465,"util/":411}],409:[function(require,module,exports){
+},{"object.assign/polyfill":467,"util/":413}],411:[function(require,module,exports){
 if (typeof Object.create === 'function') {
   // implementation from standard node.js 'util' module
   module.exports = function inherits(ctor, superCtor) {
@@ -72266,14 +73961,14 @@ if (typeof Object.create === 'function') {
   }
 }
 
-},{}],410:[function(require,module,exports){
+},{}],412:[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';
 }
-},{}],411:[function(require,module,exports){
+},{}],413:[function(require,module,exports){
 (function (process,global){(function (){
 // Copyright Joyent, Inc. and other Node contributors.
 //
@@ -72863,7 +74558,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":410,"_process":467,"inherits":409}],412:[function(require,module,exports){
+},{"./support/isBuffer":412,"_process":469,"inherits":411}],414:[function(require,module,exports){
 (function (global){(function (){
 'use strict';
 
@@ -72884,7 +74579,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":466}],413:[function(require,module,exports){
+},{"possible-typed-array-names":468}],415:[function(require,module,exports){
 (function (process,global){(function (){
 module.exports = process.hrtime || hrtime
 
@@ -72915,7 +74610,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":467}],414:[function(require,module,exports){
+},{"_process":469}],416:[function(require,module,exports){
 'use strict';
 
 var bind = require('function-bind');
@@ -72927,7 +74622,7 @@ var $reflectApply = require('./reflectApply');
 /** @type {import('./actualApply')} */
 module.exports = $reflectApply || bind.call($call, $apply);
 
-},{"./functionApply":416,"./functionCall":417,"./reflectApply":419,"function-bind":435}],415:[function(require,module,exports){
+},{"./functionApply":418,"./functionCall":419,"./reflectApply":421,"function-bind":437}],417:[function(require,module,exports){
 'use strict';
 
 var bind = require('function-bind');
@@ -72939,19 +74634,19 @@ module.exports = function applyBind() {
 	return actualApply(bind, $apply, arguments);
 };
 
-},{"./actualApply":414,"./functionApply":416,"function-bind":435}],416:[function(require,module,exports){
+},{"./actualApply":416,"./functionApply":418,"function-bind":437}],418:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./functionApply')} */
 module.exports = Function.prototype.apply;
 
-},{}],417:[function(require,module,exports){
+},{}],419:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./functionCall')} */
 module.exports = Function.prototype.call;
 
-},{}],418:[function(require,module,exports){
+},{}],420:[function(require,module,exports){
 'use strict';
 
 var bind = require('function-bind');
@@ -72968,13 +74663,13 @@ module.exports = function callBindBasic(args) {
 	return $actualApply(bind, $call, args);
 };
 
-},{"./actualApply":414,"./functionCall":417,"es-errors/type":430,"function-bind":435}],419:[function(require,module,exports){
+},{"./actualApply":416,"./functionCall":419,"es-errors/type":432,"function-bind":437}],421:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./reflectApply')} */
 module.exports = typeof Reflect !== 'undefined' && Reflect && Reflect.apply;
 
-},{}],420:[function(require,module,exports){
+},{}],422:[function(require,module,exports){
 'use strict';
 
 var setFunctionLength = require('set-function-length');
@@ -73000,7 +74695,7 @@ if ($defineProperty) {
 	module.exports.apply = applyBind;
 }
 
-},{"call-bind-apply-helpers":418,"call-bind-apply-helpers/applyBind":415,"es-define-property":424,"set-function-length":469}],421:[function(require,module,exports){
+},{"call-bind-apply-helpers":420,"call-bind-apply-helpers/applyBind":417,"es-define-property":426,"set-function-length":471}],423:[function(require,module,exports){
 'use strict';
 
 var GetIntrinsic = require('get-intrinsic');
@@ -73021,7 +74716,7 @@ module.exports = function callBoundIntrinsic(name, allowMissing) {
 	return intrinsic;
 };
 
-},{"call-bind-apply-helpers":418,"get-intrinsic":436}],422:[function(require,module,exports){
+},{"call-bind-apply-helpers":420,"get-intrinsic":438}],424:[function(require,module,exports){
 'use strict';
 
 var $defineProperty = require('es-define-property');
@@ -73079,7 +74774,7 @@ module.exports = function defineDataProperty(
 	}
 };
 
-},{"es-define-property":424,"es-errors/syntax":429,"es-errors/type":430,"gopd":441}],423:[function(require,module,exports){
+},{"es-define-property":426,"es-errors/syntax":431,"es-errors/type":432,"gopd":443}],425:[function(require,module,exports){
 'use strict';
 
 var callBind = require('call-bind-apply-helpers');
@@ -73111,7 +74806,7 @@ module.exports = desc && typeof desc.get === 'function'
 		}
 		: false;
 
-},{"call-bind-apply-helpers":418,"gopd":441}],424:[function(require,module,exports){
+},{"call-bind-apply-helpers":420,"gopd":443}],426:[function(require,module,exports){
 'use strict';
 
 /** @type {import('.')} */
@@ -73127,55 +74822,55 @@ if ($defineProperty) {
 
 module.exports = $defineProperty;
 
-},{}],425:[function(require,module,exports){
+},{}],427:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./eval')} */
 module.exports = EvalError;
 
-},{}],426:[function(require,module,exports){
+},{}],428:[function(require,module,exports){
 'use strict';
 
 /** @type {import('.')} */
 module.exports = Error;
 
-},{}],427:[function(require,module,exports){
+},{}],429:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./range')} */
 module.exports = RangeError;
 
-},{}],428:[function(require,module,exports){
+},{}],430:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./ref')} */
 module.exports = ReferenceError;
 
-},{}],429:[function(require,module,exports){
+},{}],431:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./syntax')} */
 module.exports = SyntaxError;
 
-},{}],430:[function(require,module,exports){
+},{}],432:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./type')} */
 module.exports = TypeError;
 
-},{}],431:[function(require,module,exports){
+},{}],433:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./uri')} */
 module.exports = URIError;
 
-},{}],432:[function(require,module,exports){
+},{}],434:[function(require,module,exports){
 'use strict';
 
 /** @type {import('.')} */
 module.exports = Object;
 
-},{}],433:[function(require,module,exports){
+},{}],435:[function(require,module,exports){
 'use strict';
 
 var isCallable = require('is-callable');
@@ -73246,7 +74941,7 @@ module.exports = function forEach(list, iterator, thisArg) {
     }
 };
 
-},{"is-callable":449}],434:[function(require,module,exports){
+},{"is-callable":451}],436:[function(require,module,exports){
 'use strict';
 
 /* eslint no-invalid-this: 1 */
@@ -73332,14 +75027,14 @@ module.exports = function bind(that) {
     return bound;
 };
 
-},{}],435:[function(require,module,exports){
+},{}],437:[function(require,module,exports){
 'use strict';
 
 var implementation = require('./implementation');
 
 module.exports = Function.prototype.bind || implementation;
 
-},{"./implementation":434}],436:[function(require,module,exports){
+},{"./implementation":436}],438:[function(require,module,exports){
 'use strict';
 
 var undefined;
@@ -73719,7 +75414,7 @@ module.exports = function GetIntrinsic(name, allowMissing) {
 	return value;
 };
 
-},{"call-bind-apply-helpers/functionApply":416,"call-bind-apply-helpers/functionCall":417,"es-define-property":424,"es-errors":426,"es-errors/eval":425,"es-errors/range":427,"es-errors/ref":428,"es-errors/syntax":429,"es-errors/type":430,"es-errors/uri":431,"es-object-atoms":432,"function-bind":435,"get-proto":439,"get-proto/Object.getPrototypeOf":437,"get-proto/Reflect.getPrototypeOf":438,"gopd":441,"has-symbols":443,"hasown":446,"math-intrinsics/abs":453,"math-intrinsics/floor":454,"math-intrinsics/max":456,"math-intrinsics/min":457,"math-intrinsics/pow":458,"math-intrinsics/round":459,"math-intrinsics/sign":460}],437:[function(require,module,exports){
+},{"call-bind-apply-helpers/functionApply":418,"call-bind-apply-helpers/functionCall":419,"es-define-property":426,"es-errors":428,"es-errors/eval":427,"es-errors/range":429,"es-errors/ref":430,"es-errors/syntax":431,"es-errors/type":432,"es-errors/uri":433,"es-object-atoms":434,"function-bind":437,"get-proto":441,"get-proto/Object.getPrototypeOf":439,"get-proto/Reflect.getPrototypeOf":440,"gopd":443,"has-symbols":445,"hasown":448,"math-intrinsics/abs":455,"math-intrinsics/floor":456,"math-intrinsics/max":458,"math-intrinsics/min":459,"math-intrinsics/pow":460,"math-intrinsics/round":461,"math-intrinsics/sign":462}],439:[function(require,module,exports){
 'use strict';
 
 var $Object = require('es-object-atoms');
@@ -73727,13 +75422,13 @@ var $Object = require('es-object-atoms');
 /** @type {import('./Object.getPrototypeOf')} */
 module.exports = $Object.getPrototypeOf || null;
 
-},{"es-object-atoms":432}],438:[function(require,module,exports){
+},{"es-object-atoms":434}],440:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./Reflect.getPrototypeOf')} */
 module.exports = (typeof Reflect !== 'undefined' && Reflect.getPrototypeOf) || null;
 
-},{}],439:[function(require,module,exports){
+},{}],441:[function(require,module,exports){
 'use strict';
 
 var reflectGetProto = require('./Reflect.getPrototypeOf');
@@ -73762,13 +75457,13 @@ module.exports = reflectGetProto
 			}
 			: null;
 
-},{"./Object.getPrototypeOf":437,"./Reflect.getPrototypeOf":438,"dunder-proto/get":423}],440:[function(require,module,exports){
+},{"./Object.getPrototypeOf":439,"./Reflect.getPrototypeOf":440,"dunder-proto/get":425}],442:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./gOPD')} */
 module.exports = Object.getOwnPropertyDescriptor;
 
-},{}],441:[function(require,module,exports){
+},{}],443:[function(require,module,exports){
 'use strict';
 
 /** @type {import('.')} */
@@ -73785,7 +75480,7 @@ if ($gOPD) {
 
 module.exports = $gOPD;
 
-},{"./gOPD":440}],442:[function(require,module,exports){
+},{"./gOPD":442}],444:[function(require,module,exports){
 'use strict';
 
 var $defineProperty = require('es-define-property');
@@ -73809,7 +75504,7 @@ hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBu
 
 module.exports = hasPropertyDescriptors;
 
-},{"es-define-property":424}],443:[function(require,module,exports){
+},{"es-define-property":426}],445:[function(require,module,exports){
 'use strict';
 
 var origSymbol = typeof Symbol !== 'undefined' && Symbol;
@@ -73825,7 +75520,7 @@ module.exports = function hasNativeSymbols() {
 	return hasSymbolSham();
 };
 
-},{"./shams":444}],444:[function(require,module,exports){
+},{"./shams":446}],446:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./shams')} */
@@ -73872,7 +75567,7 @@ module.exports = function hasSymbols() {
 	return true;
 };
 
-},{}],445:[function(require,module,exports){
+},{}],447:[function(require,module,exports){
 'use strict';
 
 var hasSymbols = require('has-symbols/shams');
@@ -73882,7 +75577,7 @@ module.exports = function hasToStringTagShams() {
 	return hasSymbols() && !!Symbol.toStringTag;
 };
 
-},{"has-symbols/shams":444}],446:[function(require,module,exports){
+},{"has-symbols/shams":446}],448:[function(require,module,exports){
 'use strict';
 
 var call = Function.prototype.call;
@@ -73892,7 +75587,7 @@ var bind = require('function-bind');
 /** @type {import('.')} */
 module.exports = bind.call(call, $hasOwn);
 
-},{"function-bind":435}],447:[function(require,module,exports){
+},{"function-bind":437}],449:[function(require,module,exports){
 if (typeof Object.create === 'function') {
   // implementation from standard node.js 'util' module
   module.exports = function inherits(ctor, superCtor) {
@@ -73921,7 +75616,7 @@ if (typeof Object.create === 'function') {
   }
 }
 
-},{}],448:[function(require,module,exports){
+},{}],450:[function(require,module,exports){
 'use strict';
 
 var hasToStringTag = require('has-tostringtag/shams')();
@@ -73967,7 +75662,7 @@ isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests
 /** @type {import('.')} */
 module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
 
-},{"call-bound":421,"has-tostringtag/shams":445}],449:[function(require,module,exports){
+},{"call-bound":423,"has-tostringtag/shams":447}],451:[function(require,module,exports){
 'use strict';
 
 var fnToStr = Function.prototype.toString;
@@ -74070,7 +75765,7 @@ module.exports = reflectApply
 		return tryFunctionObject(value);
 	};
 
-},{}],450:[function(require,module,exports){
+},{}],452:[function(require,module,exports){
 'use strict';
 
 var callBound = require('call-bound');
@@ -74119,7 +75814,7 @@ module.exports = function isGeneratorFunction(fn) {
 	return getProto(fn) === GeneratorFunction;
 };
 
-},{"call-bound":421,"get-proto":439,"has-tostringtag/shams":445,"safe-regex-test":468}],451:[function(require,module,exports){
+},{"call-bound":423,"get-proto":441,"has-tostringtag/shams":447,"safe-regex-test":470}],453:[function(require,module,exports){
 'use strict';
 
 var callBound = require('call-bound');
@@ -74190,7 +75885,7 @@ if (hasToStringTag) {
 
 module.exports = fn;
 
-},{"call-bound":421,"gopd":441,"has-tostringtag/shams":445,"hasown":446}],452:[function(require,module,exports){
+},{"call-bound":423,"gopd":443,"has-tostringtag/shams":447,"hasown":448}],454:[function(require,module,exports){
 'use strict';
 
 var whichTypedArray = require('which-typed-array');
@@ -74200,19 +75895,19 @@ module.exports = function isTypedArray(value) {
 	return !!whichTypedArray(value);
 };
 
-},{"which-typed-array":474}],453:[function(require,module,exports){
+},{"which-typed-array":476}],455:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./abs')} */
 module.exports = Math.abs;
 
-},{}],454:[function(require,module,exports){
+},{}],456:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./floor')} */
 module.exports = Math.floor;
 
-},{}],455:[function(require,module,exports){
+},{}],457:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./isNaN')} */
@@ -74220,31 +75915,31 @@ module.exports = Number.isNaN || function isNaN(a) {
 	return a !== a;
 };
 
-},{}],456:[function(require,module,exports){
+},{}],458:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./max')} */
 module.exports = Math.max;
 
-},{}],457:[function(require,module,exports){
+},{}],459:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./min')} */
 module.exports = Math.min;
 
-},{}],458:[function(require,module,exports){
+},{}],460:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./pow')} */
 module.exports = Math.pow;
 
-},{}],459:[function(require,module,exports){
+},{}],461:[function(require,module,exports){
 'use strict';
 
 /** @type {import('./round')} */
 module.exports = Math.round;
 
-},{}],460:[function(require,module,exports){
+},{}],462:[function(require,module,exports){
 'use strict';
 
 var $isNaN = require('./isNaN');
@@ -74257,7 +75952,7 @@ module.exports = function sign(number) {
 	return number < 0 ? -1 : +1;
 };
 
-},{"./isNaN":455}],461:[function(require,module,exports){
+},{"./isNaN":457}],463:[function(require,module,exports){
 'use strict';
 
 var keysShim;
@@ -74381,7 +76076,7 @@ if (!Object.keys) {
 }
 module.exports = keysShim;
 
-},{"./isArguments":463}],462:[function(require,module,exports){
+},{"./isArguments":465}],464:[function(require,module,exports){
 'use strict';
 
 var slice = Array.prototype.slice;
@@ -74415,7 +76110,7 @@ keysShim.shim = function shimObjectKeys() {
 
 module.exports = keysShim;
 
-},{"./implementation":461,"./isArguments":463}],463:[function(require,module,exports){
+},{"./implementation":463,"./isArguments":465}],465:[function(require,module,exports){
 'use strict';
 
 var toStr = Object.prototype.toString;
@@ -74434,7 +76129,7 @@ module.exports = function isArguments(value) {
 	return isArgs;
 };
 
-},{}],464:[function(require,module,exports){
+},{}],466:[function(require,module,exports){
 'use strict';
 
 // modified from https://github.com/es-shims/es6-shim
@@ -74482,7 +76177,7 @@ module.exports = function assign(target, source1) {
 	return to; // step 4
 };
 
-},{"call-bound":421,"es-object-atoms":432,"has-symbols/shams":444,"object-keys":462}],465:[function(require,module,exports){
+},{"call-bound":423,"es-object-atoms":434,"has-symbols/shams":446,"object-keys":464}],467:[function(require,module,exports){
 'use strict';
 
 var implementation = require('./implementation');
@@ -74539,7 +76234,7 @@ module.exports = function getPolyfill() {
 	return Object.assign;
 };
 
-},{"./implementation":464}],466:[function(require,module,exports){
+},{"./implementation":466}],468:[function(require,module,exports){
 'use strict';
 
 /** @type {import('.')} */
@@ -74558,7 +76253,7 @@ module.exports = [
 	'BigUint64Array'
 ];
 
-},{}],467:[function(require,module,exports){
+},{}],469:[function(require,module,exports){
 // shim for using process in browser
 var process = module.exports = {};
 
@@ -74744,7 +76439,7 @@ process.chdir = function (dir) {
 };
 process.umask = function() { return 0; };
 
-},{}],468:[function(require,module,exports){
+},{}],470:[function(require,module,exports){
 'use strict';
 
 var callBound = require('call-bound');
@@ -74763,7 +76458,7 @@ module.exports = function regexTester(regex) {
 	};
 };
 
-},{"call-bound":421,"es-errors/type":430,"is-regex":451}],469:[function(require,module,exports){
+},{"call-bound":423,"es-errors/type":432,"is-regex":453}],471:[function(require,module,exports){
 'use strict';
 
 var GetIntrinsic = require('get-intrinsic');
@@ -74807,7 +76502,7 @@ module.exports = function setFunctionLength(fn, length) {
 	return fn;
 };
 
-},{"define-data-property":422,"es-errors/type":430,"get-intrinsic":436,"gopd":441,"has-property-descriptors":442}],470:[function(require,module,exports){
+},{"define-data-property":424,"es-errors/type":432,"get-intrinsic":438,"gopd":443,"has-property-descriptors":444}],472:[function(require,module,exports){
 (function (setImmediate,clearImmediate){(function (){
 var nextTick = require('process/browser.js').nextTick;
 var apply = Function.prototype.apply;
@@ -74886,9 +76581,9 @@ exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate :
   delete immediateIds[id];
 };
 }).call(this)}).call(this,require("timers").setImmediate,require("timers").clearImmediate)
-},{"process/browser.js":467,"timers":470}],471:[function(require,module,exports){
-arguments[4][410][0].apply(exports,arguments)
-},{"dup":410}],472:[function(require,module,exports){
+},{"process/browser.js":469,"timers":472}],473:[function(require,module,exports){
+arguments[4][412][0].apply(exports,arguments)
+},{"dup":412}],474:[function(require,module,exports){
 // Currently in sync with Node.js lib/internal/util/types.js
 // https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9
 
@@ -75224,7 +76919,7 @@ exports.isAnyArrayBuffer = isAnyArrayBuffer;
   });
 });
 
-},{"is-arguments":448,"is-generator-function":450,"is-typed-array":452,"which-typed-array":474}],473:[function(require,module,exports){
+},{"is-arguments":450,"is-generator-function":452,"is-typed-array":454,"which-typed-array":476}],475:[function(require,module,exports){
 (function (process){(function (){
 // Copyright Joyent, Inc. and other Node contributors.
 //
@@ -75943,7 +77638,7 @@ function callbackify(original) {
 exports.callbackify = callbackify;
 
 }).call(this)}).call(this,require('_process'))
-},{"./support/isBuffer":471,"./support/types":472,"_process":467,"inherits":447}],474:[function(require,module,exports){
+},{"./support/isBuffer":473,"./support/types":474,"_process":469,"inherits":449}],476:[function(require,module,exports){
 (function (global){(function (){
 'use strict';
 
@@ -76064,5 +77759,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":412,"call-bind":420,"call-bound":421,"for-each":433,"get-proto":439,"gopd":441,"has-tostringtag/shams":445}]},{},[136])(136)
+},{"available-typed-arrays":414,"call-bind":422,"call-bound":423,"for-each":435,"get-proto":441,"gopd":443,"has-tostringtag/shams":447}]},{},[136])(136)
 });