@designliquido/delegua 0.35.1 → 0.35.3

package/umd/delegua.js

@@ -223,21 +223,21 @@ class AvaliadorSintaticoBase {
 }
 exports.AvaliadorSintaticoBase = AvaliadorSintaticoBase;
 
-},{"../construtos":40,"../declaracoes":78,"../tipos-de-simbolos/comum":156,"./erro-avaliador-sintatico":7}],2:[function(require,module,exports){
+},{"../construtos":39,"../declaracoes":77,"../tipos-de-simbolos/comum":156,"./erro-avaliador-sintatico":7}],2:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AvaliadorSintatico = void 0;
-const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
-const delegua_2 = __importDefault(require("../tipos-de-dados/delegua"));
 const browser_process_hrtime_1 = __importDefault(require("browser-process-hrtime"));
+const delegua_1 = __importDefault(require("../tipos-de-dados/delegua"));
+const delegua_2 = __importDefault(require("../tipos-de-simbolos/delegua"));
 const construtos_1 = require("../construtos");
 const erro_avaliador_sintatico_1 = require("./erro-avaliador-sintatico");
+const tuplas_1 = require("../construtos/tuplas");
 const declaracoes_1 = require("../declaracoes");
 const lexador_1 = require("../lexador");
-const tuplas_1 = require("../construtos/tuplas");
 /**
  * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
  * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
@@ -273,13 +273,13 @@ class AvaliadorSintatico {
         return this.simbolos[this.atual + 1].tipo === tipo;
     }
     verificarDefinicaoTipoAtual() {
-        const tipos = [...Object.values(delegua_2.default)];
+        const tipos = [...Object.values(delegua_1.default)];
         const lexema = this.simboloAtual().lexema.toLowerCase();
         const contemTipo = tipos.find((tipo) => tipo === lexema);
-        if (contemTipo && this.verificarTipoProximoSimbolo(delegua_1.default.COLCHETE_ESQUERDO)) {
+        if (contemTipo && this.verificarTipoProximoSimbolo(delegua_2.default.COLCHETE_ESQUERDO)) {
             const tiposVetores = ['inteiro[]', 'numero[]', 'número[]', 'qualquer[]', 'real[]', 'texto[]'];
             this.avancarEDevolverAnterior();
-            if (!this.verificarTipoProximoSimbolo(delegua_1.default.COLCHETE_DIREITO)) {
+            if (!this.verificarTipoProximoSimbolo(delegua_2.default.COLCHETE_DIREITO)) {
                 throw this.erro(this.simbolos[this.atual], "Esperado símbolo de fechamento do vetor ']'.");
             }
             const contemTipoVetor = tiposVetores.find((tipo) => tipo === `${lexema}[]`);
@@ -316,124 +316,124 @@ class AvaliadorSintatico {
         const simboloAtual = this.simbolos[this.atual];
         let valores = [];
         switch (simboloAtual.tipo) {
-            case delegua_1.default.CHAVE_ESQUERDA:
+            case delegua_2.default.CHAVE_ESQUERDA:
                 this.avancarEDevolverAnterior();
                 const chaves = [];
                 valores = [];
-                if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.CHAVE_DIREITA)) {
+                if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_DIREITA)) {
                     return new construtos_1.Dicionario(this.hashArquivo, Number(simboloAtual.linha), [], []);
                 }
-                while (!this.verificarSeSimboloAtualEIgualA(delegua_1.default.CHAVE_DIREITA)) {
+                while (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_DIREITA)) {
                     const chave = this.atribuir();
-                    this.consumir(delegua_1.default.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
+                    this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
                     const valor = this.atribuir();
                     chaves.push(chave);
                     valores.push(valor);
-                    if (this.simbolos[this.atual].tipo !== delegua_1.default.CHAVE_DIREITA) {
-                        this.consumir(delegua_1.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
+                    if (this.simbolos[this.atual].tipo !== delegua_2.default.CHAVE_DIREITA) {
+                        this.consumir(delegua_2.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
                     }
                 }
                 return new construtos_1.Dicionario(this.hashArquivo, Number(simboloAtual.linha), chaves, valores);
-            case delegua_1.default.COLCHETE_ESQUERDO:
+            case delegua_2.default.COLCHETE_ESQUERDO:
                 this.avancarEDevolverAnterior();
                 valores = [];
-                if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.COLCHETE_DIREITO)) {
+                if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.COLCHETE_DIREITO)) {
                     return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), []);
                 }
-                while (!this.verificarSeSimboloAtualEIgualA(delegua_1.default.COLCHETE_DIREITO)) {
+                while (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.COLCHETE_DIREITO)) {
                     let valor = null;
-                    if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.PARENTESE_ESQUERDO)) {
+                    if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO)) {
                         const expressao = this.expressao();
                         const argumentos = [expressao];
-                        while (this.simbolos[this.atual].tipo === delegua_1.default.VIRGULA) {
+                        while (this.simbolos[this.atual].tipo === delegua_2.default.VIRGULA) {
                             this.avancarEDevolverAnterior();
                             argumentos.push(this.expressao());
                         }
-                        this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
-                        this.consumir(delegua_1.default.COLCHETE_DIREITO, "Esperado ']' após a expressão.");
+                        this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+                        this.consumir(delegua_2.default.COLCHETE_DIREITO, "Esperado ']' após a expressão.");
                         return new tuplas_1.SeletorTuplas(...argumentos);
                     }
                     valor = this.atribuir();
                     valores.push(valor);
-                    if (this.simbolos[this.atual].tipo !== delegua_1.default.COLCHETE_DIREITO) {
-                        this.consumir(delegua_1.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
+                    if (this.simbolos[this.atual].tipo !== delegua_2.default.COLCHETE_DIREITO) {
+                        this.consumir(delegua_2.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
                     }
                 }
                 return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), valores);
-            case delegua_1.default.FALSO:
+            case delegua_2.default.FALSO:
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), false);
-            case delegua_1.default.FUNCAO:
-            case delegua_1.default.FUNÇÃO:
+            case delegua_2.default.FUNCAO:
+            case delegua_2.default.FUNÇÃO:
                 const simboloFuncao = this.avancarEDevolverAnterior();
                 return this.corpoDaFuncao(simboloFuncao.lexema);
-            case delegua_1.default.IDENTIFICADOR:
+            case delegua_2.default.IDENTIFICADOR:
                 const simboloIdentificador = this.avancarEDevolverAnterior();
                 // Se o próximo símbolo é um incremento ou um decremento,
                 // aqui deve retornar um unário correspondente.
                 // Caso contrário, apenas retornar um construto de variável.
                 if (this.simbolos[this.atual] &&
-                    [delegua_1.default.INCREMENTAR, delegua_1.default.DECREMENTAR].includes(this.simbolos[this.atual].tipo)) {
+                    [delegua_2.default.INCREMENTAR, delegua_2.default.DECREMENTAR].includes(this.simbolos[this.atual].tipo)) {
                     const simboloIncrementoDecremento = this.avancarEDevolverAnterior();
                     return new construtos_1.Unario(this.hashArquivo, simboloIncrementoDecremento, new construtos_1.Variavel(this.hashArquivo, simboloIdentificador), 'DEPOIS');
                 }
                 return new construtos_1.Variavel(this.hashArquivo, simboloIdentificador);
-            case delegua_1.default.IMPORTAR:
+            case delegua_2.default.IMPORTAR:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoImportar();
-            case delegua_1.default.ISTO:
+            case delegua_2.default.ISTO:
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Isto(this.hashArquivo, Number(simboloAtual.linha), simboloAtual);
-            case delegua_1.default.NULO:
+            case delegua_2.default.NULO:
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), null);
-            case delegua_1.default.NUMERO:
-            case delegua_1.default.TEXTO:
+            case delegua_2.default.NUMERO:
+            case delegua_2.default.TEXTO:
                 const simboloNumeroTexto = this.avancarEDevolverAnterior();
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloNumeroTexto.linha), simboloNumeroTexto.literal);
-            case delegua_1.default.PARENTESE_ESQUERDO:
+            case delegua_2.default.PARENTESE_ESQUERDO:
                 this.avancarEDevolverAnterior();
                 const expressao = this.expressao();
-                this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+                this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
                 return new construtos_1.Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
-            case delegua_1.default.SUPER:
+            case delegua_2.default.SUPER:
                 const simboloSuper = this.avancarEDevolverAnterior();
                 // Se o próximo símbolo for uma abertura de parênteses, significa que
                 // é uma chamada ao construtor da classe ancestral (superclasse).
                 // Se o próximo símbolo for um ponto, significa que é uma chamada
                 // a um método da superclasse.
                 switch (this.simbolos[this.atual].tipo) {
-                    case delegua_1.default.PARENTESE_ESQUERDO:
-                        return new construtos_1.Super(this.hashArquivo, simboloSuper, new lexador_1.Simbolo(delegua_1.default.IDENTIFICADOR, 'construtor', null, simboloSuper.linha, this.hashArquivo));
+                    case delegua_2.default.PARENTESE_ESQUERDO:
+                        return new construtos_1.Super(this.hashArquivo, simboloSuper, new lexador_1.Simbolo(delegua_2.default.IDENTIFICADOR, 'construtor', null, simboloSuper.linha, this.hashArquivo));
                     default:
-                        this.consumir(delegua_1.default.PONTO, "Esperado '.' após 'super'.");
-                        const metodoSuperclasse = this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome do método da Superclasse.');
+                        this.consumir(delegua_2.default.PONTO, "Esperado '.' após 'super'.");
+                        const metodoSuperclasse = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome do método da Superclasse.');
                         return new construtos_1.Super(this.hashArquivo, simboloSuper, metodoSuperclasse);
                 }
-            case delegua_1.default.VERDADEIRO:
+            case delegua_2.default.VERDADEIRO:
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), true);
-            case delegua_1.default.TIPO:
+            case delegua_2.default.TIPO:
                 this.avancarEDevolverAnterior();
-                this.consumir(delegua_1.default.DE, "Esperado 'de' após 'tipo'.");
+                this.consumir(delegua_2.default.DE, "Esperado 'de' após 'tipo'.");
                 let _expressao;
-                if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.ESCREVA, delegua_1.default.LEIA, delegua_1.default.FUNCAO, delegua_1.default.FUNÇÃO, delegua_1.default.SE, delegua_1.default.ENQUANTO, delegua_1.default.PARA, delegua_1.default.RETORNA, delegua_2.default.INTEIRO, delegua_2.default.TEXTO, delegua_2.default.VETOR, delegua_2.default.LOGICO, delegua_2.default.LÓGICO, delegua_2.default.VAZIO)) {
+                if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.ESCREVA, delegua_2.default.LEIA, delegua_2.default.FUNCAO, delegua_2.default.FUNÇÃO, delegua_2.default.SE, delegua_2.default.ENQUANTO, delegua_2.default.PARA, delegua_2.default.RETORNA, delegua_1.default.INTEIRO, delegua_1.default.TEXTO, delegua_1.default.VETOR, delegua_1.default.LOGICO, delegua_1.default.LÓGICO, delegua_1.default.VAZIO)) {
                     _expressao = this.simboloAnterior();
                 }
                 else {
                     _expressao = this.expressao();
                 }
                 return new construtos_1.TipoDe(this.hashArquivo, simboloAtual, _expressao instanceof construtos_1.Literal ? _expressao.valor : _expressao);
-            case delegua_1.default.EXPRESSAO_REGULAR:
+            case delegua_2.default.EXPRESSAO_REGULAR:
                 let valor = '';
                 let linhaAtual = this.simbolos[this.atual].linha;
-                let eParExpressaoRegular = this.simbolos.filter((l) => l.linha === linhaAtual && l.tipo === delegua_1.default.EXPRESSAO_REGULAR)
+                let eParExpressaoRegular = this.simbolos.filter((l) => l.linha === linhaAtual && l.tipo === delegua_2.default.EXPRESSAO_REGULAR)
                     .length %
                     2 ===
                     0;
                 if (eParExpressaoRegular) {
                     this.avancarEDevolverAnterior();
-                    while (!this.verificarTipoSimboloAtual(delegua_1.default.EXPRESSAO_REGULAR)) {
+                    while (!this.verificarTipoSimboloAtual(delegua_2.default.EXPRESSAO_REGULAR)) {
                         valor += this.simboloAtual().lexema || '';
                         this.avancarEDevolverAnterior();
                     }
@@ -445,30 +445,30 @@ class AvaliadorSintatico {
     }
     finalizarChamada(entidadeChamada) {
         const argumentos = [];
-        if (!this.verificarTipoSimboloAtual(delegua_1.default.PARENTESE_DIREITO)) {
+        if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
             do {
                 if (argumentos.length >= 255) {
                     throw this.erro(this.simbolos[this.atual], 'Não pode haver mais de 255 argumentos.');
                 }
                 argumentos.push(this.expressao());
-            } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
+            } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         }
-        const parenteseDireito = this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
+        const parenteseDireito = this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
         return new construtos_1.Chamada(this.hashArquivo, entidadeChamada, parenteseDireito, argumentos);
     }
     chamar() {
         let expressao = this.primario();
         while (true) {
-            if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.PARENTESE_ESQUERDO)) {
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO)) {
                 expressao = this.finalizarChamada(expressao);
             }
-            else if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO)) {
-                const nome = this.consumir(delegua_1.default.IDENTIFICADOR, "Esperado nome do método após '.'.");
+            else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO)) {
+                const nome = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado nome de método ou propriedade após '.'.");
                 expressao = new construtos_1.AcessoMetodoOuPropriedade(this.hashArquivo, expressao, nome);
             }
-            else if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.COLCHETE_ESQUERDO)) {
+            else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.COLCHETE_ESQUERDO)) {
                 const indice = this.expressao();
-                const simboloFechamento = this.consumir(delegua_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
+                const simboloFechamento = this.consumir(delegua_2.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
                 expressao = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, expressao, indice, simboloFechamento);
             }
             else {
@@ -478,7 +478,7 @@ class AvaliadorSintatico {
         return expressao;
     }
     unario() {
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.NEGACAO, delegua_1.default.SUBTRACAO, delegua_1.default.BIT_NOT, delegua_1.default.INCREMENTAR, delegua_1.default.DECREMENTAR)) {
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.NEGACAO, delegua_2.default.SUBTRACAO, delegua_2.default.BIT_NOT, delegua_2.default.INCREMENTAR, delegua_2.default.DECREMENTAR)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.unario();
             return new construtos_1.Unario(this.hashArquivo, operador, direito, 'ANTES');
@@ -487,7 +487,7 @@ class AvaliadorSintatico {
     }
     exponenciacao() {
         let expressao = this.unario();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.EXPONENCIACAO)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.EXPONENCIACAO)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.unario();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -496,7 +496,7 @@ class AvaliadorSintatico {
     }
     multiplicar() {
         let expressao = this.exponenciacao();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.DIVISAO, delegua_1.default.DIVISAO_IGUAL, delegua_1.default.DIVISAO_INTEIRA, delegua_1.default.DIVISAO_INTEIRA_IGUAL, delegua_1.default.MODULO, delegua_1.default.MODULO_IGUAL, delegua_1.default.MULTIPLICACAO, delegua_1.default.MULTIPLICACAO_IGUAL)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DIVISAO, delegua_2.default.DIVISAO_IGUAL, delegua_2.default.DIVISAO_INTEIRA, delegua_2.default.DIVISAO_INTEIRA_IGUAL, delegua_2.default.MODULO, delegua_2.default.MODULO_IGUAL, delegua_2.default.MULTIPLICACAO, delegua_2.default.MULTIPLICACAO_IGUAL)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.exponenciacao();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -510,7 +510,7 @@ class AvaliadorSintatico {
      */
     adicaoOuSubtracao() {
         let expressao = this.multiplicar();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.SUBTRACAO, delegua_1.default.ADICAO, delegua_1.default.MAIS_IGUAL, delegua_1.default.MENOS_IGUAL)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.SUBTRACAO, delegua_2.default.ADICAO, delegua_2.default.MAIS_IGUAL, delegua_2.default.MENOS_IGUAL)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.multiplicar();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -519,7 +519,7 @@ class AvaliadorSintatico {
     }
     bitShift() {
         let expressao = this.adicaoOuSubtracao();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.MENOR_MENOR, delegua_1.default.MAIOR_MAIOR)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.MENOR_MENOR, delegua_2.default.MAIOR_MAIOR)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.adicaoOuSubtracao();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -528,7 +528,7 @@ class AvaliadorSintatico {
     }
     bitE() {
         let expressao = this.bitShift();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.BIT_AND)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.BIT_AND)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.bitShift();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -537,7 +537,7 @@ class AvaliadorSintatico {
     }
     bitOu() {
         let expressao = this.bitE();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.BIT_OR, delegua_1.default.BIT_XOR)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.BIT_OR, delegua_2.default.BIT_XOR)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.bitE();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -546,7 +546,7 @@ class AvaliadorSintatico {
     }
     comparar() {
         let expressao = this.bitOu();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.MAIOR, delegua_1.default.MAIOR_IGUAL, delegua_1.default.MENOR, delegua_1.default.MENOR_IGUAL)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.MAIOR, delegua_2.default.MAIOR_IGUAL, delegua_2.default.MENOR, delegua_2.default.MENOR_IGUAL)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.bitOu();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -555,7 +555,7 @@ class AvaliadorSintatico {
     }
     comparacaoIgualdade() {
         let expressao = this.comparar();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.DIFERENTE, delegua_1.default.IGUAL_IGUAL)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DIFERENTE, delegua_2.default.IGUAL_IGUAL)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.comparar();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -564,7 +564,7 @@ class AvaliadorSintatico {
     }
     em() {
         let expressao = this.comparacaoIgualdade();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.EM)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.EM)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.comparacaoIgualdade();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
