@designliquido/delegua 0.36.1 → 0.36.2

package/interpretador/interpretador-base.js

@@ -1,1400 +1,1400 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InterpretadorBase = void 0;
-const browser_process_hrtime_1 = __importDefault(require("browser-process-hrtime"));
-const estruturas_1 = require("../estruturas");
-const construtos_1 = require("../construtos");
-const pilha_escopos_execucao_1 = require("./pilha-escopos-execucao");
-const quebras_1 = require("../quebras");
-const inferenciador_1 = require("./inferenciador");
-const metodo_primitiva_1 = require("../estruturas/metodo-primitiva");
-const lexador_1 = require("../lexador");
-const avaliador_sintatico_1 = require("../avaliador-sintatico");
-const espaco_variaveis_1 = require("../espaco-variaveis");
-const comum_1 = require("./comum");
-const excecoes_1 = require("../excecoes");
-const primitivas_dicionario_1 = __importDefault(require("../bibliotecas/primitivas-dicionario"));
-const primitivas_numero_1 = __importDefault(require("../bibliotecas/primitivas-numero"));
-const primitivas_texto_1 = __importDefault(require("../bibliotecas/primitivas-texto"));
-const primitivas_vetor_1 = __importDefault(require("../bibliotecas/primitivas-vetor"));
-const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
-const primitivos_1 = __importDefault(require("../tipos-de-dados/primitivos"));
-const delegua_2 = __importDefault(require("../tipos-de-dados/delegua"));
-/**
- * O Interpretador visita todos os elementos complexos gerados pelo avaliador sintático (_parser_),
- * e de fato executa a lógica de programação descrita no código.
- *
- * O Interpretador Base não contém dependências com o Node.js. É
- * recomendado para uso em execuções que ocorrem no navegador de internet.
- */
-class InterpretadorBase {
-    constructor(diretorioBase, performance = false, funcaoDeRetorno = null, funcaoDeRetornoMesmaLinha = null) {
-        this.resultadoInterpretador = [];
-        this.funcaoDeRetorno = null;
-        this.funcaoDeRetornoMesmaLinha = null;
-        this.interfaceDeEntrada = null; // Originalmente é `readline.Interface`
-        this.interfaceEntradaSaida = null;
-        this.emDeclaracaoTente = false;
-        this.microLexador = new lexador_1.MicroLexador();
-        this.microAvaliadorSintatico = new avaliador_sintatico_1.MicroAvaliadorSintatico();
-        this.regexInterpolacao = /\${(.*?)}/g;
-        this.tiposNumericos = [
-            delegua_2.default.INTEIRO,
-            delegua_2.default.NUMERO,
-            delegua_2.default.NÚMERO,
-            delegua_2.default.REAL
-        ];
-        this.diretorioBase = diretorioBase;
-        this.performance = performance;
-        this.funcaoDeRetorno = funcaoDeRetorno || console.log;
-        this.funcaoDeRetornoMesmaLinha = funcaoDeRetornoMesmaLinha || process.stdout.write.bind(process.stdout);
-        this.erros = [];
-        this.declaracoes = [];
-        this.resultadoInterpretador = [];
-        // Isso existe por causa de Potigol.
-        // Para acessar uma variável de classe, não é preciso a palavra `isto`.
-        this.expandirPropriedadesDeObjetosEmEspacoVariaveis = false;
-        // Por padrão é verdadeiro porque Delégua e Pituguês usam
-        // o interpretador base como implementação padrão.
-        this.requerDeclaracaoPropriedades = true;
-        this.pilhaEscoposExecucao = new pilha_escopos_execucao_1.PilhaEscoposExecucao();
-        const escopoExecucao = {
-            declaracoes: [],
-            declaracaoAtual: 0,
-            ambiente: new espaco_variaveis_1.EspacoVariaveis(),
-            finalizado: false,
-            tipo: 'outro',
-            emLacoRepeticao: false,
-        };
-        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-        (0, comum_1.carregarBibliotecasGlobais)(this.pilhaEscoposExecucao);
-    }
-    /**
-     * Construtos de comentários não têm utilidade para o Interpretador.
-     * Apenas retornamos `Promise.resolve()` para não termos erros.
-     * @param declaracao A declaração de comentário.
-     */
-    visitarDeclaracaoComentario(declaracao) {
-        return Promise.resolve();
-    }
-    async visitarDeclaracaoTendoComo(declaracao) {
-        const retornoInicializacao = await this.avaliar(declaracao.inicializacaoVariavel);
-        this.pilhaEscoposExecucao.definirConstante(declaracao.simboloVariavel.lexema, retornoInicializacao);
-        await this.executar(declaracao.corpo);
-        if (retornoInicializacao instanceof estruturas_1.ObjetoDeleguaClasse) {
-            const metodoFinalizar = retornoInicializacao.classe.metodos['finalizar'];
-            if (metodoFinalizar) {
-                const chamavel = metodoFinalizar.funcaoPorMetodoDeClasse(retornoInicializacao);
-                chamavel.chamar(this, []);
-            }
-        }
-        return null;
-    }
-    async visitarDeclaracaoInicioAlgoritmo(declaracao) {
-        throw new Error('Método não implementado.');
-    }
-    async visitarDeclaracaoCabecalhoPrograma(declaracao) {
-        throw new Error('Método não implementado.');
-    }
-    async visitarExpressaoTupla(expressao) {
-        const chaves = Object.keys(expressao);
-        const valores = [];
-        for (let chave of chaves) {
-            const valor = await this.avaliar(expressao[chave]);
-            valores.push(valor);
-        }
-        return valores;
-    }
-    async visitarExpressaoAtribuicaoPorIndicesMatriz(expressao) {
-        throw new Error('Método não implementado.');
-    }
-    async visitarExpressaoAcessoElementoMatriz(expressao) {
-        throw new Error('Método não implementado.');
-    }
-    textoParaRegex(texto) {
-        const match = texto.match(/^([\/~@;%#'])(.*?)\1([gimsuy]*)$/);
-        return match
-            ? new RegExp(match[2], match[3]
-                .split('')
-                .filter((char, pos, flagArr) => flagArr.indexOf(char) === pos)
-                .join(''))
-            : new RegExp(texto);
-    }
-    visitarExpressaoExpressaoRegular(expressao) {
-        return Promise.resolve(this.textoParaRegex(expressao.valor));
-    }
-    async visitarExpressaoTipoDe(expressao) {
-        let tipoDe = expressao.valor;
-        if (tipoDe instanceof construtos_1.Agrupamento ||
-            tipoDe instanceof construtos_1.Binario ||
-            tipoDe instanceof construtos_1.Chamada ||
-            tipoDe instanceof construtos_1.Dicionario ||
-            tipoDe instanceof construtos_1.TipoDe ||
-            tipoDe instanceof construtos_1.Unario ||
-            tipoDe instanceof construtos_1.Variavel) {
-            tipoDe = await this.avaliar(tipoDe);
-            return tipoDe.tipo || (0, inferenciador_1.inferirTipoVariavel)(tipoDe);
-        }
-        return (0, inferenciador_1.inferirTipoVariavel)((tipoDe === null || tipoDe === void 0 ? void 0 : tipoDe.valores) || tipoDe);
-    }
-    // TODO: Depreciado. Priorizar `visitarExpressaoTipoDe`.
-    async visitarExpressaoQualTipo(expressao) {
-        throw new Error('Método não implementado.');
-    }
-    async visitarExpressaoFalhar(expressao) {
-        var _a;
-        const textoFalha = (_a = expressao.explicacao.valor) !== null && _a !== void 0 ? _a : (await this.avaliar(expressao.explicacao)).valor;
-        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, textoFalha, expressao.linha);
-    }
-    async visitarExpressaoFimPara(declaracao) {
-        throw new Error('Método não implementado.');
-    }
-    async avaliar(expressao) {
-        // Descomente o código abaixo quando precisar detectar expressões undefined ou nulas.
-        // Por algum motivo o depurador do VSCode não funciona direito aqui
-        // com breakpoint condicional.
-        /* if (expressao === null || expressao === undefined) {
-            console.log('Aqui');
-        } */
-        return await expressao.aceitar(this);
-    }
-    /**
-     * Execução da leitura de valores da entrada configurada no
-     * início da aplicação.
-     * @param expressao Expressão do tipo Leia
-     * @returns Promise com o resultado da leitura.
-     */
-    async visitarExpressaoLeia(expressao) {
-        const mensagem = expressao.argumentos && expressao.argumentos[0] ? expressao.argumentos[0].valor : '> ';
-        return new Promise((resolucao) => this.interfaceEntradaSaida.question(mensagem, (resposta) => {
-            resolucao(resposta);
-        }));
-    }
-    /**
-     * Execução da leitura de valores da entrada configurada no
-     * início da aplicação.
-     * @param expressao Expressão do tipo `LeiaMultiplo`.
-     * @returns Promise com o resultado da leitura.
-     */
-    async visitarExpressaoLeiaMultiplo(expressao) {
-        const mensagem = '> ';
-        if (expressao.argumento instanceof construtos_1.Literal) {
-            let valor = expressao.argumento.valor;
-            if (typeof valor === primitivos_1.default.TEXTO) {
-                return new Promise((resolucao) => this.interfaceEntradaSaida.question(mensagem, (resposta) => {
-                    resolucao(String(resposta)
-                        .split(valor)
-                        .filter((r) => !/(\s+)/.test(r)));
-                }));
-            }
-            let respostas = [];
-            for (let i = 0; i < valor; i++) {
-                this.interfaceEntradaSaida.question(mensagem, (resposta) => {
-                    respostas.push(resposta);
-                });
-            }
-            return Promise.resolve(respostas);
-        }
-        return Promise.resolve();
-    }
-    /**
-     * Retira a interpolação de um texto.
-     * @param {texto} texto O texto
-     * @param {any[]} variaveis A lista de variaveis interpoladas
-     * @returns O texto com o valor das variaveis.
-     */
-    retirarInterpolacao(texto, variaveis) {
-        let textoFinal = texto;
-        variaveis.forEach((elemento) => {
-            var _a, _b, _c;
-            if (((_a = elemento === null || elemento === void 0 ? void 0 : elemento.valor) === null || _a === void 0 ? void 0 : _a.tipo) === delegua_2.default.LOGICO) {
-                textoFinal = textoFinal.replace('${' + elemento.variavel + '}', this.paraTexto((_b = elemento === null || elemento === void 0 ? void 0 : elemento.valor) === null || _b === void 0 ? void 0 : _b.valor));
-            }
-            else {
-                const valor = ((_c = elemento === null || elemento === void 0 ? void 0 : elemento.valor) === null || _c === void 0 ? void 0 : _c.hasOwnProperty('valor')) ? elemento === null || elemento === void 0 ? void 0 : elemento.valor.valor : elemento === null || elemento === void 0 ? void 0 : elemento.valor;
-                textoFinal = textoFinal.replace('${' + elemento.variavel + '}', `${this.paraTexto(valor)}`);
-            }
-        });
-        return textoFinal;
-    }
-    /**
-     * Resolve todas as interpolações em um texto.
-     * @param {texto} textoOriginal O texto original com as variáveis interpoladas.
-     * @returns Uma lista de variáveis interpoladas.
-     */
-    async resolverInterpolacoes(textoOriginal, linha) {
-        const variaveis = textoOriginal.match(this.regexInterpolacao);
-        let resultadosAvaliacaoSintatica = variaveis.map((s) => {
-            const nomeVariavel = s.replace(/[\$\{\}]*/gm, '');
-            let microLexador = this.microLexador.mapear(nomeVariavel);
-            const resultadoMicroAvaliadorSintatico = this.microAvaliadorSintatico.analisar(microLexador, linha);
-            return {
-                nomeVariavel,
-                resultadoMicroAvaliadorSintatico,
-            };
-        });
-        // TODO: Verificar erros do `resultadosAvaliacaoSintatica`.
-        const resolucoesPromises = await Promise.all(resultadosAvaliacaoSintatica
-            .flatMap((r) => r.resultadoMicroAvaliadorSintatico.declaracoes)
-            .map((d) => this.avaliar(d)));
-        return resolucoesPromises.map((item, indice) => ({
-            variavel: resultadosAvaliacaoSintatica[indice].nomeVariavel,
-            valor: item,
-        }));
-    }
-    async visitarExpressaoLiteral(expressao) {
-        if (this.regexInterpolacao.test(expressao.valor)) {
-            const variaveis = await this.resolverInterpolacoes(expressao.valor, expressao.linha);
-            return this.retirarInterpolacao(expressao.valor, variaveis);
-        }
-        return expressao.valor;
-    }
-    async visitarExpressaoAgrupamento(expressao) {
-        return await this.avaliar(expressao.expressao);
-    }
-    eVerdadeiro(objeto) {
-        if (objeto === null)
-            return false;
-        if (typeof objeto === primitivos_1.default.BOOLEANO)
-            return Boolean(objeto);
-        if (objeto.hasOwnProperty('valor')) {
-            return Boolean(objeto.valor);
-        }
-        return true;
-    }
-    verificarOperandoNumero(operador, operando) {
-        if (typeof operando === primitivos_1.default.NUMERO || operando.tipo === delegua_2.default.NUMERO)
-            return;
-        throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operando precisa ser um número.', Number(operador.linha));
-    }
-    async visitarExpressaoUnaria(expressao) {
-        const operando = await this.avaliar(expressao.operando);
-        let valor = operando.hasOwnProperty('valor') ? operando.valor : operando;
-        switch (expressao.operador.tipo) {
-            case delegua_1.default.SUBTRACAO:
-                this.verificarOperandoNumero(expressao.operador, valor);
-                return -valor;
-            case delegua_1.default.NEGACAO:
-                return !this.eVerdadeiro(valor);
-            case delegua_1.default.BIT_NOT:
-                return ~valor;
-            // Para incrementar e decrementar, primeiro precisamos saber se o operador
-            // veio antes do literal ou variável.
-            // Se veio antes e o operando é uma variável, precisamos incrementar/decrementar,
-            // armazenar o valor da variável pra só então devolver o valor.
-            case delegua_1.default.INCREMENTAR:
-                if (expressao.incidenciaOperador === 'ANTES') {
-                    valor++;
-                    if (expressao.operando instanceof construtos_1.Variavel) {
-                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, valor);
-                    }
-                    return valor;
-                }
-                const valorAnteriorIncremento = valor;
-                this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, ++valor);
-                return valorAnteriorIncremento;
-            case delegua_1.default.DECREMENTAR:
-                if (expressao.incidenciaOperador === 'ANTES') {
-                    valor--;
-                    if (expressao.operando instanceof construtos_1.Variavel) {
-                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, valor);
-                    }
-                    return valor;
-                }
-                const valorAnteriorDecremento = valor;
-                this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, --valor);
-                return valorAnteriorDecremento;
-        }
-        return null;
-    }
-    /**
-     * Formata uma saída de acordo com o número e espaços e casas decimais solicitados.
-     * @param declaracao A declaração de formatação de escrita.
-     * @returns {string} A saída formatada como texto e os respectivos parâmetros aplicados.
-     */
-    async visitarExpressaoFormatacaoEscrita(declaracao) {
-        let resultado = '';
-        const conteudo = await this.avaliar(declaracao.expressao);
-        const valorConteudo = (conteudo === null || conteudo === void 0 ? void 0 : conteudo.hasOwnProperty('valor')) ? conteudo.valor : conteudo;
-        const tipoConteudo = conteudo.hasOwnProperty('tipo') ? conteudo.tipo : typeof conteudo;
-        resultado = valorConteudo;
-        if ([delegua_2.default.NUMERO, primitivos_1.default.NUMERO].includes(tipoConteudo) &&
-            declaracao.casasDecimais > 0) {
-            resultado = valorConteudo.toLocaleString('pt', { maximumFractionDigits: declaracao.casasDecimais });
-        }
-        if (declaracao.espacos > 0) {
-            resultado += ' '.repeat(declaracao.espacos);
-        }
-        return resultado;
-    }
-    /**
-     * Lógica para verificação de valores iguais, para Delégua e alguns dialetos.
-     * @param esquerda Uma variável.
-     * @param direita Outra variável.
-     * @returns Verdadeiro se são iguais. Falso em caso contrário.
-     */
-    eIgual(esquerda, direita) {
-        if (esquerda === null && direita === null)
-            return true;
-        if (esquerda === null)
-            return false;
-        return esquerda === direita;
-    }
-    /**
-     * Verifica se operandos são números, que podem ser tanto variáveis puras do JavaScript
-     * (neste caso, `number`), ou podem ser variáveis de Delégua com inferência (`VariavelInterface`).
-     * @param operador O símbolo do operador.
-     * @param direita O operando direito.
-     * @param esquerda O operando esquerdo.
-     * @returns Se ambos os operandos são números ou não.
-     */
-    verificarOperandosNumeros(operador, direita, esquerda) {
-        const tipoDireita = direita.tipo
-            ? direita.tipo
-            : typeof direita === primitivos_1.default.NUMERO
-                ? delegua_2.default.NUMERO
-                : String(NaN);
-        const tipoEsquerda = esquerda.tipo
-            ? esquerda.tipo
-            : typeof esquerda === primitivos_1.default.NUMERO
-                ? delegua_2.default.NUMERO
-                : String(NaN);
-        if (this.tiposNumericos.includes(tipoDireita) && this.tiposNumericos.includes(tipoEsquerda))
-            return;
-        throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
-    }
-    async visitarExpressaoBinaria(expressao) {
-        const esquerda = await this.avaliar(expressao.esquerda);
-        const direita = await this.avaliar(expressao.direita);
-        const valorEsquerdo = (esquerda === null || esquerda === void 0 ? void 0 : esquerda.hasOwnProperty('valor')) ? esquerda.valor : esquerda;
-        const valorDireito = (direita === null || direita === void 0 ? void 0 : direita.hasOwnProperty('valor')) ? direita.valor : direita;
-        const tipoEsquerdo = (esquerda === null || esquerda === void 0 ? void 0 : esquerda.hasOwnProperty('tipo')) ? esquerda.tipo : (0, inferenciador_1.inferirTipoVariavel)(esquerda);
-        const tipoDireito = (direita === null || direita === void 0 ? void 0 : direita.hasOwnProperty('tipo')) ? direita.tipo : (0, inferenciador_1.inferirTipoVariavel)(direita);
-        switch (expressao.operador.tipo) {
-            case delegua_1.default.EXPONENCIACAO:
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                return Math.pow(valorEsquerdo, valorDireito);
-            case delegua_1.default.MAIOR:
-                if (this.tiposNumericos.includes(tipoEsquerdo) && this.tiposNumericos.includes(tipoDireito)) {
-                    return Number(valorEsquerdo) > Number(valorDireito);
-                }
-                return String(valorEsquerdo) > String(valorDireito);
-            case delegua_1.default.MAIOR_IGUAL:
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                return Number(valorEsquerdo) >= Number(valorDireito);
-            case delegua_1.default.MENOR:
-                if (this.tiposNumericos.includes(tipoEsquerdo) && this.tiposNumericos.includes(tipoDireito)) {
-                    return Number(valorEsquerdo) < Number(valorDireito);
-                }
-                return String(valorEsquerdo) < String(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 (this.tiposNumericos.includes(tipoEsquerdo) &&
-                    this.tiposNumericos.includes(tipoDireito)) {
-                    return Number(valorEsquerdo) + Number(valorDireito);
-                }
-                return this.paraTexto(valorEsquerdo) + this.paraTexto(valorDireito);
-            case delegua_1.default.DIVISAO:
-            case delegua_1.default.DIVISAO_IGUAL:
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                return Number(valorEsquerdo) / Number(valorDireito);
-            case delegua_1.default.DIVISAO_INTEIRA:
-            case delegua_1.default.DIVISAO_INTEIRA_IGUAL:
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                return Math.floor(Number(valorEsquerdo) / Number(valorDireito));
-            case delegua_1.default.MULTIPLICACAO:
-            case delegua_1.default.MULTIPLICACAO_IGUAL:
-                if (tipoEsquerdo === delegua_2.default.TEXTO || tipoDireito === delegua_2.default.TEXTO) {
-                    // Sem ambos os valores resolvem como texto, multiplica normal.
-                    // Se apenas um resolve como texto, o outro repete o
-                    // texto n vezes, sendo n o valor do outro.
-                    if (tipoEsquerdo === delegua_2.default.TEXTO && tipoDireito === delegua_2.default.TEXTO) {
-                        return Number(valorEsquerdo) * Number(valorDireito);
-                    }
-                    if (tipoEsquerdo === delegua_2.default.TEXTO) {
-                        return valorEsquerdo.repeat(Number(valorDireito));
-                    }
-                    return valorDireito.repeat(Number(valorEsquerdo));
-                }
-                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);
-        }
-    }
-    /**
-     * Faz a chamada do método de uma primitiva (por exemplo, número, texto, etc.) com seus
-     * respectivos argumentos.
-     * @param {Chamada} expressao A expressão de chamada.
-     * @param {MetodoPrimitiva} entidadeChamada O método da primitiva chamado.
-     * @returns O resultado da chamada do método da primitiva.
-     */
-    async chamarMetodoPrimitiva(expressao, entidadeChamada) {
-        const argumentosResolvidos = [];
-        for (const argumento of expressao.argumentos) {
-            const valorResolvido = await this.avaliar(argumento);
-            argumentosResolvidos.push((valorResolvido === null || valorResolvido === void 0 ? void 0 : valorResolvido.hasOwnProperty('valor')) ? valorResolvido.valor : valorResolvido);
-        }
-        return await entidadeChamada.chamar(this, argumentosResolvidos);
-    }
-    async resolverArgumentosChamada(expressao) {
-        const argumentos = [];
-        for (let i = 0; i < expressao.argumentos.length; i++) {
-            const variavelArgumento = expressao.argumentos[i];
-            const nomeArgumento = variavelArgumento.hasOwnProperty('simbolo')
-                ? variavelArgumento.simbolo.lexema
-                : undefined;
-            argumentos.push({
-                nome: nomeArgumento,
-                valor: await this.avaliar(variavelArgumento),
-            });
-        }
-        return argumentos;
-    }
-    /**
-     * Resolve paraâmetros da chamada de acordo com o tipo da entidade chamada.
-     * @param {Chamavel} entidadeChamada A entidade chamada.
-     * @returns Os parâmetros resolvidos.
-     */
-    resolverParametrosChamada(entidadeChamada) {
-        if (entidadeChamada instanceof estruturas_1.DeleguaFuncao) {
-            return entidadeChamada.declaracao.parametros;
-        }
-        if (entidadeChamada instanceof estruturas_1.DescritorTipoClasse) {
-            return entidadeChamada.metodos.construtor
-                ? entidadeChamada.metodos.construtor.declaracao.parametros
-                : [];
-        }
-        return [];
-    }
-    /**
-     * Executa uma chamada de função, método ou classe.
-     * @param expressao A expressão chamada.
-     * @returns O resultado da chamada.
-     */
-    async visitarExpressaoDeChamada(expressao) {
-        try {
-            const variavelEntidadeChamada = await this.avaliar(expressao.entidadeChamada);
-            if (variavelEntidadeChamada === null) {
-                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Chamada de função ou método inexistente: ' + String(expressao.entidadeChamada), expressao.linha));
-            }
-            const entidadeChamada = variavelEntidadeChamada.hasOwnProperty('valor')
-                ? variavelEntidadeChamada.valor
-                : variavelEntidadeChamada;
-            if (entidadeChamada instanceof estruturas_1.DeleguaModulo) {
-                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Entidade chamada é um módulo de Delégua. Provavelmente você quer chamar um de seus componentes?', expressao.linha));
-            }
-            if (entidadeChamada instanceof metodo_primitiva_1.MetodoPrimitiva) {
-                return await this.chamarMetodoPrimitiva(expressao, entidadeChamada);
-            }
-            const argumentos = await this.resolverArgumentosChamada(expressao);
-            // TODO: Aparentemente isso nunca é usado se o bloco de resolução de parâmetros,
-            // mais abaixo, também não é.
-            // Estudar remoção mais adiante.
-            const parametros = this.resolverParametrosChamada(entidadeChamada);
-            const aridade = entidadeChamada.aridade ? entidadeChamada.aridade() : entidadeChamada.length;
-            // Completar os parâmetros não preenchidos com nulos.
-            if (argumentos.length < aridade) {
-                const diferenca = aridade - argumentos.length;
-                for (let i = 0; i < diferenca; i++) {
-                    argumentos.push(null);
-                }
-            } /* else {
-                // TODO: Aparentemente isso aqui nunca funcionou.
-                // Avaliar de simplesmente apagar este código, e usar o que foi
-                // implementado em `DeleguaFuncao.chamar`.
-                if (
-                    parametros &&
-                    parametros.length > 0 &&
-                    parametros[parametros.length - 1].abrangencia === 'multiplo'
-                ) {
-                    let novosArgumentos = argumentos.slice(0, parametros.length - 1);
-                    novosArgumentos = novosArgumentos.concat(
-                        argumentos.slice(parametros.length - 1, argumentos.length)
-                    );
-                    argumentos = novosArgumentos;
-                }
-            } */
-            if (entidadeChamada instanceof estruturas_1.FuncaoPadrao) {
-                try {
-                    return entidadeChamada.chamar(this, argumentos.map((a) => a && a.valor && a.valor.hasOwnProperty('valor') ? a.valor.valor : a === null || a === void 0 ? void 0 : a.valor), expressao.entidadeChamada.simbolo);
-                }
-                catch (erro) {
-                    this.erros.push({
-                        erroInterno: erro,
-                        linha: expressao.linha,
-                        hashArquivo: expressao.hashArquivo,
-                    });
-                }
-            }
-            // Por algum motivo misterioso, `entidadeChamada instanceof Chamavel` dá `false` em Liquido,
-            // mesmo que esteja tudo certo com `DeleguaFuncao`,
-            // então precisamos testar o nome do construtor também.
-            if (entidadeChamada instanceof estruturas_1.Chamavel || entidadeChamada.constructor.name === 'DeleguaFuncao') {
-                const retornoEntidadeChamada = await entidadeChamada.chamar(this, argumentos);
-                return retornoEntidadeChamada;
-            }
-            // A função chamada pode ser de uma biblioteca JavaScript.
-            // Neste caso apenas testamos se o tipo é uma função.
-            // TODO: Descobrir qual caso exatamente passa aqui.
-            if (typeof entidadeChamada === primitivos_1.default.FUNCAO) {
-                let objeto = null;
-                if (expressao.entidadeChamada.objeto) {
-                    objeto = await this.avaliar(expressao.entidadeChamada.objeto);
-                }
-                return entidadeChamada.apply(objeto.hasOwnProperty('valor') ? objeto.valor : objeto, argumentos);
-            }
-            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Só pode chamar função ou classe.', expressao.linha));
-        }
-        catch (erro) {
-            this.erros.push({
-                erroInterno: erro,
-                linha: expressao.linha,
-                hashArquivo: expressao.hashArquivo,
-            });
-        }
-    }
-    /**
-     * Execução de uma expressão de atribuição.
-     * @param expressao A expressão.
-     * @returns O valor atribuído.
-     */
-    async visitarExpressaoDeAtribuicao(expressao) {
-        const valor = await this.avaliar(expressao.valor);
-        const valorResolvido = valor !== undefined && valor.hasOwnProperty('valor') ? valor.valor : valor;
-        let indice = null;
-        if (expressao.indice) {
-            indice = await this.avaliar(expressao.indice);
-        }
-        this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valorResolvido, indice);
-        return valorResolvido;
-    }
-    procurarVariavel(simbolo) {
-        return this.pilhaEscoposExecucao.obterValorVariavel(simbolo);
-    }
-    visitarExpressaoDeVariavel(expressao) {
-        return this.procurarVariavel(expressao.simbolo);
-    }
-    async visitarDeclaracaoDeExpressao(declaracao) {
-        return await this.avaliar(declaracao.expressao);
-    }
-    async visitarExpressaoLogica(expressao) {
-        const esquerda = await this.avaliar(expressao.esquerda);
-        if (expressao.operador.tipo === delegua_1.default.EM) {
-            const direita = await this.avaliar(expressao.direita);
-            if (Array.isArray(direita) || typeof direita === primitivos_1.default.TEXTO) {
-                return direita.includes(esquerda);
-            }
-            else if (direita.constructor === Object) {
-                return esquerda in direita;
-            }
-            else {
-                throw new excecoes_1.ErroEmTempoDeExecucao(esquerda, "Tipo de chamada inválida com 'em'.", expressao.linha);
-            }
-        }
-        // se um estado for verdadeiro, retorna verdadeiro
-        if (expressao.operador.tipo === delegua_1.default.OU) {
-            if (this.eVerdadeiro(esquerda))
-                return esquerda;
-        }
-        // se um estado for falso, retorna falso
-        if (expressao.operador.tipo === delegua_1.default.E) {
-            if (!this.eVerdadeiro(esquerda))
-                return esquerda;
-        }
-        return await this.avaliar(expressao.direita);
-    }
-    async visitarDeclaracaoPara(declaracao) {
-        const declaracaoInicializador = Array.isArray(declaracao.inicializador)
-            ? declaracao.inicializador[0]
-            : declaracao.inicializador;
-        if (declaracaoInicializador !== null) {
-            await this.avaliar(declaracaoInicializador);
-        }
-        let retornoExecucao;
-        while (!(retornoExecucao instanceof quebras_1.Quebra)) {
-            if (declaracao.condicao !== null && !this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
-                break;
-            }
-            try {
-                retornoExecucao = await this.executar(declaracao.corpo);
-                if (retornoExecucao instanceof quebras_1.SustarQuebra) {
-                    return null;
-                }
-                if (retornoExecucao instanceof quebras_1.ContinuarQuebra) {
-                    retornoExecucao = null;
-                }
-            }
-            catch (erro) {
-                this.erros.push({
-                    erroInterno: erro,
-                    linha: declaracao.linha,
-                    hashArquivo: declaracao.hashArquivo,
-                });
-                return Promise.reject(erro);
-            }
-            if (declaracao.incrementar !== null) {
-                await this.avaliar(declaracao.incrementar);
-            }
-        }
-        return retornoExecucao;
-    }
-    async visitarDeclaracaoParaCada(declaracao) {
-        let retornoExecucao;
-        const vetorResolvido = await this.avaliar(declaracao.vetor);
-        const valorVetorResolvido = vetorResolvido.hasOwnProperty('valor') ? vetorResolvido.valor : vetorResolvido;
-        if (!Array.isArray(valorVetorResolvido)) {
-            return Promise.reject("Variável ou literal provida em instrução 'para cada' não é um vetor.");
-        }
-        while (!(retornoExecucao instanceof quebras_1.Quebra) && declaracao.posicaoAtual < valorVetorResolvido.length) {
-            try {
-                this.pilhaEscoposExecucao.definirVariavel(declaracao.nomeVariavelIteracao, valorVetorResolvido[declaracao.posicaoAtual]);
-                retornoExecucao = await this.executar(declaracao.corpo);
-                if (retornoExecucao instanceof quebras_1.SustarQuebra) {
-                    return null;
-                }
-                if (retornoExecucao instanceof quebras_1.ContinuarQuebra) {
-                    retornoExecucao = null;
-                }
-                declaracao.posicaoAtual++;
-            }
-            catch (erro) {
-                this.erros.push({
-                    erroInterno: erro,
-                    linha: declaracao.linha,
-                    hashArquivo: declaracao.hashArquivo,
-                });
-                return Promise.reject(erro);
-            }
-        }
-        return retornoExecucao;
-    }
-    /**
-     * Executa uma expressão Se, que tem uma condição, pode ter um bloco
-     * Senão, e múltiplos blocos Senão-se.
-     * @param declaracao A declaração Se.
-     * @returns O resultado da avaliação do bloco cuja condição é verdadeira.
-     */
-    async visitarDeclaracaoSe(declaracao) {
-        if (this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
-            return await this.executar(declaracao.caminhoEntao);
-        }
-        for (let i = 0; i < declaracao.caminhosSeSenao.length; i++) {
-            const atual = declaracao.caminhosSeSenao[i];
-            if (this.eVerdadeiro(await this.avaliar(atual.condicao))) {
-                return await this.executar(atual.caminho);
-            }
-        }
-        if (declaracao.caminhoSenao !== null) {
-            return await this.executar(declaracao.caminhoSenao);
-        }
-        return null;
-    }
-    async visitarDeclaracaoEnquanto(declaracao) {
-        let retornoExecucao;
-        while (!(retornoExecucao instanceof quebras_1.Quebra) && this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
-            try {
-                retornoExecucao = await this.executar(declaracao.corpo);
-                if (retornoExecucao instanceof quebras_1.SustarQuebra) {
-                    return null;
-                }
-                if (retornoExecucao instanceof quebras_1.ContinuarQuebra) {
-                    retornoExecucao = null;
-                }
-            }
-            catch (erro) {
-                this.erros.push({
-                    erroInterno: erro,
-                    linha: declaracao.linha,
-                    hashArquivo: declaracao.hashArquivo,
-                });
-                return Promise.reject(erro);
-            }
-        }
-        return retornoExecucao;
-    }
-    async visitarDeclaracaoEscolha(declaracao) {
-        const condicaoEscolha = await this.avaliar(declaracao.identificadorOuLiteral);
-        const valorCondicaoEscolha = condicaoEscolha.hasOwnProperty('valor') ? condicaoEscolha.valor : condicaoEscolha;
-        const caminhos = declaracao.caminhos;
-        const caminhoPadrao = declaracao.caminhoPadrao;
-        let encontrado = false;
-        try {
-            for (let i = 0; i < caminhos.length; i++) {
-                const caminho = caminhos[i];
-                for (let j = 0; j < caminho.condicoes.length; j++) {
-                    const condicaoAvaliada = await this.avaliar(caminho.condicoes[j]);
-                    if (condicaoAvaliada === valorCondicaoEscolha) {
-                        encontrado = true;
-                        try {
-                            await this.executarBloco(caminho.declaracoes);
-                        }
-                        catch (erro) {
-                            this.erros.push({
-                                erroInterno: erro,
-                                linha: declaracao.linha,
-                                hashArquivo: declaracao.hashArquivo,
-                            });
-                            return Promise.reject(erro);
-                        }
-                    }
-                }
-            }
-            if (caminhoPadrao !== null && !encontrado) {
-                await this.executarBloco(caminhoPadrao.declaracoes);
-            }
-        }
-        catch (erro) {
-            this.erros.push({
-                erroInterno: erro,
-                linha: declaracao.linha,
-                hashArquivo: declaracao.hashArquivo,
-            });
-            throw erro;
-        }
-    }
-    async visitarDeclaracaoFazer(declaracao) {
-        let retornoExecucao;
-        do {
-            try {
-                retornoExecucao = await this.executar(declaracao.caminhoFazer);
-                if (retornoExecucao instanceof quebras_1.SustarQuebra) {
-                    return null;
-                }
-                if (retornoExecucao instanceof quebras_1.ContinuarQuebra) {
-                    retornoExecucao = null;
-                }
-            }
-            catch (erro) {
-                this.erros.push({
-                    erroInterno: erro,
-                    linha: declaracao.linha,
-                    hashArquivo: declaracao.hashArquivo,
-                });
-                return Promise.reject(erro);
-            }
-        } while (!(retornoExecucao instanceof quebras_1.Quebra) &&
-            this.eVerdadeiro(await this.avaliar(declaracao.condicaoEnquanto)));
-    }
-    /**
-     * Interpretação de uma declaração `tente`.
-     * @param declaracao O objeto da declaração.
-     */
-    async visitarDeclaracaoTente(declaracao) {
-        let valorRetorno;
-        try {
-            this.emDeclaracaoTente = true;
-            try {
-                valorRetorno = await this.executarBloco(declaracao.caminhoTente);
-            }
-            catch (erro) {
-                if (declaracao.caminhoPegue !== null) {
-                    // `caminhoPegue` aqui pode ser um construto de função (se `pegue` tem parâmetros)
-                    // ou um vetor de `Declaracao` (`pegue` sem parâmetros).
-                    // As execuções, portanto, são diferentes.
-                    if (Array.isArray(declaracao.caminhoPegue)) {
-                        valorRetorno = await this.executarBloco(declaracao.caminhoPegue);
-                    }
-                    else {
-                        const literalErro = new construtos_1.Literal(declaracao.hashArquivo, Number(declaracao.linha), erro.mensagem);
-                        const chamadaPegue = new construtos_1.Chamada(declaracao.caminhoPegue.hashArquivo, declaracao.caminhoPegue, null, [literalErro]);
-                        valorRetorno = await chamadaPegue.aceitar(this);
-                    }
-                }
-            }
-        }
-        finally {
-            if (declaracao.caminhoFinalmente !== null)
-                valorRetorno = await this.executarBloco(declaracao.caminhoFinalmente);
-            this.emDeclaracaoTente = false;
-        }
-        return valorRetorno;
-    }
-    async visitarDeclaracaoImportar(declaracao) {
-        return Promise.reject('Importação de arquivos não suportada por Interpretador Base.');
-    }
-    async avaliarArgumentosEscreva(argumentos) {
-        let formatoTexto = '';
-        for (const argumento of argumentos) {
-            const resultadoAvaliacao = await this.avaliar(argumento);
-            let valor = (resultadoAvaliacao === null || resultadoAvaliacao === void 0 ? void 0 : resultadoAvaliacao.hasOwnProperty('valor')) ? resultadoAvaliacao.valor : resultadoAvaliacao;
-            formatoTexto += `${this.paraTexto(valor)} `;
-        }
-        return formatoTexto.trimEnd();
-    }
-    /**
-     * Execução de uma escrita na saída padrão, sem quebras de linha.
-     * Implementada para alguns dialetos, como VisuAlg.
-     * @param declaracao A declaração.
-     * @returns Sempre nulo, por convenção de visita.
-     */
-    async visitarDeclaracaoEscrevaMesmaLinha(declaracao) {
-        try {
-            const formatoTexto = await this.avaliarArgumentosEscreva(declaracao.argumentos);
-            this.funcaoDeRetornoMesmaLinha(formatoTexto);
-            return null;
-        }
-        catch (erro) {
-            this.erros.push({
-                erroInterno: erro,
-                linha: declaracao.linha,
-                hashArquivo: declaracao.hashArquivo,
-            });
-        }
-    }
-    /**
-     * Execução de uma escrita na saída configurada, que pode ser `console` (padrão) ou
-     * alguma função para escrever numa página Web.
-     * @param declaracao A declaração.
-     * @returns Sempre nulo, por convenção de visita.
-     */
-    async visitarDeclaracaoEscreva(declaracao) {
-        try {
-            const formatoTexto = await this.avaliarArgumentosEscreva(declaracao.argumentos);
-            this.funcaoDeRetorno(formatoTexto);
-            return null;
-        }
-        catch (erro) {
-            this.erros.push({
-                erroInterno: erro,
-                linha: declaracao.linha,
-                hashArquivo: declaracao.hashArquivo,
-            });
-        }
-    }
-    /**
-     * Empilha declarações na pilha de escopos de execução, cria um novo ambiente e
-     * executa as declarações empilhadas.
-     * Se o retorno do último bloco foi uma exceção (normalmente um erro em tempo de execução),
-     * atira a exceção daqui.
-     * Isso é usado, por exemplo, em blocos tente ... pegue ... finalmente.
-     * @param declaracoes Um vetor de declaracoes a ser executado.
-     * @param ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
-     */
-    async executarBloco(declaracoes, ambiente) {
-        const escopoExecucao = {
-            declaracoes: declaracoes,
-            declaracaoAtual: 0,
-            ambiente: ambiente || new espaco_variaveis_1.EspacoVariaveis(),
-            finalizado: false,
-            tipo: 'outro',
-            emLacoRepeticao: false,
-        };
-        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-        const retornoUltimoEscopo = await this.executarUltimoEscopo();
-        if (retornoUltimoEscopo instanceof excecoes_1.ErroEmTempoDeExecucao) {
-            return Promise.reject(retornoUltimoEscopo);
-        }
-        return retornoUltimoEscopo;
-    }
-    async visitarExpressaoBloco(declaracao) {
-        return await this.executarBloco(declaracao.declaracoes);
-    }
-    async avaliacaoDeclaracaoVarOuConst(declaracao) {
-        let valorOuOutraVariavel = null;
-        if (declaracao.inicializador !== null) {
-            valorOuOutraVariavel = await this.avaliar(declaracao.inicializador);
-        }
-        let valorFinal = null;
-        if (valorOuOutraVariavel !== null && valorOuOutraVariavel !== undefined) {
-            valorFinal = valorOuOutraVariavel.hasOwnProperty('valor')
-                ? valorOuOutraVariavel.valor
-                : valorOuOutraVariavel;
-        }
-        return valorFinal;
-    }
-    /**
-     * Executa expressão de definição de constante.
-     * @param declaracao A declaração `Const`.
-     * @returns Sempre retorna nulo.
-     */
-    async visitarDeclaracaoConst(declaracao) {
-        const valorFinal = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
-        this.pilhaEscoposExecucao.definirConstante(declaracao.simbolo.lexema, valorFinal, declaracao.tipo);
-        return null;
-    }
-    /**
-     * Executa expressão de definição de múltiplas constantes.
-     * @param declaracao A declaração `ConstMultiplo`.
-     * @returns Sempre retorna nulo.
-     */
-    async visitarDeclaracaoConstMultiplo(declaracao) {
-        const valoresFinais = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
-        for (let [indice, valor] of valoresFinais.entries()) {
-            this.pilhaEscoposExecucao.definirConstante(declaracao.simbolos[indice].lexema, valor, declaracao.tipo);
-        }
-        return null;
-    }
-    visitarExpressaoContinua(declaracao) {
-        return new quebras_1.ContinuarQuebra();
-    }
-    visitarExpressaoSustar(declaracao) {
-        return new quebras_1.SustarQuebra();
-    }
-    async visitarExpressaoRetornar(declaracao) {
-        let valor = null;
-        if (declaracao.valor != null)
-            valor = await this.avaliar(declaracao.valor);
-        return new quebras_1.RetornoQuebra(valor);
-    }
-    async visitarExpressaoDeleguaFuncao(corpoDeclaracao) {
-        return new estruturas_1.DeleguaFuncao(null, corpoDeclaracao);
-    }
-    async visitarExpressaoAtribuicaoPorIndice(expressao) {
-        const promises = await Promise.all([
-            this.avaliar(expressao.objeto),
-            this.avaliar(expressao.indice),
-            this.avaliar(expressao.valor),
-        ]);
-        let objeto = promises[0];
-        let indice = promises[1];
-        const valor = promises[2];
-        if (objeto.tipo === delegua_2.default.TUPLA) {
-            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.simbolo.lexema, 'Não é possível modificar uma tupla. As tuplas são estruturas de dados imutáveis.', expressao.linha));
-        }
-        objeto = objeto.hasOwnProperty('valor') ? objeto.valor : objeto;
-        indice = indice.hasOwnProperty('valor') ? indice.valor : indice;
-        if (Array.isArray(objeto)) {
-            if (indice < 0 && objeto.length !== 0) {
-                while (indice < 0) {
-                    indice += objeto.length;
-                }
-            }
-            while (objeto.length < indice) {
-                objeto.push(null);
-            }
-            objeto[indice] = valor;
-        }
-        else if (objeto.constructor === Object ||
-            objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
-            objeto instanceof estruturas_1.DeleguaFuncao ||
-            objeto instanceof estruturas_1.DescritorTipoClasse ||
-            objeto instanceof estruturas_1.DeleguaModulo) {
-            objeto[indice] = valor;
-        }
-        else {
-            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha));
-        }
-    }
-    async visitarExpressaoAcessoIndiceVariavel(expressao) {
-        const promises = await Promise.all([this.avaliar(expressao.entidadeChamada), this.avaliar(expressao.indice)]);
-        const variavelObjeto = promises[0];
-        const indice = promises[1];
-        const objeto = variavelObjeto.hasOwnProperty('valor') ? variavelObjeto.valor : variavelObjeto;
-        let valorIndice = indice.hasOwnProperty('valor') ? indice.valor : indice;
-        if (Array.isArray(objeto)) {
-            if (!Number.isInteger(valorIndice)) {
-                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha));
-            }
-            if (valorIndice < 0 && objeto.length !== 0) {
-                while (valorIndice < 0) {
-                    valorIndice += objeto.length;
-                }
-            }
-            if (valorIndice >= objeto.length) {
-                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice do vetor fora do intervalo.', expressao.linha));
-            }
-            return objeto[valorIndice];
-        }
-        if (objeto instanceof construtos_1.Vetor) {
-            return objeto.valores[valorIndice];
-        }
-        if (objeto.constructor === Object ||
-            objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
-            objeto instanceof estruturas_1.DeleguaFuncao ||
-            objeto instanceof estruturas_1.DescritorTipoClasse ||
-            objeto instanceof estruturas_1.DeleguaModulo) {
-            return objeto[valorIndice] || null;
-        }
-        if (typeof objeto === primitivos_1.default.TEXTO) {
-            if (!Number.isInteger(valorIndice)) {
-                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha));
-            }
-            if (valorIndice < 0 && objeto.length !== 0) {
-                while (valorIndice < 0) {
-                    valorIndice += objeto.length;
-                }
-            }
-            if (valorIndice >= objeto.length) {
-                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice fora do tamanho.', expressao.linha));
-            }
-            return objeto.charAt(valorIndice);
-        }
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.entidadeChamada.nome, 'Somente listas, dicionários, classes e objetos podem ter seus valores indexados.', expressao.linha));
-    }
-    async visitarExpressaoDefinirValor(expressao) {
-        const variavelObjeto = await this.avaliar(expressao.objeto);
-        const objeto = variavelObjeto.hasOwnProperty('valor') ? variavelObjeto.valor : variavelObjeto;
-        if (objeto.constructor.name !== 'ObjetoDeleguaClasse' && objeto.constructor !== Object) {
-            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.nome, 'Somente instâncias e dicionários podem possuir campos.', expressao.linha));
-        }
-        const valor = await this.avaliar(expressao.valor);
-        if (objeto.constructor.name === 'ObjetoDeleguaClasse') {
-            objeto.definir(expressao.nome, valor);
-            return valor;
-        }
-        if (objeto.constructor === Object) {
-            objeto[expressao.nome.lexema] = valor;
-        }
-    }
-    visitarDeclaracaoDefinicaoFuncao(declaracao) {
-        const funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
-        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, funcao);
-    }
-    /**
-     * Executa uma declaração de classe.
-     * Uma variável do tipo `DeleguaClasse` é adicionada à pilha de escopos de execução.
-     * @param declaracao A declaração de classe.
-     * @returns Sempre retorna nulo, por ser requerido pelo contrato de visita.
-     */
-    async visitarDeclaracaoClasse(declaracao) {
-        let superClasse = null;
-        if (declaracao.superClasse !== null && declaracao.superClasse !== undefined) {
-            const variavelSuperClasse = await this.avaliar(declaracao.superClasse);
-            superClasse = variavelSuperClasse.valor;
-            if (!(superClasse instanceof estruturas_1.DescritorTipoClasse)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.superClasse.nome, 'Superclasse precisa ser uma classe.', declaracao.linha);
-            }
-        }
-        // TODO: Precisamos disso?
-        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, declaracao);
-        if (declaracao.superClasse !== null && declaracao.superClasse !== undefined) {
-            this.pilhaEscoposExecucao.definirVariavel('super', superClasse);
-        }
-        const metodos = {};
-        const definirMetodos = declaracao.metodos;
-        for (let i = 0; i < declaracao.metodos.length; i++) {
-            const metodoAtual = definirMetodos[i];
-            const eInicializador = metodoAtual.simbolo.lexema === 'construtor';
-            const funcao = new estruturas_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, undefined, eInicializador);
-            metodos[metodoAtual.simbolo.lexema] = funcao;
-        }
-        const descritorTipoClasse = new estruturas_1.DescritorTipoClasse(declaracao.simbolo, superClasse, metodos, declaracao.propriedades);
-        descritorTipoClasse.dialetoRequerExpansaoPropriedadesEspacoVariaveis =
-            this.expandirPropriedadesDeObjetosEmEspacoVariaveis;
-        descritorTipoClasse.dialetoRequerDeclaracaoPropriedades = this.requerDeclaracaoPropriedades;
-        // TODO: Recolocar isso se for necessário.
-        /* if (superClasse !== null) {
-            this.ambiente = this.ambiente.enclosing;
-        } */
-        this.pilhaEscoposExecucao.atribuirVariavel(declaracao.simbolo, descritorTipoClasse);
-        return null;
-    }
-    /**
-     * Executa um acesso a método, normalmente de um objeto de classe.
-     * @param {AcessoMetodoOuPropriedade} expressao A expressão de acesso.
-     * @returns O resultado da execução.
-     */
-    async visitarExpressaoAcessoMetodo(expressao) {
-        let variavelObjeto = await this.avaliar(expressao.objeto);
-        // Este caso acontece quando há encadeamento de métodos.
-        // Por exemplo, `objeto1.metodo1().metodo2()`.
-        // Como `RetornoQuebra` também possui `valor`, precisamos extrair o
-        // valor dele primeiro.
-        if (variavelObjeto.constructor.name === 'RetornoQuebra') {
-            variavelObjeto = variavelObjeto.valor;
-        }
-        const objeto = variavelObjeto.hasOwnProperty('valor') ? variavelObjeto.valor : variavelObjeto;
-        // Outro caso que `instanceof` simplesmente não funciona para casos em Liquido,
-        // então testamos também o nome do construtor.
-        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse || objeto.constructor.name === 'ObjetoDeleguaClasse') {
-            return objeto.obter(expressao.simbolo) || null;
-        }
-        // Objeto simples do JavaScript, ou dicionário de Delégua.
-        if (objeto.constructor === Object) {
-            const metodoDePrimitivaDicionario = primitivas_dicionario_1.default[expressao.simbolo.lexema];
-            if (metodoDePrimitivaDicionario) {
-                return new metodo_primitiva_1.MetodoPrimitiva(objeto, metodoDePrimitivaDicionario);
-            }
-            return objeto[expressao.simbolo.lexema] || null;
-        }
-        // Casos em que o objeto possui algum outro tipo que não o de objeto simples.
-        // Normalmente executam quando uma biblioteca é importada, e estamos tentando
-        // obter alguma propriedade ou método desse objeto.
-        // Caso 1: Função tradicional do JavaScript.
-        if (typeof objeto[expressao.simbolo.lexema] === primitivos_1.default.FUNCAO) {
-            return objeto[expressao.simbolo.lexema];
-        }
-        // Caso 2: Objeto tradicional do JavaScript.
-        if (typeof objeto[expressao.simbolo.lexema] === primitivos_1.default.OBJETO) {
-            return objeto[expressao.simbolo.lexema];
-        }
-        // A partir daqui, presume-se que o objeto é uma das estruturas
-        // de Delégua.
-        if (objeto instanceof estruturas_1.DeleguaModulo) {
-            return objeto.componentes[expressao.simbolo.lexema] || null;
-        }
-        let tipoObjeto = variavelObjeto.tipo;
-        if (tipoObjeto === null || tipoObjeto === undefined) {
-            tipoObjeto = (0, inferenciador_1.inferirTipoVariavel)(variavelObjeto);
-        }
-        // Como internamente um dicionário de Delégua é simplesmente um objeto de
-        // JavaScript, as primitivas de dicionário, especificamente, são tratadas
-        // mais acima.
-        switch (tipoObjeto) {
-            case delegua_2.default.INTEIRO:
-            case delegua_2.default.NUMERO:
-            case delegua_2.default.NÚMERO:
-                const metodoDePrimitivaNumero = primitivas_numero_1.default[expressao.simbolo.lexema];
-                if (metodoDePrimitivaNumero) {
-                    return new metodo_primitiva_1.MetodoPrimitiva(objeto, metodoDePrimitivaNumero);
-                }
-                break;
-            case delegua_2.default.TEXTO:
-                const metodoDePrimitivaTexto = primitivas_texto_1.default[expressao.simbolo.lexema];
-                if (metodoDePrimitivaTexto) {
-                    return new metodo_primitiva_1.MetodoPrimitiva(objeto, metodoDePrimitivaTexto);
-                }
-                break;
-            case delegua_2.default.VETOR:
-                const metodoDePrimitivaVetor = primitivas_vetor_1.default[expressao.simbolo.lexema];
-                if (metodoDePrimitivaVetor) {
-                    return new metodo_primitiva_1.MetodoPrimitiva(objeto, metodoDePrimitivaVetor);
-                }
-                break;
-        }
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, `Método para objeto ou primitiva não encontrado: ${expressao.simbolo.lexema}.`, expressao.linha));
-    }
-    visitarExpressaoIsto(expressao) {
-        return this.procurarVariavel(expressao.palavraChave);
-    }
-    visitarDeclaracaoAleatorio(declaracao) {
-        return Promise.resolve();
-    }
-    async visitarExpressaoDicionario(expressao) {
-        const dicionario = {};
-        for (let i = 0; i < expressao.chaves.length; i++) {
-            const promises = await Promise.all([this.avaliar(expressao.chaves[i]), this.avaliar(expressao.valores[i])]);
-            dicionario[promises[0]] = promises[1];
-        }
-        return dicionario;
-    }
-    async visitarExpressaoVetor(expressao) {
-        const valores = [];
-        for (let i = 0; i < expressao.valores.length; i++) {
-            valores.push(await this.avaliar(expressao.valores[i]));
-        }
-        return valores;
-    }
-    visitarExpressaoSuper(expressao) {
-        const superClasse = this.pilhaEscoposExecucao.obterVariavelPorNome('super');
-        const objeto = this.pilhaEscoposExecucao.obterVariavelPorNome('isto');
-        const metodo = superClasse.valor.encontrarMetodo(expressao.metodo.lexema);
-        if (metodo === undefined) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.metodo, 'Método chamado indefinido.', expressao.linha);
-        }
-        metodo.instancia = objeto.valor;
-        return metodo;
-    }
-    /**
-     * Executa expressão de definição de variável.
-     * @param declaracao A declaração Var
-     * @returns Sempre retorna nulo.
-     */
-    async visitarDeclaracaoVar(declaracao) {
-        const valorFinal = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
-        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valorFinal, declaracao.tipo);
-        return null;
-    }
-    /**
-     * Executa expressão de definição de múltiplas variáveis.
-     * @param declaracao A declaração `VarMultiplo`.
-     * @returns Sempre retorna nulo.
-     */
-    async visitarDeclaracaoVarMultiplo(declaracao) {
-        const valoresFinais = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
-        for (let [indice, valor] of valoresFinais.entries()) {
-            this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolos[indice].lexema, valor, declaracao.tipo);
-        }
-        return null;
-    }
-    paraTexto(objeto) {
-        if (objeto === null || objeto === undefined)
-            return delegua_2.default.NULO;
-        if (typeof objeto === primitivos_1.default.BOOLEANO) {
-            return objeto ? 'verdadeiro' : 'falso';
-        }
-        if (objeto instanceof quebras_1.RetornoQuebra) {
-            if (typeof objeto.valor === 'boolean')
-                return objeto.valor ? 'verdadeiro' : 'falso';
-        }
-        if (objeto instanceof Date) {
-            const formato = Intl.DateTimeFormat('pt', {
-                dateStyle: 'full',
-                timeStyle: 'full',
-            });
-            return formato.format(objeto);
-        }
-        if (Array.isArray(objeto)) {
-            let retornoVetor = '[';
-            for (let elemento of objeto) {
-                retornoVetor += typeof elemento === 'string' ? `'${elemento}', ` : `${this.paraTexto(elemento)}, `;
-            }
-            if (retornoVetor.length > 1) {
-                retornoVetor = retornoVetor.slice(0, -2);
-            }
-            retornoVetor += ']';
-            return retornoVetor;
-        }
-        if (objeto.valor instanceof estruturas_1.ObjetoPadrao)
-            return objeto.valor.paraTexto();
-        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse || objeto instanceof estruturas_1.DeleguaFuncao)
-            return objeto.paraTexto();
-        switch (objeto.constructor.name) {
-            case 'Object':
-                if ('tipo' in objeto) {
-                    switch (objeto.tipo) {
-                        case 'dicionário':
-                            return JSON.stringify(objeto.valor);
-                        default:
-                            return objeto.valor;
-                    }
-                }
-        }
-        if (typeof objeto === primitivos_1.default.OBJETO) {
-            for (const obj in objeto) {
-                let valor = objeto[obj];
-                if (typeof valor === primitivos_1.default.BOOLEANO) {
-                    valor = valor ? 'verdadeiro' : 'falso';
-                    objeto[obj] = valor;
-                }
-            }
-            return JSON.stringify(objeto);
-        }
-        return objeto.toString();
-    }
-    /**
-     * Efetivamente executa uma declaração.
-     * @param declaracao A declaração a ser executada.
-     * @param mostrarResultado Se resultado deve ser mostrado ou não. Normalmente usado
-     *                         pelo modo LAIR.
-     */
-    async executar(declaracao, mostrarResultado = false) {
-        const resultado = await declaracao.aceitar(this);
-        /* console.log("Resultado aceitar: " + resultado, this); */
-        if (mostrarResultado) {
-            this.funcaoDeRetorno(this.paraTexto(resultado));
-        }
-        if (resultado || typeof resultado === primitivos_1.default.BOOLEANO) {
-            this.resultadoInterpretador.push(this.paraTexto(resultado));
-        }
-        return resultado;
-    }
-    /**
-     * Executa o último escopo empilhado no topo na pilha de escopos do interpretador.
-     * Esse método pega exceções, mas apenas as devolve.
-     *
-     * O tratamento das exceções é feito de acordo com o bloco chamador.
-     * Por exemplo, em `tente ... pegue ... finalmente`, a exceção é capturada e tratada.
-     * Em outros blocos, pode ser desejável ter o erro em tela.
-     * @param manterAmbiente Se verdadeiro, ambiente do topo da pilha de escopo é copiado para o ambiente imediatamente abaixo.
-     * @returns O resultado da execução do escopo, se houver.
-     */
-    async executarUltimoEscopo(manterAmbiente = false) {
-        const ultimoEscopo = this.pilhaEscoposExecucao.topoDaPilha();
-        try {
-            let retornoExecucao;
-            for (; !(retornoExecucao instanceof quebras_1.Quebra) && ultimoEscopo.declaracaoAtual < ultimoEscopo.declaracoes.length; ultimoEscopo.declaracaoAtual++) {
-                retornoExecucao = await this.executar(ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual]);
-            }
-            return retornoExecucao;
-        }
-        catch (erro) {
-            const declaracaoAtual = ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual];
-            if (!this.emDeclaracaoTente) {
-                this.erros.push({
-                    erroInterno: erro,
-                    linha: declaracaoAtual.linha,
-                    hashArquivo: declaracaoAtual.hashArquivo,
-                });
-            }
-            return Promise.reject(erro);
-        }
-        finally {
-            this.pilhaEscoposExecucao.removerUltimo();
-            const escopoAnterior = this.pilhaEscoposExecucao.topoDaPilha();
-            if (manterAmbiente) {
-                escopoAnterior.ambiente.valores = Object.assign(escopoAnterior.ambiente.valores, ultimoEscopo.ambiente.valores);
-            }
-        }
-    }
-    /**
-     * Interpretação sem depurador, com medição de performance.
-     * Método que efetivamente inicia o processo de interpretação.
-     * @param declaracoes Um vetor de declarações gerado pelo Avaliador Sintático.
-     * @param manterAmbiente Se ambiente de execução (variáveis, classes, etc.) deve ser mantido. Normalmente usado
-     *                       pelo modo REPL (LAIR).
-     * @returns Um objeto com o resultado da interpretação.
-     */
-    async interpretar(declaracoes, manterAmbiente = false) {
-        this.erros = [];
-        this.emDeclaracaoTente = false;
-        const escopoExecucao = {
-            declaracoes: declaracoes,
-            declaracaoAtual: 0,
-            ambiente: new espaco_variaveis_1.EspacoVariaveis(),
-            finalizado: false,
-            tipo: 'outro',
-            emLacoRepeticao: false,
-        };
-        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-        const inicioInterpretacao = (0, browser_process_hrtime_1.default)();
-        try {
-            const retornoOuErro = await this.executarUltimoEscopo(manterAmbiente);
-            if (retornoOuErro instanceof excecoes_1.ErroEmTempoDeExecucao) {
-                this.erros.push(retornoOuErro);
-            }
-        }
-        catch (erro) {
-            this.erros.push({
-                erroInterno: erro,
-                linha: -1,
-                hashArquivo: -1,
-            });
-        }
-        finally {
-            if (this.performance) {
-                const deltaInterpretacao = (0, browser_process_hrtime_1.default)(inicioInterpretacao);
-                console.log(`[Interpretador] Tempo para interpretaçao: ${deltaInterpretacao[0] * 1e9 + deltaInterpretacao[1]}ns`);
-            }
-            const retorno = {
-                erros: this.erros,
-                resultado: this.resultadoInterpretador,
-            };
-            this.resultadoInterpretador = [];
-            return retorno;
-        }
-    }
-}
-exports.InterpretadorBase = InterpretadorBase;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterpretadorBase = void 0;
+const browser_process_hrtime_1 = __importDefault(require("browser-process-hrtime"));
+const estruturas_1 = require("../estruturas");
+const construtos_1 = require("../construtos");
+const pilha_escopos_execucao_1 = require("./pilha-escopos-execucao");
+const quebras_1 = require("../quebras");
+const inferenciador_1 = require("./inferenciador");
+const metodo_primitiva_1 = require("../estruturas/metodo-primitiva");
+const lexador_1 = require("../lexador");
+const avaliador_sintatico_1 = require("../avaliador-sintatico");
+const espaco_variaveis_1 = require("../espaco-variaveis");
+const comum_1 = require("./comum");
+const excecoes_1 = require("../excecoes");
+const primitivas_dicionario_1 = __importDefault(require("../bibliotecas/primitivas-dicionario"));
+const primitivas_numero_1 = __importDefault(require("../bibliotecas/primitivas-numero"));
+const primitivas_texto_1 = __importDefault(require("../bibliotecas/primitivas-texto"));
+const primitivas_vetor_1 = __importDefault(require("../bibliotecas/primitivas-vetor"));
+const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
+const primitivos_1 = __importDefault(require("../tipos-de-dados/primitivos"));
+const delegua_2 = __importDefault(require("../tipos-de-dados/delegua"));
+/**
+ * O Interpretador visita todos os elementos complexos gerados pelo avaliador sintático (_parser_),
+ * e de fato executa a lógica de programação descrita no código.
+ *
+ * O Interpretador Base não contém dependências com o Node.js. É
+ * recomendado para uso em execuções que ocorrem no navegador de internet.
+ */
+class InterpretadorBase {
+    constructor(diretorioBase, performance = false, funcaoDeRetorno = null, funcaoDeRetornoMesmaLinha = null) {
+        this.resultadoInterpretador = [];
+        this.funcaoDeRetorno = null;
+        this.funcaoDeRetornoMesmaLinha = null;
+        this.interfaceDeEntrada = null; // Originalmente é `readline.Interface`
+        this.interfaceEntradaSaida = null;
+        this.emDeclaracaoTente = false;
+        this.microLexador = new lexador_1.MicroLexador();
+        this.microAvaliadorSintatico = new avaliador_sintatico_1.MicroAvaliadorSintatico();
+        this.regexInterpolacao = /\${(.*?)}/g;
+        this.tiposNumericos = [
+            delegua_2.default.INTEIRO,
+            delegua_2.default.NUMERO,
+            delegua_2.default.NÚMERO,
+            delegua_2.default.REAL
+        ];
+        this.diretorioBase = diretorioBase;
+        this.performance = performance;
+        this.funcaoDeRetorno = funcaoDeRetorno || console.log;
+        this.funcaoDeRetornoMesmaLinha = funcaoDeRetornoMesmaLinha || process.stdout.write.bind(process.stdout);
+        this.erros = [];
+        this.declaracoes = [];
+        this.resultadoInterpretador = [];
+        // Isso existe por causa de Potigol.
+        // Para acessar uma variável de classe, não é preciso a palavra `isto`.
+        this.expandirPropriedadesDeObjetosEmEspacoVariaveis = false;
+        // Por padrão é verdadeiro porque Delégua e Pituguês usam
+        // o interpretador base como implementação padrão.
+        this.requerDeclaracaoPropriedades = true;
+        this.pilhaEscoposExecucao = new pilha_escopos_execucao_1.PilhaEscoposExecucao();
+        const escopoExecucao = {
+            declaracoes: [],
+            declaracaoAtual: 0,
+            ambiente: new espaco_variaveis_1.EspacoVariaveis(),
+            finalizado: false,
+            tipo: 'outro',
+            emLacoRepeticao: false,
+        };
+        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
+        (0, comum_1.carregarBibliotecasGlobais)(this.pilhaEscoposExecucao);
+    }
+    /**
+     * Construtos de comentários não têm utilidade para o Interpretador.
+     * Apenas retornamos `Promise.resolve()` para não termos erros.
+     * @param declaracao A declaração de comentário.
+     */
+    visitarDeclaracaoComentario(declaracao) {
+        return Promise.resolve();
+    }
+    async visitarDeclaracaoTendoComo(declaracao) {
+        const retornoInicializacao = await this.avaliar(declaracao.inicializacaoVariavel);
+        this.pilhaEscoposExecucao.definirConstante(declaracao.simboloVariavel.lexema, retornoInicializacao);
+        await this.executar(declaracao.corpo);
+        if (retornoInicializacao instanceof estruturas_1.ObjetoDeleguaClasse) {
+            const metodoFinalizar = retornoInicializacao.classe.metodos['finalizar'];
+            if (metodoFinalizar) {
+                const chamavel = metodoFinalizar.funcaoPorMetodoDeClasse(retornoInicializacao);
+                chamavel.chamar(this, []);
+            }
+        }
+        return null;
+    }
+    async visitarDeclaracaoInicioAlgoritmo(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarDeclaracaoCabecalhoPrograma(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoTupla(expressao) {
+        const chaves = Object.keys(expressao);
+        const valores = [];
+        for (let chave of chaves) {
+            const valor = await this.avaliar(expressao[chave]);
+            valores.push(valor);
+        }
+        return valores;
+    }
+    async visitarExpressaoAtribuicaoPorIndicesMatriz(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoAcessoElementoMatriz(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    textoParaRegex(texto) {
+        const match = texto.match(/^([\/~@;%#'])(.*?)\1([gimsuy]*)$/);
+        return match
+            ? new RegExp(match[2], match[3]
+                .split('')
+                .filter((char, pos, flagArr) => flagArr.indexOf(char) === pos)
+                .join(''))
+            : new RegExp(texto);
+    }
+    visitarExpressaoExpressaoRegular(expressao) {
+        return Promise.resolve(this.textoParaRegex(expressao.valor));
+    }
+    async visitarExpressaoTipoDe(expressao) {
+        let tipoDe = expressao.valor;
+        if (tipoDe instanceof construtos_1.Agrupamento ||
+            tipoDe instanceof construtos_1.Binario ||
+            tipoDe instanceof construtos_1.Chamada ||
+            tipoDe instanceof construtos_1.Dicionario ||
+            tipoDe instanceof construtos_1.TipoDe ||
+            tipoDe instanceof construtos_1.Unario ||
+            tipoDe instanceof construtos_1.Variavel) {
+            tipoDe = await this.avaliar(tipoDe);
+            return tipoDe.tipo || (0, inferenciador_1.inferirTipoVariavel)(tipoDe);
+        }
+        return (0, inferenciador_1.inferirTipoVariavel)((tipoDe === null || tipoDe === void 0 ? void 0 : tipoDe.valores) || tipoDe);
+    }
+    // TODO: Depreciado. Priorizar `visitarExpressaoTipoDe`.
+    async visitarExpressaoQualTipo(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoFalhar(expressao) {
+        var _a;
+        const textoFalha = (_a = expressao.explicacao.valor) !== null && _a !== void 0 ? _a : (await this.avaliar(expressao.explicacao)).valor;
+        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, textoFalha, expressao.linha);
+    }
+    async visitarExpressaoFimPara(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    async avaliar(expressao) {
+        // Descomente o código abaixo quando precisar detectar expressões undefined ou nulas.
+        // Por algum motivo o depurador do VSCode não funciona direito aqui
+        // com breakpoint condicional.
+        /* if (expressao === null || expressao === undefined) {
+            console.log('Aqui');
+        } */
+        return await expressao.aceitar(this);
+    }
+    /**
+     * Execução da leitura de valores da entrada configurada no
+     * início da aplicação.
+     * @param expressao Expressão do tipo Leia
+     * @returns Promise com o resultado da leitura.
+     */
+    async visitarExpressaoLeia(expressao) {
+        const mensagem = expressao.argumentos && expressao.argumentos[0] ? expressao.argumentos[0].valor : '> ';
+        return new Promise((resolucao) => this.interfaceEntradaSaida.question(mensagem, (resposta) => {
+            resolucao(resposta);
+        }));
+    }
+    /**
+     * Execução da leitura de valores da entrada configurada no
+     * início da aplicação.
+     * @param expressao Expressão do tipo `LeiaMultiplo`.
+     * @returns Promise com o resultado da leitura.
+     */
+    async visitarExpressaoLeiaMultiplo(expressao) {
+        const mensagem = '> ';
+        if (expressao.argumento instanceof construtos_1.Literal) {
+            let valor = expressao.argumento.valor;
+            if (typeof valor === primitivos_1.default.TEXTO) {
+                return new Promise((resolucao) => this.interfaceEntradaSaida.question(mensagem, (resposta) => {
+                    resolucao(String(resposta)
+                        .split(valor)
+                        .filter((r) => !/(\s+)/.test(r)));
+                }));
+            }
+            let respostas = [];
+            for (let i = 0; i < valor; i++) {
+                this.interfaceEntradaSaida.question(mensagem, (resposta) => {
+                    respostas.push(resposta);
+                });
+            }
+            return Promise.resolve(respostas);
+        }
+        return Promise.resolve();
+    }
+    /**
+     * Retira a interpolação de um texto.
+     * @param {texto} texto O texto
+     * @param {any[]} variaveis A lista de variaveis interpoladas
+     * @returns O texto com o valor das variaveis.
+     */
+    retirarInterpolacao(texto, variaveis) {
+        let textoFinal = texto;
+        variaveis.forEach((elemento) => {
+            var _a, _b, _c;
+            if (((_a = elemento === null || elemento === void 0 ? void 0 : elemento.valor) === null || _a === void 0 ? void 0 : _a.tipo) === delegua_2.default.LOGICO) {
+                textoFinal = textoFinal.replace('${' + elemento.variavel + '}', this.paraTexto((_b = elemento === null || elemento === void 0 ? void 0 : elemento.valor) === null || _b === void 0 ? void 0 : _b.valor));
+            }
+            else {
+                const valor = ((_c = elemento === null || elemento === void 0 ? void 0 : elemento.valor) === null || _c === void 0 ? void 0 : _c.hasOwnProperty('valor')) ? elemento === null || elemento === void 0 ? void 0 : elemento.valor.valor : elemento === null || elemento === void 0 ? void 0 : elemento.valor;
+                textoFinal = textoFinal.replace('${' + elemento.variavel + '}', `${this.paraTexto(valor)}`);
+            }
+        });
+        return textoFinal;
+    }
+    /**
+     * Resolve todas as interpolações em um texto.
+     * @param {texto} textoOriginal O texto original com as variáveis interpoladas.
+     * @returns Uma lista de variáveis interpoladas.
+     */
+    async resolverInterpolacoes(textoOriginal, linha) {
+        const variaveis = textoOriginal.match(this.regexInterpolacao);
+        let resultadosAvaliacaoSintatica = variaveis.map((s) => {
+            const nomeVariavel = s.replace(/[\$\{\}]*/gm, '');
+            let microLexador = this.microLexador.mapear(nomeVariavel);
+            const resultadoMicroAvaliadorSintatico = this.microAvaliadorSintatico.analisar(microLexador, linha);
+            return {
+                nomeVariavel,
+                resultadoMicroAvaliadorSintatico,
+            };
+        });
+        // TODO: Verificar erros do `resultadosAvaliacaoSintatica`.
+        const resolucoesPromises = await Promise.all(resultadosAvaliacaoSintatica
+            .flatMap((r) => r.resultadoMicroAvaliadorSintatico.declaracoes)
+            .map((d) => this.avaliar(d)));
+        return resolucoesPromises.map((item, indice) => ({
+            variavel: resultadosAvaliacaoSintatica[indice].nomeVariavel,
+            valor: item,
+        }));
+    }
+    async visitarExpressaoLiteral(expressao) {
+        if (this.regexInterpolacao.test(expressao.valor)) {
+            const variaveis = await this.resolverInterpolacoes(expressao.valor, expressao.linha);
+            return this.retirarInterpolacao(expressao.valor, variaveis);
+        }
+        return expressao.valor;
+    }
+    async visitarExpressaoAgrupamento(expressao) {
+        return await this.avaliar(expressao.expressao);
+    }
+    eVerdadeiro(objeto) {
+        if (objeto === null)
+            return false;
+        if (typeof objeto === primitivos_1.default.BOOLEANO)
+            return Boolean(objeto);
+        if (objeto.hasOwnProperty('valor')) {
+            return Boolean(objeto.valor);
+        }
+        return true;
+    }
+    verificarOperandoNumero(operador, operando) {
+        if (typeof operando === primitivos_1.default.NUMERO || operando.tipo === delegua_2.default.NUMERO)
+            return;
+        throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operando precisa ser um número.', Number(operador.linha));
+    }
+    async visitarExpressaoUnaria(expressao) {
+        const operando = await this.avaliar(expressao.operando);
+        let valor = operando.hasOwnProperty('valor') ? operando.valor : operando;
+        switch (expressao.operador.tipo) {
+            case delegua_1.default.SUBTRACAO:
+                this.verificarOperandoNumero(expressao.operador, valor);
+                return -valor;
+            case delegua_1.default.NEGACAO:
+                return !this.eVerdadeiro(valor);
+            case delegua_1.default.BIT_NOT:
+                return ~valor;
+            // Para incrementar e decrementar, primeiro precisamos saber se o operador
+            // veio antes do literal ou variável.
+            // Se veio antes e o operando é uma variável, precisamos incrementar/decrementar,
+            // armazenar o valor da variável pra só então devolver o valor.
+            case delegua_1.default.INCREMENTAR:
+                if (expressao.incidenciaOperador === 'ANTES') {
+                    valor++;
+                    if (expressao.operando instanceof construtos_1.Variavel) {
+                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, valor);
+                    }
+                    return valor;
+                }
+                const valorAnteriorIncremento = valor;
+                this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, ++valor);
+                return valorAnteriorIncremento;
+            case delegua_1.default.DECREMENTAR:
+                if (expressao.incidenciaOperador === 'ANTES') {
+                    valor--;
+                    if (expressao.operando instanceof construtos_1.Variavel) {
+                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, valor);
+                    }
+                    return valor;
+                }
+                const valorAnteriorDecremento = valor;
+                this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, --valor);
+                return valorAnteriorDecremento;
+        }
+        return null;
+    }
+    /**
+     * Formata uma saída de acordo com o número e espaços e casas decimais solicitados.
+     * @param declaracao A declaração de formatação de escrita.
+     * @returns {string} A saída formatada como texto e os respectivos parâmetros aplicados.
+     */
+    async visitarExpressaoFormatacaoEscrita(declaracao) {
+        let resultado = '';
+        const conteudo = await this.avaliar(declaracao.expressao);
+        const valorConteudo = (conteudo === null || conteudo === void 0 ? void 0 : conteudo.hasOwnProperty('valor')) ? conteudo.valor : conteudo;
+        const tipoConteudo = conteudo.hasOwnProperty('tipo') ? conteudo.tipo : typeof conteudo;
+        resultado = valorConteudo;
+        if ([delegua_2.default.NUMERO, primitivos_1.default.NUMERO].includes(tipoConteudo) &&
+            declaracao.casasDecimais > 0) {
+            resultado = valorConteudo.toLocaleString('pt', { maximumFractionDigits: declaracao.casasDecimais });
+        }
+        if (declaracao.espacos > 0) {
+            resultado += ' '.repeat(declaracao.espacos);
+        }
+        return resultado;
+    }
+    /**
+     * Lógica para verificação de valores iguais, para Delégua e alguns dialetos.
+     * @param esquerda Uma variável.
+     * @param direita Outra variável.
+     * @returns Verdadeiro se são iguais. Falso em caso contrário.
+     */
+    eIgual(esquerda, direita) {
+        if (esquerda === null && direita === null)
+            return true;
+        if (esquerda === null)
+            return false;
+        return esquerda === direita;
+    }
+    /**
+     * Verifica se operandos são números, que podem ser tanto variáveis puras do JavaScript
+     * (neste caso, `number`), ou podem ser variáveis de Delégua com inferência (`VariavelInterface`).
+     * @param operador O símbolo do operador.
+     * @param direita O operando direito.
+     * @param esquerda O operando esquerdo.
+     * @returns Se ambos os operandos são números ou não.
+     */
+    verificarOperandosNumeros(operador, direita, esquerda) {
+        const tipoDireita = direita.tipo
+            ? direita.tipo
+            : typeof direita === primitivos_1.default.NUMERO
+                ? delegua_2.default.NUMERO
+                : String(NaN);
+        const tipoEsquerda = esquerda.tipo
+            ? esquerda.tipo
+            : typeof esquerda === primitivos_1.default.NUMERO
+                ? delegua_2.default.NUMERO
+                : String(NaN);
+        if (this.tiposNumericos.includes(tipoDireita) && this.tiposNumericos.includes(tipoEsquerda))
+            return;
+        throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
+    }
+    async visitarExpressaoBinaria(expressao) {
+        const esquerda = await this.avaliar(expressao.esquerda);
+        const direita = await this.avaliar(expressao.direita);
+        const valorEsquerdo = (esquerda === null || esquerda === void 0 ? void 0 : esquerda.hasOwnProperty('valor')) ? esquerda.valor : esquerda;
+        const valorDireito = (direita === null || direita === void 0 ? void 0 : direita.hasOwnProperty('valor')) ? direita.valor : direita;
+        const tipoEsquerdo = (esquerda === null || esquerda === void 0 ? void 0 : esquerda.hasOwnProperty('tipo')) ? esquerda.tipo : (0, inferenciador_1.inferirTipoVariavel)(esquerda);
+        const tipoDireito = (direita === null || direita === void 0 ? void 0 : direita.hasOwnProperty('tipo')) ? direita.tipo : (0, inferenciador_1.inferirTipoVariavel)(direita);
+        switch (expressao.operador.tipo) {
+            case delegua_1.default.EXPONENCIACAO:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Math.pow(valorEsquerdo, valorDireito);
+            case delegua_1.default.MAIOR:
+                if (this.tiposNumericos.includes(tipoEsquerdo) && this.tiposNumericos.includes(tipoDireito)) {
+                    return Number(valorEsquerdo) > Number(valorDireito);
+                }
+                return String(valorEsquerdo) > String(valorDireito);
+            case delegua_1.default.MAIOR_IGUAL:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(valorEsquerdo) >= Number(valorDireito);
+            case delegua_1.default.MENOR:
+                if (this.tiposNumericos.includes(tipoEsquerdo) && this.tiposNumericos.includes(tipoDireito)) {
+                    return Number(valorEsquerdo) < Number(valorDireito);
+                }
+                return String(valorEsquerdo) < String(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 (this.tiposNumericos.includes(tipoEsquerdo) &&
+                    this.tiposNumericos.includes(tipoDireito)) {
+                    return Number(valorEsquerdo) + Number(valorDireito);
+                }
+                return this.paraTexto(valorEsquerdo) + this.paraTexto(valorDireito);
+            case delegua_1.default.DIVISAO:
+            case delegua_1.default.DIVISAO_IGUAL:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(valorEsquerdo) / Number(valorDireito);
+            case delegua_1.default.DIVISAO_INTEIRA:
+            case delegua_1.default.DIVISAO_INTEIRA_IGUAL:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Math.floor(Number(valorEsquerdo) / Number(valorDireito));
+            case delegua_1.default.MULTIPLICACAO:
+            case delegua_1.default.MULTIPLICACAO_IGUAL:
+                if (tipoEsquerdo === delegua_2.default.TEXTO || tipoDireito === delegua_2.default.TEXTO) {
+                    // Sem ambos os valores resolvem como texto, multiplica normal.
+                    // Se apenas um resolve como texto, o outro repete o
+                    // texto n vezes, sendo n o valor do outro.
+                    if (tipoEsquerdo === delegua_2.default.TEXTO && tipoDireito === delegua_2.default.TEXTO) {
+                        return Number(valorEsquerdo) * Number(valorDireito);
+                    }
+                    if (tipoEsquerdo === delegua_2.default.TEXTO) {
+                        return valorEsquerdo.repeat(Number(valorDireito));
+                    }
+                    return valorDireito.repeat(Number(valorEsquerdo));
+                }
+                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);
+        }
+    }
+    /**
+     * Faz a chamada do método de uma primitiva (por exemplo, número, texto, etc.) com seus
+     * respectivos argumentos.
+     * @param {Chamada} expressao A expressão de chamada.
+     * @param {MetodoPrimitiva} entidadeChamada O método da primitiva chamado.
+     * @returns O resultado da chamada do método da primitiva.
+     */
+    async chamarMetodoPrimitiva(expressao, entidadeChamada) {
+        const argumentosResolvidos = [];
+        for (const argumento of expressao.argumentos) {
+            const valorResolvido = await this.avaliar(argumento);
+            argumentosResolvidos.push((valorResolvido === null || valorResolvido === void 0 ? void 0 : valorResolvido.hasOwnProperty('valor')) ? valorResolvido.valor : valorResolvido);
+        }
+        return await entidadeChamada.chamar(this, argumentosResolvidos);
+    }
+    async resolverArgumentosChamada(expressao) {
+        const argumentos = [];
+        for (let i = 0; i < expressao.argumentos.length; i++) {
+            const variavelArgumento = expressao.argumentos[i];
+            const nomeArgumento = variavelArgumento.hasOwnProperty('simbolo')
+                ? variavelArgumento.simbolo.lexema
+                : undefined;
+            argumentos.push({
+                nome: nomeArgumento,
+                valor: await this.avaliar(variavelArgumento),
+            });
+        }
+        return argumentos;
+    }
+    /**
+     * Resolve paraâmetros da chamada de acordo com o tipo da entidade chamada.
+     * @param {Chamavel} entidadeChamada A entidade chamada.
+     * @returns Os parâmetros resolvidos.
+     */
+    resolverParametrosChamada(entidadeChamada) {
+        if (entidadeChamada instanceof estruturas_1.DeleguaFuncao) {
+            return entidadeChamada.declaracao.parametros;
+        }
+        if (entidadeChamada instanceof estruturas_1.DescritorTipoClasse) {
+            return entidadeChamada.metodos.construtor
+                ? entidadeChamada.metodos.construtor.declaracao.parametros
+                : [];
+        }
+        return [];
+    }
+    /**
+     * Executa uma chamada de função, método ou classe.
+     * @param expressao A expressão chamada.
+     * @returns O resultado da chamada.
+     */
+    async visitarExpressaoDeChamada(expressao) {
+        try {
+            const variavelEntidadeChamada = await this.avaliar(expressao.entidadeChamada);
+            if (variavelEntidadeChamada === null) {
+                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Chamada de função ou método inexistente: ' + String(expressao.entidadeChamada), expressao.linha));
+            }
+            const entidadeChamada = variavelEntidadeChamada.hasOwnProperty('valor')
+                ? variavelEntidadeChamada.valor
+                : variavelEntidadeChamada;
+            if (entidadeChamada instanceof estruturas_1.DeleguaModulo) {
+                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Entidade chamada é um módulo de Delégua. Provavelmente você quer chamar um de seus componentes?', expressao.linha));
+            }
+            if (entidadeChamada instanceof metodo_primitiva_1.MetodoPrimitiva) {
+                return await this.chamarMetodoPrimitiva(expressao, entidadeChamada);
+            }
+            const argumentos = await this.resolverArgumentosChamada(expressao);
+            // TODO: Aparentemente isso nunca é usado se o bloco de resolução de parâmetros,
+            // mais abaixo, também não é.
+            // Estudar remoção mais adiante.
+            const parametros = this.resolverParametrosChamada(entidadeChamada);
+            const aridade = entidadeChamada.aridade ? entidadeChamada.aridade() : entidadeChamada.length;
+            // Completar os parâmetros não preenchidos com nulos.
+            if (argumentos.length < aridade) {
+                const diferenca = aridade - argumentos.length;
+                for (let i = 0; i < diferenca; i++) {
+                    argumentos.push(null);
+                }
+            } /* else {
+                // TODO: Aparentemente isso aqui nunca funcionou.
+                // Avaliar de simplesmente apagar este código, e usar o que foi
+                // implementado em `DeleguaFuncao.chamar`.
+                if (
+                    parametros &&
+                    parametros.length > 0 &&
+                    parametros[parametros.length - 1].abrangencia === 'multiplo'
+                ) {
+                    let novosArgumentos = argumentos.slice(0, parametros.length - 1);
+                    novosArgumentos = novosArgumentos.concat(
+                        argumentos.slice(parametros.length - 1, argumentos.length)
+                    );
+                    argumentos = novosArgumentos;
+                }
+            } */
+            if (entidadeChamada instanceof estruturas_1.FuncaoPadrao) {
+                try {
+                    return entidadeChamada.chamar(this, argumentos.map((a) => a && a.valor && a.valor.hasOwnProperty('valor') ? a.valor.valor : a === null || a === void 0 ? void 0 : a.valor), expressao.entidadeChamada.simbolo);
+                }
+                catch (erro) {
+                    this.erros.push({
+                        erroInterno: erro,
+                        linha: expressao.linha,
+                        hashArquivo: expressao.hashArquivo,
+                    });
+                }
+            }
+            // Por algum motivo misterioso, `entidadeChamada instanceof Chamavel` dá `false` em Liquido,
+            // mesmo que esteja tudo certo com `DeleguaFuncao`,
+            // então precisamos testar o nome do construtor também.
+            if (entidadeChamada instanceof estruturas_1.Chamavel || entidadeChamada.constructor.name === 'DeleguaFuncao') {
+                const retornoEntidadeChamada = await entidadeChamada.chamar(this, argumentos);
+                return retornoEntidadeChamada;
+            }
+            // A função chamada pode ser de uma biblioteca JavaScript.
+            // Neste caso apenas testamos se o tipo é uma função.
+            // TODO: Descobrir qual caso exatamente passa aqui.
+            if (typeof entidadeChamada === primitivos_1.default.FUNCAO) {
+                let objeto = null;
+                if (expressao.entidadeChamada.objeto) {
+                    objeto = await this.avaliar(expressao.entidadeChamada.objeto);
+                }
+                return entidadeChamada.apply(objeto.hasOwnProperty('valor') ? objeto.valor : objeto, argumentos);
+            }
+            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Só pode chamar função ou classe.', expressao.linha));
+        }
+        catch (erro) {
+            this.erros.push({
+                erroInterno: erro,
+                linha: expressao.linha,
+                hashArquivo: expressao.hashArquivo,
+            });
+        }
+    }
+    /**
+     * Execução de uma expressão de atribuição.
+     * @param expressao A expressão.
+     * @returns O valor atribuído.
+     */
+    async visitarExpressaoDeAtribuicao(expressao) {
+        const valor = await this.avaliar(expressao.valor);
+        const valorResolvido = valor !== undefined && valor.hasOwnProperty('valor') ? valor.valor : valor;
+        let indice = null;
+        if (expressao.indice) {
+            indice = await this.avaliar(expressao.indice);
+        }
+        this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valorResolvido, indice);
+        return valorResolvido;
+    }
+    procurarVariavel(simbolo) {
+        return this.pilhaEscoposExecucao.obterValorVariavel(simbolo);
+    }
+    visitarExpressaoDeVariavel(expressao) {
+        return this.procurarVariavel(expressao.simbolo);
+    }
+    async visitarDeclaracaoDeExpressao(declaracao) {
+        return await this.avaliar(declaracao.expressao);
+    }
+    async visitarExpressaoLogica(expressao) {
+        const esquerda = await this.avaliar(expressao.esquerda);
+        if (expressao.operador.tipo === delegua_1.default.EM) {
+            const direita = await this.avaliar(expressao.direita);
+            if (Array.isArray(direita) || typeof direita === primitivos_1.default.TEXTO) {
+                return direita.includes(esquerda);
+            }
+            else if (direita.constructor === Object) {
+                return esquerda in direita;
+            }
+            else {
+                throw new excecoes_1.ErroEmTempoDeExecucao(esquerda, "Tipo de chamada inválida com 'em'.", expressao.linha);
+            }
+        }
+        // se um estado for verdadeiro, retorna verdadeiro
+        if (expressao.operador.tipo === delegua_1.default.OU) {
+            if (this.eVerdadeiro(esquerda))
+                return esquerda;
+        }
+        // se um estado for falso, retorna falso
+        if (expressao.operador.tipo === delegua_1.default.E) {
+            if (!this.eVerdadeiro(esquerda))
+                return esquerda;
+        }
+        return await this.avaliar(expressao.direita);
+    }
+    async visitarDeclaracaoPara(declaracao) {
+        const declaracaoInicializador = Array.isArray(declaracao.inicializador)
+            ? declaracao.inicializador[0]
+            : declaracao.inicializador;
+        if (declaracaoInicializador !== null) {
+            await this.avaliar(declaracaoInicializador);
+        }
+        let retornoExecucao;
+        while (!(retornoExecucao instanceof quebras_1.Quebra)) {
+            if (declaracao.condicao !== null && !this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
+                break;
+            }
+            try {
+                retornoExecucao = await this.executar(declaracao.corpo);
+                if (retornoExecucao instanceof quebras_1.SustarQuebra) {
+                    return null;
+                }
+                if (retornoExecucao instanceof quebras_1.ContinuarQuebra) {
+                    retornoExecucao = null;
+                }
+            }
+            catch (erro) {
+                this.erros.push({
+                    erroInterno: erro,
+                    linha: declaracao.linha,
+                    hashArquivo: declaracao.hashArquivo,
+                });
+                return Promise.reject(erro);
+            }
+            if (declaracao.incrementar !== null) {
+                await this.avaliar(declaracao.incrementar);
+            }
+        }
+        return retornoExecucao;
+    }
+    async visitarDeclaracaoParaCada(declaracao) {
+        let retornoExecucao;
+        const vetorResolvido = await this.avaliar(declaracao.vetor);
+        const valorVetorResolvido = vetorResolvido.hasOwnProperty('valor') ? vetorResolvido.valor : vetorResolvido;
+        if (!Array.isArray(valorVetorResolvido)) {
+            return Promise.reject("Variável ou literal provida em instrução 'para cada' não é um vetor.");
+        }
+        while (!(retornoExecucao instanceof quebras_1.Quebra) && declaracao.posicaoAtual < valorVetorResolvido.length) {
+            try {
+                this.pilhaEscoposExecucao.definirVariavel(declaracao.nomeVariavelIteracao, valorVetorResolvido[declaracao.posicaoAtual]);
+                retornoExecucao = await this.executar(declaracao.corpo);
+                if (retornoExecucao instanceof quebras_1.SustarQuebra) {
+                    return null;
+                }
+                if (retornoExecucao instanceof quebras_1.ContinuarQuebra) {
+                    retornoExecucao = null;
+                }
+                declaracao.posicaoAtual++;
+            }
+            catch (erro) {
+                this.erros.push({
+                    erroInterno: erro,
+                    linha: declaracao.linha,
+                    hashArquivo: declaracao.hashArquivo,
+                });
+                return Promise.reject(erro);
+            }
+        }
+        return retornoExecucao;
+    }
+    /**
+     * Executa uma expressão Se, que tem uma condição, pode ter um bloco
+     * Senão, e múltiplos blocos Senão-se.
+     * @param declaracao A declaração Se.
+     * @returns O resultado da avaliação do bloco cuja condição é verdadeira.
+     */
+    async visitarDeclaracaoSe(declaracao) {
+        if (this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
+            return await this.executar(declaracao.caminhoEntao);
+        }
+        for (let i = 0; i < declaracao.caminhosSeSenao.length; i++) {
+            const atual = declaracao.caminhosSeSenao[i];
+            if (this.eVerdadeiro(await this.avaliar(atual.condicao))) {
+                return await this.executar(atual.caminho);
+            }
+        }
+        if (declaracao.caminhoSenao !== null) {
+            return await this.executar(declaracao.caminhoSenao);
+        }
+        return null;
+    }
+    async visitarDeclaracaoEnquanto(declaracao) {
+        let retornoExecucao;
+        while (!(retornoExecucao instanceof quebras_1.Quebra) && this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
+            try {
+                retornoExecucao = await this.executar(declaracao.corpo);
+                if (retornoExecucao instanceof quebras_1.SustarQuebra) {
+                    return null;
+                }
+                if (retornoExecucao instanceof quebras_1.ContinuarQuebra) {
+                    retornoExecucao = null;
+                }
+            }
+            catch (erro) {
+                this.erros.push({
+                    erroInterno: erro,
+                    linha: declaracao.linha,
+                    hashArquivo: declaracao.hashArquivo,
+                });
+                return Promise.reject(erro);
+            }
+        }
+        return retornoExecucao;
+    }
+    async visitarDeclaracaoEscolha(declaracao) {
+        const condicaoEscolha = await this.avaliar(declaracao.identificadorOuLiteral);
+        const valorCondicaoEscolha = condicaoEscolha.hasOwnProperty('valor') ? condicaoEscolha.valor : condicaoEscolha;
+        const caminhos = declaracao.caminhos;
+        const caminhoPadrao = declaracao.caminhoPadrao;
+        let encontrado = false;
+        try {
+            for (let i = 0; i < caminhos.length; i++) {
+                const caminho = caminhos[i];
+                for (let j = 0; j < caminho.condicoes.length; j++) {
+                    const condicaoAvaliada = await this.avaliar(caminho.condicoes[j]);
+                    if (condicaoAvaliada === valorCondicaoEscolha) {
+                        encontrado = true;
+                        try {
+                            await this.executarBloco(caminho.declaracoes);
+                        }
+                        catch (erro) {
+                            this.erros.push({
+                                erroInterno: erro,
+                                linha: declaracao.linha,
+                                hashArquivo: declaracao.hashArquivo,
+                            });
+                            return Promise.reject(erro);
+                        }
+                    }
+                }
+            }
+            if (caminhoPadrao !== null && !encontrado) {
+                await this.executarBloco(caminhoPadrao.declaracoes);
+            }
+        }
+        catch (erro) {
+            this.erros.push({
+                erroInterno: erro,
+                linha: declaracao.linha,
+                hashArquivo: declaracao.hashArquivo,
+            });
+            throw erro;
+        }
+    }
+    async visitarDeclaracaoFazer(declaracao) {
+        let retornoExecucao;
+        do {
+            try {
+                retornoExecucao = await this.executar(declaracao.caminhoFazer);
+                if (retornoExecucao instanceof quebras_1.SustarQuebra) {
+                    return null;
+                }
+                if (retornoExecucao instanceof quebras_1.ContinuarQuebra) {
+                    retornoExecucao = null;
+                }
+            }
+            catch (erro) {
+                this.erros.push({
+                    erroInterno: erro,
+                    linha: declaracao.linha,
+                    hashArquivo: declaracao.hashArquivo,
+                });
+                return Promise.reject(erro);
+            }
+        } while (!(retornoExecucao instanceof quebras_1.Quebra) &&
+            this.eVerdadeiro(await this.avaliar(declaracao.condicaoEnquanto)));
+    }
+    /**
+     * Interpretação de uma declaração `tente`.
+     * @param declaracao O objeto da declaração.
+     */
+    async visitarDeclaracaoTente(declaracao) {
+        let valorRetorno;
+        try {
+            this.emDeclaracaoTente = true;
+            try {
+                valorRetorno = await this.executarBloco(declaracao.caminhoTente);
+            }
+            catch (erro) {
+                if (declaracao.caminhoPegue !== null) {
+                    // `caminhoPegue` aqui pode ser um construto de função (se `pegue` tem parâmetros)
+                    // ou um vetor de `Declaracao` (`pegue` sem parâmetros).
+                    // As execuções, portanto, são diferentes.
+                    if (Array.isArray(declaracao.caminhoPegue)) {
+                        valorRetorno = await this.executarBloco(declaracao.caminhoPegue);
+                    }
+                    else {
+                        const literalErro = new construtos_1.Literal(declaracao.hashArquivo, Number(declaracao.linha), erro.mensagem);
+                        const chamadaPegue = new construtos_1.Chamada(declaracao.caminhoPegue.hashArquivo, declaracao.caminhoPegue, null, [literalErro]);
+                        valorRetorno = await chamadaPegue.aceitar(this);
+                    }
+                }
+            }
+        }
+        finally {
+            if (declaracao.caminhoFinalmente !== null)
+                valorRetorno = await this.executarBloco(declaracao.caminhoFinalmente);
+            this.emDeclaracaoTente = false;
+        }
+        return valorRetorno;
+    }
+    async visitarDeclaracaoImportar(declaracao) {
+        return Promise.reject('Importação de arquivos não suportada por Interpretador Base.');
+    }
+    async avaliarArgumentosEscreva(argumentos) {
+        let formatoTexto = '';
+        for (const argumento of argumentos) {
+            const resultadoAvaliacao = await this.avaliar(argumento);
+            let valor = (resultadoAvaliacao === null || resultadoAvaliacao === void 0 ? void 0 : resultadoAvaliacao.hasOwnProperty('valor')) ? resultadoAvaliacao.valor : resultadoAvaliacao;
+            formatoTexto += `${this.paraTexto(valor)} `;
+        }
+        return formatoTexto.trimEnd();
+    }
+    /**
+     * Execução de uma escrita na saída padrão, sem quebras de linha.
+     * Implementada para alguns dialetos, como VisuAlg.
+     * @param declaracao A declaração.
+     * @returns Sempre nulo, por convenção de visita.
+     */
+    async visitarDeclaracaoEscrevaMesmaLinha(declaracao) {
+        try {
+            const formatoTexto = await this.avaliarArgumentosEscreva(declaracao.argumentos);
+            this.funcaoDeRetornoMesmaLinha(formatoTexto);
+            return null;
+        }
+        catch (erro) {
+            this.erros.push({
+                erroInterno: erro,
+                linha: declaracao.linha,
+                hashArquivo: declaracao.hashArquivo,
+            });
+        }
+    }
+    /**
+     * Execução de uma escrita na saída configurada, que pode ser `console` (padrão) ou
+     * alguma função para escrever numa página Web.
+     * @param declaracao A declaração.
+     * @returns Sempre nulo, por convenção de visita.
+     */
+    async visitarDeclaracaoEscreva(declaracao) {
+        try {
+            const formatoTexto = await this.avaliarArgumentosEscreva(declaracao.argumentos);
+            this.funcaoDeRetorno(formatoTexto);
+            return null;
+        }
+        catch (erro) {
+            this.erros.push({
+                erroInterno: erro,
+                linha: declaracao.linha,
+                hashArquivo: declaracao.hashArquivo,
+            });
+        }
+    }
+    /**
+     * Empilha declarações na pilha de escopos de execução, cria um novo ambiente e
+     * executa as declarações empilhadas.
+     * Se o retorno do último bloco foi uma exceção (normalmente um erro em tempo de execução),
+     * atira a exceção daqui.
+     * Isso é usado, por exemplo, em blocos tente ... pegue ... finalmente.
+     * @param declaracoes Um vetor de declaracoes a ser executado.
+     * @param ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
+     */
+    async executarBloco(declaracoes, ambiente) {
+        const escopoExecucao = {
+            declaracoes: declaracoes,
+            declaracaoAtual: 0,
+            ambiente: ambiente || new espaco_variaveis_1.EspacoVariaveis(),
+            finalizado: false,
+            tipo: 'outro',
+            emLacoRepeticao: false,
+        };
+        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
+        const retornoUltimoEscopo = await this.executarUltimoEscopo();
+        if (retornoUltimoEscopo instanceof excecoes_1.ErroEmTempoDeExecucao) {
+            return Promise.reject(retornoUltimoEscopo);
+        }
+        return retornoUltimoEscopo;
+    }
+    async visitarExpressaoBloco(declaracao) {
+        return await this.executarBloco(declaracao.declaracoes);
+    }
+    async avaliacaoDeclaracaoVarOuConst(declaracao) {
+        let valorOuOutraVariavel = null;
+        if (declaracao.inicializador !== null) {
+            valorOuOutraVariavel = await this.avaliar(declaracao.inicializador);
+        }
+        let valorFinal = null;
+        if (valorOuOutraVariavel !== null && valorOuOutraVariavel !== undefined) {
+            valorFinal = valorOuOutraVariavel.hasOwnProperty('valor')
+                ? valorOuOutraVariavel.valor
+                : valorOuOutraVariavel;
+        }
+        return valorFinal;
+    }
+    /**
+     * Executa expressão de definição de constante.
+     * @param declaracao A declaração `Const`.
+     * @returns Sempre retorna nulo.
+     */
+    async visitarDeclaracaoConst(declaracao) {
+        const valorFinal = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
+        this.pilhaEscoposExecucao.definirConstante(declaracao.simbolo.lexema, valorFinal, declaracao.tipo);
+        return null;
+    }
+    /**
+     * Executa expressão de definição de múltiplas constantes.
+     * @param declaracao A declaração `ConstMultiplo`.
+     * @returns Sempre retorna nulo.
+     */
+    async visitarDeclaracaoConstMultiplo(declaracao) {
+        const valoresFinais = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
+        for (let [indice, valor] of valoresFinais.entries()) {
+            this.pilhaEscoposExecucao.definirConstante(declaracao.simbolos[indice].lexema, valor, declaracao.tipo);
+        }
+        return null;
+    }
+    visitarExpressaoContinua(declaracao) {
+        return new quebras_1.ContinuarQuebra();
+    }
+    visitarExpressaoSustar(declaracao) {
+        return new quebras_1.SustarQuebra();
+    }
+    async visitarExpressaoRetornar(declaracao) {
+        let valor = null;
+        if (declaracao.valor != null)
+            valor = await this.avaliar(declaracao.valor);
+        return new quebras_1.RetornoQuebra(valor);
+    }
+    async visitarExpressaoDeleguaFuncao(corpoDeclaracao) {
+        return new estruturas_1.DeleguaFuncao(null, corpoDeclaracao);
+    }
+    async visitarExpressaoAtribuicaoPorIndice(expressao) {
+        const promises = await Promise.all([
+            this.avaliar(expressao.objeto),
+            this.avaliar(expressao.indice),
+            this.avaliar(expressao.valor),
+        ]);
+        let objeto = promises[0];
+        let indice = promises[1];
+        const valor = promises[2];
+        if (objeto.tipo === delegua_2.default.TUPLA) {
+            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.simbolo.lexema, 'Não é possível modificar uma tupla. As tuplas são estruturas de dados imutáveis.', expressao.linha));
+        }
+        objeto = objeto.hasOwnProperty('valor') ? objeto.valor : objeto;
+        indice = indice.hasOwnProperty('valor') ? indice.valor : indice;
+        if (Array.isArray(objeto)) {
+            if (indice < 0 && objeto.length !== 0) {
+                while (indice < 0) {
+                    indice += objeto.length;
+                }
+            }
+            while (objeto.length < indice) {
+                objeto.push(null);
+            }
+            objeto[indice] = valor;
+        }
+        else if (objeto.constructor === Object ||
+            objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
+            objeto instanceof estruturas_1.DeleguaFuncao ||
+            objeto instanceof estruturas_1.DescritorTipoClasse ||
+            objeto instanceof estruturas_1.DeleguaModulo) {
+            objeto[indice] = valor;
+        }
+        else {
+            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha));
+        }
+    }
+    async visitarExpressaoAcessoIndiceVariavel(expressao) {
+        const promises = await Promise.all([this.avaliar(expressao.entidadeChamada), this.avaliar(expressao.indice)]);
+        const variavelObjeto = promises[0];
+        const indice = promises[1];
+        const objeto = variavelObjeto.hasOwnProperty('valor') ? variavelObjeto.valor : variavelObjeto;
+        let valorIndice = indice.hasOwnProperty('valor') ? indice.valor : indice;
+        if (Array.isArray(objeto)) {
+            if (!Number.isInteger(valorIndice)) {
+                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha));
+            }
+            if (valorIndice < 0 && objeto.length !== 0) {
+                while (valorIndice < 0) {
+                    valorIndice += objeto.length;
+                }
+            }
+            if (valorIndice >= objeto.length) {
+                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice do vetor fora do intervalo.', expressao.linha));
+            }
+            return objeto[valorIndice];
+        }
+        if (objeto instanceof construtos_1.Vetor) {
+            return objeto.valores[valorIndice];
+        }
+        if (objeto.constructor === Object ||
+            objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
+            objeto instanceof estruturas_1.DeleguaFuncao ||
+            objeto instanceof estruturas_1.DescritorTipoClasse ||
+            objeto instanceof estruturas_1.DeleguaModulo) {
+            return objeto[valorIndice] || null;
+        }
+        if (typeof objeto === primitivos_1.default.TEXTO) {
+            if (!Number.isInteger(valorIndice)) {
+                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha));
+            }
+            if (valorIndice < 0 && objeto.length !== 0) {
+                while (valorIndice < 0) {
+                    valorIndice += objeto.length;
+                }
+            }
+            if (valorIndice >= objeto.length) {
+                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice fora do tamanho.', expressao.linha));
+            }
+            return objeto.charAt(valorIndice);
+        }
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.entidadeChamada.nome, 'Somente listas, dicionários, classes e objetos podem ter seus valores indexados.', expressao.linha));
+    }
+    async visitarExpressaoDefinirValor(expressao) {
+        const variavelObjeto = await this.avaliar(expressao.objeto);
+        const objeto = variavelObjeto.hasOwnProperty('valor') ? variavelObjeto.valor : variavelObjeto;
+        if (objeto.constructor.name !== 'ObjetoDeleguaClasse' && objeto.constructor !== Object) {
+            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.nome, 'Somente instâncias e dicionários podem possuir campos.', expressao.linha));
+        }
+        const valor = await this.avaliar(expressao.valor);
+        if (objeto.constructor.name === 'ObjetoDeleguaClasse') {
+            objeto.definir(expressao.nome, valor);
+            return valor;
+        }
+        if (objeto.constructor === Object) {
+            objeto[expressao.nome.lexema] = valor;
+        }
+    }
+    visitarDeclaracaoDefinicaoFuncao(declaracao) {
+        const funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
+        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, funcao);
+    }
+    /**
+     * Executa uma declaração de classe.
+     * Uma variável do tipo `DeleguaClasse` é adicionada à pilha de escopos de execução.
+     * @param declaracao A declaração de classe.
+     * @returns Sempre retorna nulo, por ser requerido pelo contrato de visita.
+     */
+    async visitarDeclaracaoClasse(declaracao) {
+        let superClasse = null;
+        if (declaracao.superClasse !== null && declaracao.superClasse !== undefined) {
+            const variavelSuperClasse = await this.avaliar(declaracao.superClasse);
+            superClasse = variavelSuperClasse.valor;
+            if (!(superClasse instanceof estruturas_1.DescritorTipoClasse)) {
+                throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.superClasse.nome, 'Superclasse precisa ser uma classe.', declaracao.linha);
+            }
+        }
+        // TODO: Precisamos disso?
+        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, declaracao);
+        if (declaracao.superClasse !== null && declaracao.superClasse !== undefined) {
+            this.pilhaEscoposExecucao.definirVariavel('super', superClasse);
+        }
+        const metodos = {};
+        const definirMetodos = declaracao.metodos;
+        for (let i = 0; i < declaracao.metodos.length; i++) {
+            const metodoAtual = definirMetodos[i];
+            const eInicializador = metodoAtual.simbolo.lexema === 'construtor';
+            const funcao = new estruturas_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, undefined, eInicializador);
+            metodos[metodoAtual.simbolo.lexema] = funcao;
+        }
+        const descritorTipoClasse = new estruturas_1.DescritorTipoClasse(declaracao.simbolo, superClasse, metodos, declaracao.propriedades);
+        descritorTipoClasse.dialetoRequerExpansaoPropriedadesEspacoVariaveis =
+            this.expandirPropriedadesDeObjetosEmEspacoVariaveis;
+        descritorTipoClasse.dialetoRequerDeclaracaoPropriedades = this.requerDeclaracaoPropriedades;
+        // TODO: Recolocar isso se for necessário.
+        /* if (superClasse !== null) {
+            this.ambiente = this.ambiente.enclosing;
+        } */
+        this.pilhaEscoposExecucao.atribuirVariavel(declaracao.simbolo, descritorTipoClasse);
+        return null;
+    }
+    /**
+     * Executa um acesso a método, normalmente de um objeto de classe.
+     * @param {AcessoMetodoOuPropriedade} expressao A expressão de acesso.
+     * @returns O resultado da execução.
+     */
+    async visitarExpressaoAcessoMetodo(expressao) {
+        let variavelObjeto = await this.avaliar(expressao.objeto);
+        // Este caso acontece quando há encadeamento de métodos.
+        // Por exemplo, `objeto1.metodo1().metodo2()`.
+        // Como `RetornoQuebra` também possui `valor`, precisamos extrair o
+        // valor dele primeiro.
+        if (variavelObjeto.constructor.name === 'RetornoQuebra') {
+            variavelObjeto = variavelObjeto.valor;
+        }
+        const objeto = variavelObjeto.hasOwnProperty('valor') ? variavelObjeto.valor : variavelObjeto;
+        // Outro caso que `instanceof` simplesmente não funciona para casos em Liquido,
+        // então testamos também o nome do construtor.
+        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse || objeto.constructor.name === 'ObjetoDeleguaClasse') {
+            return objeto.obter(expressao.simbolo) || null;
+        }
+        // Objeto simples do JavaScript, ou dicionário de Delégua.
+        if (objeto.constructor === Object) {
+            const metodoDePrimitivaDicionario = primitivas_dicionario_1.default[expressao.simbolo.lexema];
+            if (metodoDePrimitivaDicionario) {
+                return new metodo_primitiva_1.MetodoPrimitiva(objeto, metodoDePrimitivaDicionario);
+            }
+            return objeto[expressao.simbolo.lexema] || null;
+        }
+        // Casos em que o objeto possui algum outro tipo que não o de objeto simples.
+        // Normalmente executam quando uma biblioteca é importada, e estamos tentando
+        // obter alguma propriedade ou método desse objeto.
+        // Caso 1: Função tradicional do JavaScript.
+        if (typeof objeto[expressao.simbolo.lexema] === primitivos_1.default.FUNCAO) {
+            return objeto[expressao.simbolo.lexema];
+        }
+        // Caso 2: Objeto tradicional do JavaScript.
+        if (typeof objeto[expressao.simbolo.lexema] === primitivos_1.default.OBJETO) {
+            return objeto[expressao.simbolo.lexema];
+        }
+        // A partir daqui, presume-se que o objeto é uma das estruturas
+        // de Delégua.
+        if (objeto instanceof estruturas_1.DeleguaModulo) {
+            return objeto.componentes[expressao.simbolo.lexema] || null;
+        }
+        let tipoObjeto = variavelObjeto.tipo;
+        if (tipoObjeto === null || tipoObjeto === undefined) {
+            tipoObjeto = (0, inferenciador_1.inferirTipoVariavel)(variavelObjeto);
+        }
+        // Como internamente um dicionário de Delégua é simplesmente um objeto de
+        // JavaScript, as primitivas de dicionário, especificamente, são tratadas
+        // mais acima.
+        switch (tipoObjeto) {
+            case delegua_2.default.INTEIRO:
+            case delegua_2.default.NUMERO:
+            case delegua_2.default.NÚMERO:
+                const metodoDePrimitivaNumero = primitivas_numero_1.default[expressao.simbolo.lexema];
+                if (metodoDePrimitivaNumero) {
+                    return new metodo_primitiva_1.MetodoPrimitiva(objeto, metodoDePrimitivaNumero);
+                }
+                break;
+            case delegua_2.default.TEXTO:
+                const metodoDePrimitivaTexto = primitivas_texto_1.default[expressao.simbolo.lexema];
+                if (metodoDePrimitivaTexto) {
+                    return new metodo_primitiva_1.MetodoPrimitiva(objeto, metodoDePrimitivaTexto);
+                }
+                break;
+            case delegua_2.default.VETOR:
+                const metodoDePrimitivaVetor = primitivas_vetor_1.default[expressao.simbolo.lexema];
+                if (metodoDePrimitivaVetor) {
+                    return new metodo_primitiva_1.MetodoPrimitiva(objeto, metodoDePrimitivaVetor);
+                }
+                break;
+        }
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, `Método para objeto ou primitiva não encontrado: ${expressao.simbolo.lexema}.`, expressao.linha));
+    }
+    visitarExpressaoIsto(expressao) {
+        return this.procurarVariavel(expressao.palavraChave);
+    }
+    visitarDeclaracaoAleatorio(declaracao) {
+        return Promise.resolve();
+    }
+    async visitarExpressaoDicionario(expressao) {
+        const dicionario = {};
+        for (let i = 0; i < expressao.chaves.length; i++) {
+            const promises = await Promise.all([this.avaliar(expressao.chaves[i]), this.avaliar(expressao.valores[i])]);
+            dicionario[promises[0]] = promises[1];
+        }
+        return dicionario;
+    }
+    async visitarExpressaoVetor(expressao) {
+        const valores = [];
+        for (let i = 0; i < expressao.valores.length; i++) {
+            valores.push(await this.avaliar(expressao.valores[i]));
+        }
+        return valores;
+    }
+    visitarExpressaoSuper(expressao) {
+        const superClasse = this.pilhaEscoposExecucao.obterVariavelPorNome('super');
+        const objeto = this.pilhaEscoposExecucao.obterVariavelPorNome('isto');
+        const metodo = superClasse.valor.encontrarMetodo(expressao.metodo.lexema);
+        if (metodo === undefined) {
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.metodo, 'Método chamado indefinido.', expressao.linha);
+        }
+        metodo.instancia = objeto.valor;
+        return metodo;
+    }
+    /**
+     * Executa expressão de definição de variável.
+     * @param declaracao A declaração Var
+     * @returns Sempre retorna nulo.
+     */
+    async visitarDeclaracaoVar(declaracao) {
+        const valorFinal = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
+        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valorFinal, declaracao.tipo);
+        return null;
+    }
+    /**
+     * Executa expressão de definição de múltiplas variáveis.
+     * @param declaracao A declaração `VarMultiplo`.
+     * @returns Sempre retorna nulo.
+     */
+    async visitarDeclaracaoVarMultiplo(declaracao) {
+        const valoresFinais = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
+        for (let [indice, valor] of valoresFinais.entries()) {
+            this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolos[indice].lexema, valor, declaracao.tipo);
+        }
+        return null;
+    }
+    paraTexto(objeto) {
+        if (objeto === null || objeto === undefined)
+            return delegua_2.default.NULO;
+        if (typeof objeto === primitivos_1.default.BOOLEANO) {
+            return objeto ? 'verdadeiro' : 'falso';
+        }
+        if (objeto instanceof quebras_1.RetornoQuebra) {
+            if (typeof objeto.valor === 'boolean')
+                return objeto.valor ? 'verdadeiro' : 'falso';
+        }
+        if (objeto instanceof Date) {
+            const formato = Intl.DateTimeFormat('pt', {
+                dateStyle: 'full',
+                timeStyle: 'full',
+            });
+            return formato.format(objeto);
+        }
+        if (Array.isArray(objeto)) {
+            let retornoVetor = '[';
+            for (let elemento of objeto) {
+                retornoVetor += typeof elemento === 'string' ? `'${elemento}', ` : `${this.paraTexto(elemento)}, `;
+            }
+            if (retornoVetor.length > 1) {
+                retornoVetor = retornoVetor.slice(0, -2);
+            }
+            retornoVetor += ']';
+            return retornoVetor;
+        }
+        if (objeto.valor instanceof estruturas_1.ObjetoPadrao)
+            return objeto.valor.paraTexto();
+        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse || objeto instanceof estruturas_1.DeleguaFuncao)
+            return objeto.paraTexto();
+        switch (objeto.constructor.name) {
+            case 'Object':
+                if ('tipo' in objeto) {
+                    switch (objeto.tipo) {
+                        case 'dicionário':
+                            return JSON.stringify(objeto.valor);
+                        default:
+                            return objeto.valor;
+                    }
+                }
+        }
+        if (typeof objeto === primitivos_1.default.OBJETO) {
+            for (const obj in objeto) {
+                let valor = objeto[obj];
+                if (typeof valor === primitivos_1.default.BOOLEANO) {
+                    valor = valor ? 'verdadeiro' : 'falso';
+                    objeto[obj] = valor;
+                }
+            }
+            return JSON.stringify(objeto);
+        }
+        return objeto.toString();
+    }
+    /**
+     * Efetivamente executa uma declaração.
+     * @param declaracao A declaração a ser executada.
+     * @param mostrarResultado Se resultado deve ser mostrado ou não. Normalmente usado
+     *                         pelo modo LAIR.
+     */
+    async executar(declaracao, mostrarResultado = false) {
+        const resultado = await declaracao.aceitar(this);
+        /* console.log("Resultado aceitar: " + resultado, this); */
+        if (mostrarResultado) {
+            this.funcaoDeRetorno(this.paraTexto(resultado));
+        }
+        if (resultado || typeof resultado === primitivos_1.default.BOOLEANO) {
+            this.resultadoInterpretador.push(this.paraTexto(resultado));
+        }
+        return resultado;
+    }
+    /**
+     * Executa o último escopo empilhado no topo na pilha de escopos do interpretador.
+     * Esse método pega exceções, mas apenas as devolve.
+     *
+     * O tratamento das exceções é feito de acordo com o bloco chamador.
+     * Por exemplo, em `tente ... pegue ... finalmente`, a exceção é capturada e tratada.
+     * Em outros blocos, pode ser desejável ter o erro em tela.
+     * @param manterAmbiente Se verdadeiro, ambiente do topo da pilha de escopo é copiado para o ambiente imediatamente abaixo.
+     * @returns O resultado da execução do escopo, se houver.
+     */
+    async executarUltimoEscopo(manterAmbiente = false) {
+        const ultimoEscopo = this.pilhaEscoposExecucao.topoDaPilha();
+        try {
+            let retornoExecucao;
+            for (; !(retornoExecucao instanceof quebras_1.Quebra) && ultimoEscopo.declaracaoAtual < ultimoEscopo.declaracoes.length; ultimoEscopo.declaracaoAtual++) {
+                retornoExecucao = await this.executar(ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual]);
+            }
+            return retornoExecucao;
+        }
+        catch (erro) {
+            const declaracaoAtual = ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual];
+            if (!this.emDeclaracaoTente) {
+                this.erros.push({
+                    erroInterno: erro,
+                    linha: declaracaoAtual.linha,
+                    hashArquivo: declaracaoAtual.hashArquivo,
+                });
+            }
+            return Promise.reject(erro);
+        }
+        finally {
+            this.pilhaEscoposExecucao.removerUltimo();
+            const escopoAnterior = this.pilhaEscoposExecucao.topoDaPilha();
+            if (manterAmbiente) {
+                escopoAnterior.ambiente.valores = Object.assign(escopoAnterior.ambiente.valores, ultimoEscopo.ambiente.valores);
+            }
+        }
+    }
+    /**
+     * Interpretação sem depurador, com medição de performance.
+     * Método que efetivamente inicia o processo de interpretação.
+     * @param declaracoes Um vetor de declarações gerado pelo Avaliador Sintático.
+     * @param manterAmbiente Se ambiente de execução (variáveis, classes, etc.) deve ser mantido. Normalmente usado
+     *                       pelo modo REPL (LAIR).
+     * @returns Um objeto com o resultado da interpretação.
+     */
+    async interpretar(declaracoes, manterAmbiente = false) {
+        this.erros = [];
+        this.emDeclaracaoTente = false;
+        const escopoExecucao = {
+            declaracoes: declaracoes,
+            declaracaoAtual: 0,
+            ambiente: new espaco_variaveis_1.EspacoVariaveis(),
+            finalizado: false,
+            tipo: 'outro',
+            emLacoRepeticao: false,
+        };
+        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
+        const inicioInterpretacao = (0, browser_process_hrtime_1.default)();
+        try {
+            const retornoOuErro = await this.executarUltimoEscopo(manterAmbiente);
+            if (retornoOuErro instanceof excecoes_1.ErroEmTempoDeExecucao) {
+                this.erros.push(retornoOuErro);
+            }
+        }
+        catch (erro) {
+            this.erros.push({
+                erroInterno: erro,
+                linha: -1,
+                hashArquivo: -1,
+            });
+        }
+        finally {
+            if (this.performance) {
+                const deltaInterpretacao = (0, browser_process_hrtime_1.default)(inicioInterpretacao);
+                console.log(`[Interpretador] Tempo para interpretaçao: ${deltaInterpretacao[0] * 1e9 + deltaInterpretacao[1]}ns`);
+            }
+            const retorno = {
+                erros: this.erros,
+                resultado: this.resultadoInterpretador,
+            };
+            this.resultadoInterpretador = [];
+            return retorno;
+        }
+    }
+}
+exports.InterpretadorBase = InterpretadorBase;
 //# sourceMappingURL=interpretador-base.js.map