@designliquido/delegua 0.9.2 → 0.9.4

package/fontes/interpretador/interpretador.js

@@ -22,69 +22,31 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Interpretador = void 0;
-var caminho = __importStar(require("path"));
-var browser_process_hrtime_1 = __importDefault(require("browser-process-hrtime"));
-var espaco_variaveis_1 = require("../espaco-variaveis");
-var biblioteca_global_1 = __importDefault(require("../bibliotecas/biblioteca-global"));
-var importar_biblioteca_1 = __importDefault(require("../bibliotecas/importar-biblioteca"));
-var excecoes_1 = require("../excecoes");
-var estruturas_1 = require("../estruturas");
-var pilha_escopos_execucao_1 = require("./pilha-escopos-execucao");
-var quebras_1 = require("../quebras");
-var inferenciador_1 = require("./inferenciador");
-var metodo_primitiva_1 = require("../estruturas/metodo-primitiva");
-var primitivas_texto_1 = __importDefault(require("../bibliotecas/primitivas-texto"));
-var primitivas_vetor_1 = __importDefault(require("../bibliotecas/primitivas-vetor"));
-var delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
+const caminho = __importStar(require("path"));
+const browser_process_hrtime_1 = __importDefault(require("browser-process-hrtime"));
+const espaco_variaveis_1 = require("../espaco-variaveis");
+const biblioteca_global_1 = __importDefault(require("../bibliotecas/biblioteca-global"));
+const importar_biblioteca_1 = __importDefault(require("../bibliotecas/importar-biblioteca"));
+const excecoes_1 = require("../excecoes");
+const estruturas_1 = require("../estruturas");
+const pilha_escopos_execucao_1 = require("./pilha-escopos-execucao");
+const quebras_1 = require("../quebras");
+const inferenciador_1 = require("./inferenciador");
+const metodo_primitiva_1 = require("../estruturas/metodo-primitiva");
+const primitivas_texto_1 = __importDefault(require("../bibliotecas/primitivas-texto"));
+const primitivas_vetor_1 = __importDefault(require("../bibliotecas/primitivas-vetor"));
+const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
 /**
  * O Interpretador visita todos os elementos complexos gerados pelo avaliador sintático (_parser_),
  * e de fato executa a lógica de programação descrita no código.
  */