@@ -573,7 +573,7 @@ class AvaliadorSintatico {
     }
     e() {
         let expressao = this.em();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.E)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.E)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.em();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
@@ -582,7 +582,7 @@ class AvaliadorSintatico {
     }
     ou() {
         let expressao = this.e();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.OU)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.OU)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.e();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
@@ -597,16 +597,21 @@ class AvaliadorSintatico {
         const expressao = this.ou();
         if (expressao instanceof construtos_1.Binario &&
             [
-                delegua_1.default.MAIS_IGUAL,
-                delegua_1.default.MENOS_IGUAL,
-                delegua_1.default.MULTIPLICACAO_IGUAL,
-                delegua_1.default.DIVISAO_IGUAL,
-                delegua_1.default.DIVISAO_INTEIRA_IGUAL,
-                delegua_1.default.MODULO_IGUAL,
+                delegua_2.default.MAIS_IGUAL,
+                delegua_2.default.MENOS_IGUAL,
+                delegua_2.default.MULTIPLICACAO_IGUAL,
+                delegua_2.default.DIVISAO_IGUAL,
+                delegua_2.default.DIVISAO_INTEIRA_IGUAL,
+                delegua_2.default.MODULO_IGUAL,
             ].includes(expressao.operador.tipo)) {
-            return new construtos_1.Atribuir(this.hashArquivo, expressao.esquerda.simbolo, expressao);
+            let simbolo = expressao.esquerda.simbolo;
+            if (expressao.esquerda instanceof construtos_1.AcessoIndiceVariavel) {
+                simbolo = expressao.esquerda.entidadeChamada.simbolo;
+                return new construtos_1.Atribuir(this.hashArquivo, simbolo, expressao, expressao.esquerda.indice);
+            }
+            return new construtos_1.Atribuir(this.hashArquivo, simbolo, expressao);
         }
-        else if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.IGUAL)) {
+        else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL)) {
             const igual = this.simbolos[this.atual - 1];
             const valor = this.expressao();
             if (expressao instanceof construtos_1.Variavel) {
@@ -625,13 +630,13 @@ class AvaliadorSintatico {
         return expressao;
     }
     expressao() {
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.LEIA))
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.LEIA))
             return this.declaracaoLeia();
         return this.atribuir();
     }
     blocoEscopo() {
         let declaracoes = [];
-        while (!this.verificarTipoSimboloAtual(delegua_1.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
+        while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
             const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
             if (Array.isArray(retornoDeclaracao)) {
                 declaracoes = declaracoes.concat(retornoDeclaracao);
@@ -640,8 +645,8 @@ class AvaliadorSintatico {
                 declaracoes.push(retornoDeclaracao);
             }
         }
-        this.consumir(delegua_1.default.CHAVE_DIREITA, "Esperado '}' após o bloco.");
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' após o bloco.");
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return declaracoes;
     }
     declaracaoEnquanto() {
@@ -657,22 +662,22 @@ class AvaliadorSintatico {
     }
     declaracaoEscreva() {
         const simboloAtual = this.simbolos[this.atual];
-        this.consumir(delegua_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
+        this.consumir(delegua_2.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
         const argumentos = [];
-        if (!this.verificarTipoSimboloAtual(delegua_1.default.PARENTESE_DIREITO)) {
+        if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
             do {
                 argumentos.push(this.expressao());
-            } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
+            } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         }
-        this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
+        this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
         // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
     }
     declaracaoExpressao() {
         const expressao = this.expressao();
         // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Expressao(expressao);
     }
     declaracaoComentarioMultilinha() {
@@ -681,7 +686,7 @@ class AvaliadorSintatico {
         do {
             simboloComentario = this.avancarEDevolverAnterior();
             conteudos.push(simboloComentario.literal);
-        } while (simboloComentario.tipo === delegua_1.default.LINHA_COMENTARIO);
+        } while (simboloComentario.tipo === delegua_2.default.LINHA_COMENTARIO);
         return new construtos_1.Comentario(simboloComentario.hashArquivo, simboloComentario.linha, conteudos, true);
     }
     declaracaoComentarioUmaLinha() {
@@ -693,24 +698,24 @@ class AvaliadorSintatico {
             this.erro(this.simbolos[this.atual - 1], "'continua' precisa estar em um laço de repetição.");
         }
         // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Continua(this.simbolos[this.atual - 1]);
     }
     declaracaoEscolha() {
         try {
             this.blocos += 1;
             const condicao = this.expressao();
-            this.consumir(delegua_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo do 'escolha'.");
+            this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo do 'escolha'.");
             const caminhos = [];
             let caminhoPadrao = null;
-            while (!this.verificarSeSimboloAtualEIgualA(delegua_1.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
-                if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.CASO)) {
+            while (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
+                if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CASO)) {
                     const caminhoCondicoes = [this.expressao()];
-                    this.consumir(delegua_1.default.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
-                    while (this.verificarTipoSimboloAtual(delegua_1.default.CASO)) {
-                        this.consumir(delegua_1.default.CASO, null);
+                    this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
+                    while (this.verificarTipoSimboloAtual(delegua_2.default.CASO)) {
+                        this.consumir(delegua_2.default.CASO, null);
                         caminhoCondicoes.push(this.expressao());
-                        this.consumir(delegua_1.default.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
+                        this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
                     }
                     let declaracoes = [];
                     do {
@@ -721,27 +726,27 @@ class AvaliadorSintatico {
                         else {
                             declaracoes.push(retornoDeclaracao);
                         }
-                    } while (!this.verificarTipoSimboloAtual(delegua_1.default.CASO) &&
-                        !this.verificarTipoSimboloAtual(delegua_1.default.PADRAO) &&
-                        !this.verificarTipoSimboloAtual(delegua_1.default.CHAVE_DIREITA));
+                    } while (!this.verificarTipoSimboloAtual(delegua_2.default.CASO) &&
+                        !this.verificarTipoSimboloAtual(delegua_2.default.PADRAO) &&
+                        !this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA));
                     caminhos.push({
                         condicoes: caminhoCondicoes,
                         declaracoes,
                     });
                 }
-                else if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.PADRAO)) {
+                else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PADRAO)) {
                     if (caminhoPadrao !== null) {
                         const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(this.simbolos[this.atual], "Você só pode ter um 'padrao' em cada declaração de 'escolha'.");
                         this.erros.push(excecao);
                         throw excecao;
                     }
-                    this.consumir(delegua_1.default.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
+                    this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
                     const declaracoes = [];
                     do {
                         declaracoes.push(this.resolverDeclaracao());
-                    } while (!this.verificarTipoSimboloAtual(delegua_1.default.CASO) &&
-                        !this.verificarTipoSimboloAtual(delegua_1.default.PADRAO) &&
-                        !this.verificarTipoSimboloAtual(delegua_1.default.CHAVE_DIREITA));
+                    } while (!this.verificarTipoSimboloAtual(delegua_2.default.CASO) &&
+                        !this.verificarTipoSimboloAtual(delegua_2.default.PADRAO) &&
+                        !this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA));
                     caminhoPadrao = {
                         declaracoes,
                     };
@@ -762,7 +767,7 @@ class AvaliadorSintatico {
         try {
             this.blocos += 1;
             const caminhoFazer = this.resolverDeclaracao();
-            this.consumir(delegua_1.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
+            this.consumir(delegua_2.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
             const condicaoEnquanto = this.expressao();
             return new declaracoes_1.Fazer(simboloFazer.hashArquivo, Number(simboloFazer.linha), caminhoFazer, condicaoEnquanto);
         }
@@ -771,9 +776,9 @@ class AvaliadorSintatico {
         }
     }
     declaracaoImportar() {
-        this.consumir(delegua_1.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
+        this.consumir(delegua_2.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
         const caminho = this.expressao();
-        const simboloFechamento = this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
+        const simboloFechamento = this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
         return new declaracoes_1.Importar(caminho, simboloFechamento);
     }
     /**
@@ -782,21 +787,21 @@ class AvaliadorSintatico {
      */
     declaracaoLeia() {
         const simboloLeia = this.simbolos[this.atual];
-        this.consumir(delegua_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos argumentos em instrução `leia`.");
+        this.consumir(delegua_2.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos argumentos em instrução `leia`.");
         const argumentos = [];
-        if (this.simbolos[this.atual].tipo !== delegua_1.default.PARENTESE_DIREITO) {
+        if (this.simbolos[this.atual].tipo !== delegua_2.default.PARENTESE_DIREITO) {
             do {
                 argumentos.push(this.expressao());
-            } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
+            } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         }
-        this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos em instrução `leia`.");
+        this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos em instrução `leia`.");
         return new declaracoes_1.Leia(simboloLeia, argumentos);
     }
     declaracaoPara() {
         try {
             const simboloPara = this.simbolos[this.atual - 1];
             this.blocos += 1;
-            if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.CADA)) {
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CADA)) {
                 return this.declaracaoParaCada(simboloPara);
             }
             return this.declaracaoParaTradicional(simboloPara);
@@ -806,8 +811,8 @@ class AvaliadorSintatico {
         }
     }
     declaracaoParaCada(simboloPara) {
-        const nomeVariavelIteracao = this.consumir(delegua_1.default.IDENTIFICADOR, "Esperado identificador de variável de iteração para instrução 'para cada'.");
-        if (!this.verificarSeSimboloAtualEIgualA(delegua_1.default.DE, delegua_1.default.EM)) {
+        const nomeVariavelIteracao = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado identificador de variável de iteração para instrução 'para cada'.");
+        if (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.DE, delegua_2.default.EM)) {
             throw this.erro(this.simbolos[this.atual], "Esperado palavras reservadas 'em' ou 'de' após variável de iteração em instrução 'para cada'.");
         }
         const vetor = this.expressao();
@@ -815,33 +820,33 @@ class AvaliadorSintatico {
         return new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), nomeVariavelIteracao.lexema, vetor, corpo);
     }
     declaracaoParaTradicional(simboloPara) {
-        const comParenteses = this.verificarSeSimboloAtualEIgualA(delegua_1.default.PARENTESE_ESQUERDO);
+        const comParenteses = this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO);
         let inicializador;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA)) {
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA)) {
             inicializador = null;
         }
-        else if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VARIAVEL)) {
+        else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VARIAVEL)) {
             inicializador = this.declaracaoDeVariaveis();
         }
-        else if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.CONSTANTE)) {
+        else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CONSTANTE)) {
             inicializador = this.declaracaoDeConstantes();
         }
         else {
             inicializador = this.declaracaoExpressao();
         }
         let condicao = null;
