@designliquido/delegua 0.8.1 → 0.9.0-0

package/fontes/interpretador/dialetos/egua-classico.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 };
 };
@@ -84,23 +120,35 @@ var InterpretadorEguaClassico = /** @class */ (function () {
             return Boolean(objeto);
         return true;
     };
-    InterpretadorEguaClassico.prototype.verificarOperandoNumero = function (operador, operand) {
-        if (typeof operand === 'number')
+    InterpretadorEguaClassico.prototype.verificarOperandoNumero = function (operador, operando) {
+        if (typeof operando === 'number' || operando.tipo === 'número')
             return;
         throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operador precisa ser um número.', operador.linha);
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoUnaria = function (expr) {
-        var direita = this.avaliar(expr.direita);
-        switch (expr.operador.tipo) {
-            case delegua_1.default.SUBTRACAO:
-                this.verificarOperandoNumero(expr.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(expr.direita)];
+                    case 1:
+                        direita = _a.sent();
+                        valor = direita.hasOwnProperty('valor') ?
+                            direita.valor :
+                            direita;
+                        switch (expr.operador.tipo) {
+                            case delegua_1.default.SUBTRACAO:
+                                this.verificarOperandoNumero(expr.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];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.prototype.eIgual = function (esquerda, direita) {
         if (esquerda.tipo) {
@@ -134,128 +182,172 @@ var InterpretadorEguaClassico = /** @class */ (function () {
         throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoBinaria = function (expressao) {
-        var esquerda = this.avaliar(expressao.esquerda);
-        var direita = this.avaliar(expressao.direita);
-        var valorEsquerdo = esquerda.hasOwnProperty('valor')
-            ? esquerda.valor
-            : esquerda;
-        var valorDireito = direita.hasOwnProperty('valor')
-            ? direita.valor
-            : direita;
-        var tipoEsquerdo = esquerda.hasOwnProperty('tipo')
-            ? esquerda.tipo
-            : (0, inferenciador_1.inferirTipoVariavel)(esquerda);
-        var tipoDireito = 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:
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                return Number(valorEsquerdo) - Number(valorDireito);
-            case delegua_1.default.ADICAO:
-                if (tipoEsquerdo === 'número' && tipoDireito === 'número') {
-                    return Number(esquerda) + Number(direita);
-                }
-                else if (tipoEsquerdo === 'texto' &&
-                    tipoDireito === 'texto') {
-                    return String(esquerda) + String(direita);
+        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.hasOwnProperty('valor')
+                            ? esquerda.valor
+                            : esquerda;
+                        valorDireito = direita.hasOwnProperty('valor')
+                            ? direita.valor
+                            : direita;
+                        tipoEsquerdo = esquerda.hasOwnProperty('tipo')
+                            ? esquerda.tipo
+                            : (0, inferenciador_1.inferirTipoVariavel)(esquerda);
+                        tipoDireito = 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:
+                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                                return [2 /*return*/, Number(valorEsquerdo) - Number(valorDireito)];
+                            case delegua_1.default.ADICAO:
+                                if (tipoEsquerdo === 'número' && tipoDireito === 'número') {
+                                    return [2 /*return*/, Number(esquerda) + Number(direita)];
+                                }
+                                else if (tipoEsquerdo === 'texto' &&
+                                    tipoDireito === 'texto') {
+                                    return [2 /*return*/, String(esquerda) + String(direita)];
+                                }
+                                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'Operadores precisam ser dois números ou duas strings.');
+                            case delegua_1.default.DIVISAO:
+                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                                return [2 /*return*/, Number(valorEsquerdo) / Number(valorDireito)];
+                            case delegua_1.default.MULTIPLICACAO:
+                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                                return [2 /*return*/, Number(valorEsquerdo) * Number(valorDireito)];
+                            case delegua_1.default.MODULO:
+                                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 [2 /*return*/, null];
+                    case 3:
+                        erro_1 = _a.sent();
+                        return [2 /*return*/, Promise.reject(erro_1)];
+                    case 4: return [2 /*return*/];
                 }
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'Operadores precisam ser dois números ou duas strings.');
-            case delegua_1.default.DIVISAO:
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                return Number(valorEsquerdo) / Number(valorDireito);
-            case delegua_1.default.MULTIPLICACAO:
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                return Number(valorEsquerdo) * Number(valorDireito);
-            case delegua_1.default.MODULO:
-                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);
-        }
-        return null;
+            });
+        });
     };
     InterpretadorEguaClassico.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 chamavel_1.Chamavel)) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Só pode chamar função ou classe.', expressao.linha);