-var Interpretador = /** @class */ (function () {
-    function Interpretador(importador, diretorioBase, performance, funcaoDeRetorno) {
-        if (performance === void 0) { performance = false; }
-        if (funcaoDeRetorno === void 0) { funcaoDeRetorno = null; }
+class Interpretador {
+    constructor(importador, diretorioBase, performance = false, funcaoDeRetorno = null) {
         this.funcaoDeRetorno = null;
         this.interfaceDeEntrada = null;
         this.resultadoInterpretador = [];
@@ -97,7 +59,7 @@ var Interpretador = /** @class */ (function () {
         this.erros = [];
         this.declaracoes = [];
         this.pilhaEscoposExecucao = new pilha_escopos_execucao_1.PilhaEscoposExecucao();
-        var escopoExecucao = {
+        const escopoExecucao = {
             declaracoes: [],
             declaracaoAtual: 0,
             ambiente: new espaco_variaveis_1.EspacoVariaveis(),
@@ -111,129 +73,95 @@ var Interpretador = /** @class */ (function () {
      * @param expressao Expressão do tipo Leia
      * @returns Promise com o resultado da leitura.
      */
-    Interpretador.prototype.visitarExpressaoLeia = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var mensagem;
-            var _this = this;
-            return __generator(this, function (_a) {
-                mensagem = expressao.argumentos && expressao.argumentos[0] ? expressao.argumentos[0].valor : '';
-                return [2 /*return*/, new Promise(function (resolucao) {
-                        return _this.interfaceEntradaSaida.question(mensagem, function (resposta) {
-                            resolucao(resposta);
-                        });
-                    })];
-            });
-        });
-    };
+    async visitarExpressaoLeia(expressao) {
+        const mensagem = expressao.argumentos && expressao.argumentos[0] ? expressao.argumentos[0].valor : '';
+        return new Promise(resolucao => this.interfaceEntradaSaida.question(mensagem, (resposta) => {
+            resolucao(resposta);
+        }));
+    }
     /**
      * Retira a interpolação de um texto.
      * @param {texto} texto O texto
      * @param {any[]} variaveis A lista de variaveis interpoladas
      * @returns O texto com o valor das variaveis.
      */
-    Interpretador.prototype.retirarInterpolacao = function (texto, variaveis) {
-        var _this = this;
-        var valoresVariaveis = variaveis.map(function (v) { return ({
-            valorResolvido: _this.pilhaEscoposExecucao.obterVariavelPorNome(v.variavel),
+    retirarInterpolacao(texto, variaveis) {
+        const valoresVariaveis = variaveis.map((v) => ({
+            valorResolvido: this.pilhaEscoposExecucao.obterVariavelPorNome(v.variavel),
             variavel: v.variavel,
-        }); });
-        var textoFinal = texto;
-        valoresVariaveis.forEach(function (elemento) {
-            var valorFinal = elemento.valorResolvido.hasOwnProperty('valor')
+        }));
+        let textoFinal = texto;
+        valoresVariaveis.forEach((elemento) => {
+            const valorFinal = elemento.valorResolvido.hasOwnProperty('valor')
                 ? elemento.valorResolvido.valor
                 : elemento.valorResolvido;
             textoFinal = textoFinal.replace('${' + elemento.variavel + '}', valorFinal);
         });
         return textoFinal;
-    };
+    }
     /**
      * Busca variáveis interpoladas.
      * @param {texto} textoOriginal O texto original com as variáveis interpoladas.
      * @returns Uma lista de variáveis interpoladas.
      */
-    Interpretador.prototype.buscarVariaveisInterpolacao = function (textoOriginal) {
-        var _this = this;
-        var variaveis = textoOriginal.match(this.regexInterpolacao);
-        return variaveis.map(function (s) {
-            var nomeVariavel = s.replace(/[\$\{\}]*/g, '');
+    buscarVariaveisInterpolacao(textoOriginal) {
+        const variaveis = textoOriginal.match(this.regexInterpolacao);
+        return variaveis.map((s) => {
+            const nomeVariavel = s.replace(/[\$\{\}]*/g, '');
             return {
                 variavel: nomeVariavel,
-                valor: _this.pilhaEscoposExecucao.obterVariavelPorNome(nomeVariavel),
+                valor: this.pilhaEscoposExecucao.obterVariavelPorNome(nomeVariavel),
             };
         });
-    };
-    Interpretador.prototype.visitarExpressaoLiteral = function (expressao) {
+    }
+    visitarExpressaoLiteral(expressao) {
         if (this.regexInterpolacao.test(expressao.valor)) {
-            var variaveis = this.buscarVariaveisInterpolacao(expressao.valor);
+            const variaveis = this.buscarVariaveisInterpolacao(expressao.valor);
             return this.retirarInterpolacao(expressao.valor, variaveis);
         }
         return expressao.valor;
-    };
-    Interpretador.prototype.avaliar = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, expressao.aceitar(this)];
-                    case 1: 
-                    // Descomente o código abaixo quando precisar detectar expressões undefined ou nulas.
-                    // Por algum motivo o depurador do VSCode não funciona direito aqui
-                    // com breakpoint condicional.
-                    /* if (expressao === null || expressao === undefined) {
-                        console.log('Aqui');
-                    } */
-                    return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoAgrupamento = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(expressao.expressao)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Interpretador.prototype.eVerdadeiro = function (objeto) {
+    }
+    async avaliar(expressao) {
+        // Descomente o código abaixo quando precisar detectar expressões undefined ou nulas.
+        // Por algum motivo o depurador do VSCode não funciona direito aqui
+        // com breakpoint condicional.
+        /* if (expressao === null || expressao === undefined) {
+            console.log('Aqui');
+        } */
+        return await expressao.aceitar(this);
+    }
+    async visitarExpressaoAgrupamento(expressao) {
+        return await this.avaliar(expressao.expressao);
+    }
+    eVerdadeiro(objeto) {
         if (objeto === null)
             return false;
         if (typeof objeto === 'boolean')
             return Boolean(objeto);
         return true;
-    };
-    Interpretador.prototype.verificarOperandoNumero = function (operador, operando) {
+    }
+    verificarOperandoNumero(operador, operando) {
         if (typeof operando === 'number' || operando.tipo === 'número')
             return;
         throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operando precisa ser um número.', Number(operador.linha));
-    };
-    Interpretador.prototype.visitarExpressaoUnaria = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var direita, valor;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(expressao.direita)];
-                    case 1:
-                        direita = _a.sent();
-                        valor = direita.hasOwnProperty('valor') ?
-                            direita.valor :
-                            direita;
-                        switch (expressao.operador.tipo) {
-                            case delegua_1.default.SUBTRACAO:
-                                this.verificarOperandoNumero(expressao.operador, valor);
-                                return [2 /*return*/, -valor];
-                            case delegua_1.default.NEGACAO:
-                                return [2 /*return*/, !this.eVerdadeiro(valor)];
-                            case delegua_1.default.BIT_NOT:
-                                return [2 /*return*/, ~valor];
-                        }
-                        return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    Interpretador.prototype.eIgual = function (esquerda, direita) {
+    }
+    async visitarExpressaoUnaria(expressao) {
+        const direita = await this.avaliar(expressao.direita);
+        const valor = direita.hasOwnProperty('valor') ?
+            direita.valor :
+            direita;
+        switch (expressao.operador.tipo) {
+            case delegua_1.default.SUBTRACAO:
+                this.verificarOperandoNumero(expressao.operador, valor);
+                return -valor;
+            case delegua_1.default.NEGACAO:
+                return !this.eVerdadeiro(valor);
+            case delegua_1.default.BIT_NOT:
+                return ~valor;
+        }
+        return null;
+    }
+    eIgual(esquerda, direita) {
         if (esquerda === null && direita === null)
             return true;
         if (esquerda === null)
@@ -248,7 +176,7 @@ var Interpretador = /** @class */ (function () {
             return esquerda.valor === direita.valor;
         }
         return esquerda === direita;
-    };
+    }
     /**
      * Verifica se operandos são números, que podem ser tanto variáveis puras do JavaScript
      * (neste caso, `number`), ou podem ser variáveis de Delégua com inferência (`VariavelInterface`).
@@ -257,13 +185,13 @@ var Interpretador = /** @class */ (function () {
      * @param esquerda O operando esquerdo.
      * @returns Se ambos os operandos são números ou não.
      */
-    Interpretador.prototype.verificarOperandosNumeros = function (operador, direita, esquerda) {
-        var tipoDireita = direita.tipo
+    verificarOperandosNumeros(operador, direita, esquerda) {
+        const tipoDireita = direita.tipo
             ? direita.tipo
             : typeof direita === 'number'
                 ? 'número'
                 : String(NaN);
-        var tipoEsquerda = esquerda.tipo
+        const tipoEsquerda = esquerda.tipo
             ? esquerda.tipo
             : typeof esquerda === 'number'
                 ? 'número'
@@ -271,609 +199,376 @@ var Interpretador = /** @class */ (function () {
         if (tipoDireita === 'número' && tipoEsquerda === 'número')
             return;
         throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
-    };
-    Interpretador.prototype.visitarExpressaoBinaria = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var esquerda, direita, valorEsquerdo, valorDireito, tipoEsquerdo, tipoDireito, erro_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        return [4 /*yield*/, this.avaliar(expressao.esquerda)];
-                    case 1:
-                        esquerda = _a.sent();
-                        return [4 /*yield*/, this.avaliar(expressao.direita)];
-                    case 2:
-                        direita = _a.sent();
-                        valorEsquerdo = (esquerda === null || esquerda === void 0 ? void 0 : esquerda.hasOwnProperty('valor'))
-                            ? esquerda.valor
-                            : esquerda;
-                        valorDireito = (direita === null || direita === void 0 ? void 0 : direita.hasOwnProperty('valor'))
-                            ? direita.valor
-                            : direita;
-                        tipoEsquerdo = (esquerda === null || esquerda === void 0 ? void 0 : esquerda.hasOwnProperty('tipo'))
-                            ? esquerda.tipo
-                            : (0, inferenciador_1.inferirTipoVariavel)(esquerda);
-                        tipoDireito = (direita === null || direita === void 0 ? void 0 : direita.hasOwnProperty('tipo'))
-                            ? direita.tipo
-                            : (0, inferenciador_1.inferirTipoVariavel)(direita);
-                        switch (expressao.operador.tipo) {
-                            case delegua_1.default.EXPONENCIACAO:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Math.pow(valorEsquerdo, valorDireito)];
-                            case delegua_1.default.MAIOR:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) > Number(valorDireito)];
-                            case delegua_1.default.MAIOR_IGUAL:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) >= Number(valorDireito)];
-                            case delegua_1.default.MENOR:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) < Number(valorDireito)];
-                            case delegua_1.default.MENOR_IGUAL:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) <= Number(valorDireito)];
-                            case delegua_1.default.SUBTRACAO:
-                            case delegua_1.default.MENOS_IGUAL:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) - Number(valorDireito)];
-                            case delegua_1.default.ADICAO:
-                            case delegua_1.default.MAIS_IGUAL:
-                                if (tipoEsquerdo === 'número' && tipoDireito === 'número') {
-                                    return [2 /*return*/, Number(valorEsquerdo) + Number(valorDireito)];
-                                }
-                                else {
-                                    return [2 /*return*/, String(valorEsquerdo) + String(valorDireito)];
-                                }
-                            case delegua_1.default.DIVISAO:
-                            case delegua_1.default.DIVISAO_IGUAL:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) / Number(valorDireito)];
-                            case delegua_1.default.MULTIPLICACAO:
-                            case delegua_1.default.MULTIPLICACAO_IGUAL:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) * Number(valorDireito)];
-                            case delegua_1.default.MODULO:
-                            case delegua_1.default.MODULO_IGUAL:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) % Number(valorDireito)];
-                            case delegua_1.default.BIT_AND:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) & Number(valorDireito)];
-                            case delegua_1.default.BIT_XOR:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) ^ Number(valorDireito)];
-                            case delegua_1.default.BIT_OR:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) | Number(valorDireito)];
-                            case delegua_1.default.MENOR_MENOR:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) << Number(valorDireito)];
-                            case delegua_1.default.MAIOR_MAIOR:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) >> Number(valorDireito)];
-                            case delegua_1.default.DIFERENTE:
-                                return [2 /*return*/, !this.eIgual(valorEsquerdo, valorDireito)];
-                            case delegua_1.default.IGUAL_IGUAL:
-                                return [2 /*return*/, this.eIgual(valorEsquerdo, valorDireito)];
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        erro_1 = _a.sent();
-                        return [2 /*return*/, Promise.reject(erro_1)];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
+    }
+    async visitarExpressaoBinaria(expressao) {
+        try {
+            const esquerda = await this.avaliar(expressao.esquerda);
+            const direita = await this.avaliar(expressao.direita);
+            const valorEsquerdo = (esquerda === null || esquerda === void 0 ? void 0 : esquerda.hasOwnProperty('valor'))
+                ? esquerda.valor
+                : esquerda;
+            const valorDireito = (direita === null || direita === void 0 ? void 0 : direita.hasOwnProperty('valor'))
+                ? direita.valor
+                : direita;
+            const tipoEsquerdo = (esquerda === null || esquerda === void 0 ? void 0 : esquerda.hasOwnProperty('tipo'))
+                ? esquerda.tipo
+                : (0, inferenciador_1.inferirTipoVariavel)(esquerda);
+            const tipoDireito = (direita === null || direita === void 0 ? void 0 : direita.hasOwnProperty('tipo'))
+                ? direita.tipo
+                : (0, inferenciador_1.inferirTipoVariavel)(direita);
+            switch (expressao.operador.tipo) {
+                case delegua_1.default.EXPONENCIACAO:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Math.pow(valorEsquerdo, valorDireito);
+                case delegua_1.default.MAIOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) > Number(valorDireito);
+                case delegua_1.default.MAIOR_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) >= Number(valorDireito);
+                case delegua_1.default.MENOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) < Number(valorDireito);
+                case delegua_1.default.MENOR_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) <= Number(valorDireito);
+                case delegua_1.default.SUBTRACAO:
+                case delegua_1.default.MENOS_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) - Number(valorDireito);
+                case delegua_1.default.ADICAO:
+                case delegua_1.default.MAIS_IGUAL:
+                    if (tipoEsquerdo === 'número' && tipoDireito === 'número') {
+                        return Number(valorEsquerdo) + Number(valorDireito);
+                    }
+                    else {
+                        return String(valorEsquerdo) + String(valorDireito);
+                    }
+                case delegua_1.default.DIVISAO:
+                case delegua_1.default.DIVISAO_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) / Number(valorDireito);
+                case delegua_1.default.MULTIPLICACAO:
+                case delegua_1.default.MULTIPLICACAO_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) * Number(valorDireito);
+                case delegua_1.default.MODULO:
+                case delegua_1.default.MODULO_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) % Number(valorDireito);
+                case delegua_1.default.BIT_AND:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) & Number(valorDireito);
+                case delegua_1.default.BIT_XOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) ^ Number(valorDireito);
+                case delegua_1.default.BIT_OR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) | Number(valorDireito);
+                case delegua_1.default.MENOR_MENOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) << Number(valorDireito);
+                case delegua_1.default.MAIOR_MAIOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) >> Number(valorDireito);
+                case delegua_1.default.DIFERENTE:
+                    return !this.eIgual(valorEsquerdo, valorDireito);
+                case delegua_1.default.IGUAL_IGUAL:
+                    return this.eIgual(valorEsquerdo, valorDireito);
+            }
+        }
+        catch (erro) {
+            return Promise.reject(erro);
+        }
+    }
     /**
      * Executa uma chamada de função, método ou classe.
      * @param expressao A expressão chamada.
      * @returns O resultado da chamada.
      */