-        if (!this.verificarTipoSimboloAtual(delegua_1.default.PONTO_E_VIRGULA)) {
+        if (!this.verificarTipoSimboloAtual(delegua_2.default.PONTO_E_VIRGULA)) {
             condicao = this.expressao();
         }
         // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         let incrementar = null;
-        if (!this.verificarTipoSimboloAtual(delegua_1.default.PARENTESE_DIREITO)) {
+        if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
             incrementar = this.expressao();
-            this.verificarSeSimboloAtualEIgualA(delegua_1.default.INCREMENTAR, delegua_1.default.DECREMENTAR);
+            this.verificarSeSimboloAtualEIgualA(delegua_2.default.INCREMENTAR, delegua_2.default.DECREMENTAR);
         }
         if (comParenteses) {
-            this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após cláusulas de inicialização, condição e incremento.");
+            this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após cláusulas de inicialização, condição e incremento.");
         }
         const corpo = this.resolverDeclaracao();
         return new declaracoes_1.Para(this.hashArquivo, Number(simboloPara.linha), inicializador, condicao, incrementar, corpo);
@@ -850,30 +855,30 @@ class AvaliadorSintatico {
         const simboloChave = this.simbolos[this.atual - 1];
         let valor = null;
         if ([
-            delegua_1.default.CHAVE_ESQUERDA,
-            delegua_1.default.COLCHETE_ESQUERDO,
-            delegua_1.default.FALSO,
-            delegua_1.default.IDENTIFICADOR,
-            delegua_1.default.ISTO,
-            delegua_1.default.NEGACAO,
-            delegua_1.default.NUMERO,
-            delegua_1.default.NULO,
-            delegua_1.default.PARENTESE_ESQUERDO,
-            delegua_1.default.SUPER,
-            delegua_1.default.TEXTO,
-            delegua_1.default.VERDADEIRO,
+            delegua_2.default.CHAVE_ESQUERDA,
+            delegua_2.default.COLCHETE_ESQUERDO,
+            delegua_2.default.FALSO,
+            delegua_2.default.IDENTIFICADOR,
+            delegua_2.default.ISTO,
+            delegua_2.default.NEGACAO,
+            delegua_2.default.NUMERO,
+            delegua_2.default.NULO,
+            delegua_2.default.PARENTESE_ESQUERDO,
+            delegua_2.default.SUPER,
+            delegua_2.default.TEXTO,
+            delegua_2.default.VERDADEIRO,
         ].includes(this.simbolos[this.atual].tipo)) {
             valor = this.expressao();
         }
         // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Retorna(simboloChave, valor);
     }
     declaracaoSe() {
         const condicao = this.expressao();
         const caminhoEntao = this.resolverDeclaracao();
         let caminhoSenao = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.SENAO, delegua_1.default.SENÃO)) {
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.SENAO, delegua_2.default.SENÃO)) {
             caminhoSenao = this.resolverDeclaracao();
         }
         return new declaracoes_1.Se(condicao, caminhoEntao, [], caminhoSenao);
