@designliquido/delegua 1.23.3 → 1.23.5

package/umd/delegua.js

@@ -712,9 +712,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
     }
     async visitarExpressaoDeChamada(expressao) {
         for (const argumento of expressao.argumentos) {
-            if (argumento instanceof construtos_1.Variavel) {
-                this.gerenciadorEscopos.marcarComoUsada(argumento.simbolo.lexema);
-            }
+            this.marcarVariaveisUsadasEmExpressao(argumento);
         }
         switch (expressao.entidadeChamada.constructor) {
             case construtos_1.AcessoMetodo:
@@ -2247,15 +2245,26 @@ class AvaliadorSintaticoBase {
     declaracaoDeVariaveis() {
         throw new Error('Método não implementado.');
     }
-    async comparar() {
-        let expressao = await this.adicaoOuSubtracao();
+    validacaoComparacao(operador, esquerda, direita) { }
+    criarConstrutoComparacao(esquerda, operador, direita) {
+        return new construtos_1.Binario(this.hashArquivo, esquerda, operador, direita);
+    }
+    async logicaComumComparacao(metodoProximoNivel) {
+        let expressao = await metodoProximoNivel();
         while (this.verificarSeSimboloAtualEIgualA(comum_1.default.MAIOR, comum_1.default.MAIOR_IGUAL, comum_1.default.MENOR, comum_1.default.MENOR_IGUAL)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = await this.adicaoOuSubtracao();
-            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+            const operador = this.simboloAnterior
+                ? this.simboloAnterior()
+                : this.simbolos[this.atual - 1];
+            const esquerda = expressao;
+            const direita = await metodoProximoNivel();
+            this.validacaoComparacao(operador, esquerda, direita);
+            expressao = this.criarConstrutoComparacao(esquerda, operador, direita);
         }
         return expressao;
     }
+    async comparar() {
+        return await this.logicaComumComparacao(() => this.adicaoOuSubtracao());
+    }
     async comparacaoIgualdade() {
         let expressao = await this.comparar();
         while (this.verificarSeSimboloAtualEIgualA(comum_1.default.DIFERENTE, comum_1.default.IGUAL, comum_1.default.IGUAL_IGUAL)) {
@@ -2775,7 +2784,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 this.avancarEDevolverAnterior();
                 valores = [];
                 if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.COLCHETE_DIREITO)) {
-                    return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), [], 'qualquer[]');
+                    return new construtos_1.Vetor(this.hashArquivo, simboloAtual.linha, [], 'qualquer[]');
                 }
                 if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO)) {
                     return this.construtoTupla();
@@ -2810,21 +2819,34 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 const valoresSemComentarios = valores.filter((v) => v.constructor !== construtos_1.ComentarioComoConstruto);
                 let elementoSeparador = false; // O primeiro elemento não pode ser separador.
                 for (const elemento of valoresSemComentarios) {
+                    const simboloErro = elemento.simbolo || simboloAtual;
                     if (elementoSeparador) {
                         if (elemento.constructor !== construtos_1.Separador) {
-                            throw this.erro(elemento.simbolo, 'Não podem haver duas vírgulas seguidas em uma definição de vetor, ou definição de vetor começando em vírgula.');
+                            throw this.erro(simboloErro, 'Os itens dos vetores devem ser separados através de uma vírgula.');
                         }
                         elementoSeparador = false;
                     }
                     else {
                         if (elemento.constructor === construtos_1.Separador) {
-                            throw this.erro(elemento.simbolo, 'Não podem haver duas vírgulas seguidas em uma definição de vetor, ou definição de vetor começando em vírgula.');
+                            throw this.erro(simboloErro, 'Não podem haver duas vírgulas seguidas em uma definição de vetor, ou definição de vetor começando em vírgula.');
                         }
                         elementoSeparador = true;
                     }
                 }
                 const valoresSemSeparadores = valoresSemComentarios.filter((v) => v.constructor !== construtos_1.Separador);
-                const tipoVetor = (0, inferenciador_1.inferirTipoVariavel)(valoresSemSeparadores);
+                let tipoVetor;
+                if (valoresSemSeparadores.length === 0) {
+                    tipoVetor = 'qualquer[]';
+                }
+                else {
+                    const primeiroElemento = valoresSemSeparadores[0];
+                    if (primeiroElemento instanceof construtos_1.Vetor) {
+                        tipoVetor = primeiroElemento.tipo + '[]';
+                    }
+                    else {
+                        tipoVetor = (0, inferenciador_1.inferirTipoVariavel)(valoresSemSeparadores);
+                    }
+                }
                 return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), valores, tipoVetor);
             case delegua_2.default.ENQUANTO:
                 this.avancarEDevolverAnterior();
@@ -3509,16 +3531,14 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         return expressao;
     }