-    Interpretador.prototype.visitarExpressaoDeChamada = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var variavelEntidadeChamada, entidadeChamada, argumentos, i, _a, _b, argumentosResolvidos, _i, _c, argumento, valorResolvido, parametros, diferenca, i, novosArgumentos, erro_2;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        _d.trys.push([0, 11, , 12]);
-                        return [4 /*yield*/, this.avaliar(expressao.entidadeChamada)];
-                    case 1:
-                        variavelEntidadeChamada = _d.sent();
-                        entidadeChamada = variavelEntidadeChamada.hasOwnProperty('valor')
-                            ? variavelEntidadeChamada.valor
-                            : variavelEntidadeChamada;
-                        argumentos = [];
-                        i = 0;
-                        _d.label = 2;
-                    case 2:
-                        if (!(i < expressao.argumentos.length)) return [3 /*break*/, 5];
-                        _b = (_a = argumentos).push;
-                        return [4 /*yield*/, this.avaliar(expressao.argumentos[i])];
-                    case 3:
-                        _b.apply(_a, [_d.sent()]);
-                        _d.label = 4;
-                    case 4:
-                        i++;
-                        return [3 /*break*/, 2];
-                    case 5:
-                        if (!(entidadeChamada instanceof estruturas_1.Chamavel)) {
-                            return [2 /*return*/, Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Só pode chamar função ou classe.', expressao.linha))];
-                        }
-                        if (!(entidadeChamada instanceof metodo_primitiva_1.MetodoPrimitiva)) return [3 /*break*/, 10];
-                        argumentosResolvidos = [];
-                        _i = 0, _c = expressao.argumentos;
-                        _d.label = 6;
-                    case 6:
-                        if (!(_i < _c.length)) return [3 /*break*/, 9];
-                        argumento = _c[_i];
-                        return [4 /*yield*/, this.avaliar(argumento)];
-                    case 7:
-                        valorResolvido = _d.sent();
-                        argumentosResolvidos.push(valorResolvido.hasOwnProperty('valor')
-                            ? valorResolvido.valor
-                            : valorResolvido);
-                        _d.label = 8;
-                    case 8:
-                        _i++;
-                        return [3 /*break*/, 6];
-                    case 9: return [2 /*return*/, entidadeChamada.chamar(argumentosResolvidos)];
-                    case 10:
-                        parametros = void 0;
-                        if (entidadeChamada instanceof estruturas_1.DeleguaFuncao) {
-                            parametros = entidadeChamada.declaracao.parametros;
-                        }
-                        else if (entidadeChamada instanceof estruturas_1.DeleguaClasse) {
-                            parametros = entidadeChamada.metodos.inicializacao
-                                ? entidadeChamada.metodos.inicializacao.declaracao.parametros
-                                : [];
-                        }
-                        else {
-                            parametros = [];
-                        }
-                        // Completar os parâmetros não preenchidos com nulos.
-                        if (argumentos.length < entidadeChamada.aridade()) {
-                            diferenca = entidadeChamada.aridade() - argumentos.length;
-                            for (i = 0; i < diferenca; i++) {
-                                argumentos.push(null);
-                            }
-                        }
-                        else {
-                            if (parametros &&
-                                parametros.length > 0 &&
-                                parametros[parametros.length - 1].tipo === 'estrela') {
-                                novosArgumentos = argumentos.slice(0, parametros.length - 1);
-                                novosArgumentos.push(argumentos.slice(parametros.length - 1, argumentos.length));
-                                argumentos = novosArgumentos;
-                            }
-                        }
-                        if (entidadeChamada instanceof estruturas_1.FuncaoPadrao) {
-                            try {
-                                return [2 /*return*/, entidadeChamada.chamar(argumentos, expressao.entidadeChamada.nome)];
-                            }
-                            catch (erro) {
-                                this.erros.push(erro);
-                            }
-                        }
-                        return [2 /*return*/, entidadeChamada.chamar(this, argumentos)];
-                    case 11:
-                        erro_2 = _d.sent();
-                        console.log(erro_2);
-                        return [3 /*break*/, 12];
-                    case 12: return [2 /*return*/];
+    async visitarExpressaoDeChamada(expressao) {
+        try {
+            const variavelEntidadeChamada = await this.avaliar(expressao.entidadeChamada);
+            const entidadeChamada = variavelEntidadeChamada.hasOwnProperty('valor')
+                ? variavelEntidadeChamada.valor
+                : variavelEntidadeChamada;
+            let argumentos = [];
+            for (let i = 0; i < expressao.argumentos.length; i++) {
+                argumentos.push(await this.avaliar(expressao.argumentos[i]));
+            }
+            if (!(entidadeChamada instanceof estruturas_1.Chamavel)) {
+                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Só pode chamar função ou classe.', expressao.linha));
+            }
+            if (entidadeChamada instanceof metodo_primitiva_1.MetodoPrimitiva) {
+                const argumentosResolvidos = [];
+                for (const argumento of expressao.argumentos) {
+                    const valorResolvido = await this.avaliar(argumento);
+                    argumentosResolvidos.push(valorResolvido.hasOwnProperty('valor')
+                        ? valorResolvido.valor
+                        : valorResolvido);
                 }
-            });
-        });
-    };
+                return entidadeChamada.chamar(argumentosResolvidos);
+            }
+            let parametros;
+            if (entidadeChamada instanceof estruturas_1.DeleguaFuncao) {
+                parametros = entidadeChamada.declaracao.parametros;
+            }
+            else if (entidadeChamada instanceof estruturas_1.DeleguaClasse) {
+                parametros = entidadeChamada.metodos.inicializacao
+                    ? entidadeChamada.metodos.inicializacao.declaracao.parametros
+                    : [];
+            }
+            else {
+                parametros = [];
+            }
+            // Completar os parâmetros não preenchidos com nulos.
+            if (argumentos.length < entidadeChamada.aridade()) {
+                const diferenca = entidadeChamada.aridade() - argumentos.length;
+                for (let i = 0; i < diferenca; i++) {
+                    argumentos.push(null);
+                }
+            }
+            else {
+                if (parametros &&
+                    parametros.length > 0 &&
+                    parametros[parametros.length - 1].tipo === 'estrela') {
+                    const novosArgumentos = argumentos.slice(0, parametros.length - 1);
+                    novosArgumentos.push(argumentos.slice(parametros.length - 1, argumentos.length));
+                    argumentos = novosArgumentos;
+                }
+            }
+            if (entidadeChamada instanceof estruturas_1.FuncaoPadrao) {
+                try {
+                    return entidadeChamada.chamar(argumentos, expressao.entidadeChamada.nome);
+                }
+                catch (erro) {
+                    this.erros.push(erro);
+                }
+            }
+            return entidadeChamada.chamar(this, argumentos);
+        }
+        catch (erro) {
+            console.log(erro);
+        }
+    }
     /**
      * Execução de uma expressão de atribuição.
      * @param expressao A expressão.
      * @returns O valor atribuído.
      */
-    Interpretador.prototype.visitarExpressaoDeAtribuicao = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var valor;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(expressao.valor)];
-                    case 1:
-                        valor = _a.sent();
-                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valor);
-                        return [2 /*return*/, valor];
-                }
-            });
-        });
-    };
-    Interpretador.prototype.procurarVariavel = function (simbolo) {
+    async visitarExpressaoDeAtribuicao(expressao) {
+        const valor = await this.avaliar(expressao.valor);
+        this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valor);
+        return valor;
+    }
+    procurarVariavel(simbolo) {
         return this.pilhaEscoposExecucao.obterVariavel(simbolo);
-    };
-    Interpretador.prototype.visitarExpressaoDeVariavel = function (expressao) {
+    }
+    visitarExpressaoDeVariavel(expressao) {
         return this.procurarVariavel(expressao.simbolo);
-    };
-    Interpretador.prototype.visitarDeclaracaoDeExpressao = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(declaracao.expressao)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoLogica = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var esquerda, direita;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(expressao.esquerda)];
-                    case 1:
-                        esquerda = _a.sent();
-                        if (!(expressao.operador.tipo === delegua_1.default.EM)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.avaliar(expressao.direita)];
-                    case 2:
-                        direita = _a.sent();
-                        if (Array.isArray(direita) || typeof direita === 'string') {
-                            return [2 /*return*/, direita.includes(esquerda)];
-                        }
-                        else if (direita.constructor === Object) {
-                            return [2 /*return*/, esquerda in direita];
-                        }
-                        else {
-                            throw new excecoes_1.ErroEmTempoDeExecucao(esquerda, "Tipo de chamada inválida com 'em'.", expressao.linha);
-                        }
-                        _a.label = 3;
-                    case 3:
-                        // se um estado for verdadeiro, retorna verdadeiro
-                        if (expressao.operador.tipo === delegua_1.default.OU) {
-                            if (this.eVerdadeiro(esquerda))
-                                return [2 /*return*/, esquerda];
-                        }
-                        // se um estado for falso, retorna falso
-                        if (expressao.operador.tipo === delegua_1.default.E) {
-                            if (!this.eVerdadeiro(esquerda))
-                                return [2 /*return*/, esquerda];
-                        }
-                        return [4 /*yield*/, this.avaliar(expressao.direita)];
-                    case 4: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
+    }
+    async visitarDeclaracaoDeExpressao(declaracao) {
+        return await this.avaliar(declaracao.expressao);
+    }
+    async visitarExpressaoLogica(expressao) {
+        const esquerda = await this.avaliar(expressao.esquerda);
+        if (expressao.operador.tipo === delegua_1.default.EM) {
+            const direita = await this.avaliar(expressao.direita);
+            if (Array.isArray(direita) || typeof direita === 'string') {
+                return direita.includes(esquerda);
+            }
+            else if (direita.constructor === Object) {
+                return esquerda in direita;
+            }
+            else {
+                throw new excecoes_1.ErroEmTempoDeExecucao(esquerda, "Tipo de chamada inválida com 'em'.", expressao.linha);
+            }
+        }
+        // se um estado for verdadeiro, retorna verdadeiro
+        if (expressao.operador.tipo === delegua_1.default.OU) {
+            if (this.eVerdadeiro(esquerda))
+                return esquerda;
+        }
+        // se um estado for falso, retorna falso
+        if (expressao.operador.tipo === delegua_1.default.E) {
+            if (!this.eVerdadeiro(esquerda))
+                return esquerda;
+        }
+        return await this.avaliar(expressao.direita);
+    }
     /**
      * Executa uma expressão Se, que tem uma condição, pode ter um bloco
      * Senão, e múltiplos blocos Senão-se.
      * @param declaracao A declaração Se.
      * @returns O resultado da avaliação do bloco cuja condição é verdadeira.
      */