@@ -883,16 +888,16 @@ class AvaliadorSintatico {
             this.erro(this.simbolos[this.atual - 1], "'sustar' ou 'pausa' deve estar dentro de um laço de repetição.");
         }
         // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Sustar(this.simbolos[this.atual - 1]);
     }
     declaracaoTente() {
         const simboloTente = this.simbolos[this.atual - 1];
-        this.consumir(delegua_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'tente'.");
+        this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'tente'.");
         const blocoTente = this.blocoEscopo();
         let blocoPegue = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.PEGUE)) {
-            if (this.verificarTipoSimboloAtual(delegua_1.default.PARENTESE_ESQUERDO)) {
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PEGUE)) {
+            if (this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_ESQUERDO)) {
                 // Caso 1: com parâmetro de erro.
                 // `pegue` recebe um `FuncaoConstruto`.
                 blocoPegue = this.corpoDaFuncao('bloco `pegue`');
@@ -900,25 +905,25 @@ class AvaliadorSintatico {
             else {
                 // Caso 2: sem parâmetro de erro.
                 // `pegue` recebe um bloco.
-                this.consumir(delegua_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
+                this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
                 blocoPegue = this.blocoEscopo();
             }
         }
         let blocoSenao = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.SENAO, delegua_1.default.SENÃO)) {
-            this.consumir(delegua_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'senão'.");
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.SENAO, delegua_2.default.SENÃO)) {
+            this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'senão'.");
             blocoSenao = this.blocoEscopo();
         }
         let blocoFinalmente = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.FINALMENTE)) {
-            this.consumir(delegua_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'finalmente'.");
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.FINALMENTE)) {
+            this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'finalmente'.");
             blocoFinalmente = this.blocoEscopo();
         }
         return new declaracoes_1.Tente(simboloTente.hashArquivo, Number(simboloTente.linha), blocoTente, blocoPegue, blocoSenao, blocoFinalmente);
     }
     resolverDecorador() {
         this.pilhaDecoradores = [];
-        while (this.verificarTipoSimboloAtual(delegua_1.default.ARROBA)) {
+        while (this.verificarTipoSimboloAtual(delegua_2.default.ARROBA)) {
             let nomeDecorador = '';
             let linha;
             let parametros = [];
@@ -926,12 +931,12 @@ class AvaliadorSintatico {
             linha = this.simbolos[this.atual].linha;
             let simbolosLinhaAtual = this.simbolos.filter((l) => l.linha === linha);
             for (let simbolo of simbolosLinhaAtual) {
-                parenteseEsquerdo = this.verificarSeSimboloAtualEIgualA(delegua_1.default.PARENTESE_ESQUERDO);
+                parenteseEsquerdo = this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO);
                 if (parenteseEsquerdo) {
-                    if (!this.verificarTipoSimboloAtual(delegua_1.default.PARENTESE_DIREITO)) {
+                    if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
                         parametros = this.logicaComumParametros();
                     }
-                    this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+                    this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
                     break;
                 }
                 this.avancarEDevolverAnterior();
@@ -950,65 +955,65 @@ class AvaliadorSintatico {
      */
     resolverDeclaracao() {
         switch (this.simbolos[this.atual].tipo) {
-            case delegua_1.default.CHAVE_ESQUERDA:
+            case delegua_2.default.CHAVE_ESQUERDA:
                 const simboloInicioBloco = this.avancarEDevolverAnterior();
                 return new declaracoes_1.Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), this.blocoEscopo());
-            case delegua_1.default.COMENTARIO:
+            case delegua_2.default.COMENTARIO:
                 return this.declaracaoComentarioUmaLinha();
-            case delegua_1.default.CONSTANTE:
+            case delegua_2.default.CONSTANTE:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoDeConstantes();
-            case delegua_1.default.CONTINUA:
+            case delegua_2.default.CONTINUA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoContinua();
-            case delegua_1.default.ENQUANTO:
+            case delegua_2.default.ENQUANTO:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoEnquanto();
-            case delegua_1.default.ESCOLHA:
+            case delegua_2.default.ESCOLHA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoEscolha();
-            case delegua_1.default.ESCREVA:
+            case delegua_2.default.ESCREVA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoEscreva();
-            case delegua_1.default.FALHAR:
+            case delegua_2.default.FALHAR:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoFalhar();
-            case delegua_1.default.FAZER:
+            case delegua_2.default.FAZER:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoFazer();
-            case delegua_1.default.LINHA_COMENTARIO:
+            case delegua_2.default.LINHA_COMENTARIO:
                 return this.declaracaoComentarioMultilinha();
-            case delegua_1.default.PARA:
+            case delegua_2.default.PARA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoPara();
-            case delegua_1.default.PAUSA:
-            case delegua_1.default.SUSTAR:
+            case delegua_2.default.PAUSA:
+            case delegua_2.default.SUSTAR:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoSustar();
-            case delegua_1.default.SE:
+            case delegua_2.default.SE:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoSe();
-            case delegua_1.default.RETORNA:
+            case delegua_2.default.RETORNA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoRetorna();
-            case delegua_1.default.TENDO:
+            case delegua_2.default.TENDO:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoTendoComo();
-            case delegua_1.default.TENTE:
+            case delegua_2.default.TENTE:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoTente();
-            case delegua_1.default.VARIAVEL:
+            case delegua_2.default.VARIAVEL:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoDeVariaveis();
         }
         const simboloAtual = this.simbolos[this.atual];
-        if (simboloAtual.tipo === delegua_1.default.IDENTIFICADOR) {
+        if (simboloAtual.tipo === delegua_2.default.IDENTIFICADOR) {
             // Pela gramática, a seguinte situação não pode ocorrer:
             // 1. O símbolo anterior ser um identificador; e
             // 2. O símbolo anterior estar na mesma linha do identificador atual.
             const simboloAnterior = this.simbolos[this.atual - 1];
             if (!!simboloAnterior &&
-                simboloAnterior.tipo === delegua_1.default.IDENTIFICADOR &&
+                simboloAnterior.tipo === delegua_2.default.IDENTIFICADOR &&
                 simboloAnterior.linha === simboloAtual.linha) {
                 this.erro(this.simbolos[this.atual], 'Não é permitido ter dois identificadores seguidos na mesma linha.');
             }
@@ -1018,19 +1023,19 @@ class AvaliadorSintatico {
     declaracaoTendoComo() {
         const simboloTendo = this.simbolos[this.atual - 1];
         const expressaoInicializacao = this.expressao();
-        this.consumir(delegua_1.default.COMO, "Esperado palavra reservada 'como' após expressão de inicialização de variável, em declaração 'tendo'.");
-        const simboloNomeVariavel = this.consumir(delegua_1.default.IDENTIFICADOR, "Esperado nome do identificador em declaração 'tendo'.");
-        this.consumir(delegua_1.default.CHAVE_ESQUERDA, "Esperado chave esquerda para abertura de bloco em declaração 'tendo'.");
+        this.consumir(delegua_2.default.COMO, "Esperado palavra reservada 'como' após expressão de inicialização de variável, em declaração 'tendo'.");
+        const simboloNomeVariavel = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado nome do identificador em declaração 'tendo'.");
+        this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado chave esquerda para abertura de bloco em declaração 'tendo'.");
         const blocoCorpo = this.blocoEscopo();
         return new declaracoes_1.TendoComo(simboloTendo.linha, simboloTendo.hashArquivo, simboloNomeVariavel, expressaoInicializacao, new declaracoes_1.Bloco(simboloTendo.linha, simboloTendo.hashArquivo, blocoCorpo));
     }
     declaracaoDesestruturacaoVariavel() {
         const identificadores = [];
         do {
-            identificadores.push(this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome da variável.'));
-        } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
-        this.consumir(delegua_1.default.CHAVE_DIREITA, 'Esperado chave direita para concluir relação de variáveis a serem desestruturadas.');
-        this.consumir(delegua_1.default.IGUAL, 'Esperado igual após relação de propriedades da desestruturação.');
+            identificadores.push(this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da variável.'));
+        } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
+        this.consumir(delegua_2.default.CHAVE_DIREITA, 'Esperado chave direita para concluir relação de variáveis a serem desestruturadas.');
+        this.consumir(delegua_2.default.IGUAL, 'Esperado igual após relação de propriedades da desestruturação.');
         const inicializador = this.expressao();
         // TODO: Para cada variável dos identificadores, emitir um `AcessoMetodoOuPropriedade` usando
         // como prefixo o nome do inicializador, e o sufixo o nome de cada propriedade.
@@ -1048,45 +1053,45 @@ class AvaliadorSintatico {
         const identificadores = [];
         let retorno = [];
         let tipo = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.CHAVE_ESQUERDA)) {
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_ESQUERDA)) {
             return this.declaracaoDesestruturacaoVariavel();
         }
         do {
-            identificadores.push(this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome da variável.'));
-        } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.DOIS_PONTOS)) {
+            identificadores.push(this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da variável.'));
+        } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DOIS_PONTOS)) {
             tipo = this.verificarDefinicaoTipoAtual();
             this.avancarEDevolverAnterior();
         }
-        if (!this.verificarSeSimboloAtualEIgualA(delegua_1.default.IGUAL)) {
+        if (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL)) {
             // Inicialização de variáveis sem valor.
             for (let [indice, identificador] of identificadores.entries()) {
                 retorno.push(new declaracoes_1.Var(identificador, null, tipo));
             }
-            this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+            this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
             return retorno;
         }
         const inicializadores = [];
         do {
             inicializadores.push(this.expressao());
-        } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
+        } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         if (identificadores.length !== inicializadores.length) {
             throw this.erro(this.simboloAtual(), 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
         }
         for (let [indice, identificador] of identificadores.entries()) {
-            tipo = inicializadores[indice] instanceof tuplas_1.Tupla ? delegua_2.default.TUPLA : tipo;
+            tipo = inicializadores[indice] instanceof tuplas_1.Tupla ? delegua_1.default.TUPLA : tipo;
             retorno.push(new declaracoes_1.Var(identificador, inicializadores[indice], tipo));
         }
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return retorno;
     }
     declaracaoDesestruturacaoConstante() {
         const identificadores = [];
         do {
-            identificadores.push(this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome da variável.'));
-        } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
-        this.consumir(delegua_1.default.CHAVE_DIREITA, 'Esperado chave direita para concluir relação de variáveis a serem desestruturadas.');
-        this.consumir(delegua_1.default.IGUAL, 'Esperado igual após relação de propriedades da desestruturação.');
+            identificadores.push(this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da variável.'));
+        } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
+        this.consumir(delegua_2.default.CHAVE_DIREITA, 'Esperado chave direita para concluir relação de variáveis a serem desestruturadas.');
+        this.consumir(delegua_2.default.IGUAL, 'Esperado igual após relação de propriedades da desestruturação.');
         const inicializador = this.expressao();
         // TODO: Para cada variável dos identificadores, emitir um `AcessoMetodoOuPropriedade` usando
         // como prefixo o nome do inicializador, e o sufixo o nome de cada propriedade.
@@ -1103,21 +1108,21 @@ class AvaliadorSintatico {
     declaracaoDeConstantes() {
         const identificadores = [];
         let tipo = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.CHAVE_ESQUERDA)) {
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_ESQUERDA)) {
             return this.declaracaoDesestruturacaoConstante();
         }
         do {
-            identificadores.push(this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome da constante.'));
-        } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.DOIS_PONTOS)) {
+            identificadores.push(this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da constante.'));
+        } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DOIS_PONTOS)) {
             tipo = this.verificarDefinicaoTipoAtual();
             this.avancarEDevolverAnterior();
         }
-        this.consumir(delegua_1.default.IGUAL, "Esperado '=' após identificador em instrução 'constante'.");
+        this.consumir(delegua_2.default.IGUAL, "Esperado '=' após identificador em instrução 'constante'.");
         const inicializadores = [];
         do {
             inicializadores.push(this.expressao());
-        } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
+        } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         if (identificadores.length !== inicializadores.length) {
             throw this.erro(this.simboloAtual(), 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
         }
@@ -1125,18 +1130,18 @@ class AvaliadorSintatico {
         for (let [indice, identificador] of identificadores.entries()) {
             retorno.push(new declaracoes_1.Const(identificador, inicializadores[indice], tipo));
         }
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return retorno;
     }
     funcao(tipo) {
         let simbolo;
         switch (this.simbolos[this.atual].tipo) {
-            case delegua_1.default.CONSTRUTOR:
+            case delegua_2.default.CONSTRUTOR:
                 simbolo = this.avancarEDevolverAnterior();
                 this.pilhaDecoradores = [];
                 break;
             default:
-                simbolo = this.consumir(delegua_1.default.IDENTIFICADOR, `Esperado nome de ${tipo}.`);
+                simbolo = this.consumir(delegua_2.default.IDENTIFICADOR, `Esperado nome de ${tipo}.`);
                 break;
         }
         return new declaracoes_1.FuncaoDeclaracao(simbolo, this.corpoDaFuncao(tipo), null, this.pilhaDecoradores);
@@ -1145,18 +1150,18 @@ class AvaliadorSintatico {
         const parametros = [];
         do {
             const parametro = {};
-            if (this.simbolos[this.atual].tipo === delegua_1.default.MULTIPLICACAO) {
-                this.consumir(delegua_1.default.MULTIPLICACAO, null);
+            if (this.simbolos[this.atual].tipo === delegua_2.default.MULTIPLICACAO) {
+                this.consumir(delegua_2.default.MULTIPLICACAO, null);
                 parametro.abrangencia = 'multiplo';
             }
             else {
                 parametro.abrangencia = 'padrao';
             }
-            parametro.nome = this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome do parâmetro.');
-            if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.IGUAL)) {
+            parametro.nome = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome do parâmetro.');
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL)) {
                 parametro.valorPadrao = this.primario();
             }
-            if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.DOIS_PONTOS)) {
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DOIS_PONTOS)) {
                 let tipoDadoParametro = this.verificarDefinicaoTipoAtual();
                 parametro.tipoDado = {
                     nome: this.simbolos[this.atual - 2].lexema,
@@ -1168,43 +1173,43 @@ class AvaliadorSintatico {
             parametros.push(parametro);
             if (parametro.abrangencia === 'multiplo')
                 break;
-        } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
+        } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         return parametros;
     }
     corpoDaFuncao(tipo) {
         // O parêntese esquerdo é considerado o símbolo inicial para
         // fins de pragma.
-        const parenteseEsquerdo = this.consumir(delegua_1.default.PARENTESE_ESQUERDO, `Esperado '(' após o nome ${tipo}.`);
+        const parenteseEsquerdo = this.consumir(delegua_2.default.PARENTESE_ESQUERDO, `Esperado '(' após o nome ${tipo}.`);
         let parametros = [];
-        if (!this.verificarTipoSimboloAtual(delegua_1.default.PARENTESE_DIREITO)) {
+        if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
             parametros = this.logicaComumParametros();
         }
-        this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+        this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
         let tipoRetorno = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.DOIS_PONTOS)) {
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DOIS_PONTOS)) {
             tipoRetorno = this.verificarDefinicaoTipoAtual();
             this.avancarEDevolverAnterior();
         }
-        this.consumir(delegua_1.default.CHAVE_ESQUERDA, `Esperado '{' antes do escopo do ${tipo}.`);
+        this.consumir(delegua_2.default.CHAVE_ESQUERDA, `Esperado '{' antes do escopo do ${tipo}.`);
         const corpo = this.blocoEscopo();
         return new construtos_1.FuncaoConstruto(this.hashArquivo, Number(parenteseEsquerdo.linha), parametros, corpo, tipoRetorno);
     }
     declaracaoDeClasse() {
-        const simbolo = this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome da classe.');
+        const simbolo = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da classe.');
         const pilhaDecoradoresClasse = this.pilhaDecoradores;
         let superClasse = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.HERDA)) {
-            this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome da Superclasse.');
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.HERDA)) {
+            this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da Superclasse.');
             superClasse = new construtos_1.Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
         }
-        this.consumir(delegua_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo da classe.");
+        this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo da classe.");
         this.pilhaDecoradores = [];
         const metodos = [];
         const propriedades = [];
-        while (!this.verificarTipoSimboloAtual(delegua_1.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
+        while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
             // Se o símbolo atual é arroba, é um decorador.
             // Caso contrário, verificamos o próximo símbolo.
-            if (this.simbolos[this.atual].tipo === delegua_1.default.ARROBA) {
+            if (this.simbolos[this.atual].tipo === delegua_2.default.ARROBA) {
                 this.resolverDecorador();
                 continue;
             }
@@ -1212,15 +1217,15 @@ class AvaliadorSintatico {
             // Caso contrário, é uma propriedade.
             const proximoSimbolo = this.simbolos[this.atual + 1];
             switch (proximoSimbolo.tipo) {
-                case delegua_1.default.PARENTESE_ESQUERDO:
+                case delegua_2.default.PARENTESE_ESQUERDO:
                     metodos.push(this.funcao('método'));
                     this.pilhaDecoradores = [];
                     break;
-                case delegua_1.default.DOIS_PONTOS:
-                    const nomePropriedade = this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado identificador para nome de propriedade.');
-                    this.consumir(delegua_1.default.DOIS_PONTOS, 'Esperado dois-pontos após nome de propriedade.');
+                case delegua_2.default.DOIS_PONTOS:
+                    const nomePropriedade = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado identificador para nome de propriedade.');
+                    this.consumir(delegua_2.default.DOIS_PONTOS, 'Esperado dois-pontos após nome de propriedade.');
                     const tipoPropriedade = this.avancarEDevolverAnterior();
-                    this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+                    this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
                     propriedades.push(new declaracoes_1.PropriedadeClasse(nomePropriedade, tipoPropriedade.lexema, this.pilhaDecoradores));
                     this.pilhaDecoradores = [];
                     break;
@@ -1228,7 +1233,7 @@ class AvaliadorSintatico {
                     throw this.erro(this.simbolos[this.atual], 'Esperado definição de método ou propriedade.');
             }
         }
-        this.consumir(delegua_1.default.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
+        this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
         return new declaracoes_1.Classe(simbolo, superClasse, metodos, propriedades, pilhaDecoradoresClasse);
     }
     /**
@@ -1241,13 +1246,13 @@ class AvaliadorSintatico {
      */
     resolverDeclaracaoForaDeBloco() {
         try {
-            if ((this.verificarTipoSimboloAtual(delegua_1.default.FUNCAO) ||
-                this.verificarTipoSimboloAtual(delegua_1.default.FUNÇÃO)) &&
-                this.verificarTipoProximoSimbolo(delegua_1.default.IDENTIFICADOR)) {
+            if ((this.verificarTipoSimboloAtual(delegua_2.default.FUNCAO) ||
+                this.verificarTipoSimboloAtual(delegua_2.default.FUNÇÃO)) &&
+                this.verificarTipoProximoSimbolo(delegua_2.default.IDENTIFICADOR)) {
                 this.avancarEDevolverAnterior();
                 return this.funcao('funcao');
             }
-            if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.CLASSE)) {
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CLASSE)) {
                 return this.declaracaoDeClasse();
             }
             return this.resolverDeclaracao();
@@ -1268,15 +1273,15 @@ class AvaliadorSintatico {
         while (!this.estaNoFinal()) {
             const tipoSimboloAtual = this.simbolos[this.atual - 1].tipo;
             switch (tipoSimboloAtual) {
-                case delegua_1.default.CLASSE:
-                case delegua_1.default.FUNCAO:
-                case delegua_1.default.FUNÇÃO:
-                case delegua_1.default.VARIAVEL:
-                case delegua_1.default.PARA:
-                case delegua_1.default.SE:
-                case delegua_1.default.ENQUANTO:
-                case delegua_1.default.ESCREVA:
-                case delegua_1.default.RETORNA:
+                case delegua_2.default.CLASSE:
+                case delegua_2.default.FUNCAO:
+                case delegua_2.default.FUNÇÃO:
+                case delegua_2.default.VARIAVEL:
+                case delegua_2.default.PARA:
+                case delegua_2.default.SE:
+                case delegua_2.default.ENQUANTO:
+                case delegua_2.default.ESCREVA:
+                case delegua_2.default.RETORNA:
                     return;
             }
             this.avancarEDevolverAnterior();
@@ -1313,7 +1318,7 @@ class AvaliadorSintatico {
 }
 exports.AvaliadorSintatico = AvaliadorSintatico;
 
-},{"../construtos":40,"../construtos/tuplas":49,"../declaracoes":78,"../lexador":146,"../tipos-de-dados/delegua":154,"../tipos-de-simbolos/delegua":157,"./erro-avaliador-sintatico":7,"browser-process-hrtime":332}],3:[function(require,module,exports){
+},{"../construtos":39,"../construtos/tuplas":48,"../declaracoes":77,"../lexador":146,"../tipos-de-dados/delegua":154,"../tipos-de-simbolos/delegua":157,"./erro-avaliador-sintatico":7,"browser-process-hrtime":332}],3:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -1963,7 +1968,7 @@ class AvaliadorSintaticoEguaClassico {
 }
 exports.AvaliadorSintaticoEguaClassico = AvaliadorSintaticoEguaClassico;
 
-},{"../../construtos":40,"../../declaracoes":78,"../../tipos-de-simbolos/egua-classico":158,"../erro-avaliador-sintatico":7}],4:[function(require,module,exports){
+},{"../../construtos":39,"../../declaracoes":77,"../../tipos-de-simbolos/egua-classico":158,"../erro-avaliador-sintatico":7}],4:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -2735,7 +2740,7 @@ class AvaliadorSintaticoPitugues {
 }
 exports.AvaliadorSintaticoPitugues = AvaliadorSintaticoPitugues;
 
-},{"../../construtos":40,"../../declaracoes":78,"../../lexador":146,"../../tipos-de-simbolos/pitugues":161,"../erro-avaliador-sintatico":7,"browser-process-hrtime":332}],5:[function(require,module,exports){
+},{"../../construtos":39,"../../declaracoes":77,"../../lexador":146,"../../tipos-de-simbolos/pitugues":161,"../erro-avaliador-sintatico":7,"browser-process-hrtime":332}],5:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -2905,7 +2910,7 @@ class AvaliadorSintaticoPortugolIpt extends avaliador_sintatico_base_1.Avaliador
 }
 exports.AvaliadorSintaticoPortugolIpt = AvaliadorSintaticoPortugolIpt;
 
