@designliquido/delegua 0.8.1 → 0.9.0

package/fontes/interpretador/interpretador.js

@@ -22,6 +22,42 @@ 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 };
 };
@@ -48,8 +84,11 @@ var primitivas_vetor_1 = __importDefault(require("../bibliotecas/primitivas-veto
 var Interpretador = /** @class */ (function () {
     function Interpretador(importador, diretorioBase, performance, funcaoDeRetorno) {
         if (performance === void 0) { performance = false; }
+        if (funcaoDeRetorno === void 0) { funcaoDeRetorno = null; }
         this.funcaoDeRetorno = null;
+        this.interfaceDeEntrada = null;
         this.resultadoInterpretador = [];
+        this.interfaceEntradaSaida = null;
         this.regexInterpolacao = /\$\{([a-z_][\w]*)\}/gi;
         this.importador = importador;
         this.diretorioBase = diretorioBase;
@@ -69,10 +108,22 @@ var Interpretador = /** @class */ (function () {
     /**
      * Execução da leitura de valores da entrada configurada no
      * início da aplicação.
-     * @param expressao
+     * @param expressao Expressão do tipo Leia
+     * @returns Promise com o resultado da leitura.
      */
     Interpretador.prototype.visitarExpressaoLeia = function (expressao) {
-        throw new Error('Método não implementado.');
+        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);
+                        });
+                    })];
+            });
+        });
     };
     /**
      * Retira a interpolação de um texto.
@@ -119,10 +170,24 @@ var Interpretador = /** @class */ (function () {
         return expressao.valor;
     };
     Interpretador.prototype.avaliar = function (expressao) {
-        return expressao.aceitar(this);
+        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: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
     };
     Interpretador.prototype.visitarExpressaoAgrupamento = function (expressao) {
-        return this.avaliar(expressao.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) {
         if (objeto === null)
@@ -132,22 +197,34 @@ var Interpretador = /** @class */ (function () {
         return true;
     };
     Interpretador.prototype.verificarOperandoNumero = function (operador, operando) {
-        if (typeof operando === 'number')
+        if (typeof operando === 'number' || operando.tipo === 'número')
             return;
-        throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operando precisa ser um número.', operador.linha);
+        throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operando precisa ser um número.', Number(operador.linha));
     };
     Interpretador.prototype.visitarExpressaoUnaria = function (expressao) {
-        var direita = this.avaliar(expressao.direita);
-        switch (expressao.operador.tipo) {
-            case delegua_1.default.SUBTRACAO:
-                this.verificarOperandoNumero(expressao.operador, direita);
-                return -direita;
-            case delegua_1.default.NEGACAO:
-                return !this.eVerdadeiro(direita);
-            case delegua_1.default.BIT_NOT:
-                return ~direita;
-        }
-        return null;
+        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) {
         if (esquerda === null && direita === null)
@@ -189,80 +266,98 @@ var Interpretador = /** @class */ (function () {
         throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
     };
     Interpretador.prototype.visitarExpressaoBinaria = function (expressao) {
-        var esquerda = this.avaliar(expressao.esquerda);
-        var direita = this.avaliar(expressao.direita);
-        var valorEsquerdo = (esquerda === null || esquerda === void 0 ? void 0 : esquerda.hasOwnProperty('valor'))
-            ? esquerda.valor
-            : esquerda;
-        var valorDireito = (direita === null || direita === void 0 ? void 0 : direita.hasOwnProperty('valor'))
-            ? direita.valor
-            : direita;
-        var tipoEsquerdo = (esquerda === null || esquerda === void 0 ? void 0 : esquerda.hasOwnProperty('tipo'))
-            ? esquerda.tipo
-            : (0, inferenciador_1.inferirTipoVariavel)(esquerda);
-        var 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);
+        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*/];
                 }
-            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);
-        }
+            });
+        });
     };
     /**
      * Executa uma chamada de função, método ou classe.
@@ -270,65 +365,99 @@ var Interpretador = /** @class */ (function () {
      * @returns O resultado da chamada.
      */
     Interpretador.prototype.visitarExpressaoDeChamada = function (expressao) {
-        var variavelEntidadeChamada = this.avaliar(expressao.entidadeChamada);
-        var entidadeChamada = variavelEntidadeChamada.hasOwnProperty('valor')
-            ? variavelEntidadeChamada.valor
-            : variavelEntidadeChamada;
-        var argumentos = [];
-        for (var i = 0; i < expressao.argumentos.length; i++) {
-            argumentos.push(this.avaliar(expressao.argumentos[i]));
-        }
-        if (!(entidadeChamada instanceof estruturas_1.Chamavel)) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Só pode chamar função ou classe.', expressao.linha);
-        }
-        if (entidadeChamada instanceof metodo_primitiva_1.MetodoPrimitiva) {
-            var argumentosResolvidos = [];
-            for (var _i = 0, _a = expressao.argumentos; _i < _a.length; _i++) {
-                var argumento = _a[_i];
-                var valorResolvido = this.avaliar(argumento);
-                argumentosResolvidos.push(valorResolvido.hasOwnProperty('valor')
-                    ? valorResolvido.valor
-                    : valorResolvido);
-            }
-            return entidadeChamada.chamar(argumentosResolvidos);
-        }
-        var 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()) {
-            var diferenca = entidadeChamada.aridade() - argumentos.length;
-            for (var i = 0; i < diferenca; i++) {
-                argumentos.push(null);
-            }
-        }
-        else {
-            if (parametros &&
-                parametros.length > 0 &&
-                parametros[parametros.length - 1].tipo === 'estrela') {
-                var 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);
+        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*/];
+                }
+            });
+        });
     };
     /**
      * Execução de uma expressão de atribuição.
@@ -336,9 +465,18 @@ var Interpretador = /** @class */ (function () {
      * @returns O valor atribuído.
      */
     Interpretador.prototype.visitarExpressaoDeAtribuicao = function (expressao) {
-        var valor = this.avaliar(expressao.valor);
-        this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valor);
-        return valor;
+        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) {
         return this.pilhaEscoposExecucao.obterVariavel(simbolo);
@@ -347,33 +485,53 @@ var Interpretador = /** @class */ (function () {
         return this.procurarVariavel(expressao.simbolo);
     };
     Interpretador.prototype.visitarDeclaracaoDeExpressao = function (declaracao) {
-        return this.avaliar(declaracao.expressao);
+        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) {
-        var esquerda = this.avaliar(expressao.esquerda);
-        if (expressao.operador.tipo === delegua_1.default.EM) {
-            var direita = 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 this.avaliar(expressao.direita);
+        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()];
+                }
+            });
+        });
     };
     /**
      * Executa uma expressão Se, que tem uma condição, pode ter um bloco
@@ -382,146 +540,288 @@ var Interpretador = /** @class */ (function () {
      * @returns O resultado da avaliação do bloco cuja condição é verdadeira.
      */
     Interpretador.prototype.visitarExpressaoSe = function (declaracao) {
-        if (this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
-            return this.executar(declaracao.caminhoEntao);
-        }
-        for (var i = 0; i < declaracao.caminhosSeSenao.length; i++) {
-            var atual = declaracao.caminhosSeSenao[i];
-            if (this.eVerdadeiro(this.avaliar(atual.condicao))) {
-                return this.executar(atual.caminho);
-            }
-        }
-        if (declaracao.caminhoSenao !== null) {
-            return this.executar(declaracao.caminhoSenao);
-        }
-        return null;
+        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) {
-        if (declaracao.inicializador !== null) {
-            this.avaliar(declaracao.inicializador);
-        }
-        var retornoExecucao;
-        while (!(retornoExecucao instanceof quebras_1.Quebra)) {
-            if (declaracao.condicao !== null &&
-                !this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
-                break;
-            }
-            try {
-                retornoExecucao = this.executar(declaracao.corpo);
-            }
-            catch (erro) {
-                throw erro;
-            }
-            if (declaracao.incrementar !== null) {
-                this.avaliar(declaracao.incrementar);
-            }
-        }
-        return null;
+        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) {
-        var retornoExecucao;
-        do {
-            try {
-                retornoExecucao = this.executar(declaracao.caminhoFazer);
-            }
-            catch (erro) {
-                throw erro;
-            }
-        } while (!(retornoExecucao instanceof quebras_1.Quebra) &&
-            this.eVerdadeiro(this.avaliar(declaracao.condicaoEnquanto)));
+        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) {
-        var condicaoEscolha = this.avaliar(declaracao.identificadorOuLiteral);
-        var caminhos = declaracao.caminhos;
-        var caminhoPadrao = declaracao.caminhoPadrao;
-        var encontrado = false;
-        try {
-            for (var i = 0; i < caminhos.length; i++) {
-                var caminho_1 = caminhos[i];
-                for (var j = 0; j < caminho_1.condicoes.length; j++) {
-                    if (this.avaliar(caminho_1.condicoes[j]) === condicaoEscolha) {
+        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];
                         encontrado = true;
-                        try {
-                            this.executarBloco(caminho_1.declaracoes);
-                        }
-                        catch (erro) {
-                            throw erro;
-                        }
-                    }
+                        _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*/];
                 }
-            }
-            if (caminhoPadrao !== null && encontrado === false) {
-                this.executarBloco(caminhoPadrao.declaracoes);
-            }
-        }
-        catch (erro) {
-            throw erro;
-        }
+            });
+        });
     };
     Interpretador.prototype.visitarExpressaoTente = function (declaracao) {
-        try {
-            var sucesso = true;
-            try {
-                this.executarBloco(declaracao.caminhoTente);
-            }
-            catch (erro) {
-                sucesso = false;
-                if (declaracao.caminhoPegue !== null) {
-                    this.executarBloco(declaracao.caminhoPegue);
-                }
-                else {
-                    this.erros.push(erro);
+        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*/];
                 }
-            }
-            if (sucesso && declaracao.caminhoSenao !== null) {
-                this.executarBloco(declaracao.caminhoSenao);
-            }
-        }
-        finally {
-            if (declaracao.caminhoFinalmente !== null)
-                this.executarBloco(declaracao.caminhoFinalmente);
-        }
+            });
+        });
     };
     Interpretador.prototype.visitarExpressaoEnquanto = function (declaracao) {
-        var retornoExecucao;
-        while (!(retornoExecucao instanceof quebras_1.Quebra) &&
-            this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
-            try {
-                retornoExecucao = this.executar(declaracao.corpo);
-            }
-            catch (erro) {
-                throw erro;
-            }
-        }
-        return null;
+        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) {
-        var caminhoRelativo = this.avaliar(declaracao.caminho);
-        var caminhoTotal = caminho.join(this.diretorioBase, caminhoRelativo);
-        var 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;
-            }
-        }
-        var conteudoImportacao = this.importador.importar(caminhoRelativo);
-        var retornoInterpretador = this.interpretar(conteudoImportacao.retornoAvaliadorSintatico.declaracoes, true);
-        var funcoesChamaveis = this.pilhaEscoposExecucao.obterTodasDeleguaFuncao();
-        var eDicionario = function (objeto) { return objeto.constructor === Object; };
-        if (eDicionario(funcoesChamaveis)) {
-            var novoModulo = new estruturas_1.DeleguaModulo();
-            var chaves = Object.keys(funcoesChamaveis);
-            for (var i = 0; i < chaves.length; i++) {
-                novoModulo.componentes[chaves[i]] = funcoesChamaveis[chaves[i]];
-            }
-            return novoModulo;
-        }
-        return funcoesChamaveis;
+        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];
+                            }
+                        }
+                        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];
+                        }
+                        return [2 /*return*/, funcoesChamaveis];
+                }
+            });
+        });
     };
     /**
      * Execução de uma escrita na saída configurada, que pode ser `console` (padrão) ou
@@ -530,24 +830,42 @@ var Interpretador = /** @class */ (function () {
      * @returns Sempre nulo, por convenção de visita.
      */
     Interpretador.prototype.visitarExpressaoEscreva = function (declaracao) {
-        try {
-            var valor = void 0;
-            for (var _i = 0, _a = declaracao.argumentos; _i < _a.length; _i++) {
-                var argumento = _a[_i];
-                var resultadoAvaliacao = this.avaliar(argumento);
-                valor = (resultadoAvaliacao === null || resultadoAvaliacao === void 0 ? void 0 : resultadoAvaliacao.hasOwnProperty('valor'))
-                    ? resultadoAvaliacao.valor
-                    : resultadoAvaliacao;
-            }
-            var 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);
-        }
+        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*/];
+                }
+            });
+        });
     };
     /**
      * Empilha declarações na pilha de escopos de execução, cria um novo ambiente e
@@ -559,20 +877,37 @@ var Interpretador = /** @class */ (function () {
      * @param ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
      */
     Interpretador.prototype.executarBloco = function (declaracoes, ambiente) {
-        var escopoExecucao = {
-            declaracoes: declaracoes,
-            declaracaoAtual: 0,
-            ambiente: ambiente || new espaco_variaveis_1.EspacoVariaveis(),
-        };
-        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-        var retornoUltimoEscopo = this.executarUltimoEscopo();
-        if (retornoUltimoEscopo instanceof excecoes_1.ErroEmTempoDeExecucao) {
-            throw retornoUltimoEscopo;
-        }
-        return retornoUltimoEscopo;
+        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 this.executarBloco(declaracao.declaracoes);
+        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()];
+                }
+            });
+        });
     };
     /**
      * Executa expressão de definição de variável.
@@ -580,14 +915,25 @@ var Interpretador = /** @class */ (function () {
      * @returns Sempre retorna nulo.
      */
     Interpretador.prototype.visitarExpressaoVar = function (declaracao) {
-        var valorOuOutraVariavel = null;
-        if (declaracao.inicializador !== null) {
-            valorOuOutraVariavel = this.avaliar(declaracao.inicializador);
-        }
-        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valorOuOutraVariavel.hasOwnProperty('valor')
-            ? valorOuOutraVariavel.valor
-            : valorOuOutraVariavel);
-        return null;
+        return __awaiter(this, void 0, void 0, function () {
+            var valorOuOutraVariavel;
+            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:
+                        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valorOuOutraVariavel.hasOwnProperty('valor')
+                            ? valorOuOutraVariavel.valor
+                            : valorOuOutraVariavel);
+                        return [2 /*return*/, null];
+                }
+            });
+        });
     };
     Interpretador.prototype.visitarExpressaoContinua = function (declaracao) {
         return new quebras_1.ContinuarQuebra();
@@ -596,100 +942,150 @@ var Interpretador = /** @class */ (function () {
         return new quebras_1.SustarQuebra();
     };
     Interpretador.prototype.visitarExpressaoRetornar = function (declaracao) {
-        var valor = null;
-        if (declaracao.valor != null)
-            valor = this.avaliar(declaracao.valor);
-        return new quebras_1.RetornoQuebra(valor);
+        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) {
         return new estruturas_1.DeleguaFuncao(null, expressao);
     };
     Interpretador.prototype.visitarExpressaoAtribuicaoSobrescrita = function (expressao) {
-        var objeto = this.avaliar(expressao.objeto);
-        var indice = this.avaliar(expressao.indice);
-        var valor = this.avaliar(expressao.valor);
-        if (Array.isArray(objeto)) {
-            if (indice < 0 && objeto.length !== 0) {
-                while (indice < 0) {
-                    indice += objeto.length;
+        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];
+                        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*/];
                 }
-            }
-            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 {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha);
-        }
+            });
+        });
     };
     Interpretador.prototype.visitarExpressaoAcessoIndiceVariavel = function (expressao) {
-        var variavelObjeto = this.avaliar(expressao.entidadeChamada);
-        var objeto = variavelObjeto.hasOwnProperty('valor')
-            ? variavelObjeto.valor
-            : variavelObjeto;
-        var indice = this.avaliar(expressao.indice);
-        var valorIndice = indice.hasOwnProperty('valor') ? indice.valor : indice;
-        if (Array.isArray(objeto)) {
-            if (!Number.isInteger(valorIndice)) {
-                throw 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) {
-                throw 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)) {
-                throw 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;
+        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) {
+                                throw 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*/];
                 }
