@designliquido/delegua 0.9.2 → 0.9.4

package/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.js

@@ -4,11 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AvaliadorSintaticoEguaP = void 0;
-var browser_process_hrtime_1 = __importDefault(require("browser-process-hrtime"));
-var construtos_1 = require("../../construtos");
-var declaracoes_1 = require("../../declaracoes");
-var eguap_1 = __importDefault(require("../../tipos-de-simbolos/eguap"));
-var erro_avaliador_sintatico_1 = require("../erro-avaliador-sintatico");
+const browser_process_hrtime_1 = __importDefault(require("browser-process-hrtime"));
+const construtos_1 = require("../../construtos");
+const declaracoes_1 = require("../../declaracoes");
+const eguap_1 = __importDefault(require("../../tipos-de-simbolos/eguap"));
+const erro_avaliador_sintatico_1 = require("../erro-avaliador-sintatico");
 /**
  * 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.
@@ -17,15 +17,14 @@ var erro_avaliador_sintatico_1 = require("../erro-avaliador-sintatico");
  * A grande diferença entre este avaliador e os demais é a forma como são entendidos os blocos de escopo.
  * Este avaliador espera uma estrutura de pragmas, que explica quantos espaços há na frente de cada linha.
  */
-var AvaliadorSintaticoEguaP = /** @class */ (function () {
-    function AvaliadorSintaticoEguaP(performance) {
-        if (performance === void 0) { performance = false; }
+class AvaliadorSintaticoEguaP {
+    constructor(performance = false) {
         this.atual = 0;
-        this.ciclos = 0;
+        this.blocos = 0;
         this.performance = performance;
         this.escopos = [];
     }
-    AvaliadorSintaticoEguaP.prototype.sincronizar = function () {
+    sincronizar() {
         this.avancarEDevolverAnterior();
         while (!this.estaNoFinal()) {
             switch (this.simboloAtual().tipo) {
@@ -42,90 +41,85 @@ var AvaliadorSintaticoEguaP = /** @class */ (function () {
             }
             this.avancarEDevolverAnterior();
         }
-    };
-    AvaliadorSintaticoEguaP.prototype.erro = function (simbolo, mensagemDeErro) {
-        var excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simbolo, mensagemDeErro);
+    }
+    erro(simbolo, mensagemDeErro) {
+        const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simbolo, mensagemDeErro);
         this.erros.push(excecao);
         return excecao;
-    };
-    AvaliadorSintaticoEguaP.prototype.consumir = function (tipo, mensagemDeErro) {
+    }
+    consumir(tipo, mensagemDeErro) {
         if (this.verificarTipoSimboloAtual(tipo))
             return this.avancarEDevolverAnterior();
         throw this.erro(this.simboloAtual(), mensagemDeErro);
-    };
-    AvaliadorSintaticoEguaP.prototype.verificarTipoSimboloAtual = function (tipo) {
+    }
+    verificarTipoSimboloAtual(tipo) {
         if (this.estaNoFinal())
             return false;
         return this.simboloAtual().tipo === tipo;
-    };
-    AvaliadorSintaticoEguaP.prototype.verificarTipoProximoSimbolo = function (tipo) {
+    }
+    verificarTipoProximoSimbolo(tipo) {
         if (this.estaNoFinal())
             return false;
         return this.simbolos[this.atual + 1].tipo === tipo;
-    };
-    AvaliadorSintaticoEguaP.prototype.simboloAtual = function () {
+    }
+    simboloAtual() {
         return this.simbolos[this.atual];
-    };
-    AvaliadorSintaticoEguaP.prototype.simboloAnterior = function () {
+    }
+    simboloAnterior() {
         return this.simbolos[this.atual - 1];
-    };
-    AvaliadorSintaticoEguaP.prototype.simboloNaPosicao = function (posicao) {
+    }
+    simboloNaPosicao(posicao) {
         return this.simbolos[this.atual + posicao];
-    };
-    AvaliadorSintaticoEguaP.prototype.estaNoFinal = function () {
+    }
+    estaNoFinal() {
         return this.atual >= this.simbolos.length;
-    };
-    AvaliadorSintaticoEguaP.prototype.avancarEDevolverAnterior = function () {
+    }
+    avancarEDevolverAnterior() {
         if (!this.estaNoFinal())
             this.atual += 1;
         return this.simboloAnterior();
-    };
-    AvaliadorSintaticoEguaP.prototype.verificarSeSimboloAtualEIgualA = function () {
-        var argumentos = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            argumentos[_i] = arguments[_i];
-        }
-        for (var i = 0; i < argumentos.length; i++) {
-            var tipoAtual = argumentos[i];
+    }
+    verificarSeSimboloAtualEIgualA(...argumentos) {
+        for (let i = 0; i < argumentos.length; i++) {
+            const tipoAtual = argumentos[i];
             if (this.verificarTipoSimboloAtual(tipoAtual)) {
                 this.avancarEDevolverAnterior();
                 return true;
             }
         }
         return false;
-    };
-    AvaliadorSintaticoEguaP.prototype.primario = function () {
+    }
+    primario() {
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.SUPER)) {
-            var simboloChave = this.simboloAnterior();
+            const simboloChave = this.simboloAnterior();
             this.consumir(eguap_1.default.PONTO, "Esperado '.' após 'super'.");
-            var metodo = this.consumir(eguap_1.default.IDENTIFICADOR, 'Esperado nome do método da SuperClasse.');
+            const metodo = this.consumir(eguap_1.default.IDENTIFICADOR, 'Esperado nome do método da SuperClasse.');
             return new construtos_1.Super(this.hashArquivo, simboloChave, metodo);
         }
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.COLCHETE_ESQUERDO)) {
-            var valores = [];
+            const valores = [];
             if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.COLCHETE_DIREITO)) {
                 return new construtos_1.Vetor(this.hashArquivo, 0, []);
             }
             while (!this.verificarSeSimboloAtualEIgualA(eguap_1.default.COLCHETE_DIREITO)) {
-                var valor = this.atribuir();
+                const valor = this.atribuir();
                 valores.push(valor);
-                if (this.simboloAtual().tipo !==
-                    eguap_1.default.COLCHETE_DIREITO) {
+                if (this.simboloAtual().tipo !== eguap_1.default.COLCHETE_DIREITO) {
                     this.consumir(eguap_1.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
                 }
             }
             return new construtos_1.Vetor(this.hashArquivo, 0, valores);
         }
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.CHAVE_ESQUERDA)) {
-            var chaves = [];
-            var valores = [];
+            const chaves = [];
+            const valores = [];
             if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.CHAVE_DIREITA)) {
                 return new construtos_1.Dicionario(this.hashArquivo, 0, [], []);
             }
             while (!this.verificarSeSimboloAtualEIgualA(eguap_1.default.CHAVE_DIREITA)) {
-                var chave = this.atribuir();
+                const chave = this.atribuir();
                 this.consumir(eguap_1.default.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
-                var valor = this.atribuir();
+                const valor = this.atribuir();
                 chaves.push(chave);
                 valores.push(valor);
                 if (this.simboloAtual().tipo !== eguap_1.default.CHAVE_DIREITA) {
@@ -143,23 +137,23 @@ var AvaliadorSintaticoEguaP = /** @class */ (function () {
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.ISTO))
             return new construtos_1.Isto(this.hashArquivo, 0, this.simboloAnterior());
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.NUMERO, eguap_1.default.TEXTO)) {
-            var simboloAnterior = this.simboloAnterior();
+            const simboloAnterior = this.simboloAnterior();
             return new construtos_1.Literal(this.hashArquivo, Number(simboloAnterior.linha), simboloAnterior.literal);
         }
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.IDENTIFICADOR)) {
             return new construtos_1.Variavel(this.hashArquivo, this.simboloAnterior());
         }
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.PARENTESE_ESQUERDO)) {
-            var expressao = this.expressao();
+            const expressao = this.expressao();
             this.consumir(eguap_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
             return new construtos_1.Agrupamento(this.hashArquivo, 0, expressao);
         }
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.IMPORTAR))
             return this.declaracaoImportar();
         throw this.erro(this.simboloAtual(), 'Esperado expressão.');