-},{"../../construtos":40,"../../declaracoes":78,"../../tipos-de-simbolos/portugol-ipt":162,"../avaliador-sintatico-base":1}],6:[function(require,module,exports){
+},{"../../construtos":39,"../../declaracoes":77,"../../tipos-de-simbolos/portugol-ipt":162,"../avaliador-sintatico-base":1}],6:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -3081,7 +3086,7 @@ class MicroAvaliadorSintaticoBase {
 }
 exports.MicroAvaliadorSintaticoBase = MicroAvaliadorSintaticoBase;
 
-},{"../construtos":40,"../tipos-de-simbolos/comum":156,"./erro-avaliador-sintatico":7}],10:[function(require,module,exports){
+},{"../construtos":39,"../tipos-de-simbolos/comum":156,"./erro-avaliador-sintatico":7}],10:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -3370,7 +3375,7 @@ class MicroAvaliadorSintatico extends micro_avaliador_sintatico_base_1.MicroAval
 }
 exports.MicroAvaliadorSintatico = MicroAvaliadorSintatico;
 
-},{"../construtos":40,"../tipos-de-simbolos/microgramaticas/delegua":160,"./erro-avaliador-sintatico":7,"./micro-avaliador-sintatico-base":9}],11:[function(require,module,exports){
+},{"../construtos":39,"../tipos-de-simbolos/microgramaticas/delegua":160,"./erro-avaliador-sintatico":7,"./micro-avaliador-sintatico-base":9}],11:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -3903,7 +3908,7 @@ async function tupla(interpretador, vetor) {
 }
 exports.tupla = tupla;
 