-    Interpretador.prototype.visitarExpressaoSe = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, i, atual, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _a = this.eVerdadeiro;
-                        return [4 /*yield*/, this.avaliar(declaracao.condicao)];
-                    case 1:
-                        if (!_a.apply(this, [_c.sent()])) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.executar(declaracao.caminhoEntao)];
-                    case 2: return [2 /*return*/, _c.sent()];
-                    case 3:
-                        i = 0;
-                        _c.label = 4;
-                    case 4:
-                        if (!(i < declaracao.caminhosSeSenao.length)) return [3 /*break*/, 8];
-                        atual = declaracao.caminhosSeSenao[i];
-                        _b = this.eVerdadeiro;
-                        return [4 /*yield*/, this.avaliar(atual.condicao)];
-                    case 5:
-                        if (!_b.apply(this, [_c.sent()])) return [3 /*break*/, 7];
-                        return [4 /*yield*/, this.executar(atual.caminho)];
-                    case 6: return [2 /*return*/, _c.sent()];
-                    case 7:
-                        i++;
-                        return [3 /*break*/, 4];
-                    case 8:
-                        if (!(declaracao.caminhoSenao !== null)) return [3 /*break*/, 10];
-                        return [4 /*yield*/, this.executar(declaracao.caminhoSenao)];
-                    case 9: return [2 /*return*/, _c.sent()];
-                    case 10: return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoPara = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var retornoExecucao, _a, _b, erro_3;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!(declaracao.inicializador !== null)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.avaliar(declaracao.inicializador)];
-                    case 1:
-                        _c.sent();
-                        _c.label = 2;
-                    case 2:
-                        if (!!(retornoExecucao instanceof quebras_1.Quebra)) return [3 /*break*/, 11];
-                        _a = declaracao.condicao !== null;
-                        if (!_a) return [3 /*break*/, 4];
-                        _b = this.eVerdadeiro;
-                        return [4 /*yield*/, this.avaliar(declaracao.condicao)];
-                    case 3:
-                        _a = !_b.apply(this, [_c.sent()]);
-                        _c.label = 4;
-                    case 4:
-                        if (_a) {
-                            return [3 /*break*/, 11];
-                        }
-                        _c.label = 5;
-                    case 5:
-                        _c.trys.push([5, 7, , 8]);
-                        return [4 /*yield*/, this.executar(declaracao.corpo)];
-                    case 6:
-                        retornoExecucao = _c.sent();
-                        return [3 /*break*/, 8];
-                    case 7:
-                        erro_3 = _c.sent();
-                        return [2 /*return*/, Promise.reject(erro_3)];
-                    case 8:
-                        if (!(declaracao.incrementar !== null)) return [3 /*break*/, 10];
-                        return [4 /*yield*/, this.avaliar(declaracao.incrementar)];
-                    case 9:
-                        _c.sent();
-                        _c.label = 10;
-                    case 10: return [3 /*break*/, 2];
-                    case 11: return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoFazer = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var retornoExecucao, erro_4, _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _c.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, this.executar(declaracao.caminhoFazer)];
-                    case 1:
-                        retornoExecucao = _c.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        erro_4 = _c.sent();
-                        return [2 /*return*/, Promise.reject(erro_4)];
-                    case 3:
-                        _a = !(retornoExecucao instanceof quebras_1.Quebra);
-                        if (!_a) return [3 /*break*/, 5];
-                        _b = this.eVerdadeiro;
-                        return [4 /*yield*/, this.avaliar(declaracao.condicaoEnquanto)];
-                    case 4:
-                        _a = _b.apply(this, [_c.sent()]);
-                        _c.label = 5;
-                    case 5:
-                        if (_a) return [3 /*break*/, 0];
-                        _c.label = 6;
-                    case 6: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoEscolha = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var condicaoEscolha, caminhos, caminhoPadrao, encontrado, i, caminho_1, j, erro_5, erro_6;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(declaracao.identificadorOuLiteral)];
-                    case 1:
-                        condicaoEscolha = _a.sent();
-                        caminhos = declaracao.caminhos;
-                        caminhoPadrao = declaracao.caminhoPadrao;
-                        encontrado = false;
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 14, , 15]);
-                        i = 0;
-                        _a.label = 3;
-                    case 3:
-                        if (!(i < caminhos.length)) return [3 /*break*/, 11];
-                        caminho_1 = caminhos[i];
-                        j = 0;
-                        _a.label = 4;
-                    case 4:
-                        if (!(j < caminho_1.condicoes.length)) return [3 /*break*/, 10];
-                        return [4 /*yield*/, this.avaliar(caminho_1.condicoes[j])];
-                    case 5:
-                        if (!((_a.sent()) === condicaoEscolha)) return [3 /*break*/, 9];
+    async visitarExpressaoSe(declaracao) {
+        if (this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
+            return await this.executar(declaracao.caminhoEntao);
+        }
+        for (let i = 0; i < declaracao.caminhosSeSenao.length; i++) {
+            const atual = declaracao.caminhosSeSenao[i];
+            if (this.eVerdadeiro(await this.avaliar(atual.condicao))) {
+                return await this.executar(atual.caminho);
+            }
+        }
+        if (declaracao.caminhoSenao !== null) {
+            return await this.executar(declaracao.caminhoSenao);
+        }
+        return null;
+    }
+    async visitarExpressaoPara(declaracao) {
+        if (declaracao.inicializador !== null) {
+            await this.avaliar(declaracao.inicializador);
+        }
+        let retornoExecucao;
+        while (!(retornoExecucao instanceof quebras_1.Quebra)) {
+            if (declaracao.condicao !== null &&
+                !this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
+                break;
+            }
+            try {
+                retornoExecucao = await this.executar(declaracao.corpo);
+            }
+            catch (erro) {
+                return Promise.reject(erro);
+            }
+            if (declaracao.incrementar !== null) {
+                await this.avaliar(declaracao.incrementar);
+            }
+        }
+        return null;
+    }
+    async visitarExpressaoFazer(declaracao) {
+        let retornoExecucao;
+        do {
+            try {
+                retornoExecucao = await this.executar(declaracao.caminhoFazer);
+            }
+            catch (erro) {
+                return Promise.reject(erro);
+            }
+        } while (!(retornoExecucao instanceof quebras_1.Quebra) &&
+            this.eVerdadeiro(await this.avaliar(declaracao.condicaoEnquanto)));
+    }
+    async visitarExpressaoEscolha(declaracao) {
+        const condicaoEscolha = await this.avaliar(declaracao.identificadorOuLiteral);
+        const caminhos = declaracao.caminhos;
+        const caminhoPadrao = declaracao.caminhoPadrao;
+        let encontrado = false;
+        try {
+            for (let i = 0; i < caminhos.length; i++) {
+                const caminho = caminhos[i];
+                for (let j = 0; j < caminho.condicoes.length; j++) {
+                    if (await this.avaliar(caminho.condicoes[j]) === condicaoEscolha) {
                         encontrado = true;
-                        _a.label = 6;
-                    case 6:
-                        _a.trys.push([6, 8, , 9]);
-                        return [4 /*yield*/, this.executarBloco(caminho_1.declaracoes)];
-                    case 7:
-                        _a.sent();
-                        return [3 /*break*/, 9];
-                    case 8:
-                        erro_5 = _a.sent();
-                        return [2 /*return*/, Promise.reject(erro_5)];
-                    case 9:
-                        j++;
-                        return [3 /*break*/, 4];
-                    case 10:
-                        i++;
-                        return [3 /*break*/, 3];
-                    case 11:
-                        if (!(caminhoPadrao !== null && encontrado === false)) return [3 /*break*/, 13];
-                        return [4 /*yield*/, this.executarBloco(caminhoPadrao.declaracoes)];
-                    case 12:
-                        _a.sent();
-                        _a.label = 13;
-                    case 13: return [3 /*break*/, 15];
-                    case 14:
-                        erro_6 = _a.sent();
-                        throw erro_6;
-                    case 15: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoTente = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var sucesso, erro_7;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, , 10, 13]);
-                        sucesso = true;
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 7]);
-                        return [4 /*yield*/, this.executarBloco(declaracao.caminhoTente)];
-                    case 2:
-                        _a.sent();
-                        return [3 /*break*/, 7];
-                    case 3:
-                        erro_7 = _a.sent();
-                        sucesso = false;
-                        if (!(declaracao.caminhoPegue !== null)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, this.executarBloco(declaracao.caminhoPegue)];
-                    case 4:
-                        _a.sent();
-                        return [3 /*break*/, 6];
-                    case 5:
-                        this.erros.push(erro_7);
-                        _a.label = 6;
-                    case 6: return [3 /*break*/, 7];
-                    case 7:
-                        if (!(sucesso && declaracao.caminhoSenao !== null)) return [3 /*break*/, 9];
-                        return [4 /*yield*/, this.executarBloco(declaracao.caminhoSenao)];
-                    case 8:
-                        _a.sent();
-                        _a.label = 9;
-                    case 9: return [3 /*break*/, 13];
-                    case 10:
-                        if (!(declaracao.caminhoFinalmente !== null)) return [3 /*break*/, 12];
-                        return [4 /*yield*/, this.executarBloco(declaracao.caminhoFinalmente)];
-                    case 11:
-                        _a.sent();
-                        _a.label = 12;
-                    case 12: return [7 /*endfinally*/];
-                    case 13: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoEnquanto = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var retornoExecucao, _a, _b, erro_8;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _a = !(retornoExecucao instanceof quebras_1.Quebra);
-                        if (!_a) return [3 /*break*/, 2];
-                        _b = this.eVerdadeiro;
-                        return [4 /*yield*/, this.avaliar(declaracao.condicao)];
-                    case 1:
-                        _a = _b.apply(this, [_c.sent()]);
-                        _c.label = 2;
-                    case 2:
-                        if (!_a) return [3 /*break*/, 7];
-                        _c.label = 3;
-                    case 3:
-                        _c.trys.push([3, 5, , 6]);
-                        return [4 /*yield*/, this.executar(declaracao.corpo)];
-                    case 4:
-                        retornoExecucao = _c.sent();
-                        return [3 /*break*/, 6];
-                    case 5:
-                        erro_8 = _c.sent();
-                        throw erro_8;
-                    case 6: return [3 /*break*/, 0];
-                    case 7: return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoImportar = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var caminhoRelativo, caminhoTotal, nomeArquivo, conteudoImportacao, retornoInterpretador, funcoesChamaveis, eDicionario, novoModulo, chaves, i;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(declaracao.caminho)];
-                    case 1:
-                        caminhoRelativo = _a.sent();
-                        caminhoTotal = caminho.join(this.diretorioBase, caminhoRelativo);
-                        nomeArquivo = caminho.basename(caminhoTotal);
-                        if (!caminhoTotal.endsWith('.egua') &&
-                            !caminhoTotal.endsWith('.delegua')) {
-                            try {
-                                return [2 /*return*/, (0, importar_biblioteca_1.default)(caminhoRelativo)];
-                            }
-                            catch (erro) {
-                                this.erros.push(erro);
-                                return [2 /*return*/, null];
-                            }
+                        try {
+                            await this.executarBloco(caminho.declaracoes);
                         }
-                        conteudoImportacao = this.importador.importar(caminhoRelativo);
-                        retornoInterpretador = this.interpretar(conteudoImportacao.retornoAvaliadorSintatico.declaracoes, true);
-                        funcoesChamaveis = this.pilhaEscoposExecucao.obterTodasDeleguaFuncao();
-                        eDicionario = function (objeto) { return objeto.constructor === Object; };
-                        if (eDicionario(funcoesChamaveis)) {
-                            novoModulo = new estruturas_1.DeleguaModulo();
-                            chaves = Object.keys(funcoesChamaveis);
-                            for (i = 0; i < chaves.length; i++) {
-                                novoModulo.componentes[chaves[i]] = funcoesChamaveis[chaves[i]];
-                            }
-                            return [2 /*return*/, novoModulo];
+                        catch (erro) {
+                            return Promise.reject(erro);
                         }
-                        return [2 /*return*/, funcoesChamaveis];
+                    }
                 }