-        }
-        var parametros;
-        if (entidadeChamada instanceof funcao_1.DeleguaFuncao) {
-            parametros = entidadeChamada.declaracao.parametros;
-        }
-        else if (entidadeChamada instanceof delegua_classe_1.DeleguaClasse) {
-            parametros = entidadeChamada.metodos.inicializacao
-                ? entidadeChamada.metodos.inicializacao.declaracao.parametros
-                : [];
-        }
-        else {
-            parametros = [];
-        }
-        // Isso aqui completa 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 funcao_padrao_1.FuncaoPadrao) {
-            return entidadeChamada.chamar(argumentos, expressao.entidadeChamada.nome);
-        }
-        return entidadeChamada.chamar(this, argumentos);
+        return __awaiter(this, void 0, void 0, function () {
+            var variavelEntidadeChamada, entidadeChamada, argumentos, i, _a, _b, parametros, diferenca, i, novosArgumentos;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.avaliar(expressao.entidadeChamada)];
+                    case 1:
+                        variavelEntidadeChamada = _c.sent();
+                        entidadeChamada = variavelEntidadeChamada.hasOwnProperty('valor')
+                            ? variavelEntidadeChamada.valor
+                            : variavelEntidadeChamada;
+                        argumentos = [];
+                        i = 0;
+                        _c.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, [_c.sent()]);
+                        _c.label = 4;
+                    case 4:
+                        i++;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        if (!(entidadeChamada instanceof chamavel_1.Chamavel)) {
+                            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Só pode chamar função ou classe.', expressao.linha);
+                        }
+                        if (entidadeChamada instanceof funcao_1.DeleguaFuncao) {
+                            parametros = entidadeChamada.declaracao.parametros;
+                        }
+                        else if (entidadeChamada instanceof delegua_classe_1.DeleguaClasse) {
+                            parametros = entidadeChamada.metodos.inicializacao
+                                ? entidadeChamada.metodos.inicializacao.declaracao.parametros
+                                : [];
+                        }
+                        else {
+                            parametros = [];
+                        }
+                        // Isso aqui completa 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 funcao_padrao_1.FuncaoPadrao) {
+                            return [2 /*return*/, entidadeChamada.chamar(argumentos, expressao.entidadeChamada.nome)];
+                        }
+                        return [2 /*return*/, entidadeChamada.chamar(this, argumentos)];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.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];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.prototype.procurarVariavel = function (simbolo, expressao) {
         return this.pilhaEscoposExecucao.obterVariavel(simbolo);
@@ -264,187 +356,360 @@ var InterpretadorEguaClassico = /** @class */ (function () {
         return this.procurarVariavel(expressao.simbolo, expressao);
     };
     InterpretadorEguaClassico.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()];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.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()];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.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];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoPara = function (declaracao) {
-        if (declaracao.inicializador !== null) {
-            this.avaliar(declaracao.inicializador);
-        }
-        while (true) {
-            if (declaracao.condicao !== null) {
-                if (!this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
-                    break;
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, erro_2;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(declaracao.inicializador !== null)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.avaliar(declaracao.inicializador)];
+                    case 1:
+                        _b.sent();
+                        _b.label = 2;
+                    case 2:
+                        if (!true) return [3 /*break*/, 10];
+                        if (!(declaracao.condicao !== null)) return [3 /*break*/, 4];
+                        _a = this.eVerdadeiro;
+                        return [4 /*yield*/, this.avaliar(declaracao.condicao)];
+                    case 3:
+                        if (!_a.apply(this, [_b.sent()])) {
+                            return [3 /*break*/, 10];
+                        }
+                        _b.label = 4;
+                    case 4:
+                        _b.trys.push([4, 6, , 7]);
+                        return [4 /*yield*/, this.executar(declaracao.corpo)];
+                    case 5:
+                        _b.sent();
+                        return [3 /*break*/, 7];
+                    case 6:
+                        erro_2 = _b.sent();
+                        throw erro_2;
+                    case 7:
+                        if (!(declaracao.incrementar !== null)) return [3 /*break*/, 9];
+                        return [4 /*yield*/, this.avaliar(declaracao.incrementar)];
+                    case 8:
+                        _b.sent();
+                        _b.label = 9;
+                    case 9: return [3 /*break*/, 2];
+                    case 10: return [2 /*return*/, null];
                 }
-            }
-            try {
-                this.executar(declaracao.corpo);
-            }
-            catch (erro) {
-                throw erro;
-            }
-            if (declaracao.incrementar !== null) {
-                this.avaliar(declaracao.incrementar);
-            }
-        }
-        return null;
+            });
+        });
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoFazer = function (declaracao) {
-        do {
-            try {
-                this.executar(declaracao.caminhoFazer);
-            }
-            catch (erro) {
-                throw erro;
-            }
-        } while (this.eVerdadeiro(this.avaliar(declaracao.condicaoEnquanto)));
+        return __awaiter(this, void 0, void 0, function () {
+            var erro_3, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.executar(declaracao.caminhoFazer)];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        erro_3 = _b.sent();
+                        throw erro_3;
+                    case 3:
+                        _a = this.eVerdadeiro;
+                        return [4 /*yield*/, this.avaliar(declaracao.condicaoEnquanto)];
+                    case 4:
+                        if (_a.apply(this, [_b.sent()])) return [3 /*break*/, 0];
+                        _b.label = 5;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.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, k, erro_4, i, erro_5;
+            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, 19, , 20]);
+                        i = 0;
+                        _a.label = 3;
+                    case 3:
+                        if (!(i < caminhos.length)) return [3 /*break*/, 14];
+                        caminho_1 = caminhos[i];
+                        j = 0;
+                        _a.label = 4;
+                    case 4:
+                        if (!(j < caminho_1.condicoes.length)) return [3 /*break*/, 13];
+                        return [4 /*yield*/, this.avaliar(caminho_1.condicoes[j])];
+                    case 5:
+                        if (!((_a.sent()) === condicaoEscolha)) return [3 /*break*/, 12];
                         encontrado = true;