-},{"../construtos":40,"../estruturas":101,"../estruturas/delegua-classe":98,"../estruturas/funcao-padrao":100,"../estruturas/objeto-delegua-classe":104,"../excecoes":107}],16:[function(require,module,exports){
+},{"../construtos":39,"../estruturas":100,"../estruturas/delegua-classe":97,"../estruturas/funcao-padrao":99,"../estruturas/objeto-delegua-classe":103,"../excecoes":106}],16:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
@@ -4171,11 +4176,17 @@ exports.Atribuir = void 0;
  * Construto de atribuição de um valor a um símbolo.
  */
 class Atribuir {
-    constructor(hashArquivo, simbolo, valor) {
+    constructor(hashArquivo, simbolo, valor, 
+    // indice so é usado para variaveis de vetores
+    // TODO: criar alguma validaçao para garantir que indice so seja passado para variaveis de vetores
+    indice) {
         this.linha = Number(simbolo.linha);
         this.hashArquivo = hashArquivo;
         this.simbolo = simbolo;
         this.valor = valor;
+        if (indice !== undefined) {
+            this.indice = indice;
+        }
     }
     async aceitar(visitante) {
         return await visitante.visitarExpressaoDeAtribuicao(this);
@@ -4189,14 +4200,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Binario = void 0;
 /**
  * Binário é uma estrutura com um operador e dois operandos: esquerda e direita.
- * Implementa as seguintes operações:
+ * Implementa as seguintes operações para Delégua e todos os dialetos:
  *
- * - `+` (Adição) e `+=` (Adição com Atribuição)
- * - `-` (Subtração) e `-=` (Subtração com Atribuição)
- * - `*` (Multiplicação) e `*=` (Multiplicação com Atribuição)
- * - `/` (Divisão) e `/=` (Divisão com Atribuição)
- * - `%` (Módulo) e `%=` (Módulo com Atribuição)
- * - `**` (Exponenciação)
+ * - `+` (Adição);
+ * - `-` (Subtração);
+ * - `*` (Multiplicação);
+ * - `/` (Divisão);
+ * - `%` (Módulo);
+ *
+ * Algumas outras operações podem ser suportadas de dialeto para dialeto,
+ * como por exemplo:
+ *
+ * - `+=` (Adição com Atribuição);
+ * - `-=` (Subtração com Atribuição);
+ * - `*=` (Multiplicação com Atribuição);
+ * - `/=` (Divisão com Atribuição);
+ * - `%=` (Módulo com Atribuição);
+ * - `**` (Exponenciação);
+ * - `::` (Concatenação);
+ * - `\` (Divisão inteira).
  */
 class Binario {
     constructor(hashArquivo, esquerda, operador, direita) {
@@ -4235,7 +4257,7 @@ class Chamada {
 }
 exports.Chamada = Chamada;
 
-},{"../geracao-identificadores":110}],29:[function(require,module,exports){
+},{"../geracao-identificadores":109}],29:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Comentario = void 0;
@@ -4260,33 +4282,6 @@ exports.Comentario = Comentario;
 },{}],30:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConstanteOuVariavel = void 0;
-/**
- * Este construto existe para alguns dialetos, como Potigol, onde
- * não é possível definir se um construto é constante, variável,
- * identificador de função, tipo ou classe no momento da avaliação
- * primária.
- *
- * Durante o restante da avaliação sintática, esse construto deve **obrigatoriamente**
- * resolver para `Constante`, `Variavel` ou algum construto de chamada/declaração de
- * função.
- */
-class ConstanteOuVariavel {
-    constructor(hashArquivo, simbolo) {
-        this.linha = Number(simbolo.linha);
-        this.hashArquivo = hashArquivo;
-        this.simbolo = simbolo;
-    }
-    async aceitar(visitante) {
-        return Promise.reject(new Error('Este método não deveria ser chamado. ' +
-            'O construto deve resolver como constante ou variável ainda na avaliação sintática.'));
-    }
-}
-exports.ConstanteOuVariavel = ConstanteOuVariavel;
-
-},{}],31:[function(require,module,exports){
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 exports.Constante = void 0;
 /**
  * O construto de constante.
@@ -4303,11 +4298,11 @@ class Constante {
 }
 exports.Constante = Constante;
 
-},{}],32:[function(require,module,exports){
+},{}],31:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],33:[function(require,module,exports){
+},{}],32:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Decorador = void 0;
@@ -4328,7 +4323,7 @@ class Decorador {
 }
 exports.Decorador = Decorador;
 
-},{}],34:[function(require,module,exports){
+},{}],33:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefinirValor = void 0;
@@ -4346,7 +4341,7 @@ class DefinirValor {
 }
 exports.DefinirValor = DefinirValor;
 
-},{}],35:[function(require,module,exports){
+},{}],34:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dicionario = void 0;
@@ -4363,7 +4358,7 @@ class Dicionario {
 }
 exports.Dicionario = Dicionario;
 
-},{}],36:[function(require,module,exports){
+},{}],35:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExpressaoRegular = void 0;
@@ -4380,7 +4375,7 @@ class ExpressaoRegular {
 }
 exports.ExpressaoRegular = ExpressaoRegular;
 
-},{}],37:[function(require,module,exports){
+},{}],36:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FimPara = void 0;
@@ -4407,7 +4402,7 @@ class FimPara {
 }
 exports.FimPara = FimPara;
 
-},{}],38:[function(require,module,exports){
+},{}],37:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FormatacaoEscrita = void 0;
@@ -4430,7 +4425,7 @@ class FormatacaoEscrita {
 }
 exports.FormatacaoEscrita = FormatacaoEscrita;
 
-},{}],39:[function(require,module,exports){
+},{}],38:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FuncaoConstruto = void 0;
@@ -4448,7 +4443,7 @@ class FuncaoConstruto {
 }
 exports.FuncaoConstruto = FuncaoConstruto;
 
-},{}],40:[function(require,module,exports){
+},{}],39:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -4476,7 +4471,6 @@ __exportStar(require("./binario"), exports);
 __exportStar(require("./chamada"), exports);
 __exportStar(require("./comentario"), exports);
 __exportStar(require("./constante"), exports);
-__exportStar(require("./constante-ou-variavel"), exports);
 __exportStar(require("./construto"), exports);
 __exportStar(require("./decorador"), exports);
 __exportStar(require("./definir-valor"), exports);
@@ -4496,7 +4490,7 @@ __exportStar(require("./variavel"), exports);
 __exportStar(require("./vetor"), exports);
 __exportStar(require("./qual-tipo"), exports);
 
-},{"./acesso-elemento-matriz":20,"./acesso-indice-variavel":21,"./acesso-metodo-ou-propriedade":22,"./agrupamento":23,"./atribuicao-por-indice":24,"./atribuicao-por-indices-matriz":25,"./atribuir":26,"./binario":27,"./chamada":28,"./comentario":29,"./constante":31,"./constante-ou-variavel":30,"./construto":32,"./decorador":33,"./definir-valor":34,"./dicionario":35,"./expressao-regular":36,"./fim-para":37,"./formatacao-escrita":38,"./funcao":39,"./isto":41,"./literal":42,"./logico":43,"./qual-tipo":44,"./super":45,"./tipo-de":46,"./tuplas":49,"./unario":58,"./variavel":59,"./vetor":60}],41:[function(require,module,exports){
+},{"./acesso-elemento-matriz":20,"./acesso-indice-variavel":21,"./acesso-metodo-ou-propriedade":22,"./agrupamento":23,"./atribuicao-por-indice":24,"./atribuicao-por-indices-matriz":25,"./atribuir":26,"./binario":27,"./chamada":28,"./comentario":29,"./constante":30,"./construto":31,"./decorador":32,"./definir-valor":33,"./dicionario":34,"./expressao-regular":35,"./fim-para":36,"./formatacao-escrita":37,"./funcao":38,"./isto":40,"./literal":41,"./logico":42,"./qual-tipo":43,"./super":44,"./tipo-de":45,"./tuplas":48,"./unario":57,"./variavel":58,"./vetor":59}],40:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Isto = void 0;
@@ -4512,7 +4506,7 @@ class Isto {
 }
 exports.Isto = Isto;
 
-},{}],42:[function(require,module,exports){
+},{}],41:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Literal = void 0;
@@ -4528,7 +4522,7 @@ class Literal {
 }
 exports.Literal = Literal;
 
-},{}],43:[function(require,module,exports){
+},{}],42:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logico = void 0;
@@ -4546,7 +4540,7 @@ class Logico {
 }
 exports.Logico = Logico;
 
-},{}],44:[function(require,module,exports){
+},{}],43:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QualTipo = void 0;
@@ -4564,7 +4558,7 @@ class QualTipo {
 }
 exports.QualTipo = QualTipo;
 
-},{}],45:[function(require,module,exports){
+},{}],44:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Super = void 0;
@@ -4581,7 +4575,7 @@ class Super {
 }
 exports.Super = Super;
 
-},{}],46:[function(require,module,exports){
+},{}],45:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TipoDe = void 0;
@@ -4598,7 +4592,7 @@ class TipoDe {
 }
 exports.TipoDe = TipoDe;
 
-},{}],47:[function(require,module,exports){
+},{}],46:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Deceto = void 0;
@@ -4632,7 +4626,7 @@ class Deceto extends tupla_1.Tupla {
 }
 exports.Deceto = Deceto;
 
-},{"./tupla":57}],48:[function(require,module,exports){
+},{"./tupla":56}],47:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dupla = void 0;
@@ -4646,7 +4640,7 @@ class Dupla extends tupla_1.Tupla {
 }
 exports.Dupla = Dupla;
 
-},{"./tupla":57}],49:[function(require,module,exports){
+},{"./tupla":56}],48:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -4715,7 +4709,7 @@ class SeletorTuplas {
 }
 exports.SeletorTuplas = SeletorTuplas;
 
-},{"./deceto":47,"./dupla":48,"./noneto":50,"./octeto":51,"./quarteto":52,"./quinteto":53,"./septeto":54,"./sexteto":55,"./trio":56,"./tupla":57}],50:[function(require,module,exports){
+},{"./deceto":46,"./dupla":47,"./noneto":49,"./octeto":50,"./quarteto":51,"./quinteto":52,"./septeto":53,"./sexteto":54,"./trio":55,"./tupla":56}],49:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Noneto = void 0;
@@ -4742,7 +4736,7 @@ class Noneto extends tupla_1.Tupla {
 }
 exports.Noneto = Noneto;
 
-},{"./tupla":57}],51:[function(require,module,exports){
+},{"./tupla":56}],50:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Octeto = void 0;
@@ -4768,7 +4762,7 @@ class Octeto extends tupla_1.Tupla {
 }
 exports.Octeto = Octeto;
 
-},{"./tupla":57}],52:[function(require,module,exports){
+},{"./tupla":56}],51:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Quarteto = void 0;
@@ -4784,7 +4778,7 @@ class Quarteto extends tupla_1.Tupla {
 }
 exports.Quarteto = Quarteto;
 
-},{"./tupla":57}],53:[function(require,module,exports){
+},{"./tupla":56}],52:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Quinteto = void 0;
@@ -4801,7 +4795,7 @@ class Quinteto extends tupla_1.Tupla {
 }
 exports.Quinteto = Quinteto;
 
-},{"./tupla":57}],54:[function(require,module,exports){
+},{"./tupla":56}],53:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Septeto = void 0;
@@ -4826,7 +4820,7 @@ class Septeto extends tupla_1.Tupla {
 }
 exports.Septeto = Septeto;
 
-},{"./tupla":57}],55:[function(require,module,exports){
+},{"./tupla":56}],54:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sexteto = void 0;
@@ -4844,7 +4838,7 @@ class Sexteto extends tupla_1.Tupla {
 }
 exports.Sexteto = Sexteto;
 
-},{"./tupla":57}],56:[function(require,module,exports){
+},{"./tupla":56}],55:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trio = void 0;
@@ -4859,7 +4853,7 @@ class Trio extends tupla_1.Tupla {
 }
 exports.Trio = Trio;
 
-},{"./tupla":57}],57:[function(require,module,exports){
+},{"./tupla":56}],56:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tupla = void 0;
@@ -4870,7 +4864,7 @@ class Tupla {
 }
 exports.Tupla = Tupla;
 
-},{}],58:[function(require,module,exports){
+},{}],57:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Unario = void 0;
@@ -4888,7 +4882,7 @@ class Unario {
 }
 exports.Unario = Unario;
 
-},{}],59:[function(require,module,exports){
+},{}],58:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Variavel = void 0;
@@ -4904,15 +4898,21 @@ class Variavel {
 }
 exports.Variavel = Variavel;
 
-},{}],60:[function(require,module,exports){
+},{}],59:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vetor = void 0;
 class Vetor {
-    constructor(hashArquivo, linha, valores) {
+    constructor(hashArquivo, linha, valores, tamanho) {
         this.linha = linha;
         this.hashArquivo = hashArquivo;
         this.valores = valores;
+        if (tamanho) {
+            this.tamanho = tamanho;
+        }
+        else {
+            this.tamanho = this.valores.length;
+        }
     }
     async aceitar(visitante) {
         return await visitante.visitarExpressaoVetor(this);
@@ -4920,7 +4920,7 @@ class Vetor {
 }
 exports.Vetor = Vetor;
 
-},{}],61:[function(require,module,exports){
+},{}],60:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Aleatorio = void 0;
@@ -4937,7 +4937,7 @@ class Aleatorio extends declaracao_1.Declaracao {
 }
 exports.Aleatorio = Aleatorio;
 
-},{"./declaracao":68}],62:[function(require,module,exports){
+},{"./declaracao":67}],61:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Bloco = void 0;
@@ -4953,7 +4953,7 @@ class Bloco extends declaracao_1.Declaracao {
 }
 exports.Bloco = Bloco;
 
-},{"./declaracao":68}],63:[function(require,module,exports){
+},{"./declaracao":67}],62:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CabecalhoPrograma = void 0;
@@ -4969,7 +4969,7 @@ class CabecalhoPrograma extends declaracao_1.Declaracao {
 }
 exports.CabecalhoPrograma = CabecalhoPrograma;
 
-},{"./declaracao":68}],64:[function(require,module,exports){
+},{"./declaracao":67}],63:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Classe = void 0;
@@ -4989,7 +4989,7 @@ class Classe extends declaracao_1.Declaracao {
 }
 exports.Classe = Classe;
 
-},{"./declaracao":68}],65:[function(require,module,exports){
+},{"./declaracao":67}],64:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstMultiplo = void 0;
@@ -5010,7 +5010,7 @@ class ConstMultiplo extends declaracao_1.Declaracao {
 }
 exports.ConstMultiplo = ConstMultiplo;
 
-},{"./declaracao":68}],66:[function(require,module,exports){
+},{"./declaracao":67}],65:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Const = void 0;
@@ -5031,7 +5031,7 @@ class Const extends declaracao_1.Declaracao {
 }
 exports.Const = Const;
 
-},{"./declaracao":68}],67:[function(require,module,exports){
+},{"./declaracao":67}],66:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Continua = void 0;
@@ -5046,7 +5046,7 @@ class Continua extends declaracao_1.Declaracao {
 }
 exports.Continua = Continua;
 
-},{"./declaracao":68}],68:[function(require,module,exports){
+},{"./declaracao":67}],67:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Declaracao = void 0;
@@ -5065,7 +5065,7 @@ class Declaracao {
 }
 exports.Declaracao = Declaracao;
 
-},{}],69:[function(require,module,exports){
+},{}],68:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Enquanto = void 0;
@@ -5082,7 +5082,7 @@ class Enquanto extends declaracao_1.Declaracao {
 }
 exports.Enquanto = Enquanto;
 
-},{"./declaracao":68}],70:[function(require,module,exports){
+},{"./declaracao":67}],69:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Escolha = void 0;
@@ -5103,7 +5103,7 @@ class Escolha extends declaracao_1.Declaracao {
 }
 exports.Escolha = Escolha;
 
-},{"./declaracao":68}],71:[function(require,module,exports){
+},{"./declaracao":67}],70:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EscrevaMesmaLinha = void 0;
@@ -5119,7 +5119,7 @@ class EscrevaMesmaLinha extends declaracao_1.Declaracao {
 }
 exports.EscrevaMesmaLinha = EscrevaMesmaLinha;
 
-},{"./declaracao":68}],72:[function(require,module,exports){
+},{"./declaracao":67}],71:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Escreva = void 0;
@@ -5135,7 +5135,7 @@ class Escreva extends declaracao_1.Declaracao {
 }
 exports.Escreva = Escreva;
 
-},{"./declaracao":68}],73:[function(require,module,exports){
+},{"./declaracao":67}],72:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Expressao = void 0;
@@ -5151,7 +5151,7 @@ class Expressao extends declaracao_1.Declaracao {
 }
 exports.Expressao = Expressao;
 
-},{"./declaracao":68}],74:[function(require,module,exports){
+},{"./declaracao":67}],73:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Falhar = void 0;
@@ -5168,7 +5168,7 @@ class Falhar extends declaracao_1.Declaracao {
 }
 exports.Falhar = Falhar;
 
-},{"./declaracao":68}],75:[function(require,module,exports){
+},{"./declaracao":67}],74:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Fazer = void 0;
@@ -5185,7 +5185,7 @@ class Fazer extends declaracao_1.Declaracao {
 }
 exports.Fazer = Fazer;
 
-},{"./declaracao":68}],76:[function(require,module,exports){
+},{"./declaracao":67}],75:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FuncaoDeclaracao = void 0;
@@ -5204,7 +5204,7 @@ class FuncaoDeclaracao extends declaracao_1.Declaracao {
 }
 exports.FuncaoDeclaracao = FuncaoDeclaracao;
 
-},{"./declaracao":68}],77:[function(require,module,exports){
+},{"./declaracao":67}],76:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Importar = void 0;
@@ -5221,7 +5221,7 @@ class Importar extends declaracao_1.Declaracao {
 }
 exports.Importar = Importar;
 
-},{"./declaracao":68}],78:[function(require,module,exports){
+},{"./declaracao":67}],77:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -5270,7 +5270,7 @@ __exportStar(require("./var"), exports);
 __exportStar(require("./var-multiplo"), exports);
 __exportStar(require("./aleatorio"), exports);
 
-},{"./aleatorio":61,"./bloco":62,"./cabecalho-programa":63,"./classe":64,"./const":66,"./const-multiplo":65,"./continua":67,"./declaracao":68,"./enquanto":69,"./escolha":70,"./escreva":72,"./escreva-mesma-linha":71,"./expressao":73,"./falhar":74,"./fazer":75,"./funcao":76,"./importar":77,"./inicio-algoritmo":79,"./leia":81,"./leia-multiplo":80,"./para":83,"./para-cada":82,"./propriedade-classe":84,"./retorna":85,"./se":86,"./sustar":87,"./tendo-como":88,"./tente":89,"./var":91,"./var-multiplo":90}],79:[function(require,module,exports){
+},{"./aleatorio":60,"./bloco":61,"./cabecalho-programa":62,"./classe":63,"./const":65,"./const-multiplo":64,"./continua":66,"./declaracao":67,"./enquanto":68,"./escolha":69,"./escreva":71,"./escreva-mesma-linha":70,"./expressao":72,"./falhar":73,"./fazer":74,"./funcao":75,"./importar":76,"./inicio-algoritmo":78,"./leia":80,"./leia-multiplo":79,"./para":82,"./para-cada":81,"./propriedade-classe":83,"./retorna":84,"./se":85,"./sustar":86,"./tendo-como":87,"./tente":88,"./var":90,"./var-multiplo":89}],78:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InicioAlgoritmo = void 0;
@@ -5285,7 +5285,7 @@ class InicioAlgoritmo extends declaracao_1.Declaracao {
 }
 exports.InicioAlgoritmo = InicioAlgoritmo;
 
-},{"./declaracao":68}],80:[function(require,module,exports){
+},{"./declaracao":67}],79:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LeiaMultiplo = void 0;
@@ -5308,7 +5308,7 @@ class LeiaMultiplo extends declaracao_1.Declaracao {
 }
 exports.LeiaMultiplo = LeiaMultiplo;
 
-},{"../geracao-identificadores":110,"./declaracao":68}],81:[function(require,module,exports){
+},{"../geracao-identificadores":109,"./declaracao":67}],80:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Leia = void 0;
@@ -5331,7 +5331,7 @@ class Leia extends declaracao_1.Declaracao {
 }
 exports.Leia = Leia;
 
-},{"../geracao-identificadores":110,"./declaracao":68}],82:[function(require,module,exports){
+},{"../geracao-identificadores":109,"./declaracao":67}],81:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParaCada = void 0;
@@ -5350,7 +5350,7 @@ class ParaCada extends declaracao_1.Declaracao {
 }
 exports.ParaCada = ParaCada;
 
-},{"./declaracao":68}],83:[function(require,module,exports){
+},{"./declaracao":67}],82:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Para = void 0;
@@ -5376,7 +5376,7 @@ class Para extends declaracao_1.Declaracao {
 }
 exports.Para = Para;
 
-},{"./declaracao":68}],84:[function(require,module,exports){
+},{"./declaracao":67}],83:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PropriedadeClasse = void 0;
@@ -5394,7 +5394,7 @@ class PropriedadeClasse extends declaracao_1.Declaracao {
 }
 exports.PropriedadeClasse = PropriedadeClasse;
 
-},{"./declaracao":68}],85:[function(require,module,exports){
+},{"./declaracao":67}],84:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Retorna = void 0;
@@ -5411,7 +5411,7 @@ class Retorna extends declaracao_1.Declaracao {
 }
 exports.Retorna = Retorna;
 
-},{"./declaracao":68}],86:[function(require,module,exports){
+},{"./declaracao":67}],85:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Se = void 0;
@@ -5430,7 +5430,7 @@ class Se extends declaracao_1.Declaracao {
 }
 exports.Se = Se;
 
-},{"./declaracao":68}],87:[function(require,module,exports){
+},{"./declaracao":67}],86:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sustar = void 0;
@@ -5445,7 +5445,7 @@ class Sustar extends declaracao_1.Declaracao {
 }
 exports.Sustar = Sustar;
 
-},{"./declaracao":68}],88:[function(require,module,exports){
+},{"./declaracao":67}],87:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TendoComo = void 0;
@@ -5468,7 +5468,7 @@ class TendoComo extends declaracao_1.Declaracao {
 }
 exports.TendoComo = TendoComo;
 
-},{"./declaracao":68}],89:[function(require,module,exports){
+},{"./declaracao":67}],88:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tente = void 0;
@@ -5490,7 +5490,7 @@ class Tente extends declaracao_1.Declaracao {
 }
 exports.Tente = Tente;
 
-},{"./declaracao":68}],90:[function(require,module,exports){
+},{"./declaracao":67}],89:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VarMultiplo = void 0;
@@ -5512,7 +5512,7 @@ class VarMultiplo extends declaracao_1.Declaracao {
 }
 exports.VarMultiplo = VarMultiplo;
 
-},{"./declaracao":68}],91:[function(require,module,exports){
+},{"./declaracao":67}],90:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Var = void 0;
@@ -5535,7 +5535,7 @@ class Var extends declaracao_1.Declaracao {
 }
 exports.Var = Var;
 
-},{"./declaracao":68}],92:[function(require,module,exports){
+},{"./declaracao":67}],91:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
@@ -5559,7 +5559,7 @@ function cyrb53(nomeArquivo, semente = 0) {
 }
 exports.default = cyrb53;
 
-},{}],93:[function(require,module,exports){
+},{}],92:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -5584,11 +5584,11 @@ var cyrb53_1 = require("./cyrb53");
 Object.defineProperty(exports, "cyrb53", { enumerable: true, get: function () { return __importDefault(cyrb53_1).default; } });
 __exportStar(require("./ponto-parada"), exports);
 
-},{"./cyrb53":92,"./ponto-parada":94}],94:[function(require,module,exports){
+},{"./cyrb53":91,"./ponto-parada":93}],93:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],95:[function(require,module,exports){
+},{}],94:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EspacoVariaveis = void 0;
@@ -5609,7 +5609,7 @@ class EspacoVariaveis {
 }
 exports.EspacoVariaveis = EspacoVariaveis;
 
-},{}],96:[function(require,module,exports){
+},{}],95:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Chamavel = void 0;
@@ -5623,7 +5623,7 @@ class Chamavel {
 }
 exports.Chamavel = Chamavel;
 
-},{}],97:[function(require,module,exports){
+},{}],96:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassePadrao = void 0;
@@ -5664,7 +5664,7 @@ class ClassePadrao extends chamavel_1.Chamavel {
 }
 exports.ClassePadrao = ClassePadrao;
 
-},{"./chamavel":96}],98:[function(require,module,exports){
+},{"./chamavel":95}],97:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeleguaClasse = void 0;
@@ -5743,7 +5743,7 @@ class DeleguaClasse extends chamavel_1.Chamavel {
 }
 exports.DeleguaClasse = DeleguaClasse;
 
-},{"../excecoes":107,"./chamavel":96,"./objeto-delegua-classe":104}],99:[function(require,module,exports){
+},{"../excecoes":106,"./chamavel":95,"./objeto-delegua-classe":103}],98:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeleguaFuncao = void 0;
@@ -5773,7 +5773,7 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
      */
     paraTexto() {
         var _a;
-        if (this.nome === null)
+        if (!this.nome)
             return '<função>';
         let resultado = `<função ${this.nome}`;
         let parametros = '';
@@ -5805,6 +5805,14 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
     toString() {
         return this.paraTexto();
     }
+    resolverParametrosEspalhados(argumentos, indiceArgumentoAtual) {
+        const argumentosResolvidos = [];
+        for (let i = indiceArgumentoAtual; i < argumentos.length; i++) {
+            const argumentoAtual = argumentos[i];
+            argumentosResolvidos.push(argumentoAtual && argumentoAtual.hasOwnProperty('valor') ? argumentoAtual.valor : argumentoAtual);
+        }
+        return argumentosResolvidos;
+    }
     async chamar(visitante, argumentos) {
         const ambiente = new espaco_variaveis_1.EspacoVariaveis();
         const parametros = this.declaracao.parametros || [];
@@ -5812,11 +5820,7 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
             const parametro = parametros[i];
             const nome = parametro['nome'].lexema;
             if (parametro.abrangencia === 'multiplo') {
-                const argumentosResolvidos = [];
-                for (let indiceArgumentoAtual = i; indiceArgumentoAtual < argumentos.length; indiceArgumentoAtual++) {
-                    const argumentoAtual = argumentos[indiceArgumentoAtual];
-                    argumentosResolvidos.push(argumentoAtual && argumentoAtual.hasOwnProperty('valor') ? argumentoAtual.valor : argumentoAtual);
-                }
+                const argumentosResolvidos = this.resolverParametrosEspalhados(argumentos, i);
                 // TODO: Verificar se `imutavel` é `true` aqui mesmo.
                 ambiente.valores[nome] = { tipo: 'vetor', valor: argumentosResolvidos, imutavel: true };
             }
@@ -5834,7 +5838,10 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
                 tipo: 'objeto',
                 imutavel: false,
             };
-            if (this.instancia.classe.dialetoRequerExpansaoPropriedadesEspacoVariaveis) {
+            // TODO: Apenass Potigol usa isso até então.
+            // Estudar mover isso para o dialeto.
+            if (this.instancia.classe.dialetoRequerExpansaoPropriedadesEspacoVariaveis &&
+                this.nome !== 'construtor') {
                 for (let [nomeCampo, valorCampo] of Object.entries(this.instancia.propriedades)) {
                     ambiente.valores[nomeCampo] = {
                         valor: valorCampo,
@@ -5879,7 +5886,7 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
 }
 exports.DeleguaFuncao = DeleguaFuncao;
 
-},{"../declaracoes":78,"../espaco-variaveis":95,"../interpretador/inferenciador":134,"../quebras":153,"./chamavel":96}],100:[function(require,module,exports){
+},{"../declaracoes":77,"../espaco-variaveis":94,"../interpretador/inferenciador":134,"../quebras":153,"./chamavel":95}],99:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FuncaoPadrao = void 0;
@@ -5915,7 +5922,7 @@ class FuncaoPadrao extends chamavel_1.Chamavel {
 }
 exports.FuncaoPadrao = FuncaoPadrao;
 
-},{"./chamavel":96}],101:[function(require,module,exports){
+},{"./chamavel":95}],100:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -5942,7 +5949,7 @@ __exportStar(require("./modulo"), exports);
 __exportStar(require("./objeto-delegua-classe"), exports);
 __exportStar(require("./objeto-padrao"), exports);
 
-},{"./chamavel":96,"./classe-padrao":97,"./delegua-classe":98,"./delegua-funcao":99,"./funcao-padrao":100,"./metodo-primitiva":102,"./modulo":103,"./objeto-delegua-classe":104,"./objeto-padrao":105}],102:[function(require,module,exports){
+},{"./chamavel":95,"./classe-padrao":96,"./delegua-classe":97,"./delegua-funcao":98,"./funcao-padrao":99,"./metodo-primitiva":101,"./modulo":102,"./objeto-delegua-classe":103,"./objeto-padrao":104}],101:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetodoPrimitiva = void 0;
@@ -5984,7 +5991,7 @@ class MetodoPrimitiva extends chamavel_1.Chamavel {
 }
 exports.MetodoPrimitiva = MetodoPrimitiva;
 
