@designliquido/delegua 1.15.4 → 1.15.6

package/umd/delegua.js

@@ -478,12 +478,16 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         this.pilhaVariaveis = new pilha_variaveis_1.PilhaVariaveis();
         this.gerenciadorEscopos = new gerenciador_escopos_1.GerenciadorEscopos();
         this.funcoes = {};
-        this.classesDeclararadas = new Set();
+        this.classesDeclaradas = new Set();
         this.classesRegistradas = new Map();
+        this.classesExternasConhecidas = new Set();
         this.classeAtualEmAnalise = null;
         this.atual = 0;
         this.diagnosticos = [];
     }
+    definirClassesExternasConhecidas(classesExternasConhecidas) {
+        this.classesExternasConhecidas = new Set(classesExternasConhecidas);
+    }
     verificarTipoAtribuido(declaracao) {
         if (declaracao.tipo) {
             if (['vetor', 'qualquer[]', 'inteiro[]', 'texto[]'].includes(declaracao.tipo)) {
@@ -503,6 +507,10 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                         }
                     }
                 }
+                else if (declaracao.inicializador instanceof construtos_1.Chamada) {
+                    // Chamadas de método/função podem retornar vetores.
+                    // A validação detalhada é feita em tempo de execução.
+                }
                 else {
                     this.erro(declaracao.simbolo, `Atribuição inválida para '${declaracao.simbolo.lexema}': é esperado um vetor de elementos.`);
                 }
@@ -664,6 +672,8 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         }
         // Marca como inicializada após atribuição
         this.gerenciadorEscopos.marcarComoInicializada(simboloAlvo.lexema, expressao.valor);
+        // Marca variáveis usadas no valor atribuído (ex: idade = ano - inteiro(leia(...))).
+        this.marcarVariaveisUsadasEmExpressao(expressao.valor);
         // Atualiza tipo se a variável não foi tipada explicitamente
         if (variavel.tipo === 'qualquer') {
             const tipoInferido = this.obterTipoExpressao(expressao.valor);
@@ -738,10 +748,34 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                 this.variaveis[simboloAlvo.lexema].valor = expressao.valor;
             }
         } */
+        return Promise.resolve();
     }
     async visitarDeclaracaoDeExpressao(declaracao) {
         return await declaracao.expressao.aceitar(this);
     }