-                        try {
-                            for (var k = 0; k < caminho_1.declaracoes.length; k++) {
-                                this.executar(caminho_1.declaracoes[k]);
-                            }
-                        }
-                        catch (erro) {
-                            throw erro;
-                        }
-                    }
+                        _a.label = 6;
+                    case 6:
+                        _a.trys.push([6, 11, , 12]);
+                        k = 0;
+                        _a.label = 7;
+                    case 7:
+                        if (!(k < caminho_1.declaracoes.length)) return [3 /*break*/, 10];
+                        return [4 /*yield*/, this.executar(caminho_1.declaracoes[k])];
+                    case 8:
+                        _a.sent();
+                        _a.label = 9;
+                    case 9:
+                        k++;
+                        return [3 /*break*/, 7];
+                    case 10: return [3 /*break*/, 12];
+                    case 11:
+                        erro_4 = _a.sent();
+                        throw erro_4;
+                    case 12:
+                        j++;
+                        return [3 /*break*/, 4];
+                    case 13:
+                        i++;
+                        return [3 /*break*/, 3];
+                    case 14:
+                        if (!(caminhoPadrao !== null && encontrado === false)) return [3 /*break*/, 18];
+                        i = 0;
+                        _a.label = 15;
+                    case 15:
+                        if (!(i < caminhoPadrao.declaracoes.length)) return [3 /*break*/, 18];
+                        return [4 /*yield*/, this.executar(caminhoPadrao['declaracoes'][i])];
+                    case 16:
+                        _a.sent();
+                        _a.label = 17;
+                    case 17:
+                        i++;
+                        return [3 /*break*/, 15];
+                    case 18: return [3 /*break*/, 20];
+                    case 19:
+                        erro_5 = _a.sent();
+                        throw erro_5;
+                    case 20: return [2 /*return*/];
                 }