-},{"./chamavel":96}],103:[function(require,module,exports){
+},{"./chamavel":95}],102:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeleguaModulo = void 0;
@@ -6010,7 +6017,7 @@ class DeleguaModulo {
 }
 exports.DeleguaModulo = DeleguaModulo;
 
-},{}],104:[function(require,module,exports){
+},{}],103:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjetoDeleguaClasse = void 0;
@@ -6065,7 +6072,7 @@ class ObjetoDeleguaClasse {
 }
 exports.ObjetoDeleguaClasse = ObjetoDeleguaClasse;
 
-},{"../excecoes":107}],105:[function(require,module,exports){
+},{"../excecoes":106}],104:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjetoPadrao = void 0;
@@ -6099,7 +6106,7 @@ class ObjetoPadrao {
 }
 exports.ObjetoPadrao = ObjetoPadrao;
 
-},{}],106:[function(require,module,exports){
+},{}],105:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErroEmTempoDeExecucao = void 0;
@@ -6114,7 +6121,7 @@ class ErroEmTempoDeExecucao extends Error {
 }
 exports.ErroEmTempoDeExecucao = ErroEmTempoDeExecucao;
 
-},{}],107:[function(require,module,exports){
+},{}],106:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -6133,7 +6140,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./erro-em-tempo-de-execucao"), exports);
 
-},{"./erro-em-tempo-de-execucao":106}],108:[function(require,module,exports){
+},{"./erro-em-tempo-de-execucao":105}],107:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -6811,7 +6818,7 @@ class FormatadorDelegua {
 }
 exports.FormatadorDelegua = FormatadorDelegua;
 
-},{"../construtos":40,"../tipos-de-simbolos/delegua":157}],109:[function(require,module,exports){
+},{"../construtos":39,"../tipos-de-simbolos/delegua":157}],108:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -6830,7 +6837,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./formatador-delegua"), exports);
 
-},{"./formatador-delegua":108}],110:[function(require,module,exports){
+},{"./formatador-delegua":107}],109:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uuidv4 = void 0;
@@ -6855,7 +6862,7 @@ function uuidv4() {
 }
 exports.uuidv4 = uuidv4;
 
-},{}],111:[function(require,module,exports){
+},{}],110:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -6884,15 +6891,15 @@ __exportStar(require("./interpretador"), exports);
 __exportStar(require("./lexador"), exports);
 __exportStar(require("./tradutores"), exports);
 
-},{"./avaliador-sintatico":8,"./construtos":40,"./declaracoes":78,"./depuracao":93,"./formatadores":109,"./interfaces":116,"./interpretador":133,"./lexador":146,"./tradutores":163}],112:[function(require,module,exports){
+},{"./avaliador-sintatico":8,"./construtos":39,"./declaracoes":77,"./depuracao":92,"./formatadores":108,"./interfaces":116,"./interpretador":133,"./lexador":146,"./tradutores":163}],111:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],113:[function(require,module,exports){
+},{}],112:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 
-},{}],114:[function(require,module,exports){
+},{}],113:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiagnosticoSeveridade = void 0;
@@ -6904,7 +6911,7 @@ var DiagnosticoSeveridade;
     DiagnosticoSeveridade[DiagnosticoSeveridade["SUGESTAO"] = 3] = "SUGESTAO";
 })(DiagnosticoSeveridade = exports.DiagnosticoSeveridade || (exports.DiagnosticoSeveridade = {}));
 
-},{}],115:[function(require,module,exports){
+},{}],114:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -6923,7 +6930,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./diagnostico-analisador-semantico"), exports);
 
-},{"./diagnostico-analisador-semantico":114}],116:[function(require,module,exports){
+},{"./diagnostico-analisador-semantico":113}],115:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+
+},{}],116:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -6941,6 +6952,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./avaliador-sintatico-interface"), exports);
+__exportStar(require("./formatador-comum-interface"), exports);
 __exportStar(require("./interpretador-com-depuracao-interface"), exports);
 __exportStar(require("./interpretador-interface"), exports);
 __exportStar(require("./lexador-interface"), exports);
@@ -6956,7 +6968,7 @@ __exportStar(require("./construtos"), exports);
 __exportStar(require("./erros"), exports);
 __exportStar(require("./retornos"), exports);
 