+    async visitarExpressaoBloco(declaracao) {
+        this.gerenciadorEscopos.empilharEscopo();
+        try {
+            for (const declaracaoBloco of declaracao.declaracoes) {
+                await declaracaoBloco.aceitar(this);
+            }
+        }
+        finally {
+            this.gerenciadorEscopos.desempilharEscopo();
+        }
+        return Promise.resolve();
+    }
+    visitarExpressaoAcessoIndiceVariavel(expressao) {
+        this.marcarVariaveisUsadasEmExpressao(expressao.entidadeChamada);
+        this.marcarVariaveisUsadasEmExpressao(expressao.indice);
+        return Promise.resolve();
+    }
+    visitarExpressaoAtribuicaoPorIndice(expressao) {
+        this.marcarVariaveisUsadasEmExpressao(expressao.objeto);
+        this.marcarVariaveisUsadasEmExpressao(expressao.indice);
+        this.marcarVariaveisUsadasEmExpressao(expressao.valor);
+        return Promise.resolve();
+    }
     visitarDeclaracaoAjuda(declaracao) {
         if (declaracao.elemento) {
             this.marcarVariaveisUsadasEmExpressao(declaracao.elemento);
@@ -756,7 +790,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
     }
     visitarDeclaracaoEscolha(declaracao) {
         const identificadorOuLiteral = declaracao.identificadorOuLiteral;
-        const tipo = identificadorOuLiteral.tipo;
+        const tipo = identificadorOuLiteral.tipo || 'qualquer';
         for (let caminho of declaracao.caminhos) {
             for (let condicao of caminho.condicoes) {
                 switch (condicao.constructor) {
@@ -787,8 +821,16 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         }
         return Promise.resolve();
     }
-    visitarDeclaracaoEnquanto(declaracao) {
-        return this.verificarCondicao(declaracao.condicao);
+    async visitarDeclaracaoEnquanto(declaracao) {
+        // Marca variáveis usadas na condição.
+        this.marcarVariaveisUsadasEmExpressao(declaracao.condicao);
+        // Verifica a condição (incluindo validações de tipo para operadores lógicos).
+        await this.verificarCondicao(declaracao.condicao);
+        // Visita corpo para que usos/atribuições dentro do laço sejam analisados.
+        for (const declaracaoCorpo of declaracao.corpo.declaracoes) {
+            await declaracaoCorpo.aceitar(this);
+        }
+        return Promise.resolve();
     }
     visitarDeclaracaoFazer(declaracao) {
         // Marca variáveis usadas na condição
@@ -796,16 +838,59 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         // Verifica a condição
         return this.verificarCondicao(declaracao.condicaoEnquanto);
     }
+    async visitarDeclaracaoPara(declaracao) {
+        this.gerenciadorEscopos.empilharEscopo();
+        try {
+            if (Array.isArray(declaracao.inicializador)) {
+                for (const inicializador of declaracao.inicializador) {
+                    await inicializador.aceitar(this);
+                }
+            }
+            else if (declaracao.inicializador) {
+                await declaracao.inicializador.aceitar(this);
+            }
+            // O laço precisa visitar condição/incremento/corpo para registrar usos de variáveis.
+            if (declaracao.condicao) {
+                this.marcarVariaveisUsadasEmExpressao(declaracao.condicao);
+                await this.verificarCondicao(declaracao.condicao);
+            }
+            if (declaracao.incrementar) {
+                this.marcarVariaveisUsadasEmExpressao(declaracao.incrementar);
+                this.verificarExpressao(declaracao.incrementar);
+            }
+            for (const declaracaoCorpo of declaracao.corpo.declaracoes) {
+                await declaracaoCorpo.aceitar(this);
+            }
+        }
+        finally {
+            this.gerenciadorEscopos.desempilharEscopo();
+        }
+        return Promise.resolve();
+    }
     visitarDeclaracaoParaCada(declaracao) {
         // Marca o vetor/dicionário como usado
         this.marcarVariaveisUsadasEmExpressao(declaracao.vetorOuDicionario);
         return Promise.resolve();
     }
-    visitarDeclaracaoSe(declaracao) {
+    async visitarDeclaracaoSe(declaracao) {
         // Marca variáveis usadas na condição
         this.marcarVariaveisUsadasEmExpressao(declaracao.condicao);
         // Verifica a condição (incluindo validação de tipos para operadores lógicos)
-        return this.verificarCondicao(declaracao.condicao);
+        await this.verificarCondicao(declaracao.condicao);
+        if (declaracao.caminhoEntao) {
+            await declaracao.caminhoEntao.aceitar(this);
+        }
+        if (declaracao.caminhosSeSenao && declaracao.caminhosSeSenao.length > 0) {
+            for (const caminhoSeSenao of declaracao.caminhosSeSenao) {
+                this.marcarVariaveisUsadasEmExpressao(caminhoSeSenao.condicao);
+                await this.verificarCondicao(caminhoSeSenao.condicao);
+                await caminhoSeSenao.caminho.aceitar(this);
+            }
+        }
+        if (declaracao.caminhoSenao) {
+            await declaracao.caminhoSenao.aceitar(this);
+        }
+        return Promise.resolve();
     }
     /**
      * Verifica uma expressão recursivamente, incluindo operações binárias
@@ -952,6 +1037,9 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         const tipoEsquerda = this.obterTipoExpressao(binario.esquerda);
         const tipoDireita = this.obterTipoExpressao(binario.direita);
         const tiposNumericos = ['inteiro', 'número', 'real'];
+        if (!tipoEsquerda || !tipoDireita) {
+            return;
+        }
         if ((tipoEsquerda === 'texto' && tiposNumericos.includes(tipoDireita)) ||
             (tiposNumericos.includes(tipoEsquerda) && tipoDireita === 'texto')) {
             this.aviso(binario.operador, `Esta comparação ocorre entre tipos ${tipoEsquerda} e ${tipoDireita}, e o resultado pode não ser o desejado.`);
@@ -1058,10 +1146,11 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
             case construtos_1.Variavel:
                 let entidadeChamadaVariavel = chamada.entidadeChamada;
                 const nomeFuncao = entidadeChamadaVariavel.simbolo.lexema;
-                // Lista de funções built-in que não precisam ser declaradas
-                const funcoesBuiltIn = [
+                // Lista de funções embutidas que não precisam ser declaradas
+                const funcoesEmbutidas = [
                     'inteiro',
                     'real',
+                    'numero',
                     'número',
                     'texto',
                     'leia',
@@ -1070,8 +1159,8 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                 ];
                 // Classes/construtores geralmente começam com letra maiúscula
                 const pareceSerClasse = nomeFuncao[0] === nomeFuncao[0].toUpperCase();
-                // Só verifica se a função existe se não for built-in e não parecer ser classe
-                if (!funcoesBuiltIn.includes(nomeFuncao) &&
+                // Só verifica se a função existe se não for embutidas e não parecer ser classe
+                if (!funcoesEmbutidas.includes(nomeFuncao) &&
                     !pareceSerClasse &&
                     !this.funcoes[nomeFuncao] &&
                     !this.gerenciadorEscopos.buscar(nomeFuncao)) {
@@ -1253,7 +1342,10 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         // Inferir tipo do inicializador se não foi especificado explicitamente
         let tipoInferido = declaracao.tipo;
         if (!tipoInferido && declaracao.inicializador) {
-            tipoInferido = this.obterTipoExpressao(declaracao.inicializador);
+            const tipoInicializador = this.obterTipoExpressao(declaracao.inicializador);
+            if (tipoInicializador) {
+                tipoInferido = tipoInicializador;
+            }
         }
         // Sugestão de tipo melhor quando 'qualquer' é usado explicitamente
         if (declaracao.tipoExplicito &&
@@ -1267,8 +1359,8 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                         textoOriginal: 'qualquer',
                         textoSubstituto: tipoMelhor,
                         linha: declaracao.simbolo.linha,
-                        colunaInicio: declaracao.simbolo.colunaInicio,
-                        colunaFim: declaracao.simbolo.colunaFim,
+                        colunaInicio: declaracao.simbolo.colunaInicio || 0,
+                        colunaFim: declaracao.simbolo.colunaFim || 0,
                     },
                 ]);
             }
@@ -1303,7 +1395,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         return Promise.resolve();
     }
     visitarExpressaoRetornar(declaracao) {
-        return Promise.resolve(null);
+        return Promise.resolve(undefined);
     }
     visitarExpressaoDeVariavel(expressao) {
         if (expressao instanceof construtos_1.Variavel) {
@@ -1387,11 +1479,11 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
             if (nomeSuperclasse === declaracao.simbolo.lexema) {
                 this.erro(superClasseVariavel.simbolo, `A classe '${declaracao.simbolo.lexema}' não pode herdar de si mesma.`);
             }
-            else if (!this.classesDeclararadas.has(nomeSuperclasse)) {
+            else if (!this.classesDeclaradas.has(nomeSuperclasse) && !this.classesExternasConhecidas.has(nomeSuperclasse)) {
                 this.erro(superClasseVariavel.simbolo, `Superclasse '${nomeSuperclasse}' não foi declarada.`);
             }
         }
-        this.classesDeclararadas.add(declaracao.simbolo.lexema);
+        this.classesDeclaradas.add(declaracao.simbolo.lexema);
         this.classesRegistradas.set(declaracao.simbolo.lexema, declaracao);
         // Visita corpos dos métodos com contexto de classe ativo
         const classeAnterior = this.classeAtualEmAnalise;
@@ -1403,7 +1495,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         }
         this.classeAtualEmAnalise = classeAnterior;
     }
-    visitarDeclaracaoDefinicaoFuncao(declaracao) {
+    async visitarDeclaracaoDefinicaoFuncao(declaracao) {
         var _a;
         if (declaracao.funcao.tipo === undefined) {
             this.erro(declaracao.simbolo, `Declaração de retorno da função é inválido.`);
@@ -1419,7 +1511,10 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                     this.erro(declaracao.simbolo, `Função '${declaracao.simbolo.lexema}' deve retornar '${tipoRetornoFuncao}' em todos os caminhos de execução.`);
                 }
             }
-            const retornos = declaracao.funcao.corpo.flatMap((c) => (0, comum_1.buscarRetornos)(c));
+            let retornos = [];
+            for (const declaracaoCorpo of declaracao.funcao.corpo) {
+                retornos = retornos.concat((0, comum_1.buscarRetornos)(declaracaoCorpo));
+            }
             // Filtra retornos com tipo 'qualquer' (não determinado em tempo de análise sintática)
             const retornosComTipoIndeterminado = retornos.filter((retorno) => retorno.valor !== null &&
                 retorno.valor !== undefined &&
@@ -1430,7 +1525,8 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                 declaracao.funcao.tipoExplicito &&
                 retornosComTipoIndeterminado.length > 0) {
                 const retornoComValor = retornosComTipoIndeterminado[0];
-                const tipoInferido = this.obterTipoExpressao(retornoComValor.valor);
+                const valorRetorno = retornoComValor.valor;
+                const tipoInferido = this.obterTipoExpressao(valorRetorno);
                 if (tipoInferido && tipoInferido !== 'qualquer') {
                     this.erro(declaracao.simbolo, `A função não pode ter nenhum tipo de retorno. Tipo inferido do retorno: '${tipoInferido}'.`);
                 }
@@ -1458,14 +1554,38 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         this.funcoes[declaracao.simbolo.lexema] = {
             valor: declaracao.funcao,
         };
+        this.gerenciadorEscopos.empilharEscopo();
+        try {
+            for (const parametro of declaracao.funcao.parametros) {
+                this.gerenciadorEscopos.declarar(parametro.nome.lexema, {
+                    nome: parametro.nome.lexema,
+                    tipo: parametro.tipoDado || 'qualquer',
+                    imutavel: false,
+                    valor: undefined,
+                    inicializada: true,
+                    usada: false,
+                    hashArquivo: parametro.nome.hashArquivo,
+                    linha: parametro.nome.linha,
+                });
+            }
+            for (const declaracaoCorpo of declaracao.funcao.corpo) {
+                await declaracaoCorpo.aceitar(this);
+            }
+        }
+        finally {
+            this.gerenciadorEscopos.desempilharEscopo();
+        }
         return Promise.resolve();
     }
     verificarVariaveisNaoUsadas() {
         const naoUsadas = this.gerenciadorEscopos.obterVariaveisNaoUsadas();
         for (let variavel of naoUsadas) {
             // Verifica se já existe um erro associado à variável.
-            const temErro = this.diagnosticos.some((d) => d.severidade === erros_1.DiagnosticoSeveridade.ERRO &&
-                d.simbolo.lexema === variavel.nome);
+            const temErro = this.diagnosticos.some((d) => {
+                var _a;
+                return d.severidade === erros_1.DiagnosticoSeveridade.ERRO &&
+                    ((_a = d.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) === variavel.nome;
+            });
             // Se a variável já tem um erro associado, não emitir aviso de não usada.
             if (temErro) {
                 continue;
@@ -1480,7 +1600,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
     }
     async analisar(declaracoes) {
         this.gerenciadorEscopos = new gerenciador_escopos_1.GerenciadorEscopos();
-        this.classesDeclararadas = new Set();
+        this.classesDeclaradas = new Set();
         this.classesRegistradas = new Map();
         this.classeAtualEmAnalise = null;
         this.atual = 0;
@@ -1662,6 +1782,13 @@ const comum_1 = __importDefault(require("../tipos-de-simbolos/comum"));
  * de tipos de símbolos comuns entre todos os dialetos.
  */
 class AvaliadorSintaticoBase {
+    constructor() {
+        this.simbolos = [];
+        this.erros = [];
+        this.hashArquivo = -1;
+        this.atual = 0;
+        this.blocos = 0;
+    }
     erro(simbolo, mensagemDeErro) {
         const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simbolo, mensagemDeErro);
         return excecao;
@@ -1693,6 +1820,8 @@ class AvaliadorSintaticoBase {
         return this.simbolos[this.atual].tipo === tipo;
     }
     verificarTipoProximoSimbolo(tipo) {
+        if (this.atual + 1 >= this.simbolos.length)
+            return false;
         return this.simbolos[this.atual + 1].tipo === tipo;
     }
     estaNoFinal() {
@@ -1852,7 +1981,7 @@ class AvaliadorSintaticoBase {
             }
             const parametro = {};
             if (this.simbolos[this.atual].tipo === comum_1.default.MULTIPLICACAO) {
-                this.consumir(comum_1.default.MULTIPLICACAO, null);
+                this.avancarEDevolverAnterior();
                 parametro.abrangencia = 'multiplo';
             }
             else {
@@ -2318,7 +2447,10 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             case delegua_2.default.TEXTO:
                 const simboloNumeroTexto = this.avancarEDevolverAnterior();
                 const tipoInferido = (0, inferenciador_1.inferirTipoVariavel)(simboloNumeroTexto.literal);
-                return new construtos_1.Literal(this.hashArquivo, Number(simboloNumeroTexto.linha), simboloNumeroTexto.literal, tipoInferido);
+                const delimitadorTexto = simboloNumeroTexto.tipo === delegua_2.default.TEXTO
+                    ? simboloNumeroTexto.delimitadorTexto
+                    : undefined;
+                return new construtos_1.Literal(this.hashArquivo, Number(simboloNumeroTexto.linha), simboloNumeroTexto.literal, tipoInferido, delimitadorTexto);
             case delegua_2.default.PARA:
                 const simboloPara = this.avancarEDevolverAnterior();
                 return await this.paraComoConstruto(simboloPara);
@@ -8316,7 +8448,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
     inicializarPilhaEscopos() {
         this.pilhaEscopos = new pilha_escopos_1.PilhaEscopos();
         this.pilhaEscopos.empilhar(new informacao_escopo_1.InformacaoEscopo());
-        // Registrar funções nativas (built-ins) do Prisma no escopo do parser
+        // Registrar funções nativas (embutidos) do Prisma no escopo do parser
         // para evitar erros de variável não definida durante análise semântica
         this.pilhaEscopos.definirInformacoesVariavel('tipo', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tipo', 'função', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valor', 'qualquer'),
@@ -13369,11 +13501,12 @@ exports.ListaCompreensao = ListaCompreensao;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Literal = void 0;
 class Literal {
-    constructor(hashArquivo, linha, valor, tipo = 'qualquer') {
+    constructor(hashArquivo, linha, valor, tipo = 'qualquer', delimitadorTexto) {
         this.linha = linha;
         this.hashArquivo = hashArquivo;
         this.valor = valor;
         this.tipo = tipo;
+        this.delimitadorTexto = delimitadorTexto;
     }
     async aceitar(visitante) {
         return await visitante.visitarExpressaoLiteral(this);
@@ -14467,6 +14600,9 @@ exports.Expressao = Expressao;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Extensao = void 0;
 const declaracao_1 = require("./declaracao");
+/**
+ * Declaração de Extensão de Classe.
+ */
 class Extensao extends declaracao_1.Declaracao {
     constructor(simboloTipo, metodos, ehGlobal, hashArquivo) {
         super(Number(simboloTipo.linha), hashArquivo);
@@ -14999,6 +15135,7 @@ exports.Var = Var;
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EstilizadorDelegua = void 0;
+const formatadores_1 = require("../formatadores");
 /**
  * Estilizador de código para Delégua.
  * Aplica transformações no AST para enforcar convenções e melhorar qualidade do código.
@@ -15225,10 +15362,18 @@ class EstilizadorDelegua {
         this.modoValidacao = false;
         return violacoesEncontradas;
     }
+    estilizarEFormatar(declaracoes, opcoesFormatacao = {}) {
+        var _a;
+        const declaracoesEstilizadas = this.estilizar(declaracoes);
+        const formatador = new formatadores_1.FormatadorDelegua(opcoesFormatacao.quebraLinha || '\n', (_a = opcoesFormatacao.tamanhoIndentacao) !== null && _a !== void 0 ? _a : 4, {
+            delimitadorTexto: opcoesFormatacao.delimitadorTexto,
+        });
+        return formatador.formatar(declaracoesEstilizadas);
+    }
 }
 exports.EstilizadorDelegua = EstilizadorDelegua;
 
-},{}],125:[function(require,module,exports){
+},{"../formatadores":134}],125:[function(require,module,exports){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -15642,13 +15787,152 @@ const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
  * Normalmente usado por IDEs, mas pode ser usado por linha de comando ou programaticamente.
  */
 class FormatadorDelegua {
-    constructor(quebraLinha, tamanhoIndentacao = 4) {
+    constructor(quebraLinha, tamanhoIndentacao = 4, opcoes = {}) {
         this.quebraLinha = quebraLinha;
         this.tamanhoIndentacao = tamanhoIndentacao;
         this.indentacaoAtual = 0;
         this.codigoFormatado = '';
         this.devePularLinha = true;
         this.deveIndentar = true;
+        this.delimitadorTexto = opcoes.delimitadorTexto || 'aspas-simples';
+    }
+    visitarDeclaracaoAjuda(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}ajuda(`;
+        if (declaracao.elemento) {
+            this.formatarDeclaracaoOuConstruto(declaracao.elemento);
+        }
+        this.codigoFormatado += `)${this.quebraLinha}`;
+    }
+    visitarDeclaracaoExtensao(declaracao) {
+        const global = declaracao.ehGlobal ? 'global ' : '';
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}extensão ${global}de ${declaracao.simboloTipo.lexema} {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let metodo of declaracao.metodos) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}${metodo.simbolo.lexema}`;
+            this.visitarExpressaoFuncaoConstruto(metodo.funcao);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}${this.quebraLinha}`;
+    }
+    visitarDeclaracaoInterface(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}interface ${declaracao.simbolo.lexema} {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let propriedade of declaracao.propriedades) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}${propriedade.nome.lexema}: ${propriedade.tipo || 'qualquer'}${this.quebraLinha}`;
+        }
+        for (let metodo of declaracao.metodos) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}${metodo.nome.lexema}(`;
+            for (let parametro of metodo.parametros) {
+                this.codigoFormatado += `${parametro.nome.lexema}: ${parametro.tipoDado || 'qualquer'}, `;
+            }
+            if (metodo.parametros.length > 0) {
+                this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+            }
+            this.codigoFormatado += `)`;
+            if (metodo.tipoRetorno) {
+                this.codigoFormatado += `: ${metodo.tipoRetorno}`;
+            }
+            this.codigoFormatado += this.quebraLinha;
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}${this.quebraLinha}`;
+    }
+    visitarExpressaoAjuda(expressao) {
+        this.codigoFormatado += `ajuda(`;
+        if (expressao.valor) {
+            this.formatarDeclaracaoOuConstruto(expressao.valor);
+        }
+        this.codigoFormatado += `)`;
+    }
+    visitarExpressaoEnquanto(expressao) {
+        this.codigoFormatado += `enquanto `;
+        this.formatarDeclaracaoOuConstruto(expressao.condicao);
+        this.codigoFormatado += ` {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracao of expressao.corpo.declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracao);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}`;
+    }
+    visitarExpressaoElvis(expressao) {
+        this.formatarDeclaracaoOuConstruto(expressao.esquerda);
+        this.codigoFormatado += ` ?? `;
+        this.formatarDeclaracaoOuConstruto(expressao.direita);
+    }
+    visitarExpressaoFazer(expressao) {
+        this.codigoFormatado += `fazer {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracao of expressao.caminhoFazer.declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracao);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}} enquanto `;
+        this.formatarDeclaracaoOuConstruto(expressao.condicaoEnquanto);
+    }
+    visitarExpressaoListaCompreensao(listaCompreensao) {
+        this.codigoFormatado += `[`;
+        this.formatarDeclaracaoOuConstruto(listaCompreensao.expressaoRetorno);
+        this.codigoFormatado += ` para cada `;
+        this.formatarDeclaracaoOuConstruto(listaCompreensao.referenciaVariavelIteracao);
+        this.codigoFormatado += ` de `;
+        this.formatarDeclaracaoOuConstruto(listaCompreensao.paraCada.vetorOuDicionario);
+        this.codigoFormatado += `]`;
+    }
+    visitarExpressaoPara(expressao) {
+        this.codigoFormatado += `para `;
+        this.devePularLinha = false;
+        if (expressao.inicializador) {
+            if (Array.isArray(expressao.inicializador)) {
+                this.deveIndentar = false;
+                for (let declaracaoInicializador of expressao.inicializador) {
+                    this.formatarDeclaracaoOuConstruto(declaracaoInicializador);
+                }
+                this.deveIndentar = true;
+            }
+            else {
+                this.formatarDeclaracaoOuConstruto(expressao.inicializador);
+            }
+        }
+        this.codigoFormatado += `; `;
+        this.formatarDeclaracaoOuConstruto(expressao.condicao);
+        this.codigoFormatado += `; `;
+        this.formatarDeclaracaoOuConstruto(expressao.incrementar);
+        this.devePularLinha = true;
+        this.codigoFormatado += ` {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracao of expressao.corpo.declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracao);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}`;
+    }
+    visitarExpressaoParaCada(expressao) {
+        this.codigoFormatado += `para cada ${expressao.variavelIteracao} de `;
+        this.formatarDeclaracaoOuConstruto(expressao.vetorOuDicionario);
+        this.codigoFormatado += ` {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracao of expressao.corpo.declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracao);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}`;
+    }
+    visitarExpressaoSeTernario(expressao) {
+        this.formatarDeclaracaoOuConstruto(expressao.condicao);
+        this.codigoFormatado += ` ? `;
+        this.formatarDeclaracaoOuConstruto(expressao.expressaoSe);
+        this.codigoFormatado += ` : `;
+        this.formatarDeclaracaoOuConstruto(expressao.expressaoSenao);
+    }
+    obterDelimitadorTexto(expressao) {
+        if (this.delimitadorTexto === 'aspas-duplas') {
+            return '"';
+        }
+        if (this.delimitadorTexto === 'preservar' && expressao.delimitadorTexto) {
+            return expressao.delimitadorTexto;
+        }
+        return "'";
     }
     /* istanbul ignore next */
     visitarExpressaoTuplaN(expressao) {
@@ -15688,7 +15972,7 @@ class FormatadorDelegua {
     }
     visitarDeclaracaoComentario(declaracao) {
         if (declaracao.multilinha) {
-            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}/* `;
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}/*${this.quebraLinha}`;
             for (let linhaConteudo of declaracao.conteudo) {
                 this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}  ${linhaConteudo.replace(/\s+/g, ' ')}${this.quebraLinha}`;
             }
@@ -15771,6 +16055,9 @@ class FormatadorDelegua {
     visitarDeclaracaoDeExpressao(declaracao) {
         this.codigoFormatado += ' '.repeat(this.indentacaoAtual);
         this.formatarDeclaracaoOuConstruto(declaracao.expressao);
+        if (!this.codigoFormatado.endsWith(this.quebraLinha)) {
+            this.codigoFormatado += this.quebraLinha;
+        }
     }
     visitarDeclaracaoDefinicaoFuncao(declaracao) {
         this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}função `;
@@ -15782,7 +16069,13 @@ class FormatadorDelegua {
     visitarDeclaracaoEnquanto(declaracao) {
         this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}enquanto `;
         this.formatarDeclaracaoOuConstruto(declaracao.condicao);
-        this.formatarDeclaracaoOuConstruto(declaracao.corpo);
+        this.codigoFormatado += ` {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracaoBloco of declaracao.corpo.declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}${this.quebraLinha}`;
     }
     visitarDeclaracaoEscolha(declaracao) {
         this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}escolha `;
@@ -16147,13 +16440,19 @@ class FormatadorDelegua {
     }
     visitarExpressaoLiteral(expressao) {
         if (typeof expressao.valor === 'string') {
-            const valorStr = expressao.valor
+            const delimitador = this.obterDelimitadorTexto(expressao);
+            let valorTexto = expressao.valor
                 .replace(/\\/g, '\\\\')
                 .replace(/\r/g, '\\r')
                 .replace(/\n/g, '\\n')
-                .replace(/\t/g, '\\t')
-                .replace(/'/g, "\\'");
-            this.codigoFormatado += `'${valorStr}'`;
+                .replace(/\t/g, '\\t');
+            if (delimitador === "'") {
+                valorTexto = valorTexto.replace(/'/g, "\\'");
+            }
+            else {
+                valorTexto = valorTexto.replace(/"/g, '\\"');
+            }
+            this.codigoFormatado += `${delimitador}${valorTexto}${delimitador}`;
             return;
         }
         if (['logico', 'lógico'].includes(expressao.tipo)) {
@@ -16199,7 +16498,7 @@ class FormatadorDelegua {
         this.formatarDeclaracaoOuConstruto(expressao.valor);
     }
     visitarExpressaoUnaria(expressao) {
-        let operador;
+        let operador = '';
         switch (expressao.operador.tipo) {
             case delegua_1.default.INCREMENTAR:
                 operador = `++`;
@@ -16244,6 +16543,12 @@ class FormatadorDelegua {
             case construtos_1.AcessoIndiceVariavel:
                 this.visitarExpressaoAcessoIndiceVariavel(declaracaoOuConstruto);
                 break;
+            case construtos_1.AcessoMetodo:
+                this.visitarExpressaoAcessoMetodo(declaracaoOuConstruto);
+                break;
+            case construtos_1.AcessoPropriedade:
+                this.visitarExpressaoAcessoPropriedade(declaracaoOuConstruto);
+                break;
             case construtos_1.AcessoMetodoOuPropriedade:
                 this.visitarExpressaoAcessoMetodoOuPropriedade(declaracaoOuConstruto);
                 break;
@@ -16271,6 +16576,9 @@ class FormatadorDelegua {
             case declaracoes_1.Classe:
                 this.visitarDeclaracaoClasse(declaracaoOuConstruto);
                 break;
+            case declaracoes_1.Comentario:
+                this.visitarDeclaracaoComentario(declaracaoOuConstruto);
+                break;
             case declaracoes_1.Continua:
                 this.visitarExpressaoContinua(declaracaoOuConstruto);
                 break;
@@ -16286,6 +16594,9 @@ class FormatadorDelegua {
             case declaracoes_1.Enquanto:
                 this.visitarDeclaracaoEnquanto(declaracaoOuConstruto);
                 break;
+            case declaracoes_1.Extensao:
+                this.visitarDeclaracaoExtensao(declaracaoOuConstruto);
+                break;
             case declaracoes_1.Escreva:
                 this.visitarDeclaracaoEscreva(declaracaoOuConstruto);
                 break;
@@ -16310,6 +16621,9 @@ class FormatadorDelegua {
             case declaracoes_1.Importar:
                 this.visitarDeclaracaoImportar(declaracaoOuConstruto);
                 break;
+            case declaracoes_1.InterfaceDeclaracao:
+                this.visitarDeclaracaoInterface(declaracaoOuConstruto);
+                break;
             case construtos_1.ImportarComoConstruto:
                 this.visitarExpressaoImportar(declaracaoOuConstruto);
                 break;
@@ -17173,7 +17487,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./avaliador-sintatico-interface"), exports);
 __exportStar(require("./componente-modulo-classe-interface"), exports);
 __exportStar(require("./componente-modulo-funcao-interface"), exports);
-__exportStar(require("./estilizador-comum-interface"), exports);
+__exportStar(require("./estilizador/estilizador-interface"), exports);
 __exportStar(require("./formatador-comum-interface"), exports);
 __exportStar(require("./interpretador-com-depuracao-interface"), exports);
 __exportStar(require("./interpretador-interface"), exports);
@@ -17194,7 +17508,7 @@ __exportStar(require("./construtos"), exports);
 __exportStar(require("./erros"), exports);
 __exportStar(require("./retornos"), exports);
 
-},{"./avaliador-sintatico-interface":139,"./componente-modulo-classe-interface":140,"./componente-modulo-funcao-interface":141,"./construtos":142,"./erros":146,"./estilizador-comum-interface":147,"./formatador-comum-interface":148,"./interpretador-com-depuracao-interface":150,"./interpretador-interface":151,"./lexador-interface":152,"./modulo-interface":153,"./parametro-interface":154,"./pilha-interface":155,"./primitiva-interface":156,"./resolvedor-interface":157,"./resultado-parcial-interpretador-interface":158,"./retornos":159,"./retornos/retorno-execucao-interface":162,"./simbolo-interface":165,"./tradutor-interface":166,"./variavel-interface":167,"./visitante-comum-interface":168,"./visitante-delegua-interface":169}],150:[function(require,module,exports){
+},{"./avaliador-sintatico-interface":139,"./componente-modulo-classe-interface":140,"./componente-modulo-funcao-interface":141,"./construtos":142,"./erros":146,"./estilizador/estilizador-interface":147,"./formatador-comum-interface":148,"./interpretador-com-depuracao-interface":150,"./interpretador-interface":151,"./lexador-interface":152,"./modulo-interface":153,"./parametro-interface":154,"./pilha-interface":155,"./primitiva-interface":156,"./resolvedor-interface":157,"./resultado-parcial-interpretador-interface":158,"./retornos":159,"./retornos/retorno-execucao-interface":162,"./simbolo-interface":165,"./tradutor-interface":166,"./variavel-interface":167,"./visitante-comum-interface":168,"./visitante-delegua-interface":169}],150:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 
@@ -26131,6 +26445,8 @@ class Lexador {
             if (caractere === delimitador) {
                 this.avancar();
                 this.adicionarSimbolo(delegua_1.default.TEXTO, valor);
+                const ultimoSimbolo = this.simbolos[this.simbolos.length - 1];
+                ultimoSimbolo.delimitadorTexto = delimitador;
                 return;
             }
             if (caractere === '\0' && this.eUltimaLinha()) {
@@ -26739,11 +27055,11 @@ function obterMapaLexemaParaParadigma() {
  */
 function obterFormaAlternativa(lexema, paradigmaAlvo) {
     var _a, _b;
-    const lexemaLower = lexema.toLowerCase();
+    const lexemaMinusculo = lexema.toLowerCase();
     // Encontra o grupo que contém este lexema
     for (const grupo of exports.gruposPalavrasParadigma) {
-        const temImperativo = (_a = grupo.imperativo) === null || _a === void 0 ? void 0 : _a.some((p) => p === lexemaLower);
-        const temInfinitivo = (_b = grupo.infinitivo) === null || _b === void 0 ? void 0 : _b.some((p) => p === lexemaLower);
+        const temImperativo = (_a = grupo.imperativo) === null || _a === void 0 ? void 0 : _a.some((p) => p === lexemaMinusculo);
+        const temInfinitivo = (_b = grupo.infinitivo) === null || _b === void 0 ? void 0 : _b.some((p) => p === lexemaMinusculo);
         if (temImperativo || temInfinitivo) {
             // Retorna a primeira forma do paradigma alvo
             if (paradigmaAlvo === 'imperativo' && grupo.imperativo && grupo.imperativo.length > 0) {
@@ -27337,7 +27653,7 @@ exports.palavrasReservadasMicroGramatica = {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Simbolo = void 0;
 class Simbolo {
-    constructor(tipo, lexema, literal, linha, hashArquivo, colunaInicio = 0, colunaFim = 0) {
+    constructor(tipo, lexema, literal, linha, hashArquivo, colunaInicio = 0, colunaFim = 0, delimitadorTexto) {
         this.tipo = tipo;
         this.lexema = lexema;
         this.literal = literal;
@@ -27345,6 +27661,7 @@ class Simbolo {
         this.hashArquivo = hashArquivo;
         this.colunaInicio = colunaInicio;
         this.colunaFim = colunaFim;
+        this.delimitadorTexto = delimitadorTexto;
     }
     paraTexto() {
         return this.tipo + ' ' + this.lexema + ' ' + this.literal;
@@ -43475,7 +43792,7 @@ class TradutorAssemblyScript {
     }
     traduzirDeclaracaoTendoComo(declaracaoTendoComo) {
         // TendoComo is a resource management pattern (like try-with-resources in Java)
-        // AssemblyScript doesn't have built-in support, so we'll just treat it as a scope
+        // AssemblyScript doesn't have embutidos support, so we'll just treat it as a scope
         let resultado = `// tendo ${declaracaoTendoComo.simboloVariavel.lexema} como recurso\n`;
         resultado += ' '.repeat(this.indentacao);
         resultado += `let ${declaracaoTendoComo.simboloVariavel.lexema} = `;
@@ -44824,7 +45141,7 @@ class TradutorElixir {
         return Promise.resolve(`${objeto}.${metodo}`);
     }
     /**
-     * Mapeia métodos built-in de Delégua para Elixir
+     * Mapeia métodos embutidos de Delégua para Elixir
      */
     mapearMetodoBuiltIn(metodo, objeto, argumentos) {
         switch (metodo) {
@@ -44956,7 +45273,7 @@ class TradutorElixir {
             const acessoMetodo = expressao.entidadeChamada;
             const objeto = await acessoMetodo.objeto.aceitar(this);
             const metodo = this.converterIdentificador(acessoMetodo.nomeMetodo);
-            // Mapear métodos built-in
+            // Mapear métodos embutidos
             const metodoMapeado = this.mapearMetodoBuiltIn(metodo, objeto, argumentos);
             if (metodoMapeado) {
                 return Promise.resolve(metodoMapeado);
@@ -44968,7 +45285,7 @@ class TradutorElixir {
             const acesso = expressao.entidadeChamada;
             const objeto = await acesso.objeto.aceitar(this);
             const simbolo = this.converterIdentificador(acesso.simbolo.lexema);
-            // Mapear métodos built-in
+            // Mapear métodos embutidos
             const metodoMapeado = this.mapearMetodoBuiltIn(simbolo, objeto, argumentos);
             if (metodoMapeado) {
                 return Promise.resolve(metodoMapeado);