-            }
-            if (caminhoPadrao !== null && encontrado === false) {
-                for (var i = 0; i < caminhoPadrao.declaracoes.length; i++) {
-                    this.executar(caminhoPadrao['declaracoes'][i]);
-                }
-            }
-        }
-        catch (erro) {
-            throw erro;
-        }
+            });
+        });
     };
     InterpretadorEguaClassico.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);
+        return __awaiter(this, void 0, void 0, function () {
+            var sucesso, erro_6;
+            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_6 = _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_6);
+                        _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*/];
                 }
-                else {
-                    this.erros.push(erro);
-                }
-            }
-            if (sucesso && declaracao.caminhoSenao !== null) {
-                this.executarBloco(declaracao.caminhoSenao);
-            }
-        }
-        finally {
-            if (declaracao.caminhoFinalmente !== null)
-                this.executarBloco(declaracao.caminhoFinalmente);
-        }
+            });
+        });
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoEnquanto = function (declaracao) {
-        while (this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
-            try {
-                this.executar(declaracao.corpo);
-            }
-            catch (erro) {
-                throw erro;
-            }
-        }
-        return null;
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, erro_7;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.eVerdadeiro;
+                        return [4 /*yield*/, this.avaliar(declaracao.condicao)];
+                    case 1:
+                        if (!_a.apply(this, [_b.sent()])) return [3 /*break*/, 6];
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.executar(declaracao.corpo)];
+                    case 3:
+                        _b.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        erro_7 = _b.sent();
+                        throw erro_7;
+                    case 5: return [3 /*break*/, 0];
+                    case 6: return [2 /*return*/, null];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoImportar = function (declaracao) {
-        var caminhoRelativo = this.avaliar(declaracao.caminho);
-        var caminhoTotal = caminho.join(this.diretorioBase, caminhoRelativo);
-        // const nomeArquivo = caminho.basename(caminhoTotal);
-        var dados = (0, importar_biblioteca_1.default)(caminhoRelativo);
-        if (dados)
-            return dados;
-        try {
-            if (!fs.existsSync(caminhoTotal)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.simboloFechamento, 'Não foi possível encontrar arquivo importado.', declaracao.linha);
-            }
-        }
-        catch (erro) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.simboloFechamento, 'Não foi possível ler o arquivo.', declaracao.linha);
-        }
-        dados = fs.readFileSync(caminhoTotal).toString();
-        var delegua = new delegua_2.Delegua(this.Delegua.dialeto, false);
-        delegua.executar(dados);
-        var exportar = this.pilhaEscoposExecucao.obterTodasDeleguaFuncao();
-        var eDicionario = function (objeto) { return objeto.constructor === Object; };
-        if (eDicionario(exportar)) {
-            var novoModulo = new modulo_1.DeleguaModulo();
-            var chaves = Object.keys(exportar);
-            for (var i = 0; i < chaves.length; i++) {
-                novoModulo[chaves[i]] = exportar[chaves[i]];
-            }
-            return novoModulo;
-        }
-        return exportar;
+        return __awaiter(this, void 0, void 0, function () {
+            var caminhoRelativo, caminhoTotal, dados, delegua, exportar, 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);
+                        dados = (0, importar_biblioteca_1.default)(caminhoRelativo);
+                        if (dados)
+                            return [2 /*return*/, dados];
+                        try {
+                            if (!fs.existsSync(caminhoTotal)) {
+                                throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.simboloFechamento, 'Não foi possível encontrar arquivo importado.', declaracao.linha);
+                            }
+                        }
+                        catch (erro) {
+                            throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.simboloFechamento, 'Não foi possível ler o arquivo.', declaracao.linha);
+                        }
+                        dados = fs.readFileSync(caminhoTotal).toString();
+                        delegua = new delegua_2.Delegua(this.Delegua.dialeto, false);
+                        delegua.executar(dados);
+                        exportar = this.pilhaEscoposExecucao.obterTodasDeleguaFuncao();
+                        eDicionario = function (objeto) { return objeto.constructor === Object; };
+                        if (eDicionario(exportar)) {
+                            novoModulo = new modulo_1.DeleguaModulo();
+                            chaves = Object.keys(exportar);
+                            for (i = 0; i < chaves.length; i++) {
+                                novoModulo[chaves[i]] = exportar[chaves[i]];
+                            }
+                            return [2 /*return*/, novoModulo];
+                        }
+                        return [2 /*return*/, exportar];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoEscreva = function (declaracao) {
-        try {
-            var valor = this.avaliar(declaracao.argumentos[0]);
-            console.log(this.paraTexto(valor));
-            return null;
-        }
-        catch (erro) {
-            this.erros.push(erro);
-        }
+        return __awaiter(this, void 0, void 0, function () {
+            var valor, erro_8;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.avaliar(declaracao.argumentos[0])];
+                    case 1:
+                        valor = _a.sent();
+                        console.log(this.paraTexto(valor));
+                        return [2 /*return*/, null];
+                    case 2:
+                        erro_8 = _a.sent();
+                        this.erros.push(erro_8);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
     };
     /**
      * Empilha declarações na pilha de escopos de execução, cria um novo ambiente e
@@ -457,20 +722,37 @@ var InterpretadorEguaClassico = /** @class */ (function () {
      * @param ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
      */
     InterpretadorEguaClassico.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) {
+                            throw retornoUltimoEscopo;
+                        }
+                        return [2 /*return*/, retornoUltimoEscopo];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.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.
@@ -478,14 +760,25 @@ var InterpretadorEguaClassico = /** @class */ (function () {
      * @returns Sempre retorna nulo.
      */
     InterpretadorEguaClassico.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];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoContinua = function (declaracao) {
         return new quebras_1.ContinuarQuebra();
@@ -494,164 +787,270 @@ var InterpretadorEguaClassico = /** @class */ (function () {
         return new quebras_1.SustarQuebra();
     };
     InterpretadorEguaClassico.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)];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoDeleguaFuncao = function (expressao) {
         return new funcao_1.DeleguaFuncao(null, expressao);
     };
     InterpretadorEguaClassico.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 objeto, indice, valor;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.avaliar(expressao.objeto)];
+                    case 1:
+                        objeto = _a.sent();
+                        return [4 /*yield*/, this.avaliar(expressao.indice)];
+                    case 2:
+                        indice = _a.sent();
+                        return [4 /*yield*/, this.avaliar(expressao.valor)];
+                    case 3:
+                        valor = _a.sent();
+                        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 objeto_delegua_classe_1.ObjetoDeleguaClasse ||
+                            objeto instanceof funcao_1.DeleguaFuncao ||
+                            objeto instanceof delegua_classe_1.DeleguaClasse ||
+                            objeto instanceof modulo_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);
+                        }
+                        return [2 /*return*/];
                 }