-            }
-            if (valorIndice >= objeto.length) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice fora do tamanho.', expressao.linha);
-            }
-            return objeto.charAt(valorIndice);
-        }
-        else {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.entidadeChamada.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha);
-        }
+            });
+        });
     };
-    Interpretador.prototype.visitarExpressaoDefinir = function (expressao) {
-        var objeto = this.avaliar(expressao.objeto);
-        if (!(objeto instanceof estruturas_1.ObjetoDeleguaClasse) &&
-            objeto.constructor !== Object) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente instâncias e dicionários podem possuir campos.', expressao.linha);
-        }
-        var valor = this.avaliar(expressao.valor);
-        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse) {
-            objeto.set(expressao.nome, valor);
-            return valor;
-        }
-        else if (objeto.constructor === Object) {
-            objeto[expressao.simbolo.lexema] = valor;
-        }
+    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*/];
+                }
+            });
+        });
     };
     Interpretador.prototype.visitarExpressaoFuncao = function (declaracao) {
         var funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
@@ -701,33 +1097,44 @@ var Interpretador = /** @class */ (function () {
      * @returns Sempre retorna nulo, por ser requerido pelo contrato de visita.
      */
     Interpretador.prototype.visitarExpressaoClasse = function (declaracao) {
-        var superClasse = null;
-        if (declaracao.superClasse !== null) {
-            var variavelSuperClasse = 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);
-        }
-        var metodos = {};
-        var definirMetodos = declaracao.metodos;
-        for (var i = 0; i < declaracao.metodos.length; i++) {
-            var metodoAtual = definirMetodos[i];
-            var eInicializador = metodoAtual.simbolo.lexema === 'construtor';
-            var funcao = new estruturas_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, undefined, eInicializador);
-            metodos[metodoAtual.simbolo.lexema] = funcao;
-        }
-        var 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;
+        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];
+                }
+            });
+        });
     };
     /**
      * Executa um acesso a método, normalmente de um objeto de classe.
@@ -735,49 +1142,95 @@ var Interpretador = /** @class */ (function () {
      * @returns O resultado da execução.
      */
     Interpretador.prototype.visitarExpressaoAcessoMetodo = function (expressao) {
-        var variavelObjeto = this.avaliar(expressao.objeto);
-        var objeto = variavelObjeto === null || variavelObjeto === void 0 ? void 0 : variavelObjeto.valor;
-        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse) {
-            return objeto.get(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':
-                var metodoDePrimitivaTexto = primitivas_texto_1.default[expressao.simbolo.lexema];
-                if (metodoDePrimitivaTexto) {
-                    return new metodo_primitiva_1.MetodoPrimitiva(objeto, metodoDePrimitivaTexto);
-                }
-                break;
-            case 'vetor':
-                var metodoDePrimitivaVetor = primitivas_vetor_1.default[expressao.simbolo.lexema];
-                if (metodoDePrimitivaVetor) {
-                    return new metodo_primitiva_1.MetodoPrimitiva(objeto, metodoDePrimitivaVetor);
+        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))];
                 }
-                break;
-        }
-        throw 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) {
-        var dicionario = {};
-        for (var i = 0; i < expressao.chaves.length; i++) {
-            dicionario[this.avaliar(expressao.chaves[i])] = this.avaliar(expressao.valores[i]);
-        }
-        return dicionario;
+        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];
+                }
+            });
+        });
     };
     Interpretador.prototype.visitarExpressaoVetor = function (expressao) {
-        var valores = [];
-        for (var i = 0; i < expressao.valores.length; i++) {
-            valores.push(this.avaliar(expressao.valores[i]));
-        }
-        return valores;
+        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];
+                }
+            });
+        });
     };
     // TODO: Após remoção do Resolvedor, simular casos que usem 'super' e 'isto'.
     Interpretador.prototype.visitarExpressaoSuper = function (expressao) {
@@ -818,14 +1271,23 @@ var Interpretador = /** @class */ (function () {
      */
     Interpretador.prototype.executar = function (declaracao, mostrarResultado) {
         if (mostrarResultado === void 0) { mostrarResultado = false; }
-        var resultado = declaracao.aceitar(this);
-        if (mostrarResultado) {
-            this.funcaoDeRetorno(this.paraTexto(resultado));
-        }
-        if (resultado || typeof resultado === 'boolean') {
-            this.resultadoInterpretador.push(this.paraTexto(resultado));
-        }
-        return resultado;
+        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];
+                }
+            });
+        });
     };
     /**
      * Executa o último escopo empilhado no topo na pilha de escopos do interpretador.
@@ -839,25 +1301,42 @@ var Interpretador = /** @class */ (function () {
      */
     Interpretador.prototype.executarUltimoEscopo = function (manterAmbiente) {
         if (manterAmbiente === void 0) { manterAmbiente = false; }
-        var ultimoEscopo = this.pilhaEscoposExecucao.topoDaPilha();
-        try {
-            var retornoExecucao = void 0;
-            for (; !(retornoExecucao instanceof quebras_1.Quebra) &&
-                ultimoEscopo.declaracaoAtual < ultimoEscopo.declaracoes.length; ultimoEscopo.declaracaoAtual++) {
-                retornoExecucao = this.executar(ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual]);
-            }
-            return retornoExecucao;
-        }
-        catch (erro) {
-            return erro;
-        }
-        finally {
-            this.pilhaEscoposExecucao.removerUltimo();
-            if (manterAmbiente) {
-                var escopoAnterior = this.pilhaEscoposExecucao.topoDaPilha();
-                escopoAnterior.ambiente.valores = Object.assign(escopoAnterior.ambiente.valores, ultimoEscopo.ambiente.valores);
-            }
-        }
+        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*/];
+                }
+            });
+        });
     };
     /**
      * Interpretação sem depurador, com medição de performance.
@@ -869,29 +1348,48 @@ var Interpretador = /** @class */ (function () {
      */
     Interpretador.prototype.interpretar = function (declaracoes, manterAmbiente) {
         if (manterAmbiente === void 0) { manterAmbiente = false; }
-        this.erros = [];
-        var escopoExecucao = {
-            declaracoes: declaracoes,
-            declaracaoAtual: 0,
-            ambiente: new espaco_variaveis_1.EspacoVariaveis(),
-        };
-        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-        var inicioInterpretacao = (0, browser_process_hrtime_1.default)();
-        try {
-            this.executarUltimoEscopo(manterAmbiente);
-        }
-        finally {
-            if (this.performance) {
-                var deltaInterpretacao = (0, browser_process_hrtime_1.default)(inicioInterpretacao);
-                console.log("[Interpretador] Tempo para interpreta\u00E7ao: ".concat(deltaInterpretacao[0] * 1e9 + deltaInterpretacao[1], "ns"));
-            }
-            var retorno = {
-                erros: this.erros,
-                resultado: this.resultadoInterpretador,
-            };
-            this.resultadoInterpretador = [];
-            return retorno;
-        }
+        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;
 }());