-},{"./avaliador-sintatico-interface":112,"./construtos":113,"./erros":115,"./interpretador-com-depuracao-interface":117,"./interpretador-interface":118,"./lexador-interface":119,"./parametro-interface":120,"./pilha-interface":121,"./resolvedor-interface":122,"./retornos":123,"./retornos/retorno-execucao-interface":125,"./simbolo-interface":128,"./tradutor-interface":129,"./variavel-interface":130,"./visitante-comum-interface":131}],117:[function(require,module,exports){
+},{"./avaliador-sintatico-interface":111,"./construtos":112,"./erros":114,"./formatador-comum-interface":115,"./interpretador-com-depuracao-interface":117,"./interpretador-interface":118,"./lexador-interface":119,"./parametro-interface":120,"./pilha-interface":121,"./resolvedor-interface":122,"./retornos":123,"./retornos/retorno-execucao-interface":125,"./simbolo-interface":128,"./tradutor-interface":129,"./variavel-interface":130,"./visitante-comum-interface":131}],117:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 
@@ -7088,7 +7100,7 @@ function carregarBibliotecasGlobais(pilhaEscoposExecucao) {
 }
 exports.carregarBibliotecasGlobais = carregarBibliotecasGlobais;
 
-},{"../bibliotecas/biblioteca-global":15,"../estruturas/funcao-padrao":100}],133:[function(require,module,exports){
+},{"../bibliotecas/biblioteca-global":15,"../estruturas/funcao-padrao":99}],133:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -7525,6 +7537,12 @@ class InterpretadorBase {
         }
         return resultado;
     }
+    /**
+     * Lógica para verificação de valores iguais, para Delégua e alguns dialetos.
+     * @param esquerda Uma variável.
+     * @param direita Outra variável.
+     * @returns Verdadeiro se são iguais. Falso em caso contrário.
+     */
     eIgual(esquerda, direita) {
         if (esquerda === null && direita === null)
             return true;
@@ -7746,7 +7764,7 @@ class InterpretadorBase {
                     });
                 }
             }
-            // Por algum motivo misterioso, `entidadeChamada instanceof Chamavel` dá `false` em Liquido, 
+            // Por algum motivo misterioso, `entidadeChamada instanceof Chamavel` dá `false` em Liquido,
             // mesmo que esteja tudo certo com `DeleguaFuncao`,
             // então precisamos testar o nome do construtor também.
             if (entidadeChamada instanceof estruturas_1.Chamavel || entidadeChamada.constructor.name === 'DeleguaFuncao') {
@@ -7781,7 +7799,11 @@ class InterpretadorBase {
     async visitarExpressaoDeAtribuicao(expressao) {
         const valor = await this.avaliar(expressao.valor);
         const valorResolvido = valor !== undefined && valor.hasOwnProperty('valor') ? valor.valor : valor;
-        this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valorResolvido);
+        let indice = null;
+        if (expressao.indice) {
+            indice = await this.avaliar(expressao.indice);
+        }
+        this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valorResolvido, indice);
         return valorResolvido;
     }
     procurarVariavel(simbolo) {
@@ -8211,14 +8233,17 @@ class InterpretadorBase {
             }
             return objeto[valorIndice];
         }
-        else if (objeto.constructor === Object ||
+        if (objeto instanceof construtos_1.Vetor) {
+            return objeto.valores[valorIndice];
+        }
+        if (objeto.constructor === Object ||
             objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
             objeto instanceof estruturas_1.DeleguaFuncao ||
             objeto instanceof estruturas_1.DeleguaClasse ||
             objeto instanceof estruturas_1.DeleguaModulo) {
             return objeto[valorIndice] || null;
         }
-        else if (typeof objeto === primitivos_1.default.TEXTO) {
+        if (typeof objeto === primitivos_1.default.TEXTO) {
             if (!Number.isInteger(valorIndice)) {
                 return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha));
             }
@@ -8232,9 +8257,7 @@ class InterpretadorBase {
             }
             return objeto.charAt(valorIndice);
         }
-        else {
-            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.entidadeChamada.nome, 'Somente listas, dicionários, classes e objetos podem ter seus valores indexados.', expressao.linha));
-        }
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.entidadeChamada.nome, 'Somente listas, dicionários, classes e objetos podem ter seus valores indexados.', expressao.linha));
     }
     async visitarExpressaoDefinirValor(expressao) {
         const variavelObjeto = await this.avaliar(expressao.objeto);
@@ -8257,6 +8280,7 @@ class InterpretadorBase {
     }
     /**
      * Executa uma declaração de classe.
+     * Uma variável do tipo `DeleguaClasse` é adicionada à pilha de escopos de execução.
      * @param declaracao A declaração de classe.
      * @returns Sempre retorna nulo, por ser requerido pelo contrato de visita.
      */
@@ -8300,15 +8324,15 @@ class InterpretadorBase {
      */
     async visitarExpressaoAcessoMetodo(expressao) {
         let variavelObjeto = await this.avaliar(expressao.objeto);
-        // Este caso acontece quando há encadeamento de métodos. 
+        // Este caso acontece quando há encadeamento de métodos.
         // Por exemplo, `objeto1.metodo1().metodo2()`.
-        // Como `RetornoQuebra` também possui `valor`, precisamos extrair o 
+        // Como `RetornoQuebra` também possui `valor`, precisamos extrair o
         // valor dele primeiro.
         if (variavelObjeto.constructor.name === 'RetornoQuebra') {
             variavelObjeto = variavelObjeto.valor;
         }
         const objeto = variavelObjeto.hasOwnProperty('valor') ? variavelObjeto.valor : variavelObjeto;
-        // Outro caso que `instanceof` simplesmente não funciona para casos em Liquido, 
+        // Outro caso que `instanceof` simplesmente não funciona para casos em Liquido,
         // então testamos também o nome do construtor.
         if (objeto instanceof estruturas_1.ObjetoDeleguaClasse || objeto.constructor.name === 'ObjetoDeleguaClasse') {
             return objeto.obter(expressao.simbolo) || null;
@@ -8582,7 +8606,7 @@ class InterpretadorBase {
 exports.InterpretadorBase = InterpretadorBase;
 
 }).call(this)}).call(this,require('_process'))
-},{"../avaliador-sintatico":8,"../bibliotecas/primitivas-dicionario":16,"../bibliotecas/primitivas-numero":17,"../bibliotecas/primitivas-texto":18,"../bibliotecas/primitivas-vetor":19,"../construtos":40,"../espaco-variaveis":95,"../estruturas":101,"../estruturas/metodo-primitiva":102,"../excecoes":107,"../lexador":146,"../quebras":153,"../tipos-de-dados/delegua":154,"../tipos-de-dados/primitivos":155,"../tipos-de-simbolos/delegua":157,"./comum":132,"./inferenciador":134,"./pilha-escopos-execucao":137,"_process":371,"browser-process-hrtime":332}],136:[function(require,module,exports){
+},{"../avaliador-sintatico":8,"../bibliotecas/primitivas-dicionario":16,"../bibliotecas/primitivas-numero":17,"../bibliotecas/primitivas-texto":18,"../bibliotecas/primitivas-vetor":19,"../construtos":39,"../espaco-variaveis":94,"../estruturas":100,"../estruturas/metodo-primitiva":101,"../excecoes":106,"../lexador":146,"../quebras":153,"../tipos-de-dados/delegua":154,"../tipos-de-dados/primitivos":155,"../tipos-de-simbolos/delegua":157,"./comum":132,"./inferenciador":134,"./pilha-escopos-execucao":137,"_process":371,"browser-process-hrtime":332}],136:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -9152,7 +9176,7 @@ class InterpretadorComDepuracao extends interpretador_base_1.InterpretadorBase {
 }
 exports.InterpretadorComDepuracao = InterpretadorComDepuracao;
 
-},{"../declaracoes":78,"../espaco-variaveis":95,"../quebras":153,"./inferenciador":134,"./interpretador-base":135,"lodash":364}],137:[function(require,module,exports){
+},{"../declaracoes":77,"../espaco-variaveis":94,"../quebras":153,"./inferenciador":134,"./interpretador-base":135,"lodash":364}],137:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -9287,7 +9311,7 @@ class PilhaEscoposExecucao {
             imutavel: false,
         };
     }
-    atribuirVariavel(simbolo, valor) {
+    atribuirVariavel(simbolo, valor, indice) {
         for (let i = 1; i <= this.pilha.length; i++) {
             const ambiente = this.pilha[this.pilha.length - i].ambiente;
             if (ambiente.valores[simbolo.lexema] !== undefined) {
@@ -9297,11 +9321,21 @@ class PilhaEscoposExecucao {
                 }
                 const tipo = (variavel && variavel.hasOwnProperty('tipo') ? variavel.tipo : (0, inferenciador_1.inferirTipoVariavel)(valor)).toLowerCase();
                 const valorResolvido = this.converterValor(tipo, valor);
-                ambiente.valores[simbolo.lexema] = {
-                    valor: valorResolvido,
-                    tipo,
-                    imutavel: false,
-                };
+                if (indice !== undefined && indice !== null) {
+                    if (variavel.valor instanceof Array) {
+                        variavel.valor[indice] = valorResolvido;
+                    }
+                    else {
+                        throw new excecoes_1.ErroEmTempoDeExecucao(simbolo, "Variável não é um vetor.");
+                    }
+                }
+                else {
+                    ambiente.valores[simbolo.lexema] = {
+                        valor: valorResolvido,
+                        tipo,
+                        imutavel: false,
+                    };
+                }
                 return;
             }
         }
@@ -9387,7 +9421,7 @@ class PilhaEscoposExecucao {
 }
 exports.PilhaEscoposExecucao = PilhaEscoposExecucao;
 
-},{"../estruturas":101,"../excecoes":107,"../lexador":146,"../tipos-de-dados/delegua":154,"./inferenciador":134}],138:[function(require,module,exports){
+},{"../estruturas":100,"../excecoes":106,"../lexador":146,"../tipos-de-dados/delegua":154,"./inferenciador":134}],138:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -24993,7 +25027,7 @@ class TradutorAssemblyScript {
 }
 exports.TradutorAssemblyScript = TradutorAssemblyScript;
 
-},{"../construtos":40,"../declaracoes":78,"../tipos-de-simbolos/delegua":157}],167:[function(require,module,exports){
+},{"../construtos":39,"../declaracoes":77,"../tipos-de-simbolos/delegua":157}],167:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -25013,7 +25047,7 @@ class TradutorJavaScript {
         this.indentacao = 0;
         this.dicionarioConstrutos = {
             AcessoIndiceVariavel: this.traduzirAcessoIndiceVariavel.bind(this),
-            AcessoMetodoOuPropriedade: this.trazudirConstrutoAcessoMetodo.bind(this),
+            AcessoMetodoOuPropriedade: this.traduzirConstrutoAcessoMetodo.bind(this),
             Agrupamento: this.traduzirConstrutoAgrupamento.bind(this),
             AtribuicaoPorIndice: this.traduzirConstrutoAtribuicaoPorIndice.bind(this),
             Atribuir: this.traduzirConstrutoAtribuir.bind(this),
@@ -25180,14 +25214,18 @@ class TradutorJavaScript {
         else {
             resultado += retorno;
         }
-        resultado += '(';
+        if (!retorno.endsWith('length')) {
+            resultado += '(';
+        }
         for (let parametro of chamada.argumentos) {
             resultado += this.dicionarioConstrutos[parametro.constructor.name](parametro) + ', ';
         }
         if (chamada.argumentos.length > 0) {
             resultado = resultado.slice(0, -2);
         }
-        resultado += ')';
+        if (!retorno.endsWith('length')) {
+            resultado += ')';
+        }
         return resultado;
     }
     traduzirConstrutoComentario(comentario) {
@@ -25469,7 +25507,7 @@ class TradutorJavaScript {
         }
         return resultado;
     }
-    trazudirConstrutoAcessoMetodo(acessoMetodo) {
+    traduzirConstrutoAcessoMetodo(acessoMetodo) {
         if (acessoMetodo.objeto instanceof construtos_1.Variavel) {
             let objetoVariavel = acessoMetodo.objeto;
             return `${objetoVariavel.simbolo.lexema}.${this.traduzirFuncoesNativas(acessoMetodo.simbolo.lexema)}`;
@@ -25568,7 +25606,7 @@ class TradutorJavaScript {
 }
 exports.TradutorJavaScript = TradutorJavaScript;
 
-},{"../construtos":40,"../declaracoes":78,"../tipos-de-simbolos/delegua":157}],168:[function(require,module,exports){
+},{"../construtos":39,"../declaracoes":77,"../tipos-de-simbolos/delegua":157}],168:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorPortugolIpt = void 0;
@@ -26093,7 +26131,7 @@ class TradutorPython {
 }
 exports.TradutorPython = TradutorPython;
 
-},{"../construtos":40,"../declaracoes":78,"../tipos-de-simbolos/delegua":157}],170:[function(require,module,exports){
+},{"../construtos":39,"../declaracoes":77,"../tipos-de-simbolos/delegua":157}],170:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorReversoJavaScript = void 0;
@@ -72095,5 +72133,5 @@ module.exports = function hasToStringTagShams() {
 	return hasSymbols() && !!Symbol.toStringTag;
 };
 
-},{"has-symbols/shams":354}]},{},[111])(111)
+},{"has-symbols/shams":354}]},{},[110])(110)
 });