-            });
-        });
-    };
+            }
+            if (caminhoPadrao !== null && encontrado === false) {
+                await this.executarBloco(caminhoPadrao.declaracoes);
+            }
+        }
+        catch (erro) {
+            throw erro;
+        }
+    }
+    async visitarExpressaoTente(declaracao) {
+        try {
+            let sucesso = true;
+            try {
+                await this.executarBloco(declaracao.caminhoTente);
+            }
+            catch (erro) {
+                sucesso = false;
+                if (declaracao.caminhoPegue !== null) {
+                    await this.executarBloco(declaracao.caminhoPegue);
+                }
+                else {
+                    this.erros.push(erro);
+                }
+            }
+            if (sucesso && declaracao.caminhoSenao !== null) {
+                await this.executarBloco(declaracao.caminhoSenao);
+            }
+        }
+        finally {
+            if (declaracao.caminhoFinalmente !== null)
+                await this.executarBloco(declaracao.caminhoFinalmente);
+        }
+    }
+    async visitarExpressaoEnquanto(declaracao) {
+        let retornoExecucao;
+        while (!(retornoExecucao instanceof quebras_1.Quebra) &&
+            this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
+            try {
+                retornoExecucao = await this.executar(declaracao.corpo);
+            }
+            catch (erro) {
+                throw erro;
+            }
+        }
+        return null;
+    }
+    async visitarExpressaoImportar(declaracao) {
+        const caminhoRelativo = await this.avaliar(declaracao.caminho);
+        const caminhoTotal = caminho.join(this.diretorioBase, caminhoRelativo);
+        const nomeArquivo = caminho.basename(caminhoTotal);
+        if (!caminhoTotal.endsWith('.egua') &&
+            !caminhoTotal.endsWith('.delegua')) {
+            try {
+                return (0, importar_biblioteca_1.default)(caminhoRelativo);
+            }
+            catch (erro) {
+                this.erros.push(erro);
+                return null;
+            }
+        }
+        const conteudoImportacao = this.importador.importar(caminhoRelativo);
+        const retornoInterpretador = this.interpretar(conteudoImportacao.retornoAvaliadorSintatico.declaracoes, true);
+        const funcoesChamaveis = this.pilhaEscoposExecucao.obterTodasDeleguaFuncao();
+        const eDicionario = (objeto) => objeto.constructor === Object;
+        if (eDicionario(funcoesChamaveis)) {
+            const novoModulo = new estruturas_1.DeleguaModulo();
+            const chaves = Object.keys(funcoesChamaveis);
+            for (let i = 0; i < chaves.length; i++) {
+                novoModulo.componentes[chaves[i]] = funcoesChamaveis[chaves[i]];
+            }
+            return novoModulo;
+        }
+        return funcoesChamaveis;
+    }
     /**
      * Execução de uma escrita na saída configurada, que pode ser `console` (padrão) ou
      * alguma função para escrever numa página Web.
      * @param declaracao A declaração.
      * @returns Sempre nulo, por convenção de visita.
      */