-    };
-    AvaliadorSintaticoEguaP.prototype.finalizarChamada = function (entidadeChamada) {
-        var argumentos = [];
+    }
+    finalizarChamada(entidadeChamada) {
+        const argumentos = [];
         if (!this.verificarTipoSimboloAtual(eguap_1.default.PARENTESE_DIREITO)) {
             do {
                 if (argumentos.length >= 255) {
@@ -168,22 +162,22 @@ var AvaliadorSintaticoEguaP = /** @class */ (function () {
                 argumentos.push(this.expressao());
             } while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.VIRGULA));
         }
-        var parenteseDireito = this.consumir(eguap_1.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
+        const parenteseDireito = this.consumir(eguap_1.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
         return new construtos_1.Chamada(this.hashArquivo, entidadeChamada, parenteseDireito, argumentos);
-    };
-    AvaliadorSintaticoEguaP.prototype.chamar = function () {
-        var expressao = this.primario();
+    }
+    chamar() {
+        let expressao = this.primario();
         while (true) {
             if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.PARENTESE_ESQUERDO)) {
                 expressao = this.finalizarChamada(expressao);
             }
             else if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.PONTO)) {
-                var nome = this.consumir(eguap_1.default.IDENTIFICADOR, "Esperado nome do método após '.'.");
+                const nome = this.consumir(eguap_1.default.IDENTIFICADOR, "Esperado nome do método após '.'.");
                 expressao = new construtos_1.AcessoMetodo(this.hashArquivo, expressao, nome);
             }
             else if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.COLCHETE_ESQUERDO)) {
-                var indice = this.expressao();
-                var simboloFechamento = this.consumir(eguap_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
+                const indice = this.expressao();
+                const simboloFechamento = this.consumir(eguap_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
                 expressao = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, expressao, indice, simboloFechamento);
             }
             else {
@@ -191,122 +185,122 @@ var AvaliadorSintaticoEguaP = /** @class */ (function () {
             }
         }
         return expressao;
-    };
-    AvaliadorSintaticoEguaP.prototype.unario = function () {
+    }
+    unario() {
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.NEGACAO, eguap_1.default.SUBTRACAO, eguap_1.default.BIT_NOT)) {
-            var operador = this.simboloAnterior();
-            var direito = this.unario();
+            const operador = this.simboloAnterior();
+            const direito = this.unario();
             return new construtos_1.Unario(this.hashArquivo, operador, direito);
         }
         return this.chamar();