-            }
-            while (objeto.length < indice) {
-                objeto.push(null);
-            }
-            objeto[indice] = valor;
-        }
-        else if (objeto.constructor === Object ||
-            objeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse ||
-            objeto instanceof funcao_1.DeleguaFuncao ||
-            objeto instanceof delegua_classe_1.DeleguaClasse ||
-            objeto instanceof modulo_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);
-        }
+            });
+        });
     };
     InterpretadorEguaClassico.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 (indice < 0 && objeto.length !== 0) {
-                while (indice < 0) {
-                    indice += objeto.length;
-                }
-            }
-            if (indice >= objeto.length) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice do vetor fora do intervalo.', expressao.linha);
-            }
-            return objeto[indice];
-        }
-        else if (objeto.constructor === Object ||
-            objeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse ||
-            objeto instanceof funcao_1.DeleguaFuncao ||
-            objeto instanceof delegua_classe_1.DeleguaClasse ||
-            objeto instanceof modulo_1.DeleguaModulo) {
-            return objeto[indice] || null;
-        }
-        else if (typeof objeto === 'string') {
-            if (!Number.isInteger(indice)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha);
-            }
-            if (indice < 0 && objeto.length !== 0) {
-                while (indice < 0) {
-                    indice += 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)) {
+                                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha);
+                            }
+                            if (indice < 0 && objeto.length !== 0) {
+                                while (indice < 0) {
+                                    indice += objeto.length;
+                                }
+                            }
+                            if (indice >= objeto.length) {
+                                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice do vetor fora do intervalo.', expressao.linha);
+                            }
+                            return [2 /*return*/, objeto[indice]];
+                        }
+                        else if (objeto.constructor === Object ||
+                            objeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse ||
+                            objeto instanceof funcao_1.DeleguaFuncao ||
+                            objeto instanceof delegua_classe_1.DeleguaClasse ||
+                            objeto instanceof modulo_1.DeleguaModulo) {
+                            return [2 /*return*/, objeto[indice] || null];
+                        }
+                        else if (typeof objeto === 'string') {
+                            if (!Number.isInteger(indice)) {
+                                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha);
+                            }
+                            if (indice < 0 && objeto.length !== 0) {
+                                while (indice < 0) {
+                                    indice += objeto.length;
+                                }
+                            }
+                            if (indice >= objeto.length) {
+                                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice fora do tamanho.', expressao.linha);
+                            }
+                            return [2 /*return*/, objeto.charAt(indice)];
+                        }
+                        else {
+                            throw 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 (indice >= objeto.length) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice fora do tamanho.', expressao.linha);
-            }
-            return objeto.charAt(indice);
-        }
-        else {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.entidadeChamada.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha);
-        }
+            });
+        });
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoDefinir = function (expressao) {
-        var objeto = this.avaliar(expressao.objeto);
-        if (!(objeto instanceof objeto_delegua_classe_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 objeto_delegua_classe_1.ObjetoDeleguaClasse) {
-            objeto.set(expressao.nome, valor);
-            return valor;
-        }
-        else if (objeto.constructor === Object) {
-            objeto[expressao.simbolo.lexema] = valor;
-        }
+        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 objeto_delegua_classe_1.ObjetoDeleguaClasse) &&
+                            objeto.constructor !== Object) {
+                            throw 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 objeto_delegua_classe_1.ObjetoDeleguaClasse) {
+                            objeto.set(expressao.nome, valor);
+                            return [2 /*return*/, valor];
+                        }
+                        else if (objeto.constructor === Object) {
+                            objeto[expressao.simbolo.lexema] = valor;
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoFuncao = function (declaracao) {
         var funcao = new funcao_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, funcao);
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoClasse = function (declaracao) {
-        var superClasse = null;
-        if (declaracao.superClasse !== null) {
-            var variavelSuperClasse = this.avaliar(declaracao.superClasse);
-            superClasse = variavelSuperClasse.valor;
-            if (!(superClasse instanceof delegua_classe_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 funcao_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, undefined, eInicializador);
-            metodos[metodoAtual.simbolo.lexema] = funcao;
-        }
-        var deleguaClasse = new delegua_classe_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 delegua_classe_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 funcao_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, undefined, eInicializador);
+                            metodos[metodoAtual.simbolo.lexema] = funcao;
+                        }
+                        deleguaClasse = new delegua_classe_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];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoAcessoMetodo = function (expressao) {
-        var variavelObjeto = this.avaliar(expressao.objeto);
-        var objeto = variavelObjeto === null || variavelObjeto === void 0 ? void 0 : variavelObjeto.valor;
-        if (objeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse) {
-            return objeto.get(expressao.simbolo) || null;
-        }
-        else if (objeto.constructor === Object) {
-            return objeto[expressao.simbolo.lexema] || null;
-        }
-        else if (objeto instanceof modulo_1.DeleguaModulo) {
-            return objeto[expressao.simbolo.lexema] || null;
-        }
-        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.nome, 'Você só pode acessar métodos do objeto e dicionários.', expressao.linha);
+        return __awaiter(this, void 0, void 0, function () {
+            var variavelObjeto, objeto;
+            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 objeto_delegua_classe_1.ObjetoDeleguaClasse) {
+                            return [2 /*return*/, objeto.get(expressao.simbolo) || null];
+                        }
+                        else if (objeto.constructor === Object) {
+                            return [2 /*return*/, objeto[expressao.simbolo.lexema] || null];
+                        }
+                        else if (objeto instanceof modulo_1.DeleguaModulo) {
+                            return [2 /*return*/, objeto[expressao.simbolo.lexema] || null];
+                        }
+                        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.nome, 'Você só pode acessar métodos do objeto e dicionários.', expressao.linha);
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoIsto = function (expressao) {
         return this.procurarVariavel(expressao.palavraChave, expressao);
     };
     InterpretadorEguaClassico.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, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        dicionario = {};