-    Interpretador.prototype.visitarExpressaoEscreva = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var valor, _i, _a, argumento, resultadoAvaliacao, formatoTexto, erro_9;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 5, , 6]);
-                        valor = void 0;
-                        _i = 0, _a = declaracao.argumentos;
-                        _b.label = 1;
-                    case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 4];
-                        argumento = _a[_i];
-                        return [4 /*yield*/, this.avaliar(argumento)];
-                    case 2:
-                        resultadoAvaliacao = _b.sent();
-                        valor = (resultadoAvaliacao === null || resultadoAvaliacao === void 0 ? void 0 : resultadoAvaliacao.hasOwnProperty('valor'))
-                            ? resultadoAvaliacao.valor
-                            : resultadoAvaliacao;
-                        _b.label = 3;
-                    case 3:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 4:
-                        formatoTexto = this.paraTexto(valor);
-                        // Por enquanto `escreva` não devolve resultado no interpretador.
-                        // this.resultadoInterpretador.push(formatoTexto);
-                        this.funcaoDeRetorno(formatoTexto);
-                        return [2 /*return*/, null];
-                    case 5:
-                        erro_9 = _b.sent();
-                        this.erros.push(erro_9);
-                        return [3 /*break*/, 6];
-                    case 6: return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async visitarExpressaoEscreva(declaracao) {
+        try {
+            let valor;
+            for (const argumento of declaracao.argumentos) {
+                const resultadoAvaliacao = await this.avaliar(argumento);
+                valor = (resultadoAvaliacao === null || resultadoAvaliacao === void 0 ? void 0 : resultadoAvaliacao.hasOwnProperty('valor'))
+                    ? resultadoAvaliacao.valor
+                    : resultadoAvaliacao;
+            }
+            const formatoTexto = this.paraTexto(valor);
+            // Por enquanto `escreva` não devolve resultado no interpretador.
+            // this.resultadoInterpretador.push(formatoTexto);
+            this.funcaoDeRetorno(formatoTexto);
+            return null;
+        }
+        catch (erro) {
+            this.erros.push(erro);
+        }
+    }
     /**
      * Empilha declarações na pilha de escopos de execução, cria um novo ambiente e
      * executa as declarações empilhadas.
@@ -883,386 +578,265 @@ var Interpretador = /** @class */ (function () {
      * @param declaracoes Um vetor de declaracoes a ser executado.
      * @param ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
      */
-    Interpretador.prototype.executarBloco = function (declaracoes, ambiente) {
-        return __awaiter(this, void 0, void 0, function () {
-            var escopoExecucao, retornoUltimoEscopo;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        escopoExecucao = {
-                            declaracoes: declaracoes,
-                            declaracaoAtual: 0,
-                            ambiente: ambiente || new espaco_variaveis_1.EspacoVariaveis(),
-                        };
-                        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-                        return [4 /*yield*/, this.executarUltimoEscopo()];
-                    case 1:
-                        retornoUltimoEscopo = _a.sent();
-                        if (retornoUltimoEscopo instanceof excecoes_1.ErroEmTempoDeExecucao) {
-                            return [2 /*return*/, Promise.reject(retornoUltimoEscopo)];
-                        }
-                        return [2 /*return*/, retornoUltimoEscopo];
-                }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoBloco = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.executarBloco(declaracao.declaracoes)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
+    async executarBloco(declaracoes, ambiente) {
+        const escopoExecucao = {
+            declaracoes: declaracoes,
+            declaracaoAtual: 0,
+            ambiente: ambiente || new espaco_variaveis_1.EspacoVariaveis(),
+        };
+        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
+        const retornoUltimoEscopo = await this.executarUltimoEscopo();
+        if (retornoUltimoEscopo instanceof excecoes_1.ErroEmTempoDeExecucao) {
+            return Promise.reject(retornoUltimoEscopo);
+        }
+        return retornoUltimoEscopo;
+    }
+    async visitarExpressaoBloco(declaracao) {
+        return await this.executarBloco(declaracao.declaracoes);
+    }
     /**
      * Executa expressão de definição de variável.
      * @param declaracao A declaração Var
      * @returns Sempre retorna nulo.
      */
-    Interpretador.prototype.visitarExpressaoVar = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var valorOuOutraVariavel, valorFinal;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        valorOuOutraVariavel = null;
-                        if (!(declaracao.inicializador !== null)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.avaliar(declaracao.inicializador)];
-                    case 1:
-                        valorOuOutraVariavel = _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        valorFinal = null;
-                        if (valorOuOutraVariavel !== null && valorOuOutraVariavel !== undefined) {
-                            valorFinal = valorOuOutraVariavel.hasOwnProperty('valor')
-                                ? valorOuOutraVariavel.valor
-                                : valorOuOutraVariavel;
-                        }
-                        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valorFinal);
-                        return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoContinua = function (declaracao) {
+    async visitarExpressaoVar(declaracao) {
+        let valorOuOutraVariavel = null;
+        if (declaracao.inicializador !== null) {
+            valorOuOutraVariavel = await this.avaliar(declaracao.inicializador);
+        }
+        let valorFinal = null;
+        if (valorOuOutraVariavel !== null && valorOuOutraVariavel !== undefined) {
+            valorFinal = valorOuOutraVariavel.hasOwnProperty('valor')
+                ? valorOuOutraVariavel.valor
+                : valorOuOutraVariavel;
+        }
+        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valorFinal);
+        return null;
+    }
+    visitarExpressaoContinua(declaracao) {
         return new quebras_1.ContinuarQuebra();
-    };
-    Interpretador.prototype.visitarExpressaoSustar = function (declaracao) {
+    }
+    visitarExpressaoSustar(declaracao) {
         return new quebras_1.SustarQuebra();
-    };
-    Interpretador.prototype.visitarExpressaoRetornar = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var valor;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        valor = null;
-                        if (!(declaracao.valor != null)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.avaliar(declaracao.valor)];
-                    case 1:
-                        valor = _a.sent();
-                        _a.label = 2;
-                    case 2: return [2 /*return*/, new quebras_1.RetornoQuebra(valor)];
-                }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoDeleguaFuncao = function (expressao) {
+    }
+    async visitarExpressaoRetornar(declaracao) {
+        let valor = null;
+        if (declaracao.valor != null)
+            valor = await this.avaliar(declaracao.valor);
+        return new quebras_1.RetornoQuebra(valor);
+    }
+    visitarExpressaoDeleguaFuncao(expressao) {
         return new estruturas_1.DeleguaFuncao(null, expressao);
-    };
-    Interpretador.prototype.visitarExpressaoAtribuicaoSobrescrita = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var promises, objeto, indice, valor;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Promise.all([
-                            this.avaliar(expressao.objeto),
-                            this.avaliar(expressao.indice),
-                            this.avaliar(expressao.valor)
-                        ])];
-                    case 1:
-                        promises = _a.sent();
-                        objeto = promises[0];
-                        indice = promises[1];
-                        valor = promises[2];
-                        objeto = objeto.hasOwnProperty('valor') ? objeto.valor : objeto;
-                        indice = indice.hasOwnProperty('valor') ? indice.valor : indice;
-                        if (Array.isArray(objeto)) {
-                            if (indice < 0 && objeto.length !== 0) {
-                                while (indice < 0) {
-                                    indice += objeto.length;
-                                }
-                            }
-                            while (objeto.length < indice) {
-                                objeto.push(null);
-                            }
-                            objeto[indice] = valor;
-                        }
-                        else if (objeto.constructor === Object ||
-                            objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
-                            objeto instanceof estruturas_1.DeleguaFuncao ||
-                            objeto instanceof estruturas_1.DeleguaClasse ||
-                            objeto instanceof estruturas_1.DeleguaModulo) {
-                            objeto[indice] = valor;
-                        }
-                        else {
-                            return [2 /*return*/, Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha))];
-                        }
-                        return [2 /*return*/];
+    }
+    async visitarExpressaoAtribuicaoSobrescrita(expressao) {
+        const promises = await Promise.all([
+            this.avaliar(expressao.objeto),
+            this.avaliar(expressao.indice),
+            this.avaliar(expressao.valor)
+        ]);
+        let objeto = promises[0];
+        let indice = promises[1];
+        const valor = promises[2];
+        objeto = objeto.hasOwnProperty('valor') ? objeto.valor : objeto;
+        indice = indice.hasOwnProperty('valor') ? indice.valor : indice;
+        if (Array.isArray(objeto)) {
+            if (indice < 0 && objeto.length !== 0) {
+                while (indice < 0) {
+                    indice += objeto.length;
                 }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoAcessoIndiceVariavel = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var variavelObjeto, objeto, indice, valorIndice;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(expressao.entidadeChamada)];
-                    case 1:
-                        variavelObjeto = _a.sent();
-                        objeto = variavelObjeto.hasOwnProperty('valor')
-                            ? variavelObjeto.valor
-                            : variavelObjeto;
-                        return [4 /*yield*/, this.avaliar(expressao.indice)];
-                    case 2:
-                        indice = _a.sent();
-                        valorIndice = indice.hasOwnProperty('valor') ? indice.valor : indice;
-                        if (Array.isArray(objeto)) {
-                            if (!Number.isInteger(valorIndice)) {
-                                return [2 /*return*/, Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha))];
-                            }
-                            if (valorIndice < 0 && objeto.length !== 0) {
-                                while (valorIndice < 0) {
-                                    valorIndice += objeto.length;
-                                }
-                            }
-                            if (valorIndice >= objeto.length) {
-                                return [2 /*return*/, Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice do vetor fora do intervalo.', expressao.linha))];
-                            }
-                            return [2 /*return*/, objeto[valorIndice]];
-                        }
-                        else 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 [2 /*return*/, objeto[valorIndice] || null];
-                        }
-                        else if (typeof objeto === 'string') {
-                            if (!Number.isInteger(valorIndice)) {
-                                return [2 /*return*/, Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha))];
-                            }
-                            if (valorIndice < 0 && objeto.length !== 0) {
-                                while (valorIndice < 0) {
-                                    valorIndice += objeto.length;
-                                }
-                            }
-                            if (valorIndice >= objeto.length) {
-                                return [2 /*return*/, Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice fora do tamanho.', expressao.linha))];
-                            }
-                            return [2 /*return*/, objeto.charAt(valorIndice)];
-                        }
-                        else {
-                            return [2 /*return*/, Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.entidadeChamada.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha))];
-                        }
-                        return [2 /*return*/];
+            }
+            while (objeto.length < indice) {
+                objeto.push(null);
+            }
+            objeto[indice] = valor;
+        }
+        else if (objeto.constructor === Object ||
+            objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
+            objeto instanceof estruturas_1.DeleguaFuncao ||
+            objeto instanceof estruturas_1.DeleguaClasse ||
+            objeto instanceof estruturas_1.DeleguaModulo) {
+            objeto[indice] = valor;
+        }
+        else {
+            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha));
+        }
+    }
+    async visitarExpressaoAcessoIndiceVariavel(expressao) {
+        const variavelObjeto = await this.avaliar(expressao.entidadeChamada);
+        const objeto = variavelObjeto.hasOwnProperty('valor')
+            ? variavelObjeto.valor
+            : variavelObjeto;
+        const indice = await this.avaliar(expressao.indice);
+        let valorIndice = indice.hasOwnProperty('valor') ? indice.valor : indice;
+        if (Array.isArray(objeto)) {
+            if (!Number.isInteger(valorIndice)) {
+                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha));
+            }
+            if (valorIndice < 0 && objeto.length !== 0) {
+                while (valorIndice < 0) {
+                    valorIndice += objeto.length;
                 }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoDefinirValor = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var objeto, valor;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(expressao.objeto)];