-    };
-    AvaliadorSintaticoEguaP.prototype.exponenciacao = function () {
-        var expressao = this.unario();
+    }
+    exponenciacao() {
+        let expressao = this.unario();
         while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.EXPONENCIACAO)) {
-            var operador = this.simboloAnterior();
-            var direito = this.unario();
+            const operador = this.simboloAnterior();
+            const direito = this.unario();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
-    };
-    AvaliadorSintaticoEguaP.prototype.multiplicar = function () {
-        var expressao = this.exponenciacao();
+    }
+    multiplicar() {
+        let expressao = this.exponenciacao();
         while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.DIVISAO, eguap_1.default.MULTIPLICACAO, eguap_1.default.MODULO)) {
-            var operador = this.simboloAnterior();
-            var direito = this.exponenciacao();
+            const operador = this.simboloAnterior();
+            const direito = this.exponenciacao();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
-    };
-    AvaliadorSintaticoEguaP.prototype.adicaoOuSubtracao = function () {
-        var expressao = this.multiplicar();
+    }
+    adicaoOuSubtracao() {
+        let expressao = this.multiplicar();
         while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.SUBTRACAO, eguap_1.default.ADICAO)) {
-            var operador = this.simboloAnterior();
-            var direito = this.multiplicar();
+            const operador = this.simboloAnterior();
+            const direito = this.multiplicar();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
-    };
-    AvaliadorSintaticoEguaP.prototype.bitFill = function () {
-        var expressao = this.adicaoOuSubtracao();
+    }
+    bitFill() {
+        let expressao = this.adicaoOuSubtracao();
         while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.MENOR_MENOR, eguap_1.default.MAIOR_MAIOR)) {
-            var operador = this.simboloAnterior();
-            var direito = this.adicaoOuSubtracao();
+            const operador = this.simboloAnterior();
+            const direito = this.adicaoOuSubtracao();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
-    };
-    AvaliadorSintaticoEguaP.prototype.bitE = function () {
-        var expressao = this.bitFill();
+    }
+    bitE() {
+        let expressao = this.bitFill();
         while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.BIT_AND)) {
-            var operador = this.simboloAnterior();
-            var direito = this.bitFill();
+            const operador = this.simboloAnterior();
+            const direito = this.bitFill();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
-    };
-    AvaliadorSintaticoEguaP.prototype.bitOu = function () {
-        var expressao = this.bitE();
+    }
+    bitOu() {
+        let expressao = this.bitE();
         while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.BIT_OR, eguap_1.default.BIT_XOR)) {
-            var operador = this.simboloAnterior();
-            var direito = this.bitE();
+            const operador = this.simboloAnterior();
+            const direito = this.bitE();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
-    };
-    AvaliadorSintaticoEguaP.prototype.comparar = function () {
-        var expressao = this.bitOu();
+    }
+    comparar() {
+        let expressao = this.bitOu();
         while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.MAIOR, eguap_1.default.MAIOR_IGUAL, eguap_1.default.MENOR, eguap_1.default.MENOR_IGUAL)) {
-            var operador = this.simboloAnterior();
-            var direito = this.bitOu();
+            const operador = this.simboloAnterior();
+            const direito = this.bitOu();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
-    };
-    AvaliadorSintaticoEguaP.prototype.comparacaoIgualdade = function () {
-        var expressao = this.comparar();
+    }
+    comparacaoIgualdade() {
+        let expressao = this.comparar();
         while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.DIFERENTE, eguap_1.default.IGUAL_IGUAL)) {
-            var operador = this.simboloAnterior();
-            var direito = this.comparar();
+            const operador = this.simboloAnterior();
+            const direito = this.comparar();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
-    };
-    AvaliadorSintaticoEguaP.prototype.em = function () {
-        var expressao = this.comparacaoIgualdade();
+    }
+    em() {
+        let expressao = this.comparacaoIgualdade();
         while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.EM)) {
-            var operador = this.simboloAnterior();
-            var direito = this.comparacaoIgualdade();
+            const operador = this.simboloAnterior();
+            const direito = this.comparacaoIgualdade();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
-    };
-    AvaliadorSintaticoEguaP.prototype.e = function () {
-        var expressao = this.em();
+    }
+    e() {
+        let expressao = this.em();
         while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.E)) {
-            var operador = this.simboloAnterior();
-            var direito = this.em();
+            const operador = this.simboloAnterior();
+            const direito = this.em();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
-    };
-    AvaliadorSintaticoEguaP.prototype.ou = function () {
-        var expressao = this.e();
+    }
+    ou() {
+        let expressao = this.e();
         while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.OU)) {
-            var operador = this.simboloAnterior();
-            var direito = this.e();
+            const operador = this.simboloAnterior();
+            const direito = this.e();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
-    };
-    AvaliadorSintaticoEguaP.prototype.atribuir = function () {
-        var expressao = this.ou();
+    }
+    atribuir() {
+        const expressao = this.ou();
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.IGUAL) ||
             this.verificarSeSimboloAtualEIgualA(eguap_1.default.MAIS_IGUAL)) {
-            var igual = this.simboloAnterior();
-            var valor = this.atribuir();
+            const igual = this.simboloAnterior();
+            const valor = this.atribuir();
             if (expressao instanceof construtos_1.Variavel) {
-                var simbolo = expressao.simbolo;
+                const simbolo = expressao.simbolo;
                 return new construtos_1.Atribuir(this.hashArquivo, simbolo, valor);
             }
             else if (expressao instanceof construtos_1.AcessoMetodo) {
@@ -318,40 +312,40 @@ var AvaliadorSintaticoEguaP = /** @class */ (function () {
             this.erro(igual, 'Tarefa de atribuição inválida');
         }
         return expressao;
-    };
-    AvaliadorSintaticoEguaP.prototype.expressao = function () {
+    }
+    expressao() {
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.LEIA))
             return this.declaracaoLeia();
         return this.atribuir();
-    };
-    AvaliadorSintaticoEguaP.prototype.declaracaoEscreva = function () {
-        var simboloAtual = this.simboloAtual();
+    }
+    declaracaoEscreva() {
+        const simboloAtual = this.simboloAtual();
         this.consumir(eguap_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
-        var argumentos = [];
+        const argumentos = [];
         do {
             argumentos.push(this.expressao());
         } while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.VIRGULA));
         this.consumir(eguap_1.default.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
         return new declaracoes_1.Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
-    };
-    AvaliadorSintaticoEguaP.prototype.declaracaoExpressao = function () {
-        var expressao = this.expressao();
+    }
+    declaracaoExpressao() {
+        const expressao = this.expressao();
         return new declaracoes_1.Expressao(expressao);
-    };
-    AvaliadorSintaticoEguaP.prototype.declaracaoLeia = function () {
-        var simboloAtual = this.simbolos[this.atual];
+    }
+    declaracaoLeia() {
+        const simboloAtual = this.simbolos[this.atual];
         this.consumir(eguap_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em leia.");
-        var argumentos = [];
+        const argumentos = [];
         do {
             argumentos.push(this.expressao());
         } while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.VIRGULA));
         this.consumir(eguap_1.default.PARENTESE_DIREITO, "Esperado ')' após os valores em leia.");
         return new declaracoes_1.Leia(simboloAtual.hashArquivo, Number(simboloAtual.linha), argumentos);