+                        i = 0;
+                        _c.label = 1;
+                    case 1:
+                        if (!(i < expressao.chaves.length)) return [3 /*break*/, 5];
+                        _a = dicionario;
+                        return [4 /*yield*/, this.avaliar(expressao.chaves[i])];
+                    case 2:
+                        _b = _c.sent();
+                        return [4 /*yield*/, this.avaliar(expressao.valores[i])];
+                    case 3:
+                        _a[_b] = _c.sent();
+                        _c.label = 4;
+                    case 4:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 5: return [2 /*return*/, dicionario];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.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];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoSuper = function (expressao) {
         var distancia = this.locais.get(expressao);
@@ -687,7 +1086,14 @@ var InterpretadorEguaClassico = /** @class */ (function () {
     };
     InterpretadorEguaClassico.prototype.executar = function (declaracao, mostrarResultado) {
         if (mostrarResultado === void 0) { mostrarResultado = false; }
-        return declaracao.aceitar(this);
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, declaracao.aceitar(this)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
     };
     /**
      * Executa o último escopo empilhado no topo na pilha de escopos do Interpretador.
@@ -703,36 +1109,66 @@ var InterpretadorEguaClassico = /** @class */ (function () {
      * @returns O resultado da execução do escopo, se houver.
      */
     InterpretadorEguaClassico.prototype.executarUltimoEscopo = function () {
-        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();
-        }
+        return __awaiter(this, void 0, void 0, function () {
+            var ultimoEscopo, retornoExecucao, erro_9;
+            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_9 = _a.sent();
+                        return [2 /*return*/, erro_9];
+                    case 7:
+                        this.pilhaEscoposExecucao.removerUltimo();
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
     };
     InterpretadorEguaClassico.prototype.interpretar = function (declaracoes) {
-        this.erros = [];
-        var retornoResolvedor = this.resolvedor.resolver(declaracoes);
-        this.locais = retornoResolvedor.locais;
-        var escopoExecucao = {
-            declaracoes: declaracoes,
-            declaracaoAtual: 0,
-            ambiente: new espaco_variaveis_1.EspacoVariaveis(),
-        };
-        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-        this.executarUltimoEscopo();
-        return {
-            erros: this.erros,
-        };
+        return __awaiter(this, void 0, void 0, function () {
+            var retornoResolvedor, escopoExecucao;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.erros = [];
+                        retornoResolvedor = this.resolvedor.resolver(declaracoes);
+                        this.locais = retornoResolvedor.locais;
+                        escopoExecucao = {
+                            declaracoes: declaracoes,
+                            declaracaoAtual: 0,
+                            ambiente: new espaco_variaveis_1.EspacoVariaveis(),
+                        };
+                        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
+                        return [4 /*yield*/, this.executarUltimoEscopo()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, {
+                                erros: this.erros,
+                            }];
+                }
+            });
+        });
+    };
+    InterpretadorEguaClassico.prototype.finalizacao = function () {
+        this.funcaoDeRetorno();
     };
     return InterpretadorEguaClassico;
 }());