-                    case 1:
-                        objeto = _a.sent();
-                        if (!(objeto instanceof estruturas_1.ObjetoDeleguaClasse) &&
-                            objeto.constructor !== Object) {
-                            return [2 /*return*/, Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente instâncias e dicionários podem possuir campos.', expressao.linha))];
-                        }
-                        return [4 /*yield*/, this.avaliar(expressao.valor)];
-                    case 2:
-                        valor = _a.sent();
-                        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse) {
-                            objeto.set(expressao.nome, valor);
-                            return [2 /*return*/, valor];
-                        }
-                        else if (objeto.constructor === Object) {
-                            objeto[expressao.simbolo.lexema] = valor;
-                        }
-                        return [2 /*return*/];
+            }
+            if (valorIndice >= objeto.length) {
+                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice do vetor fora do intervalo.', expressao.linha));
+            }
+            return objeto[valorIndice];
+        }
+        else 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 === 'string') {
+            if (!Number.isInteger(valorIndice)) {
+                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha));
+            }
+            if (valorIndice < 0 && objeto.length !== 0) {
+                while (valorIndice < 0) {
+                    valorIndice += objeto.length;
                 }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoFuncao = function (declaracao) {
-        var funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
+            }
+            if (valorIndice >= objeto.length) {
+                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice fora do tamanho.', expressao.linha));
+            }
+            return objeto.charAt(valorIndice);
+        }
+        else {
+            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.entidadeChamada.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha));
+        }
+    }
+    async visitarExpressaoDefinirValor(expressao) {
+        const variavelObjeto = await this.avaliar(expressao.objeto);
+        const objeto = variavelObjeto.hasOwnProperty('valor')
+            ? variavelObjeto.valor
+            : variavelObjeto;
+        if (!(objeto instanceof estruturas_1.ObjetoDeleguaClasse) &&
+            objeto.constructor !== Object) {
+            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente instâncias e dicionários podem possuir campos.', expressao.linha));
+        }
+        const valor = await this.avaliar(expressao.valor);
+        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse) {
+            objeto.definir(expressao.nome, valor);
+            return valor;
+        }
+        else if (objeto.constructor === Object) {
+            objeto[expressao.simbolo.lexema] = valor;
+        }
+    }
+    visitarExpressaoFuncao(declaracao) {
+        const funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, funcao);
-    };
+    }
     /**
      * Executa uma declaração de classe.
      * @param declaracao A declaração de classe.
      * @returns Sempre retorna nulo, por ser requerido pelo contrato de visita.
      */
-    Interpretador.prototype.visitarExpressaoClasse = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var superClasse, variavelSuperClasse, metodos, definirMetodos, i, metodoAtual, eInicializador, funcao, deleguaClasse;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        superClasse = null;
-                        if (!(declaracao.superClasse !== null)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.avaliar(declaracao.superClasse)];
-                    case 1:
-                        variavelSuperClasse = _a.sent();
-                        superClasse = variavelSuperClasse.valor;
-                        if (!(superClasse instanceof estruturas_1.DeleguaClasse)) {
-                            throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.superClasse.nome, 'SuperClasse precisa ser uma classe.', declaracao.linha);
-                        }
-                        _a.label = 2;
-                    case 2:
-                        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, null);
-                        if (declaracao.superClasse !== null) {
-                            this.pilhaEscoposExecucao.definirVariavel('super', superClasse);
-                        }
-                        metodos = {};
-                        definirMetodos = declaracao.metodos;
-                        for (i = 0; i < declaracao.metodos.length; i++) {
-                            metodoAtual = definirMetodos[i];
-                            eInicializador = metodoAtual.simbolo.lexema === 'construtor';
-                            funcao = new estruturas_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, undefined, eInicializador);
-                            metodos[metodoAtual.simbolo.lexema] = funcao;
-                        }
-                        deleguaClasse = new estruturas_1.DeleguaClasse(declaracao.simbolo.lexema, superClasse, metodos);
-                        // TODO: Recolocar isso se for necessário.
-                        /* if (superClasse !== null) {
-                            this.ambiente = this.ambiente.enclosing;
-                        } */
-                        this.pilhaEscoposExecucao.atribuirVariavel(declaracao.simbolo, deleguaClasse);
-                        return [2 /*return*/, null];
-                }
-            });
-        });
-    };
+    async visitarExpressaoClasse(declaracao) {
+        let superClasse = null;
+        if (declaracao.superClasse !== null) {
+            const variavelSuperClasse = await this.avaliar(declaracao.superClasse);
+            superClasse = variavelSuperClasse.valor;
+            if (!(superClasse instanceof estruturas_1.DeleguaClasse)) {
+                throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.superClasse.nome, 'SuperClasse precisa ser uma classe.', declaracao.linha);
+            }
+        }
+        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, null);
+        if (declaracao.superClasse !== null) {
+            this.pilhaEscoposExecucao.definirVariavel('super', superClasse);
+        }
+        const metodos = {};
+        const definirMetodos = declaracao.metodos;
+        for (let i = 0; i < declaracao.metodos.length; i++) {
+            const metodoAtual = definirMetodos[i];
+            const eInicializador = metodoAtual.simbolo.lexema === 'construtor';
+            const funcao = new estruturas_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, undefined, eInicializador);
+            metodos[metodoAtual.simbolo.lexema] = funcao;
+        }
+        const deleguaClasse = new estruturas_1.DeleguaClasse(declaracao.simbolo.lexema, superClasse, metodos);
+        // TODO: Recolocar isso se for necessário.
+        /* if (superClasse !== null) {
+            this.ambiente = this.ambiente.enclosing;
+        } */
+        this.pilhaEscoposExecucao.atribuirVariavel(declaracao.simbolo, deleguaClasse);
+        return null;
+    }
     /**
      * Executa um acesso a método, normalmente de um objeto de classe.
      * @param expressao A expressão de acesso.
      * @returns O resultado da execução.
      */
-    Interpretador.prototype.visitarExpressaoAcessoMetodo = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var variavelObjeto, objeto, metodoDePrimitivaTexto, metodoDePrimitivaVetor;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(expressao.objeto)];
-                    case 1:
-                        variavelObjeto = _a.sent();
-                        objeto = variavelObjeto === null || variavelObjeto === void 0 ? void 0 : variavelObjeto.valor;
-                        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse) {
-                            return [2 /*return*/, objeto.get(expressao.simbolo) || null];
-                        }
-                        if (objeto.constructor === Object) {
-                            return [2 /*return*/, objeto[expressao.simbolo.lexema] || null];
-                        }
-                        if (objeto instanceof estruturas_1.DeleguaModulo) {
-                            return [2 /*return*/, objeto.componentes[expressao.simbolo.lexema] || null];
-                        }
-                        switch (variavelObjeto.tipo) {
-                            case 'texto':
-                                metodoDePrimitivaTexto = primitivas_texto_1.default[expressao.simbolo.lexema];
-                                if (metodoDePrimitivaTexto) {
-                                    return [2 /*return*/, new metodo_primitiva_1.MetodoPrimitiva(objeto, metodoDePrimitivaTexto)];
-                                }
-                                break;
-                            case 'vetor':
-                                metodoDePrimitivaVetor = primitivas_vetor_1.default[expressao.simbolo.lexema];
-                                if (metodoDePrimitivaVetor) {
-                                    return [2 /*return*/, new metodo_primitiva_1.MetodoPrimitiva(objeto, metodoDePrimitivaVetor)];
-                                }
-                                break;
-                        }
-                        return [2 /*return*/, Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.nome, 'Você só pode acessar métodos do objeto e dicionários.', expressao.linha))];
-                }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoIsto = function (expressao) {
-        return this.procurarVariavel(expressao.palavraChave);
-    };
-    Interpretador.prototype.visitarExpressaoDicionario = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var dicionario, i, promises;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        dicionario = {};
-                        i = 0;
-                        _a.label = 1;
-                    case 1:
-                        if (!(i < expressao.chaves.length)) return [3 /*break*/, 4];
-                        return [4 /*yield*/, Promise.all([
-                                this.avaliar(expressao.chaves[i]),
-                                this.avaliar(expressao.valores[i])
-                            ])];
-                    case 2:
-                        promises = _a.sent();
-                        dicionario[promises[0]] = promises[1];
-                        _a.label = 3;
-                    case 3:
-                        i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/, dicionario];
+    async visitarExpressaoAcessoMetodo(expressao) {
+        const variavelObjeto = await this.avaliar(expressao.objeto);
+        const objeto = variavelObjeto.hasOwnProperty('valor')
+            ? variavelObjeto.valor
+            : variavelObjeto;
+        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse) {
+            return objeto.obter(expressao.simbolo) || null;
+        }
+        if (objeto.constructor === Object) {
+            return objeto[expressao.simbolo.lexema] || null;
+        }
+        if (objeto instanceof estruturas_1.DeleguaModulo) {
+            return objeto.componentes[expressao.simbolo.lexema] || null;
+        }
+        switch (variavelObjeto.tipo) {
+            case 'texto':
+                const metodoDePrimitivaTexto = primitivas_texto_1.default[expressao.simbolo.lexema];
+                if (metodoDePrimitivaTexto) {
+                    return new metodo_primitiva_1.MetodoPrimitiva(objeto, metodoDePrimitivaTexto);
                 }
-            });
-        });
-    };
-    Interpretador.prototype.visitarExpressaoVetor = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var valores, i, _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        valores = [];
-                        i = 0;
-                        _c.label = 1;
-                    case 1:
-                        if (!(i < expressao.valores.length)) return [3 /*break*/, 4];
-                        _b = (_a = valores).push;
-                        return [4 /*yield*/, this.avaliar(expressao.valores[i])];
-                    case 2:
-                        _b.apply(_a, [_c.sent()]);
-                        _c.label = 3;
-                    case 3:
-                        i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/, valores];
+                break;
+            case 'vetor':
+                const metodoDePrimitivaVetor = primitivas_vetor_1.default[expressao.simbolo.lexema];
+                if (metodoDePrimitivaVetor) {
+                    return new metodo_primitiva_1.MetodoPrimitiva(objeto, metodoDePrimitivaVetor);
                 }
-            });
-        });
-    };
+                break;
+        }
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.nome, 'Você só pode acessar métodos do objeto e dicionários.', expressao.linha));
+    }
+    visitarExpressaoIsto(expressao) {
+        return this.procurarVariavel(expressao.palavraChave);
+    }
+    async visitarExpressaoDicionario(expressao) {
+        const dicionario = {};
+        for (let i = 0; i < expressao.chaves.length; i++) {
+            const promises = await Promise.all([
+                this.avaliar(expressao.chaves[i]),
+                this.avaliar(expressao.valores[i])
+            ]);
+            dicionario[promises[0]] = promises[1];
+        }
+        return dicionario;
+    }
+    async visitarExpressaoVetor(expressao) {
+        const valores = [];
+        for (let i = 0; i < expressao.valores.length; i++) {
+            valores.push(await this.avaliar(expressao.valores[i]));
+        }
+        return valores;
+    }
     // TODO: Após remoção do Resolvedor, simular casos que usem 'super' e 'isto'.