-    };
-    AvaliadorSintaticoEguaP.prototype.blocoEscopo = function () {
-        var declaracoes = [];
-        var simboloAtual = this.simboloAtual();
-        var simboloAnterior = this.simboloAnterior();
+    }
+    blocoEscopo() {
+        const declaracoes = [];
+        let simboloAtual = this.simboloAtual();
+        const simboloAnterior = this.simboloAnterior();
         // Situação 1: não tem bloco de escopo.
         //
         // Exemplo: `se verdadeiro: escreva('Alguma coisa')`.
@@ -365,12 +359,12 @@ var AvaliadorSintaticoEguaP = /** @class */ (function () {
             // Verifica-se o número de espaços à esquerda da linha através dos pragmas.
             // Se número de espaços da linha do símbolo atual é menor ou igual ao número de espaços
             // da linha anterior, e bloco ainda não começou, é uma situação de erro.
-            var espacosIndentacaoLinhaAtual = this.pragmas[simboloAtual.linha].espacosIndentacao;
-            var espacosIndentacaoLinhaAnterior = this.pragmas[simboloAnterior.linha].espacosIndentacao;
+            let espacosIndentacaoLinhaAtual = this.pragmas[simboloAtual.linha].espacosIndentacao;
+            const espacosIndentacaoLinhaAnterior = this.pragmas[simboloAnterior.linha].espacosIndentacao;
             if (espacosIndentacaoLinhaAtual <= espacosIndentacaoLinhaAnterior) {
-                this.erro(simboloAtual, "Indenta\u00E7\u00E3o inconsistente na linha ".concat(simboloAtual.linha, ". ") +
-                    "Esperado: >= ".concat(espacosIndentacaoLinhaAnterior, ". ") +
-                    "Atual: ".concat(espacosIndentacaoLinhaAtual));
+                this.erro(simboloAtual, `Indentação inconsistente na linha ${simboloAtual.linha}. ` +
+                    `Esperado: >= ${espacosIndentacaoLinhaAnterior}. ` +
+                    `Atual: ${espacosIndentacaoLinhaAtual}`);
             }
             else {
                 // Indentação ok, é um bloco de escopo.
@@ -378,30 +372,29 @@ var AvaliadorSintaticoEguaP = /** @class */ (function () {
                 // de indentação do bloco.
                 // Se `simboloAtual` for definido em algum momento como indefinido,
                 // Significa que o código acabou, então o bloco também acabou.
-                var espacosIndentacaoBloco = espacosIndentacaoLinhaAtual;
+                const espacosIndentacaoBloco = espacosIndentacaoLinhaAtual;
                 while (espacosIndentacaoLinhaAtual === espacosIndentacaoBloco) {
                     declaracoes.push(this.declaracao());
                     simboloAtual = this.simboloAtual();
                     if (!simboloAtual)
                         break;
-                    espacosIndentacaoLinhaAtual =
-                        this.pragmas[simboloAtual.linha].espacosIndentacao;
+                    espacosIndentacaoLinhaAtual = this.pragmas[simboloAtual.linha].espacosIndentacao;
                 }
             }
         }
         return declaracoes;
-    };
-    AvaliadorSintaticoEguaP.prototype.declaracaoSe = function () {
+    }
+    declaracaoSe() {
         this.consumir(eguap_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'se'.");
-        var condicao = this.expressao();
+        const condicao = this.expressao();
         this.consumir(eguap_1.default.PARENTESE_DIREITO, "Esperado ')' após condição do se.");
-        var caminhoEntao = this.resolverDeclaracao();
-        var caminhosSeSenao = [];
+        const caminhoEntao = this.resolverDeclaracao();
+        const caminhosSeSenao = [];
         while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.SENAOSE, eguap_1.default.SENÃOSE)) {
             this.consumir(eguap_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'senaose' ou 'senãose'.");
-            var condicaoSeSenao = this.expressao();
+            const condicaoSeSenao = this.expressao();
             this.consumir(eguap_1.default.PARENTESE_DIREITO, "Esperado ')' após codição do 'senaose' ou 'senãose'.");
-            var caminho = this.resolverDeclaracao();
+            const caminho = this.resolverDeclaracao();
             caminhosSeSenao.push({
                 condicao: condicaoSeSenao,
                 caminho: caminho,
@@ -412,31 +405,31 @@ var AvaliadorSintaticoEguaP = /** @class */ (function () {
         /* if (this.escopos.length > 0) {
             this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESPACO_INDENTACAO);
         } */
-        var caminhoSenao = null;
+        let caminhoSenao = null;
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.SENAO, eguap_1.default.SENÃO)) {
             caminhoSenao = this.resolverDeclaracao();
         }
         return new declaracoes_1.Se(condicao, caminhoEntao, caminhosSeSenao, caminhoSenao);
-    };
-    AvaliadorSintaticoEguaP.prototype.declaracaoEnquanto = function () {
+    }
+    declaracaoEnquanto() {
         try {
-            this.ciclos += 1;
+            this.blocos += 1;
             this.consumir(eguap_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'enquanto'.");
-            var condicao = this.expressao();
+            const condicao = this.expressao();
             this.consumir(eguap_1.default.PARENTESE_DIREITO, "Esperado ')' após condicional.");
-            var corpo = this.resolverDeclaracao();
+            const corpo = this.resolverDeclaracao();
             return new declaracoes_1.Enquanto(condicao, corpo);
         }
         finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
-    };
-    AvaliadorSintaticoEguaP.prototype.declaracaoPara = function () {
+    }
+    declaracaoPara() {
         try {
-            var simboloPara = this.simboloAnterior();
-            this.ciclos += 1;
+            const simboloPara = this.simboloAnterior();
+            this.blocos += 1;
             this.consumir(eguap_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'para'.");
-            var inicializador = void 0;
+            let inicializador;
             if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.PONTO_E_VIRGULA)) {
                 inicializador = null;
             }
@@ -446,63 +439,62 @@ var AvaliadorSintaticoEguaP = /** @class */ (function () {
             else {
                 inicializador = this.declaracaoExpressao();
             }
-            var condicao = null;
+            let condicao = null;
             if (!this.verificarTipoSimboloAtual(eguap_1.default.PONTO_E_VIRGULA)) {
                 condicao = this.expressao();
             }
-            var incrementar = null;
+            let incrementar = null;
             if (!this.verificarTipoSimboloAtual(eguap_1.default.PARENTESE_DIREITO)) {
                 incrementar = this.expressao();
             }
             this.consumir(eguap_1.default.PARENTESE_DIREITO, "Esperado ')' após cláusulas");
-            var corpo = this.resolverDeclaracao();
+            const corpo = this.resolverDeclaracao();
             return new declaracoes_1.Para(this.hashArquivo, Number(simboloPara.linha), inicializador, condicao, incrementar, corpo);
         }
         catch (erro) {
             throw erro;
         }
         finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
-    };
-    AvaliadorSintaticoEguaP.prototype.declaracaoSustar = function () {
-        if (this.ciclos < 1) {
+    }
+    declaracaoSustar() {
+        if (this.blocos < 1) {
             this.erro(this.simboloAnterior(), "'sustar' deve estar dentro de um laço de repetição.");
         }
         return new declaracoes_1.Sustar(this.simboloAtual());
-    };
-    AvaliadorSintaticoEguaP.prototype.declaracaoContinua = function () {
-        if (this.ciclos < 1) {
+    }
+    declaracaoContinua() {
+        if (this.blocos < 1) {
             this.erro(this.simboloAnterior(), "'continua' precisa estar em um laço de repetição.");
         }
         return new declaracoes_1.Continua(this.simboloAtual());
-    };
-    AvaliadorSintaticoEguaP.prototype.declaracaoRetorna = function () {
-        var palavraChave = this.simboloAnterior();
-        var valor = null;
+    }
+    declaracaoRetorna() {
+        const palavraChave = this.simboloAnterior();
+        let valor = null;
         if (!this.verificarTipoSimboloAtual(eguap_1.default.PONTO_E_VIRGULA)) {
             valor = this.expressao();
         }
         return new declaracoes_1.Retorna(palavraChave, valor);
-    };
-    AvaliadorSintaticoEguaP.prototype.declaracaoEscolha = function () {
+    }
+    declaracaoEscolha() {
         try {
-            this.ciclos += 1;
+            this.blocos += 1;
             this.consumir(eguap_1.default.DOIS_PONTOS, "Esperado ':' após 'escolha'.");
-            var condicao = this.expressao();
-            var caminhos = [];
-            var caminhoPadrao = null;
-            while (!this.verificarSeSimboloAtualEIgualA(eguap_1.default.CHAVE_DIREITA) &&
-                !this.estaNoFinal()) {
+            const condicao = this.expressao();
+            const caminhos = [];
+            let caminhoPadrao = null;
+            while (!this.verificarSeSimboloAtualEIgualA(eguap_1.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
                 if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.CASO)) {
-                    var caminhoCondicoes = [this.expressao()];
+                    const caminhoCondicoes = [this.expressao()];
                     this.consumir(eguap_1.default.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
                     while (this.verificarTipoSimboloAtual(eguap_1.default.CASO)) {
                         this.consumir(eguap_1.default.CASO, null);
                         caminhoCondicoes.push(this.expressao());
                         this.consumir(eguap_1.default.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
                     }
-                    var declaracoes = [];
+                    const declaracoes = [];
                     do {
                         declaracoes.push(this.resolverDeclaracao());
                     } while (!this.verificarTipoSimboloAtual(eguap_1.default.CASO) &&
@@ -510,76 +502,76 @@ var AvaliadorSintaticoEguaP = /** @class */ (function () {
                         !this.verificarTipoSimboloAtual(eguap_1.default.CHAVE_DIREITA));
                     caminhos.push({
                         condicoes: caminhoCondicoes,
-                        declaracoes: declaracoes,
+                        declaracoes,
                     });
                 }
                 else if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.PADRAO)) {
                     if (caminhoPadrao !== null) {
-                        var excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(this.simboloAtual(), "Você só pode ter um 'padrao' em cada declaração de 'escolha'.");
+                        const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(this.simboloAtual(), "Você só pode ter um 'padrao' em cada declaração de 'escolha'.");
                         this.erros.push(excecao);
                         throw excecao;
                     }
                     this.consumir(eguap_1.default.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
-                    var declaracoes = [];
+                    const declaracoes = [];
                     do {
                         declaracoes.push(this.resolverDeclaracao());
                     } while (!this.verificarTipoSimboloAtual(eguap_1.default.CASO) &&
                         !this.verificarTipoSimboloAtual(eguap_1.default.PADRAO) &&
                         !this.verificarTipoSimboloAtual(eguap_1.default.CHAVE_DIREITA));
                     caminhoPadrao = {
-                        declaracoes: declaracoes,
+                        declaracoes,
                     };
                 }
             }
             return new declaracoes_1.Escolha(condicao, caminhos, caminhoPadrao);
         }
         finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
-    };
-    AvaliadorSintaticoEguaP.prototype.declaracaoImportar = function () {
+    }
+    declaracaoImportar() {
         this.consumir(eguap_1.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
-        var caminho = this.expressao();
-        var simboloFechamento = this.consumir(eguap_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
+        const caminho = this.expressao();
+        const simboloFechamento = this.consumir(eguap_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
         return new declaracoes_1.Importar(caminho, simboloFechamento);
-    };
-    AvaliadorSintaticoEguaP.prototype.declaracaoTente = function () {
-        var simboloTente = this.simboloAnterior();
+    }
+    declaracaoTente() {
+        const simboloTente = this.simboloAnterior();
         this.consumir(eguap_1.default.DOIS_PONTOS, "Esperado ':' após a declaração 'tente'.");
-        var blocoTente = this.blocoEscopo();
-        var blocoPegue = null;
+        const blocoTente = this.blocoEscopo();
+        let blocoPegue = null;
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.PEGUE)) {
             this.consumir(eguap_1.default.DOIS_PONTOS, "Esperado ':' após a declaração 'pegue'.");
             blocoPegue = this.blocoEscopo();
         }
-        var blocoSenao = null;
+        let blocoSenao = null;
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.SENAO, eguap_1.default.SENÃO)) {
             this.consumir(eguap_1.default.DOIS_PONTOS, "Esperado ':' após a declaração 'pegue'.");
             blocoSenao = this.blocoEscopo();
         }
-        var blocoFinalmente = null;
+        let blocoFinalmente = null;
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.FINALMENTE)) {
             this.consumir(eguap_1.default.DOIS_PONTOS, "Esperado ':' após a declaração 'pegue'.");
             blocoFinalmente = this.blocoEscopo();
         }
         return new declaracoes_1.Tente(simboloTente.hashArquivo, Number(simboloTente.linha), blocoTente, blocoPegue, blocoSenao, blocoFinalmente);
-    };
-    AvaliadorSintaticoEguaP.prototype.declaracaoFazer = function () {
-        var simboloFazer = this.simboloAnterior();
+    }
+    declaracaoFazer() {
+        const simboloFazer = this.simboloAnterior();
         try {
-            this.ciclos += 1;
-            var caminhoFazer = this.resolverDeclaracao();
+            this.blocos += 1;
+            const caminhoFazer = this.resolverDeclaracao();
             this.consumir(eguap_1.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
             this.consumir(eguap_1.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração 'enquanto'.");
-            var condicaoEnquanto = this.expressao();
+            const condicaoEnquanto = this.expressao();
             this.consumir(eguap_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração do 'enquanto'.");
             return new declaracoes_1.Fazer(simboloFazer.hashArquivo, Number(simboloFazer.linha), caminhoFazer, condicaoEnquanto);
         }
         finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
-    };
-    AvaliadorSintaticoEguaP.prototype.resolverDeclaracao = function () {
+    }
+    resolverDeclaracao() {
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.FAZER))
             return this.declaracaoFazer();
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.TENTE))
@@ -602,31 +594,31 @@ var AvaliadorSintaticoEguaP = /** @class */ (function () {
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.ESCREVA))
             return this.declaracaoEscreva();
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.DOIS_PONTOS)) {
-            var simboloInicioBloco = this.simboloAnterior();
+            const simboloInicioBloco = this.simboloAnterior();
             return new declaracoes_1.Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), this.blocoEscopo());
         }
         return this.declaracaoExpressao();
-    };
-    AvaliadorSintaticoEguaP.prototype.declaracaoDeVariavel = function () {
-        var simbolo = this.consumir(eguap_1.default.IDENTIFICADOR, 'Esperado nome de variável.');
-        var inicializador = null;
+    }
+    declaracaoDeVariavel() {
+        const simbolo = this.consumir(eguap_1.default.IDENTIFICADOR, 'Esperado nome de variável.');
+        let inicializador = null;
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.IGUAL) ||
             this.verificarSeSimboloAtualEIgualA(eguap_1.default.MAIS_IGUAL)) {
             inicializador = this.expressao();
         }
         return new declaracoes_1.Var(simbolo, inicializador);
-    };
-    AvaliadorSintaticoEguaP.prototype.funcao = function (tipo) {
-        var simbolo = this.consumir(eguap_1.default.IDENTIFICADOR, "Esperado nome ".concat(tipo, "."));
+    }
+    funcao(tipo) {
+        const simbolo = this.consumir(eguap_1.default.IDENTIFICADOR, `Esperado nome ${tipo}.`);
         return new declaracoes_1.FuncaoDeclaracao(simbolo, this.corpoDaFuncao(tipo));
-    };
-    AvaliadorSintaticoEguaP.prototype.logicaComumParametros = function () {
-        var parametros = [];
+    }
+    logicaComumParametros() {
+        const parametros = [];
         do {
             if (parametros.length >= 255) {
                 this.erro(this.simboloAtual(), 'Não pode haver mais de 255 parâmetros');
             }
-            var parametro = {};
+            const parametro = {};
             if (this.simboloAtual().tipo === eguap_1.default.MULTIPLICACAO) {
                 this.consumir(eguap_1.default.MULTIPLICACAO, null);
                 parametro['tipo'] = 'estrela';
@@ -643,39 +635,38 @@ var AvaliadorSintaticoEguaP = /** @class */ (function () {
                 break;
         } while (this.verificarSeSimboloAtualEIgualA(eguap_1.default.VIRGULA));
         return parametros;
-    };
-    AvaliadorSintaticoEguaP.prototype.corpoDaFuncao = function (tipo) {
-        this.consumir(eguap_1.default.PARENTESE_ESQUERDO, "Esperado '(' ap\u00F3s o nome ".concat(tipo, "."));
-        var parametros = [];
+    }
+    corpoDaFuncao(tipo) {
+        this.consumir(eguap_1.default.PARENTESE_ESQUERDO, `Esperado '(' após o nome ${tipo}.`);
+        let parametros = [];
         if (!this.verificarTipoSimboloAtual(eguap_1.default.PARENTESE_DIREITO)) {
             parametros = this.logicaComumParametros();
         }
         this.consumir(eguap_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
-        this.consumir(eguap_1.default.DOIS_PONTOS, "Esperado ':' antes do escopo do ".concat(tipo, "."));
-        var corpo = this.blocoEscopo();
+        this.consumir(eguap_1.default.DOIS_PONTOS, `Esperado ':' antes do escopo do ${tipo}.`);
+        const corpo = this.blocoEscopo();
         return new construtos_1.FuncaoConstruto(this.hashArquivo, 0, parametros, corpo);
-    };
-    AvaliadorSintaticoEguaP.prototype.declaracaoDeClasse = function () {
-        var simbolo = this.consumir(eguap_1.default.IDENTIFICADOR, 'Esperado nome da classe.');
-        var superClasse = null;
+    }
+    declaracaoDeClasse() {
+        const simbolo = this.consumir(eguap_1.default.IDENTIFICADOR, 'Esperado nome da classe.');
+        let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(eguap_1.default.HERDA)) {
             this.consumir(eguap_1.default.IDENTIFICADOR, 'Esperado nome da SuperClasse.');
             superClasse = new construtos_1.Variavel(this.hashArquivo, this.simboloAnterior());
         }
         this.consumir(eguap_1.default.DOIS_PONTOS, "Esperado ':' antes do escopo da classe.");
-        var metodos = [];
-        while (!this.verificarTipoSimboloAtual(eguap_1.default.CHAVE_DIREITA) &&
-            !this.estaNoFinal()) {
+        const metodos = [];
+        while (!this.verificarTipoSimboloAtual(eguap_1.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
             metodos.push(this.funcao('método'));
         }
         return new declaracoes_1.Classe(simbolo, superClasse, metodos);
-    };
+    }
     /**
      * Consome o símbolo atual, verificando se é uma declaração de função, variável, classe
      * ou uma expressão.
      * @returns Objeto do tipo `Declaracao`.
      */
-    AvaliadorSintaticoEguaP.prototype.declaracao = function () {
+    declaracao() {
         try {
             if ((this.verificarTipoSimboloAtual(eguap_1.default.FUNCAO) ||
                 this.verificarTipoSimboloAtual(eguap_1.default.FUNÇÃO)) &&
@@ -693,30 +684,29 @@ var AvaliadorSintaticoEguaP = /** @class */ (function () {
             this.sincronizar();
             return null;
         }
-    };
-    AvaliadorSintaticoEguaP.prototype.analisar = function (retornoLexador, hashArquivo) {
-        var inicioAnalise = (0, browser_process_hrtime_1.default)();
+    }
+    analisar(retornoLexador, hashArquivo) {
+        const inicioAnalise = (0, browser_process_hrtime_1.default)();
         this.erros = [];
         this.atual = 0;
-        this.ciclos = 0;
+        this.blocos = 0;
         this.escopos = [];
         this.hashArquivo = hashArquivo || 0;
         this.simbolos = (retornoLexador === null || retornoLexador === void 0 ? void 0 : retornoLexador.simbolos) || [];
         this.pragmas = (retornoLexador === null || retornoLexador === void 0 ? void 0 : retornoLexador.pragmas) || {};
-        var declaracoes = [];
+        const declaracoes = [];
         while (!this.estaNoFinal()) {
             declaracoes.push(this.declaracao());
         }
         if (this.performance) {
-            var deltaAnalise = (0, browser_process_hrtime_1.default)(inicioAnalise);
-            console.log("[Avaliador Sint\u00E1tico] Tempo para an\u00E1lise: ".concat(deltaAnalise[0] * 1e9 + deltaAnalise[1], "ns"));
+            const deltaAnalise = (0, browser_process_hrtime_1.default)(inicioAnalise);
+            console.log(`[Avaliador Sintático] Tempo para análise: ${deltaAnalise[0] * 1e9 + deltaAnalise[1]}ns`);
         }
         return {
             declaracoes: declaracoes,
             erros: this.erros,
         };
-    };
-    return AvaliadorSintaticoEguaP;
-}());
+    }
+}
 exports.AvaliadorSintaticoEguaP = AvaliadorSintaticoEguaP;
 //# sourceMappingURL=avaliador-sintatico-eguap.js.map