+    validacaoComparacao(operador, esquerda, direita) {
+        this.verificarOperandosComparacao(operador, esquerda, direita);
+    }
+    criarConstrutoComparacao(esquerda, operador, direita) {
+        return new construtos_1.Binario(this.hashArquivo, esquerda, operador, direita);
+    }
     async comparar() {
-        let expressao = await this.bitOu();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.MAIOR, delegua_2.default.MAIOR_IGUAL, delegua_2.default.MENOR, delegua_2.default.MENOR_IGUAL)) {
-            const operador = this.simbolos[this.atual - 1];
-            const esquerda = expressao;
-            const direito = await this.bitOu();
-            this.verificarOperandosComparacao(operador, esquerda, direito);
-            expressao = new construtos_1.Binario(this.hashArquivo, esquerda, operador, direito);
-        }
-        return expressao;
+        return await this.logicaComumComparacao(() => this.bitOu());
     }
     async comparacaoIgualdade() {
         let expressao = await this.comparar();
@@ -4241,17 +4261,28 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         switch (inicializador.constructor) {
             case construtos_1.AcessoIndiceVariavel:
-                const entidadeChamadaAcessoIndiceVariavel = inicializador
-                    .entidadeChamada;
-                // Este condicional ocorre com chamadas aninhadas. Por exemplo, `vetor[1][2]`.
-                if (entidadeChamadaAcessoIndiceVariavel.constructor === construtos_1.AcessoIndiceVariavel) {
-                    return this.logicaComumInferenciaTiposVariaveisEConstantes(entidadeChamadaAcessoIndiceVariavel, tipo);
-                }
-                const tipoEntidadeChamadaAcessoIndiceVariavel = entidadeChamadaAcessoIndiceVariavel.tipo;
-                if (tipoEntidadeChamadaAcessoIndiceVariavel.endsWith('[]')) {
-                    return tipoEntidadeChamadaAcessoIndiceVariavel.slice(0, -2);
+                const acessoAtual = inicializador;
+                let entidade = acessoAtual.entidadeChamada;
+                let numeroIndices = 1;
+                // Percorre a cadeia de acessos aninhados para contar quantos índices existem
+                // Cada índice consome um nível de vetor, então removemos um '[]' por acesso.
+                while (entidade.constructor === construtos_1.AcessoIndiceVariavel) {
+                    numeroIndices++;
+                    entidade = entidade
+                        .entidadeChamada;
+                }
+                const tipoBase = entidade.tipo;
+                if (tipoBase.endsWith('[]')) {
+                    let tipoResultante = tipoBase;
+                    for (let i = 0; i < numeroIndices; i++) {
+                        if (tipoResultante.endsWith('[]')) {
+                            tipoResultante = tipoResultante.slice(0, -2);
+                        }
+                        else
+                            break;
+                    }
+                    return tipoResultante;
                 }
-                // Normalmente, `entidadeChamadaAcessoIndiceVariavel.tipo` aqui será 'vetor'.
                 return 'qualquer';
             case construtos_1.Chamada:
                 const entidadeChamadaChamada = inicializador.entidadeChamada;
@@ -6312,6 +6343,7 @@ const primitivas_numero_1 = __importDefault(require("../../bibliotecas/primitiva
 const primitivas_texto_1 = __importDefault(require("../../bibliotecas/primitivas-texto"));
 const primitivas_vetor_1 = __importDefault(require("../../bibliotecas/primitivas-vetor"));
 const primitivas_tupla_1 = __importDefault(require("../../bibliotecas/dialetos/pitugues/primitivas-tupla"));
+const avaliador_sintatico_base_1 = require("../avaliador-sintatico-base");
 /**
  * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
  * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
@@ -6320,8 +6352,9 @@ const primitivas_tupla_1 = __importDefault(require("../../bibliotecas/dialetos/p
  * A grande diferença entre este avaliador e os demais é a forma como são entendidos os blocos de escopo.
  * Este avaliador espera uma estrutura de pragmas, que explica quantos espaços há na frente de cada linha.
  */
-class AvaliadorSintaticoPitugues {
+class AvaliadorSintaticoPitugues extends avaliador_sintatico_base_1.AvaliadorSintaticoBase {
     constructor(performance = false) {
+        super();
         this.atual = 0;
         this.blocos = 0;
         this.performance = performance;
@@ -6374,14 +6407,27 @@ class AvaliadorSintaticoPitugues {
             return tipoPrevio;
         switch (inicializador.constructor) {
             case construtos_1.AcessoIndiceVariavel:
-                const entidadeChamadaAcessoIndiceVariavel = inicializador
-                    .entidadeChamada;
-                // Este condicional ocorre com chamadas aninhadas. Por exemplo, `vetor[1][2]`.
-                if (entidadeChamadaAcessoIndiceVariavel.constructor === construtos_1.AcessoIndiceVariavel) {
-                    return this.logicaComumInferenciaTiposVariaveisEConstantes(entidadeChamadaAcessoIndiceVariavel, tipoPrevio);
-                }
-                if (entidadeChamadaAcessoIndiceVariavel.tipo.endsWith('[]')) {
-                    return entidadeChamadaAcessoIndiceVariavel.tipo.slice(0, -2);
+                const acessoAtual = inicializador;
+                let entidade = acessoAtual.entidadeChamada;
+                let numeroIndices = 1;
+                // Percorre acessos aninhados como `vetor[1][2]` contando quantos índices foram aplicados.
+                // Cada índice consome um nível de vetor, então removemos um '[]' por acesso.
+                while (entidade.constructor === construtos_1.AcessoIndiceVariavel) {
+                    numeroIndices++;
+                    entidade = entidade
+                        .entidadeChamada;
+                }
+                const tipoBase = entidade.tipo;
+                if (tipoBase.endsWith('[]')) {
+                    let tipoResultante = tipoBase;
+                    for (let i = 0; i < numeroIndices; i++) {
+                        if (tipoResultante.endsWith('[]')) {
+                            tipoResultante = tipoResultante.slice(0, -2);
+                        }
+                        else
+                            break;
+                    }
+                    return tipoResultante;
                 }
                 // Normalmente, `entidadeChamadaAcessoIndiceVariavel.tipo` aqui será 'vetor'.
                 return 'qualquer';
@@ -6807,6 +6853,9 @@ class AvaliadorSintaticoPitugues {
                 if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.COLCHETE_DIREITO)) {
                     return new construtos_1.Vetor(this.hashArquivo, simboloAtual.linha, [], 'qualquer[]');
                 }
+                if (this.verificarTipoSimboloAtual(pitugues_2.default.VIRGULA)) {
+                    throw this.erro(this.simboloAtual(), 'Não podem haver duas vírgulas seguidas em uma definição de vetor, ou definição de vetor começando em vírgula.');
+                }
                 // Ao resolver a expressão aqui, identificadores dentro da expressão de compreensão
                 // de lista serão tratados como 'qualquer', para evitar erros de tipo.
                 this.intuirTipoQualquerParaIdentificadores = true;
@@ -6817,13 +6866,35 @@ class AvaliadorSintaticoPitugues {
                 }
                 // Aqui já sabemos que não é uma compreensão de lista.
                 const valoresVetor = [retornoExpressaoOuPrimeiroValor];
+                this.ignorarComentarios();
                 while (!this.verificarSeSimboloAtualEIgualA(pitugues_2.default.COLCHETE_DIREITO)) {
-                    this.consumir(pitugues_2.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
-                    this.ignorarComentarios();
-                    valoresVetor.push(await this.atribuir());
-                    this.ignorarComentarios();
+                    if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA)) {
+                        this.ignorarComentarios();
+                        if (this.verificarTipoSimboloAtual(pitugues_2.default.VIRGULA)) {
+                            throw this.erro(this.simboloAtual(), 'Não podem haver duas vírgulas seguidas em uma definição de vetor, ou definição de vetor começando em vírgula.');
+                        }
+                    }
+                    else {
+                        throw this.erro(this.simboloAtual() || simboloAtual, 'Os itens dos vetores devem ser separados através de uma vírgula.');
+                    }
+                    if (!this.verificarTipoSimboloAtual(pitugues_2.default.COLCHETE_DIREITO)) {
+                        valoresVetor.push(await this.atribuir());
+                        this.ignorarComentarios();
+                    }
+                }
+                let tipoVetor;
+                if (valoresVetor.length === 0) {
+                    tipoVetor = 'qualquer[]';
+                }
+                else {
+                    const primeiroElemento = valoresVetor[0];
+                    if (primeiroElemento instanceof construtos_1.Vetor) {
+                        tipoVetor = primeiroElemento.tipo + '[]';
+                    }
+                    else {
+                        tipoVetor = (0, inferenciador_1.inferirTipoVariavel)(valoresVetor);
+                    }
                 }
-                const tipoVetor = (0, inferenciador_1.inferirTipoVariavel)(valoresVetor);
                 return new construtos_1.Vetor(this.hashArquivo, simboloAtual.linha, valoresVetor, tipoVetor);
             case pitugues_2.default.COMENTARIO:
                 const simboloComentario = this.avancarEDevolverAnterior();
@@ -7048,14 +7119,42 @@ class AvaliadorSintaticoPitugues {
         }
         return expressao;
     }
-    async comparar() {
-        let expressao = await this.bitOu();
-        while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.MAIOR, pitugues_2.default.MAIOR_IGUAL, pitugues_2.default.MENOR, pitugues_2.default.MENOR_IGUAL)) {
-            const operador = this.simboloAnterior();
-            const direito = await this.bitOu();
-            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+    eOperadorDeComparacao(tipo) {
+        return [
+            pitugues_2.default.MAIOR,
+            pitugues_2.default.MAIOR_IGUAL,
+            pitugues_2.default.MENOR,
+            pitugues_2.default.MENOR_IGUAL
+        ].includes(tipo);
+    }
+    criarConstrutoComparacao(esquerda, operador, direita) {
+        let operandoCentral = null;
+        // Lógica de desugaring para comparações encadeadas (ex: 1 < x < 10)
+        if (esquerda instanceof construtos_1.Binario &&
+            this.eOperadorDeComparacao(esquerda.operador.tipo)) {
+            operandoCentral = esquerda.direita;
+        }
+        else if (esquerda instanceof construtos_1.Logico &&
+            esquerda.direita instanceof construtos_1.Binario &&
+            this.eOperadorDeComparacao(esquerda.direita.operador.tipo)) {
+            operandoCentral = esquerda.direita.direita;
+        }
+        if (operandoCentral !== null) {
+            const operadorE = {
+                tipo: pitugues_2.default.E,
+                lexema: 'e',
+                literal: null,
+                linha: operador.linha,
+                hashArquivo: this.hashArquivo
+            };
+            const novaComparacaoDireita = new construtos_1.Binario(this.hashArquivo, operandoCentral, operador, direita);
+            return new construtos_1.Logico(this.hashArquivo, esquerda, operadorE, novaComparacaoDireita);
         }
-        return expressao;
+        // Se não for encadeada, cria o Binário normal
+        return new construtos_1.Binario(this.hashArquivo, esquerda, operador, direita);
+    }
+    async comparar() {
+        return await this.logicaComumComparacao(() => this.bitOu());
     }
     async comparacaoIgualdade() {
         let expressao = await this.comparar();
@@ -7198,7 +7297,10 @@ class AvaliadorSintaticoPitugues {
         }
         return expressao;
     }
-    async declaracaoEscreva(simboloEscreva) {
+    async declaracaoEscreva() {
+        const simboloEscreva = this.simboloAnterior
+            ? this.simboloAnterior()
+            : this.simbolos[this.atual - 1];
         this.consumir(pitugues_2.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
         const argumentos = [];
         do {
@@ -7780,10 +7882,10 @@ class AvaliadorSintaticoPitugues {
         this.tiposDefinidosEmCodigo[definicaoClasse.simbolo.lexema] = definicaoClasse;
         return definicaoClasse;
     }
-    declaracaoFalhar() {
+    async declaracaoFalhar() {
         const simboloFalha = this.simbolos[this.atual - 1];
-        const textoFalha = this.consumir(pitugues_2.default.TEXTO, 'Esperado texto para explicar falha.');
-        return new declaracoes_1.Falhar(simboloFalha, textoFalha.literal);
+        const explicacao = await this.atribuir();
+        return new declaracoes_1.Falhar(simboloFalha, explicacao);
     }
     /**
      * Verifica se há pontos e vírgula no final de sentenças.
@@ -7889,11 +7991,11 @@ class AvaliadorSintaticoPitugues {
                 return this.declaracaoEscolha();
             case pitugues_2.default.IMPRIMA:
             case pitugues_2.default.ESCREVA:
-                const simboloEscrevaOuImprima = this.avancarEDevolverAnterior();
-                return this.declaracaoEscreva(simboloEscrevaOuImprima);
+                this.avancarEDevolverAnterior();
+                return this.declaracaoEscreva();
             case pitugues_2.default.FALHAR:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoFalhar();
+                return await this.declaracaoFalhar();
             case pitugues_2.default.FAZER:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoFazer();
@@ -8108,7 +8210,7 @@ class AvaliadorSintaticoPitugues {
 }
 exports.AvaliadorSintaticoPitugues = AvaliadorSintaticoPitugues;
 
-},{"../../bibliotecas/dialetos/pitugues/primitivas-tupla":30,"../../bibliotecas/primitivas-dicionario":31,"../../bibliotecas/primitivas-numero":32,"../../bibliotecas/primitivas-texto":33,"../../bibliotecas/primitivas-vetor":34,"../../construtos":67,"../../declaracoes":116,"../../inferenciador":146,"../../informacao-elemento-sintatico":147,"../../lexador":238,"../../lexador/micro-lexador-pitugues":243,"../../tipos-de-dados/dialetos/pitugues":249,"../../tipos-de-simbolos/pitugues":257,"../comum":12,"../erro-avaliador-sintatico":21,"../informacao-escopo":23,"../pilha-escopos":27,"./micro-avaliador-sintatico-pitugues":19,"browser-process-hrtime":446}],15:[function(require,module,exports){
+},{"../../bibliotecas/dialetos/pitugues/primitivas-tupla":30,"../../bibliotecas/primitivas-dicionario":31,"../../bibliotecas/primitivas-numero":32,"../../bibliotecas/primitivas-texto":33,"../../bibliotecas/primitivas-vetor":34,"../../construtos":67,"../../declaracoes":116,"../../inferenciador":146,"../../informacao-elemento-sintatico":147,"../../lexador":238,"../../lexador/micro-lexador-pitugues":243,"../../tipos-de-dados/dialetos/pitugues":249,"../../tipos-de-simbolos/pitugues":257,"../avaliador-sintatico-base":10,"../comum":12,"../erro-avaliador-sintatico":21,"../informacao-escopo":23,"../pilha-escopos":27,"./micro-avaliador-sintatico-pitugues":19,"browser-process-hrtime":446}],15:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -14341,8 +14443,12 @@ exports.Atribuir = Atribuir;
 
 },{"./variavel":95}],50:[function(require,module,exports){
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Binario = void 0;
+const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
 /**
  * Binário é uma estrutura com um operador e dois operandos: esquerda e direita.
  * Implementa as seguintes operações para Delégua e todos os dialetos:
@@ -14380,6 +14486,17 @@ class Binario {
      * @returns O tipo deduzido.
      */
     deduzirTipo() {
+        if ([
+            delegua_1.default.MAIOR,
+            delegua_1.default.MAIOR_IGUAL,
+            delegua_1.default.MENOR,
+            delegua_1.default.MENOR_IGUAL,
+            delegua_1.default.IGUAL,
+            delegua_1.default.IGUAL_IGUAL,
+            delegua_1.default.DIFERENTE,
+        ].includes(this.operador.tipo)) {
+            return 'lógico';
+        }
         if (['logico', 'lógico'].includes(this.esquerda.tipo) ||
             ['logico', 'lógico'].includes(this.direita.tipo)) {
             return 'lógico';
@@ -14411,7 +14528,7 @@ class Binario {
 }
 exports.Binario = Binario;
 
-},{}],51:[function(require,module,exports){
+},{"../tipos-de-simbolos/delegua":253}],51:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Bote = void 0;
@@ -20509,7 +20626,7 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
         }
         return argumentosResolvidos;
     }
-    resolverAmbiente(argumentos) {
+    async resolverAmbiente(visitante, argumentos) {
         const ambiente = new espaco_memoria_1.EspacoMemoria();
         const parametros = this.declaracao.parametros || [];
         for (let i = 0; i < parametros.length; i++) {
@@ -20525,15 +20642,28 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
                 };
             }
             else {
-                let argumento = argumentos[i];
-                if (argumento.valor === null) {
-                    argumentos[i].valor = parametro.valorPadrao ? parametro.valorPadrao : null;
+                let valorFinal;
+                const argumento = argumentos[i];
+                const valorExtraido = (argumento && argumento.hasOwnProperty('valor'))
+                    ? argumento.valor
+                    : argumento;
+                if (i < argumentos.length &&
+                    valorExtraido !== undefined &&
+                    valorExtraido !== null) {
+                    valorFinal = valorExtraido;
+                }
+                else if (parametro.valorPadrao) {
+                    valorFinal = await visitante.avaliar(parametro.valorPadrao);
+                }
+                else {
+                    valorFinal = null;
                 }
-                ambiente.valores[nome] =
-                    argumento && argumento.hasOwnProperty('valor') ? argumento.valor : argumento;
+                ambiente.valores[nome] = valorFinal;
                 // Se o argumento é `DeleguaFuncao`, para habilitar o recurso de _currying_,
                 // copiamos seu valor para o escopo atual. Nem sempre podemos contar com a tipagem explícita aqui.
-                if (argumento.valor && ['funcao', 'função'].includes(argumento.valor.tipo)) {
+                if (valorFinal &&
+                    typeof valorFinal === 'object' &&
+                    ['funcao', 'função'].includes(valorFinal.tipo)) {
                     parametro.referencia = true;
                 }
             }
@@ -20541,7 +20671,7 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
         return ambiente;
     }
     async chamar(visitante, argumentos) {
-        const ambiente = this.resolverAmbiente(argumentos);
+        const ambiente = await this.resolverAmbiente(visitante, argumentos);
         if (this.instancia !== undefined) {
             ambiente.valores['isto'] = {
                 valor: this.instancia,
@@ -21924,7 +22054,28 @@ class InterpretadorBase {
         throw new Error('Método não implementado.');
     }
     async visitarExpressaoFalhar(expressao) {
-        const textoFalha = expressao.explicacao.valor ?? (await this.avaliar(expressao.explicacao)).valor;
+        let valorAvaliado = expressao.explicacao;
+        // Se for um construto (ex.: Variavel), avalia para obter seu valor real
+        if (expressao.explicacao &&
+            typeof expressao.explicacao.aceitar === 'function') {
+            valorAvaliado = await this.avaliar(expressao.explicacao);
+        }
+        let textoFalha;
+        if (valorAvaliado === null || valorAvaliado === undefined) {
+            textoFalha = 'nulo';
+        }
+        else if (typeof valorAvaliado === 'string') {
+            textoFalha = valorAvaliado;
+        }
+        else if (typeof valorAvaliado === 'object' &&
+            'valor' in valorAvaliado) {
+            // Objetos tipados como { valor: 'mensagem', tipo: 'texto' }
+            textoFalha = String(valorAvaliado.valor);
+        }
+        else {
+            // Caso incomum: usa a representação textual padrão
+            textoFalha = this.paraTexto(valorAvaliado);
+        }
         throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, textoFalha, expressao.linha);
     }
     async visitarExpressaoFimPara(_) {
@@ -22181,7 +22332,7 @@ class InterpretadorBase {
      * @param esquerda O operando esquerdo.
      * @returns Se ambos os operandos são números ou não.
      */
-    verificarOperandosNumeros(operador, direita, esquerda) {
+    verificarOperandosNumeros(operador, esquerda, direita) {
         const tipoDireita = direita.tipo
             ? direita.tipo
             : typeof direita === primitivos_1.default.NUMERO
@@ -22259,23 +22410,33 @@ class InterpretadorBase {
                 const resultadoExponenciacao = Math.pow(valorEsquerdo, valorDireito);
                 return resultadoExponenciacao;
             case delegua_1.default.MAIOR:
-                if (this.tiposNumericos.includes(tipoEsquerdo) &&
-                    this.tiposNumericos.includes(tipoDireito)) {
+                if (typeof valorEsquerdo === 'string' &&
+                    typeof valorDireito === 'string') {
                     return valorEsquerdo > valorDireito;
                 }
-                return String(valorEsquerdo) > String(valorDireito);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(valorEsquerdo) > Number(valorDireito);
             case delegua_1.default.MAIOR_IGUAL:
+                if (typeof valorEsquerdo === 'string' &&
+                    typeof valorDireito === 'string') {
+                    return valorEsquerdo >= valorDireito;
+                }
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                return valorEsquerdo >= valorDireito;
+                return Number(valorEsquerdo) >= Number(valorDireito);
             case delegua_1.default.MENOR:
-                if (this.tiposNumericos.includes(tipoEsquerdo) &&
-                    this.tiposNumericos.includes(tipoDireito)) {
+                if (typeof valorEsquerdo === 'string' &&
+                    typeof valorDireito === 'string') {
                     return valorEsquerdo < valorDireito;
                 }
-                return String(valorEsquerdo) < String(valorDireito);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(valorEsquerdo) < Number(valorDireito);
             case delegua_1.default.MENOR_IGUAL:
+                if (typeof valorEsquerdo === 'string' &&
+                    typeof valorDireito === 'string') {
+                    return valorEsquerdo <= valorDireito;
+                }
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                return valorEsquerdo <= valorDireito;
+                return Number(valorEsquerdo) <= Number(valorDireito);
             case delegua_1.default.SUBTRACAO:
             case delegua_1.default.MENOS_IGUAL:
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
@@ -22605,13 +22766,29 @@ class InterpretadorBase {
             });
         }
     }
+    /** Gancho para linguagens definirem lógica de escopo (Pituguês LEGB) ou de memória (Delégua) */
+    atribuirVariavel(alvoVariavel, valorResolvido, indice) {
+        this.pilhaEscoposExecucao.atribuirVariavel(alvoVariavel.simbolo, valorResolvido, indice);
+    }
+    /** Gancho para linguagens definirem como acessar propriedades de objetos */
+    async definirPropriedadeObjeto(objeto, simbolo, valor) {
+        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse) {
+            await objeto.definir(simbolo, valor, this);
+        }
+        else if (objeto !== null && objeto !== undefined) {
+            objeto[simbolo.lexema] = valor;
+        }
+    }
     /**
      * 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);
+        let valor = await this.avaliar(expressao.valor);
+        if (valor && valor.hasOwnProperty('valorRetornado')) {
+            valor = valor.valorRetornado;
+        }
         const valorResolvido = this.resolverValor(valor);
         let indice = null;
         if (expressao.indice) {
@@ -22619,22 +22796,18 @@ class InterpretadorBase {
         }
         switch (expressao.alvo.constructor) {
             case construtos_1.AcessoMetodoOuPropriedade:
-                // Nunca será método aqui: apenas propriedade.
                 const alvoPropriedade = expressao.alvo;
                 const variavelObjeto = await this.avaliar(alvoPropriedade.objeto);
                 const objeto = this.resolverValor(variavelObjeto);
-                const valor = await this.avaliar(expressao.valor);
-                if (objeto.constructor === estruturas_1.ObjetoDeleguaClasse) {
-                    const objetoDeleguaClasse = objeto;
-                    await objetoDeleguaClasse.definir(alvoPropriedade.simbolo, valor, this);
-                }
+                const valorProp = await this.avaliar(expressao.valor);
+                await this.definirPropriedadeObjeto(objeto, alvoPropriedade.simbolo, valorProp);
                 break;
             case construtos_1.Variavel:
                 const alvoVariavel = expressao.alvo;
-                this.pilhaEscoposExecucao.atribuirVariavel(alvoVariavel.simbolo, valorResolvido, indice);
+                this.atribuirVariavel(alvoVariavel, valorResolvido, indice);
                 break;
             default:
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloOperador, `Atribuição com caso faltante: ${JSON.stringify(expressao)}.`);
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloOperador, "Alvo da atribuição inválido. O lado esquerdo de uma atribuição deve ser uma variável, propriedade ou índice.");
         }
         return valorResolvido;
     }
@@ -22929,36 +23102,47 @@ class InterpretadorBase {
         } while (!(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra) &&
             this.eVerdadeiro(await this.avaliar(declaracao.condicaoEnquanto)));
     }
+    /**
+     * Unifica a execução do bloco 'pegue', tratando tanto o caso de
+     * declarações simples quanto o caso de função com parâmetro de erro.
+     */
+    async executarBlocoPegue(pegue, erro) {
+        if (Array.isArray(pegue)) {
+            return await this.executarBloco(pegue);
+        }
+        // Caso seja FuncaoConstruto (pegue com parâmetro de erro)
+        const literalErro = new construtos_1.Literal(pegue.hashArquivo, pegue.linha, erro.mensagem || erro.message || erro);
+        const chamadaPegue = new construtos_1.Chamada(pegue.hashArquivo, pegue, [literalErro]);
+        return await chamadaPegue.aceitar(this);
+    }
     /**
      * Interpretação de uma declaração `tente`.
      * @param declaracao O objeto da declaração.
      */
     async visitarDeclaracaoTente(declaracao) {
         let valorRetorno;
+        let sucessoNoTente = false;
         try {
             this.emDeclaracaoTente = true;
             try {
                 valorRetorno = await this.executarBloco(declaracao.caminhoTente);
+                sucessoNoTente = true;
             }
             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, [literalErro]);
-                        valorRetorno = await chamadaPegue.aceitar(this);
-                    }
+                    valorRetorno = await this.executarBlocoPegue(declaracao.caminhoPegue, erro);
                 }
+                else
+                    throw erro;
+            }
+            if (sucessoNoTente && declaracao.caminhoSenao) {
+                valorRetorno = await this.executarBloco(declaracao.caminhoSenao);
             }
         }
         finally {
-            if (declaracao.caminhoFinalmente)
+            if (declaracao.caminhoFinalmente) {
                 valorRetorno = await this.executarBloco(declaracao.caminhoFinalmente);
+            }
             this.emDeclaracaoTente = false;
         }
         return valorRetorno;
@@ -23417,6 +23601,13 @@ class InterpretadorBase {
         if (tipoObjeto === null || tipoObjeto === undefined) {
             tipoObjeto = (0, inferenciador_1.inferirTipoVariavel)(variavelObjeto);
         }
+        // Trata qualquer tipo terminado em '[]' como vetor
+        if (tipoObjeto && tipoObjeto.endsWith('[]')) {
+            if (expressao.simbolo.lexema in primitivas_vetor_1.default) {
+                const metodo = primitivas_vetor_1.default[expressao.simbolo.lexema].implementacao;
+                return new metodo_primitiva_1.MetodoPrimitiva(nomeObjeto, objeto, metodo, expressao.simbolo.lexema, tipoObjeto);
+            }
+        }
         // Caso 3: Vetor simples do JavaScript.
         if (Array.isArray(objeto)) {
             if (expressao.simbolo.lexema in primitivas_vetor_1.default) {
@@ -23910,6 +24101,17 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
     pontoInicializacaoBibliotecasGlobais() {
         (0, comum_1.carregarBibliotecasGlobais)(this.pilhaEscoposExecucao);
     }
+    atribuirVariavel(alvoVariavel, valorResolvido, indice) {
+        const variavelResolvida = this.pilhaEscoposExecucao.obterValorVariavel(alvoVariavel.simbolo);
+        if (variavelResolvida.valor instanceof estruturas_1.ReferenciaMontao) {
+            const referenciaMontao = this.montao.obterReferencia(this.hashArquivoDeclaracaoAtual, this.linhaDeclaracaoAtual, variavelResolvida.valor.endereco);
+            referenciaMontao[indice] = valorResolvido;
+        }
+        else {
+            // Se não for montão, usa o comportamento padrão da Pilha
+            super.atribuirVariavel(alvoVariavel, valorResolvido, indice);
+        }
+    }
     async avaliarArgumentosEscreva(argumentos) {
         if (this.constructor !== Interpretador) {
             return await super.avaliarArgumentosEscreva(argumentos);
@@ -24684,6 +24886,23 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         if (tipoObjeto === null || tipoObjeto === undefined) {
             tipoObjeto = (0, inferenciador_1.inferirTipoVariavel)(objeto);
         }
+        // Trata qualquer tipo terminado em '[]' como vetor
+        if (tipoObjeto && tipoObjeto.endsWith('[]')) {
+            if (expressao.nomeMetodo in primitivas_vetor_1.default) {
+                const metodo = primitivas_vetor_1.default[expressao.nomeMetodo].implementacao;
+                return new estruturas_1.MetodoPrimitiva(nomeObjeto, objeto, metodo, expressao.nomeMetodo, tipoObjeto);
+            }
+            else {
+                const funcaoExt = this.encontrarMetodoExtensao(['vetor', 'objeto'], expressao.nomeMetodo, this.hashArquivoDeclaracaoAtual);
+                if (funcaoExt)
+                    return funcaoExt.funcaoPorExtensao(objeto);
+                throw new excecoes_1.ErroEmTempoDeExecucao({
+                    hashArquivo: this.hashArquivoDeclaracaoAtual,
+                    linha: this.linhaDeclaracaoAtual,
+                    lexema: expressao.nomeMetodo
+                }, `Método de primitiva '${expressao.nomeMetodo}' não existe para o tipo ${tipoObjeto}.`, expressao.linha);
+            }
+        }
         // Como internamente um dicionário de Delégua é simplesmente um objeto de
         // JavaScript, as primitivas de dicionário, especificamente, são tratadas
         // mais acima.
@@ -24859,6 +25078,19 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         if (tipoObjeto === null || tipoObjeto === undefined) {
             tipoObjeto = (0, inferenciador_1.inferirTipoVariavel)(objeto);
         }
+        // Trata qualquer tipo terminado em '[]' como vetor
+        if (tipoObjeto && tipoObjeto.endsWith('[]')) {
+            if (expressao.simbolo.lexema in primitivas_vetor_1.default) {
+                const metodo = primitivas_vetor_1.default[expressao.simbolo.lexema].implementacao;
+                return new estruturas_1.MetodoPrimitiva(nomeObjeto, objeto, metodo, expressao.simbolo.lexema, tipoObjeto);
+            }
+            else {
+                const funcaoExt = this.encontrarMetodoExtensao(['vetor', 'objeto'], expressao.simbolo.lexema, this.hashArquivoDeclaracaoAtual);
+                if (funcaoExt)
+                    return funcaoExt.funcaoPorExtensao(objeto);
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, `Método de primitiva '${expressao.simbolo.lexema}' não existe para o tipo ${tipoObjeto}.`, expressao.linha);
+            }
+        }
         // Como internamente um dicionário de Delégua é simplesmente um objeto de
         // JavaScript, as primitivas de dicionário, especificamente, são tratadas
         // mais acima.
@@ -25058,53 +25290,6 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
     async visitarExpressaoComentario(expressao) {
         return Promise.resolve();
     }
-    /**
-     * Execução de uma expressão de atribuição.
-     * @param expressao A expressão.
-     * @returns O valor atribuído.
-     */
-    async visitarExpressaoDeAtribuicao(expressao) {
-        let valor = await this.avaliar(expressao.valor);
-        if (valor && valor.hasOwnProperty('valorRetornado')) {
-            valor = valor.valorRetornado;
-        }
-        const valorResolvido = this.resolverValor(valor);
-        let indice = null;
-        if (expressao.indice) {
-            indice = this.resolverValor(await this.avaliar(expressao.indice));
-        }
-        switch (expressao.alvo.constructor) {
-            case construtos_1.Variavel:
-                const alvoVariavel = expressao.alvo;
-                const variavelResolvida = this.pilhaEscoposExecucao.obterValorVariavel(alvoVariavel.simbolo);
-                if (variavelResolvida.valor instanceof estruturas_1.ReferenciaMontao) {
-                    const referenciaMontao = this.montao.obterReferencia(this.hashArquivoDeclaracaoAtual, this.linhaDeclaracaoAtual, variavelResolvida.valor.endereco);
-                    referenciaMontao[indice] = valorResolvido;
-                }
-                else {
-                    this.pilhaEscoposExecucao.atribuirVariavel(alvoVariavel.simbolo, valorResolvido, indice);
-                }
-                break;
-            case construtos_1.AcessoMetodoOuPropriedade:
-                // Nunca será método aqui: apenas propriedade.
-                const alvoPropriedade = expressao.alvo;
-                const variavelObjeto = await this.avaliar(alvoPropriedade.objeto);
-                const objeto = this.resolverValor(variavelObjeto);
-                const valor = await this.avaliar(expressao.valor);
-                if (objeto.constructor === estruturas_1.ObjetoDeleguaClasse) {
-                    const objetoDeleguaClasse = objeto;
-                    await objetoDeleguaClasse.definir(alvoPropriedade.simbolo, valor, this);
-                }
-                else {
-                    // Se cair aqui, provavelmente `objeto.constructor.name` é 'Object'.
-                    objeto[alvoPropriedade.simbolo.lexema] = valor;
-                }
-                break;
-            default:
-                throw new excecoes_1.ErroEmTempoDeExecucao(undefined, `Atribuição com caso faltante: ${JSON.stringify(expressao)}.`);
-        }
-        return valorResolvido;
-    }
     async visitarExpressaoDefinirValor(expressao) {
         const variavelObjeto = await this.avaliar(expressao.objeto);
         const objeto = this.resolverValor(variavelObjeto);
@@ -28798,11 +28983,11 @@ const simbolo_1 = require("./simbolo");
 const palavras_reservadas_1 = require("./palavras-reservadas");
 const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
 /**
- * O Lexador é responsável por transformar o código em uma coleção de tokens de linguagem.
- * Cada token de linguagem é representado por um tipo, um lexema e informações da linha de código em que foi expresso.
- * Também é responsável por mapear as palavras reservadas da linguagem, que não podem ser usadas por outras
- * estruturas, tais como nomes de variáveis, funções, literais, classes e assim por diante.
- */
+* O Lexador é responsável por transformar o código em uma coleção de tokens de linguagem.
+* Cada token de linguagem é representado por um tipo, um lexema e informações da linha de código em que foi expresso.
+* Também é responsável por mapear as palavras reservadas da linguagem, que não podem ser usadas por outras
+* estruturas, tais como nomes de variáveis, funções, literais, classes e assim por diante.
+*/
 class Lexador {
     constructor(performance = false) {
         this.codigo = [];
@@ -28870,10 +29055,10 @@ class Lexador {
         return this.atual >= this.codigo[this.linha].length;
     }
     /**
-     * Indica se o código está na última linha.
-     * @returns Verdadeiro se contador de linhas está na última linha.
-     *          Falso caso contrário.
-     */
+    * Indica se o código está na última linha.
+    * @returns Verdadeiro se contador de linhas está na última linha.
+    *          Falso caso contrário.
+    */
     eUltimaLinha() {
         return this.linha >= this.codigo.length - 1;
     }
@@ -28881,7 +29066,9 @@ class Lexador {
         return this.eUltimaLinha() && this.codigo[this.codigo.length - 1].length <= this.atual;
     }
     avancar() {
-        this.atual += 1;
+        const linha = this.codigo[this.linha];
+        const codePoint = linha.codePointAt(this.atual);
+        this.atual += codePoint && codePoint > 0xffff ? 2 : 1;
         if (this.eFinalDaLinha() && !this.eUltimaLinha()) {
             this.linha++;
             this.atual = 0;
@@ -28899,7 +29086,12 @@ class Lexador {
     simboloAtual() {
         if (this.eFinalDaLinha())
             return '\0';
-        return this.codigo[this.linha].charAt(this.atual);
+        const linha = this.codigo[this.linha];
+        const codePoint = linha.codePointAt(this.atual);
+        if (codePoint === undefined) {
+            return '\0';
+        }
+        return String.fromCodePoint(codePoint);
     }
     comentarioMultilinha() {
         let conteudo = '';
@@ -28923,10 +29115,10 @@ class Lexador {
         }
     }
     /**
-     * Lê um comentário documentário (iniciado com `/**`), agregando o conteúdo
-     * em um único token DOCUMENTARIO. Linhas com `*` inicial (convenção JSDoc)
-     * têm o asterisco removido.
-     */
+    * Lê um comentário documentário (iniciado com `/**`), agregando o conteúdo
+    * em um único token DOCUMENTARIO. Linhas com `*` inicial (convenção JSDoc)
+    * têm o asterisco removido.
+    */
     comentarioDocumentario() {
         // Cursor está no primeiro '*' de '/**'. Avança para pular o segundo '*'.
         this.avancar();
@@ -28964,10 +29156,23 @@ class Lexador {
         this.adicionarSimbolo(delegua_1.default.COMENTARIO, conteudo.trim());
     }
     proximoSimbolo() {
-        return this.codigo[this.linha].charAt(this.atual + 1);
+        const linha = this.codigo[this.linha];
+        const atual = this.simboloAtual();
+        const incremento = atual.length;
+        const codePoint = linha.codePointAt(this.atual + incremento);
+        if (codePoint === undefined) {
+            return '\0';
+        }
+        return String.fromCodePoint(codePoint);
     }
     simboloAnterior() {
-        return this.codigo[this.linha].charAt(this.atual - 1);
+        const linha = this.codigo[this.linha];
+        const indiceAnterior = this.atual -
+            (linha.codePointAt(this.atual - 2) > 0xffff ? 2 : 1);
+        const codePoint = linha.codePointAt(indiceAnterior);
+        if (codePoint === undefined) {
+            return '\0';
+        }
     }
     analisarTexto(delimitador = '"') {
         let valor = '';
@@ -29153,6 +29358,19 @@ class Lexador {
             : delegua_1.default.IDENTIFICADOR;
         this.adicionarSimbolo(tipo);
     }
+    eEmoji(caractere) {
+        const emojiRegex = /\p{Extended_Pictographic}(?:\uFE0F|\u200D\p{Extended_Pictographic})*/u;
+        return emojiRegex.test(caractere);
+    }
+    analisarEmoji() {
+        const simboloAtual = this.simboloAtual();
+        this.erros.push({
+            linha: this.linha + 1,
+            caractere: simboloAtual,
+            mensagem: 'Emojis devem estar envoltos por aspas.',
+        });
+        this.avancar();
+    }
     analisarToken() {
         const caractere = this.simboloAtual();
         switch (caractere) {
@@ -29416,6 +29634,8 @@ class Lexador {
             default:
                 if (this.eDigito(caractere))
                     this.analisarNumero();
+                else if (this.eEmoji(caractere))
+                    this.analisarEmoji();
                 else if (this.eAlfabeto(caractere))
                     this.identificarPalavraChave();
                 else {