-    Interpretador.prototype.visitarExpressaoSuper = function (expressao) {
-        var superClasse = this.pilhaEscoposExecucao.obterVariavelPorNome('super');
-        var objeto = this.pilhaEscoposExecucao.obterVariavelPorNome('isto');
-        var metodo = superClasse.valor.encontrarMetodo(expressao.metodo.lexema);
+    visitarExpressaoSuper(expressao) {
+        const superClasse = this.pilhaEscoposExecucao.obterVariavelPorNome('super');
+        const objeto = this.pilhaEscoposExecucao.obterVariavelPorNome('isto');
+        const metodo = superClasse.valor.encontrarMetodo(expressao.metodo.lexema);
         if (metodo === undefined) {
             throw new excecoes_1.ErroEmTempoDeExecucao(expressao.metodo, 'Método chamado indefinido.', expressao.linha);
         }
         return metodo.definirInstancia(objeto.valor);
-    };
-    Interpretador.prototype.paraTexto = function (objeto) {
+    }
+    paraTexto(objeto) {
         if (objeto === null || objeto === undefined)
             return 'nulo';
         if (typeof objeto === 'boolean') {
             return objeto ? 'verdadeiro' : 'falso';
         }
         if (objeto instanceof Date) {
-            var formato = Intl.DateTimeFormat('pt', {
+            const formato = Intl.DateTimeFormat('pt', {
                 dateStyle: 'full',
                 timeStyle: 'full',
             });
@@ -1275,33 +849,23 @@ var Interpretador = /** @class */ (function () {
         if (typeof objeto === 'object')
             return JSON.stringify(objeto);
         return objeto.toString();
-    };
+    }
     /**
      * Efetivamente executa uma declaração.
      * @param declaracao A declaração a ser executada.
      * @param mostrarResultado Se resultado deve ser mostrado ou não. Normalmente usado
      *                         pelo modo LAIR.
      */
-    Interpretador.prototype.executar = function (declaracao, mostrarResultado) {
-        if (mostrarResultado === void 0) { mostrarResultado = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            var resultado;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, declaracao.aceitar(this)];
-                    case 1:
-                        resultado = _a.sent();
-                        if (mostrarResultado) {
-                            this.funcaoDeRetorno(this.paraTexto(resultado));
-                        }
-                        if (resultado || typeof resultado === 'boolean') {
-                            this.resultadoInterpretador.push(this.paraTexto(resultado));
-                        }
-                        return [2 /*return*/, resultado];
-                }
-            });
-        });
-    };
+    async executar(declaracao, mostrarResultado = false) {
+        const resultado = await declaracao.aceitar(this);
+        if (mostrarResultado) {
+            this.funcaoDeRetorno(this.paraTexto(resultado));
+        }
+        if (resultado || typeof resultado === 'boolean') {
+            this.resultadoInterpretador.push(this.paraTexto(resultado));
+        }
+        return resultado;
+    }
     /**
      * Executa o último escopo empilhado no topo na pilha de escopos do interpretador.
      * Esse método pega exceções, mas apenas as devolve.
@@ -1312,45 +876,27 @@ var Interpretador = /** @class */ (function () {
      * @param manterAmbiente Se verdadeiro, ambiente do topo da pilha de escopo é copiado para o ambiente imediatamente abaixo.
      * @returns O resultado da execução do escopo, se houver.
      */
-    Interpretador.prototype.executarUltimoEscopo = function (manterAmbiente) {
-        if (manterAmbiente === void 0) { manterAmbiente = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            var ultimoEscopo, retornoExecucao, erro_10, escopoAnterior;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        ultimoEscopo = this.pilhaEscoposExecucao.topoDaPilha();
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 6, 7, 8]);
-                        retornoExecucao = void 0;
-                        _a.label = 2;
-                    case 2:
-                        if (!(!(retornoExecucao instanceof quebras_1.Quebra) &&
-                            ultimoEscopo.declaracaoAtual < ultimoEscopo.declaracoes.length)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, this.executar(ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual])];
-                    case 3:
-                        retornoExecucao = _a.sent();
-                        _a.label = 4;
-                    case 4:
-                        ultimoEscopo.declaracaoAtual++;
-                        return [3 /*break*/, 2];
-                    case 5: return [2 /*return*/, retornoExecucao];
-                    case 6:
-                        erro_10 = _a.sent();
-                        return [2 /*return*/, Promise.reject(erro_10)];
-                    case 7:
-                        this.pilhaEscoposExecucao.removerUltimo();
-                        if (manterAmbiente) {
-                            escopoAnterior = this.pilhaEscoposExecucao.topoDaPilha();
-                            escopoAnterior.ambiente.valores = Object.assign(escopoAnterior.ambiente.valores, ultimoEscopo.ambiente.valores);
-                        }
-                        return [7 /*endfinally*/];
-                    case 8: return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async executarUltimoEscopo(manterAmbiente = false) {
+        const ultimoEscopo = this.pilhaEscoposExecucao.topoDaPilha();
+        try {
+            let retornoExecucao;
+            for (; !(retornoExecucao instanceof quebras_1.Quebra) &&
+                ultimoEscopo.declaracaoAtual < ultimoEscopo.declaracoes.length; ultimoEscopo.declaracaoAtual++) {
+                retornoExecucao = await this.executar(ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual]);
+            }
+            return retornoExecucao;
+        }
+        catch (erro) {
+            return Promise.reject(erro);
+        }
+        finally {
+            this.pilhaEscoposExecucao.removerUltimo();
+            if (manterAmbiente) {
+                const escopoAnterior = this.pilhaEscoposExecucao.topoDaPilha();
+                escopoAnterior.ambiente.valores = Object.assign(escopoAnterior.ambiente.valores, ultimoEscopo.ambiente.valores);
+            }
+        }
+    }
     /**
      * Interpretação sem depurador, com medição de performance.
      * Método que efetivamente inicia o processo de interpretação.
@@ -1359,52 +905,37 @@ var Interpretador = /** @class */ (function () {
      *                       pelo modo REPL (LEIA).
      * @returns Um objeto com o resultado da interpretação.
      */
-    Interpretador.prototype.interpretar = function (declaracoes, manterAmbiente) {
-        if (manterAmbiente === void 0) { manterAmbiente = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            var escopoExecucao, inicioInterpretacao, retornoOuErro, erro_11, deltaInterpretacao, retorno;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.erros = [];
-                        escopoExecucao = {
-                            declaracoes: declaracoes,
-                            declaracaoAtual: 0,
-                            ambiente: new espaco_variaveis_1.EspacoVariaveis(),
-                        };
-                        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-                        inicioInterpretacao = (0, browser_process_hrtime_1.default)();
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, 4, 5]);
-                        return [4 /*yield*/, this.executarUltimoEscopo(manterAmbiente)];
-                    case 2:
-                        retornoOuErro = _a.sent();
-                        if (retornoOuErro instanceof excecoes_1.ErroEmTempoDeExecucao) {
-                            this.erros.push(retornoOuErro);
-                        }
-                        return [3 /*break*/, 5];
-                    case 3:
-                        erro_11 = _a.sent();
-                        this.erros.push(erro_11);
-                        return [3 /*break*/, 5];
-                    case 4:
-                        if (this.performance) {
-                            deltaInterpretacao = (0, browser_process_hrtime_1.default)(inicioInterpretacao);
-                            console.log("[Interpretador] Tempo para interpreta\u00E7ao: ".concat(deltaInterpretacao[0] * 1e9 + deltaInterpretacao[1], "ns"));
-                        }
-                        retorno = {
-                            erros: this.erros,
-                            resultado: this.resultadoInterpretador,
-                        };
-                        this.resultadoInterpretador = [];
-                        return [2 /*return*/, retorno];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return Interpretador;
-}());
+    async interpretar(declaracoes, manterAmbiente = false) {
+        this.erros = [];
+        const escopoExecucao = {
+            declaracoes: declaracoes,
+            declaracaoAtual: 0,
+            ambiente: new espaco_variaveis_1.EspacoVariaveis(),
+        };
+        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
+        const inicioInterpretacao = (0, browser_process_hrtime_1.default)();
+        try {
+            const retornoOuErro = await this.executarUltimoEscopo(manterAmbiente);
+            if (retornoOuErro instanceof excecoes_1.ErroEmTempoDeExecucao) {
+                this.erros.push(retornoOuErro);
+            }
+        }
+        catch (erro) {
+            this.erros.push(erro);
+        }
+        finally {
+            if (this.performance) {
+                const deltaInterpretacao = (0, browser_process_hrtime_1.default)(inicioInterpretacao);
+                console.log(`[Interpretador] Tempo para interpretaçao: ${deltaInterpretacao[0] * 1e9 + deltaInterpretacao[1]}ns`);
+            }
+            const retorno = {
+                erros: this.erros,
+                resultado: this.resultadoInterpretador,
+            };
+            this.resultadoInterpretador = [];
+            return retorno;
+        }
+    }
+}
 exports.Interpretador = Interpretador;
 //# sourceMappingURL=interpretador.js.map