diff --git a/fontes/analisador-semantico/analisador-semantico-base.ts b/fontes/analisador-semantico/analisador-semantico-base.ts
index c22d5d0a..741f3cbf 100644
--- a/fontes/analisador-semantico/analisador-semantico-base.ts
+++ b/fontes/analisador-semantico/analisador-semantico-base.ts
@@ -67,12 +67,12 @@ import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from '../quebras';
  */
 export abstract class AnalisadorSemanticoBase implements AnalisadorSemanticoInterface {
     diagnosticos: DiagnosticoAnalisadorSemantico[];
-    
+
     abstract analisar(declaracoes: Declaracao[]): RetornoAnalisadorSemantico;
 
     adicionarDiagnostico(
-        simbolo: SimboloInterface, 
-        mensagem: string, 
+        simbolo: SimboloInterface,
+        mensagem: string,
         severidade: DiagnosticoSeveridade = DiagnosticoSeveridade.ERRO
     ): void {
         this.diagnosticos.push({
diff --git a/fontes/analisador-semantico/analisador-semantico.ts b/fontes/analisador-semantico/analisador-semantico.ts
index 7b9b54d4..b5986c3e 100644
--- a/fontes/analisador-semantico/analisador-semantico.ts
+++ b/fontes/analisador-semantico/analisador-semantico.ts
@@ -414,7 +414,7 @@ export class AnalisadorSemantico extends AnalisadorSemanticoBase {
     visitarDeclaracaoEscreva(declaracao: Escreva) {
         if (declaracao.argumentos.length === 0) {
             const { linha, hashArquivo } = declaracao;
-            const simbolo: SimboloInterface<''> = { literal: '', tipo:'', lexema: 'escreva', linha, hashArquivo }
+            const simbolo: SimboloInterface<''> = { literal: '', tipo: '', lexema: 'escreva', linha, hashArquivo };
             this.erro(simbolo, `É preciso ter um ou mais parametros para 'escreva(...)'`);
             return Promise.resolve();
         }
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico-base.ts b/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
index a74b02c1..c59d6288 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
@@ -1,7 +1,6 @@
 import { Binario, Chamada, Construto, FuncaoConstruto, Logico, Unario } from '../construtos';
 import {
     Classe,
-    Const,
     Continua,
     Declaracao,
     Enquanto,
@@ -13,6 +12,7 @@ import {
     Importar,
     Leia,
     Para,
+    ParaCada,
     Retorna,
     Se,
     Sustar,
@@ -38,49 +38,47 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
     atual: number;
     blocos: number;
 
-    protected declaracaoDeVariaveis(): Var[] {
-        throw new Error('Método não implementado.');
-    }
-
-    consumir(tipo: string, mensagemDeErro: string): SimboloInterface {
+    protected consumir(tipo: string, mensagemDeErro: string): SimboloInterface {
         if (this.verificarTipoSimboloAtual(tipo)) return this.avancarEDevolverAnterior();
         throw this.erro(this.simbolos[this.atual], mensagemDeErro);
     }
 
-    erro(simbolo: SimboloInterface, mensagemDeErro: string): ErroAvaliadorSintatico {
+    protected erro(simbolo: SimboloInterface, mensagemDeErro: string): ErroAvaliadorSintatico {
         const excecao = new ErroAvaliadorSintatico(simbolo, mensagemDeErro);
         this.erros.push(excecao);
         return excecao;
     }
 
-    simboloAnterior(): SimboloInterface {
+    protected simboloAnterior(): SimboloInterface {
         return this.simbolos[this.atual - 1];
     }
 
-    verificarTipoSimboloAtual(tipo: string): boolean {
+    protected verificarTipoSimboloAtual(tipo: string): boolean {
         if (this.estaNoFinal()) return false;
         return this.simbolos[this.atual].tipo === tipo;
     }
 
-    verificarTipoProximoSimbolo(tipo: string): boolean {
+    protected verificarTipoProximoSimbolo(tipo: string): boolean {
         return this.simbolos[this.atual + 1].tipo === tipo;
     }
 
-    estaNoFinal(): boolean {
+    protected estaNoFinal(): boolean {
         return this.atual === this.simbolos.length;
     }
 
-    avancarEDevolverAnterior(): SimboloInterface {
+    protected avancarEDevolverAnterior(): SimboloInterface {
         if (!this.estaNoFinal()) this.atual += 1;
         return this.simbolos[this.atual - 1];
     }
 
-    regredirEDevolverAtual(): SimboloInterface {
+    // TODO: Verificar possibilidade de remoção. 
+    // Regressão de símbolo é uma roubada por N razões.
+    protected regredirEDevolverAtual(): SimboloInterface {
         if (this.atual > 0) this.atual -= 1;
         return this.simbolos[this.atual];
     }
 
-    verificarSeSimboloAtualEIgualA(...argumentos: string[]): boolean {
+    protected verificarSeSimboloAtualEIgualA(...argumentos: string[]): boolean {
         for (let i = 0; i < argumentos.length; i++) {
             const tipoAtual = argumentos[i];
             if (this.verificarTipoSimboloAtual(tipoAtual)) {
@@ -92,17 +90,36 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
         return false;
     }
 
-    declaracaoLeia(): Leia {
-        throw new Error('Método não implementado.');
-    }
-
-    abstract primario(): Construto;
-
-    finalizarChamada(entidadeChamada: Construto): Construto {
+    /**
+     * Os métodos a seguir devem ser implementados nos seus respectivos 
+     * dialetos por diferentes razões: seja porque o dialeto correspondente
+     * tem uma abordagem diferente sobre entrada e saída, seja porque a 
+     * funcionalidade sequer existe, mas é suprimida por outra.
+     * 
+     * Esses métodos não precisam ser expostos. A recomendação geral é
+     * implementá-los como `protected`.
+     */
+    protected abstract atribuir(): Construto; // `atribuir()` deve chamar `ou()` ou algum outro método unário ou 
+                                    // binário de visita na implementação.
+    protected abstract blocoEscopo(): Declaracao[];
+    protected abstract chamar(): Construto;
+    protected abstract corpoDaFuncao(tipo: string): FuncaoConstruto;
+    protected abstract declaracaoEnquanto(): Enquanto;
+    protected abstract declaracaoEscolha(): Escolha;
+    protected abstract declaracaoEscreva(): Escreva;
+    protected abstract declaracaoFazer(): Fazer;
+    protected abstract declaracaoLeia(): Leia
+    protected abstract declaracaoPara(): Para | ParaCada;
+    protected abstract declaracaoSe(): Se;
+    protected abstract primario(): Construto;
+    protected abstract resolverDeclaracaoForaDeBloco(): Declaracao;
+
+    protected finalizarChamada(entidadeChamada: Construto): Chamada {
         const argumentos: Array<Construto> = [];
 
         if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
             do {
+                // `apply()` em JavaScript aceita até 255 parâmetros.
                 if (argumentos.length >= 255) {
                     throw this.erro(this.simbolos[this.atual], 'Não pode haver mais de 255 argumentos.');
                 }
@@ -111,13 +128,10 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
         }
 
         const parenteseDireito = this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
-
         return new Chamada(this.hashArquivo, entidadeChamada, parenteseDireito, argumentos);
     }
 
-    abstract chamar(): Construto;
-
-    unario(): Construto {
+    protected unario(): Construto {
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NEGACAO, tiposDeSimbolos.SUBTRACAO)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.unario();
@@ -127,7 +141,7 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
         return this.chamar();
     }
 
-    exponenciacao(): Construto {
+    protected exponenciacao(): Construto {
         let expressao = this.unario();
 
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.EXPONENCIACAO)) {
@@ -139,7 +153,7 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
         return expressao;
     }
 
-    multiplicar(): Construto {
+    protected multiplicar(): Construto {
         let expressao = this.exponenciacao();
 
         while (
@@ -158,7 +172,7 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
         return expressao;
     }
 
-    adicaoOuSubtracao(): Construto {
+    protected adicaoOuSubtracao(): Construto {
         let expressao = this.multiplicar();
 
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUBTRACAO, tiposDeSimbolos.ADICAO)) {
@@ -170,19 +184,15 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
         return expressao;
     }
 
-    bitShift(): Construto {
-        throw new Error('Método não implementado.');
-    }
-
-    bitE(): Construto {
-        throw new Error('Método não implementado.');
-    }
-
-    bitOu(): Construto {
+    /**
+     * Este método é usado por alguns dialetos de Portugol que possuem declarações
+     * de múltiplas variáveis na mesma linha.
+     */
+    protected declaracaoDeVariaveis(): Var[] {
         throw new Error('Método não implementado.');
     }
 
-    comparar(): Construto {
+    protected comparar(): Construto {
         let expressao = this.adicaoOuSubtracao();
 
         while (
@@ -201,7 +211,7 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
         return expressao;
     }
 
-    comparacaoIgualdade(): Construto {
+    protected comparacaoIgualdade(): Construto {
         let expressao = this.comparar();
 
         while (
@@ -219,11 +229,7 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
         return expressao;
     }
 
-    em(): Construto {
-        throw new Error('Método não implementado.');
-    }
-
-    e(): Construto {
+    protected e(): Construto {
         let expressao = this.comparacaoIgualdade();
 
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.E)) {
@@ -235,7 +241,7 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
         return expressao;
     }
 
-    ou(): Construto {
+    protected ou(): Construto {
         let expressao = this.e();
 
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.OU)) {
@@ -247,106 +253,111 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
         return expressao;
     }
 
-    /**
-     * `atribuir()` deve chamar `ou()` na implementação.
-     */
-    abstract atribuir(): Construto;
-
-    expressao(): Construto {
+    protected expressao(): Construto {
         return this.atribuir();
     }
 
-    abstract declaracaoEscreva(): Escreva;
+    protected funcao(tipo: string): FuncaoDeclaracao {
+        const simboloFuncao: SimboloInterface = this.avancarEDevolverAnterior();
 
-    declaracaoExpressao(simboloAnterior?: SimboloInterface): Expressao {
-        throw new Error('Método não implementado.');
+        const nomeFuncao: SimboloInterface = this.consumir(tiposDeSimbolos.IDENTIFICADOR, `Esperado nome ${tipo}.`);
+        return new FuncaoDeclaracao(nomeFuncao, this.corpoDaFuncao(tipo));
     }
 
-    abstract blocoEscopo(): Declaracao[];
+    protected logicaComumParametros(): ParametroInterface[] {
+        const parametros: ParametroInterface[] = [];
+
+        do {
+            if (parametros.length >= 255) {
+                this.erro(this.simbolos[this.atual], 'Não pode haver mais de 255 parâmetros');
+            }
+
+            const parametro: Partial<ParametroInterface> = {};
 
-    abstract declaracaoSe(): Se;
+            if (this.simbolos[this.atual].tipo === tiposDeSimbolos.MULTIPLICACAO) {
+                this.consumir(tiposDeSimbolos.MULTIPLICACAO, null);
+                parametro.abrangencia = 'multiplo';
+            } else {
+                parametro.abrangencia = 'padrao';
+            }
 
-    abstract declaracaoEnquanto(): Enquanto;
+            parametro.nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do parâmetro.');
 
-    abstract declaracaoPara(): Para;
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
+                parametro.valorPadrao = this.primario();
+            }
 
-    declaracaoSustar(): Sustar {
-        throw new Error('Método não implementado.');
+            parametros.push(parametro as ParametroInterface);
+
+            if (parametro.abrangencia === 'multiplo') break;
+        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
+        return parametros;
     }
 
-    declaracaoContinua(): Continua {
+    /**
+     * Os métodos a seguir só devem ser implementados se o dialeto
+     * em questão realmente possui a funcionalidade, e devem levantar
+     * erro em caso contrário.
+     */
+
+    protected bitShift(): Construto {
         throw new Error('Método não implementado.');
     }
 
-    declaracaoRetorna(): Retorna {
+    protected bitE(): Construto {
         throw new Error('Método não implementado.');
     }
 
-    abstract declaracaoEscolha(): Escolha;
-
-    declaracaoImportar(): Importar {
+    protected bitOu(): Construto {
         throw new Error('Método não implementado.');
     }
 
-    declaracaoTente(): Tente {
+    protected declaracaoContinua(): Continua {
         throw new Error('Método não implementado.');
     }
 
-    abstract declaracaoFazer(): Fazer;
-
-    resolverDeclaracao() {
+    protected declaracaoDeClasse(): Classe {
         throw new Error('Método não implementado.');
     }
 
-    declaracaoDeVariavel(): Var {
+    protected declaracaoDeVariavel(): Var {
         throw new Error('Método não implementado.');
     }
 
-    funcao(tipo: string): FuncaoDeclaracao {
-        const simboloFuncao: SimboloInterface = this.avancarEDevolverAnterior();
-
-        const nomeFuncao: SimboloInterface = this.consumir(tiposDeSimbolos.IDENTIFICADOR, `Esperado nome ${tipo}.`);
-        return new FuncaoDeclaracao(nomeFuncao, this.corpoDaFuncao(tipo));
+    protected declaracaoExpressao(simboloAnterior?: SimboloInterface): Expressao {
+        throw new Error('Método não implementado.');
     }
 
-    abstract corpoDaFuncao(tipo: string): FuncaoConstruto;
-
-    declaracaoDeClasse(): Classe {
+    protected declaracaoImportar(): Importar {
         throw new Error('Método não implementado.');
     }
 
-    protected logicaComumParametros(): ParametroInterface[] {
-        const parametros: ParametroInterface[] = [];
-
-        do {
-            if (parametros.length >= 255) {
-                this.erro(this.simbolos[this.atual], 'Não pode haver mais de 255 parâmetros');
-            }
-
-            const parametro: Partial<ParametroInterface> = {};
-
-            if (this.simbolos[this.atual].tipo === tiposDeSimbolos.MULTIPLICACAO) {
-                this.consumir(tiposDeSimbolos.MULTIPLICACAO, null);
-                parametro.abrangencia = 'multiplo';
-            } else {
-                parametro.abrangencia = 'padrao';
-            }
-
-            parametro.nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do parâmetro.');
+    protected declaracaoRetorna(): Retorna {
+        throw new Error('Método não implementado.');
+    }
 
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
-                parametro.valorPadrao = this.primario();
-            }
+    protected declaracaoSustar(): Sustar {
+        throw new Error('Método não implementado.');
+    }
 
-            parametros.push(parametro as ParametroInterface);
+    protected declaracaoTente(): Tente {
+        throw new Error('Método não implementado.');
+    }
 
-            if (parametro.abrangencia === 'multiplo') break;
-        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
-        return parametros;
+    protected em(): Construto {
+        throw new Error('Método não implementado.');
     }
 
-    abstract resolverDeclaracaoForaDeBloco(): Declaracao;
+    protected resolverDeclaracao() {
+        throw new Error('Método não implementado.');
+    }
 
+    /**
+     * Este é o ponto de entrada de toda a avaliação sintática. É o 
+     * único método mencionado na interface do avaliador sintático. 
+     * @param retornoLexador O retorno do Lexador.
+     * @param hashArquivo O hash do arquivo, gerado pela função `cyrb53`. 
+     */
     abstract analisar(
         retornoLexador: RetornoLexador<SimboloInterface>,
         hashArquivo: number
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts
index 2b634a28..093cd29d 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts
@@ -61,6 +61,7 @@ import { RetornoLexador } from '../interfaces/retornos/retorno-lexador';
 import { Simbolo } from '../lexador';
 import { TipoDadosElementar } from '../tipo-dados-elementar';
 import { RetornoDeclaracao } from './retornos';
+import { AvaliadorSintaticoBase } from './avaliador-sintatico-base';
 
 // Será usado para forçar tipagem em construtos e em algumas funções internas.
 type TipoDeSimboloDelegua = (typeof tiposDeSimbolos)[keyof typeof tiposDeSimbolos];
@@ -70,7 +71,10 @@ type TipoDeSimboloDelegua = (typeof tiposDeSimbolos)[keyof typeof tiposDeSimbolo
  * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
  * Há dois grupos de estruturas de alto nível: Construtos e Declarações.
  */
-export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloInterface, Declaracao> {
+export class AvaliadorSintatico 
+    extends AvaliadorSintaticoBase
+    implements AvaliadorSintaticoInterface<SimboloInterface, Declaracao> 
+{
     pilhaDecoradores: Decorador[];
     simbolos: SimboloInterface[];
     erros: ErroAvaliadorSintatico[];
@@ -81,6 +85,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
     performance: boolean;
 
     constructor(performance = false) {
+        super();
         this.hashArquivo = 0;
         this.atual = 0;
         this.blocos = 0;
@@ -88,34 +93,10 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         this.performance = performance;
     }
 
-    declaracaoDeVariavel(): Var {
-        throw new Error('Método não implementado.');
-    }
-
-    erro(simbolo: SimboloInterface, mensagemDeErro: string): ErroAvaliadorSintatico {
-        const excecao = new ErroAvaliadorSintatico(simbolo, mensagemDeErro);
-        this.erros.push(excecao);
-        return excecao;
-    }
-
-    consumir(tipo: string, mensagemDeErro: string): SimboloInterface {
-        if (this.verificarTipoSimboloAtual(tipo)) return this.avancarEDevolverAnterior();
-        throw this.erro(this.simbolos[this.atual], mensagemDeErro);
-    }
-
-    verificarTipoSimboloAtual(tipo: string): boolean {
-        if (this.estaNoFinal()) return false;
-        return this.simbolos[this.atual].tipo === tipo;
-    }
-
-    verificarTipoProximoSimbolo(tipo: string): boolean {
-        return this.simbolos[this.atual + 1].tipo === tipo;
-    }
-
-    verificarDefinicaoTipoAtual(): TipoDadosElementar {
+    protected verificarDefinicaoTipoAtual(): TipoDadosElementar {
         const tipos = [...Object.values(tipoDeDadosDelegua)];
 
-        const lexema = this.simboloAtual().lexema.toLowerCase();
+        const lexema = this.simbolos[this.atual].lexema.toLowerCase();
         const contemTipo = tipos.find((tipo) => tipo === lexema);
 
         if (contemTipo && this.verificarTipoProximoSimbolo(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
@@ -136,36 +117,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return contemTipo as TipoDadosElementar;
     }
 
-    simboloAtual(): SimboloInterface {
-        return this.simbolos[this.atual];
-    }
-
-    simboloAnterior(): SimboloInterface {
-        return this.simbolos[this.atual - 1];
-    }
-
-    estaNoFinal(): boolean {
-        return this.atual === this.simbolos.length;
-    }
-
-    avancarEDevolverAnterior(): SimboloInterface {
-        if (!this.estaNoFinal()) this.atual += 1;
-        return this.simbolos[this.atual - 1];
-    }
-
-    verificarSeSimboloAtualEIgualA(...argumentos: string[]): boolean {
-        for (let i = 0; i < argumentos.length; i++) {
-            const tipoAtual = argumentos[i];
-            if (this.verificarTipoSimboloAtual(tipoAtual)) {
-                this.avancarEDevolverAnterior();
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    primario(): Construto {
+    override primario(): Construto {
         const simboloAtual = this.simbolos[this.atual];
         let valores = [];
         switch (simboloAtual.tipo) {
@@ -314,24 +266,25 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
                 this.avancarEDevolverAnterior();
                 this.consumir(tiposDeSimbolos.DE, "Esperado 'de' após 'tipo'.");
                 let _expressao;
-                if (this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.ESCREVA,
-                    tiposDeSimbolos.LEIA,
-                    tiposDeSimbolos.FUNCAO,
-                    tiposDeSimbolos.FUNÇÃO,
-                    tiposDeSimbolos.SE,
-                    tiposDeSimbolos.ENQUANTO,
-                    tiposDeSimbolos.PARA,
-                    tiposDeSimbolos.RETORNA,
-                    tipoDeDadosDelegua.INTEIRO,
-                    tipoDeDadosDelegua.TEXTO,
-                    tipoDeDadosDelegua.VETOR,
-                    tipoDeDadosDelegua.LOGICO,
-                    tipoDeDadosDelegua.LÓGICO,
-                    tipoDeDadosDelegua.VAZIO,
-                )
+                if (
+                    this.verificarSeSimboloAtualEIgualA(
+                        tiposDeSimbolos.ESCREVA,
+                        tiposDeSimbolos.LEIA,
+                        tiposDeSimbolos.FUNCAO,
+                        tiposDeSimbolos.FUNÇÃO,
+                        tiposDeSimbolos.SE,
+                        tiposDeSimbolos.ENQUANTO,
+                        tiposDeSimbolos.PARA,
+                        tiposDeSimbolos.RETORNA,
+                        tipoDeDadosDelegua.INTEIRO,
+                        tipoDeDadosDelegua.TEXTO,
+                        tipoDeDadosDelegua.VETOR,
+                        tipoDeDadosDelegua.LOGICO,
+                        tipoDeDadosDelegua.LÓGICO,
+                        tipoDeDadosDelegua.VAZIO
+                    )
                 ) {
-                    _expressao = this.simboloAnterior()
+                    _expressao = this.simboloAnterior();
                 } else {
                     _expressao = this.expressao() as any;
                 }
@@ -348,12 +301,12 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
                 let eParExpressaoRegular =
                     this.simbolos.filter((l) => l.linha === linhaAtual && l.tipo === tiposDeSimbolos.EXPRESSAO_REGULAR)
                         .length %
-                    2 ===
+                        2 ===
                     0;
                 if (eParExpressaoRegular) {
                     this.avancarEDevolverAnterior();
                     while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.EXPRESSAO_REGULAR)) {
-                        valor += this.simboloAtual().lexema || '';
+                        valor += this.simbolos[this.atual].lexema || '';
                         this.avancarEDevolverAnterior();
                     }
                     this.avancarEDevolverAnterior();
@@ -364,31 +317,17 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         throw this.erro(this.simbolos[this.atual], 'Esperado expressão.');
     }
 
-    finalizarChamada(entidadeChamada: Construto): Construto {
-        const argumentos: Array<Construto> = [];
-
-        if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
-            do {
-                if (argumentos.length >= 255) {
-                    throw this.erro(this.simbolos[this.atual], 'Não pode haver mais de 255 argumentos.');
-                }
-                argumentos.push(this.expressao());
-            } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
-        }
-
-        const parenteseDireito = this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
-
-        return new Chamada(this.hashArquivo, entidadeChamada, parenteseDireito, argumentos);
-    }
-
-    chamar(): Construto {
+    override chamar(): Construto {
         let expressao = this.primario();
 
         while (true) {
             if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_ESQUERDO)) {
                 expressao = this.finalizarChamada(expressao);
             } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO)) {
-                const nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, "Esperado nome de método ou propriedade após '.'.");
+                const nome = this.consumir(
+                    tiposDeSimbolos.IDENTIFICADOR,
+                    "Esperado nome de método ou propriedade após '.'."
+                );
                 expressao = new AcessoMetodoOuPropriedade(this.hashArquivo, expressao, nome);
             } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
                 const indice = this.expressao();
@@ -405,7 +344,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return expressao;
     }
 
-    unario(): Construto {
+    override unario(): Construto {
         if (
             this.verificarSeSimboloAtualEIgualA(
                 tiposDeSimbolos.NEGACAO,
@@ -423,19 +362,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return this.chamar();
     }
 
-    exponenciacao(): Construto {
-        let expressao = this.unario();
-
-        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.EXPONENCIACAO)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.unario();
-            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
-        }
-
-        return expressao;
-    }
-
-    multiplicar(): Construto {
+    override multiplicar(): Construto {
         let expressao = this.exponenciacao();
 
         while (
@@ -463,7 +390,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
      * ser avaliado pelo Interpretador.
      * @returns Um Construto, normalmente um `Binario`, ou `Unario` se houver alguma operação unária para ser avaliada.
      */
-    adicaoOuSubtracao(): Construto {
+    override adicaoOuSubtracao(): Construto {
         let expressao = this.multiplicar();
 
         while (
@@ -482,7 +409,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return expressao;
     }
 
-    bitShift(): Construto {
+    override bitShift(): Construto {
         let expressao = this.adicaoOuSubtracao();
 
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.MENOR_MENOR, tiposDeSimbolos.MAIOR_MAIOR)) {
@@ -494,7 +421,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return expressao;
     }
 
-    bitE(): Construto {
+    override bitE(): Construto {
         let expressao = this.bitShift();
 
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.BIT_AND)) {
@@ -506,7 +433,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return expressao;
     }
 
-    bitOu(): Construto {
+    override bitOu(): Construto {
         let expressao = this.bitE();
 
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.BIT_OR, tiposDeSimbolos.BIT_XOR)) {
@@ -518,7 +445,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return expressao;
     }
 
-    comparar(): Construto {
+    override comparar(): Construto {
         let expressao = this.bitOu();
 
         while (
@@ -530,14 +457,14 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
             )
         ) {
             const operador = this.simbolos[this.atual - 1];
-            const direito = this.bitOu();
+            const direito = this.bitOu(); // Única diferença entre esta implementação e base.
             expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
     }
 
-    comparacaoIgualdade(): Construto {
+    override comparacaoIgualdade(): Construto {
         let expressao = this.comparar();
 
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DIFERENTE, tiposDeSimbolos.IGUAL_IGUAL)) {
@@ -549,7 +476,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return expressao;
     }
 
-    em(): Construto {
+    override em(): Construto {
         let expressao = this.comparacaoIgualdade();
 
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.EM)) {
@@ -561,7 +488,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return expressao;
     }
 
-    e(): Construto {
+    override e(): Construto {
         let expressao = this.em();
 
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.E)) {
@@ -573,23 +500,11 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return expressao;
     }
 
-    ou(): Construto {
-        let expressao = this.e();
-
-        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.OU)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.e();
-            expressao = new Logico(this.hashArquivo, expressao, operador, direito);
-        }
-
-        return expressao;
-    }
-
     /**
      * Método que resolve atribuições.
      * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoPorIndice`.
      */
-    atribuir(): Construto {
+    override atribuir(): Construto {
         const expressao = this.ou();
 
         if (
@@ -603,10 +518,9 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
                 tiposDeSimbolos.MODULO_IGUAL,
             ].includes(expressao.operador.tipo)
         ) {
-
-            let simbolo = (expressao.esquerda as Variavel).simbolo
+            let simbolo = (expressao.esquerda as Variavel).simbolo;
             if (expressao.esquerda instanceof AcessoIndiceVariavel) {
-                simbolo = (expressao.esquerda.entidadeChamada as Variavel).simbolo
+                simbolo = (expressao.esquerda.entidadeChamada as Variavel).simbolo;
                 return new Atribuir(
                     this.hashArquivo,
                     simbolo,
@@ -615,12 +529,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
                 );
             }
 
-            return new Atribuir(
-                this.hashArquivo,
-                simbolo,
-                expressao,
-            );
-
+            return new Atribuir(this.hashArquivo, simbolo, expressao);
         } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
             const igual = this.simbolos[this.atual - 1];
             const valor = this.expressao();
@@ -646,12 +555,12 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return expressao;
     }
 
-    expressao(): Construto {
+    override expressao(): Construto {
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.LEIA)) return this.declaracaoLeia();
         return this.atribuir();
     }
 
-    blocoEscopo(): Array<RetornoDeclaracao> {
+    override blocoEscopo(): Array<RetornoDeclaracao> {
         let declaracoes: Array<RetornoDeclaracao> = [];
 
         while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA) && !this.estaNoFinal()) {
@@ -670,7 +579,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return declaracoes;
     }
 
-    declaracaoEnquanto(): Enquanto {
+    override declaracaoEnquanto(): Enquanto {
         try {
             this.blocos += 1;
 
@@ -683,7 +592,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         }
     }
 
-    declaracaoEscreva(): Escreva {
+    override declaracaoEscreva(): Escreva {
         const simboloAtual = this.simbolos[this.atual];
 
         this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
@@ -696,7 +605,6 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
             } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
         }
 
-
         this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
 
         // Ponto-e-vírgula é opcional aqui.
@@ -705,14 +613,15 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return new Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
     }
 
-    declaracaoExpressao(): Expressao {
+    protected declaracaoExpressao(): Expressao {
         const expressao = this.expressao();
         // Ponto-e-vírgula é opcional aqui.
         this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
-        return new Expressao(expressao);
+        const decoradores = Array.from(this.pilhaDecoradores);
+        return new Expressao(expressao, decoradores);
     }
 
-    declaracaoComentarioMultilinha(): Comentario {
+    protected declaracaoComentarioMultilinha(): Comentario {
         let simboloComentario: SimboloInterface;
         const conteudos: string[] = [];
         do {
@@ -720,25 +629,15 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
             conteudos.push(simboloComentario.literal);
         } while (simboloComentario.tipo === tiposDeSimbolos.LINHA_COMENTARIO);
 
-        return new Comentario(
-            simboloComentario.hashArquivo,
-            simboloComentario.linha,
-            conteudos,
-            true
-        );
+        return new Comentario(simboloComentario.hashArquivo, simboloComentario.linha, conteudos, true);
     }
 
-    declaracaoComentarioUmaLinha(): Comentario {
+    protected declaracaoComentarioUmaLinha(): Comentario {
         const simboloComentario = this.avancarEDevolverAnterior();
-        return new Comentario(
-            simboloComentario.hashArquivo,
-            simboloComentario.linha,
-            simboloComentario.literal,
-            false
-        );
+        return new Comentario(simboloComentario.hashArquivo, simboloComentario.linha, simboloComentario.literal, false);
     }
 
-    declaracaoContinua(): Continua {
+    override declaracaoContinua(): Continua {
         if (this.blocos < 1) {
             this.erro(this.simbolos[this.atual - 1], "'continua' precisa estar em um laço de repetição.");
         }
@@ -748,7 +647,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return new Continua(this.simbolos[this.atual - 1]);
     }
 
-    declaracaoEscolha(): Escolha {
+    override declaracaoEscolha(): Escolha {
         try {
             this.blocos += 1;
 
@@ -819,35 +718,29 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         }
     }
 
-    declaracaoFalhar(): Falhar {
+    protected declaracaoFalhar(): Falhar {
         const simboloFalha: SimboloInterface = this.simbolos[this.atual - 1];
         return new Falhar(simboloFalha, this.declaracaoExpressao().expressao);
     }
 
-    declaracaoFazer(): Fazer {
+    override declaracaoFazer(): Fazer {
         const simboloFazer: SimboloInterface = this.simbolos[this.atual - 1];
         try {
             this.blocos += 1;
 
             const caminhoFazer = this.resolverDeclaracao();
-
             this.consumir(tiposDeSimbolos.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
-
             const condicaoEnquanto = this.expressao();
-
             return new Fazer(simboloFazer.hashArquivo, Number(simboloFazer.linha), caminhoFazer, condicaoEnquanto);
         } finally {
             this.blocos -= 1;
         }
     }
 
-    declaracaoImportar(): Importar {
+    override declaracaoImportar(): Importar {
         this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
-
         const caminho = this.expressao();
-
         const simboloFechamento = this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após declaração.");
-
         return new Importar(caminho as Literal, simboloFechamento);
     }
 
@@ -855,7 +748,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
      * Declaração para comando `leia`, para ler dados de entrada do usuário.
      * @returns Um objeto da classe `Leia`.
      */
-    declaracaoLeia(): Leia {
+    override declaracaoLeia(): Leia {
         const simboloLeia = this.simbolos[this.atual];
 
         this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' antes dos argumentos em instrução `leia`.");
@@ -873,7 +766,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return new Leia(simboloLeia, argumentos);
     }
 
-    declaracaoPara(): Para | ParaCada {
+    override declaracaoPara(): Para | ParaCada {
         try {
             const simboloPara: SimboloInterface = this.simbolos[this.atual - 1];
             this.blocos += 1;
@@ -910,7 +803,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
     protected declaracaoParaTradicional(simboloPara: SimboloInterface): Para {
         const comParenteses = this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_ESQUERDO);
 
-        let inicializador: Var | Expressao;
+        let inicializador: Var | Expressao | Const[];
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA)) {
             inicializador = null;
         } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL)) {
@@ -947,7 +840,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return new Para(this.hashArquivo, Number(simboloPara.linha), inicializador, condicao, incrementar, corpo);
     }
 
-    declaracaoRetorna(): Retorna {
+    override declaracaoRetorna(): Retorna {
         const simboloChave = this.simbolos[this.atual - 1];
         let valor = null;
 
@@ -975,7 +868,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return new Retorna(simboloChave, valor);
     }
 
-    declaracaoSe(): Se {
+    override declaracaoSe(): Se {
         const condicao = this.expressao();
 
         const caminhoEntao = this.resolverDeclaracao();
@@ -988,7 +881,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return new Se(condicao, caminhoEntao, [], caminhoSenao);
     }
 
-    declaracaoSustar(): Sustar {
+    override declaracaoSustar(): Sustar {
         if (this.blocos < 1) {
             this.erro(this.simbolos[this.atual - 1], "'sustar' ou 'pausa' deve estar dentro de um laço de repetição.");
         }
@@ -998,7 +891,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return new Sustar(this.simbolos[this.atual - 1]);
     }
 
-    declaracaoTente(): Tente {
+    override declaracaoTente(): Tente {
         const simboloTente: SimboloInterface = this.simbolos[this.atual - 1];
         this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'tente'.");
 
@@ -1042,12 +935,11 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         );
     }
 
-    resolverDecorador(): void {
-        this.pilhaDecoradores = [];
+    protected resolverDecorador(): void {
         while (this.verificarTipoSimboloAtual(tiposDeSimbolos.ARROBA)) {
             let nomeDecorador: string = '';
             let linha: number;
-            let parametros = [];
+            let parametros: ParametroInterface[] = [];
             let parenteseEsquerdo = false;
             linha = this.simbolos[this.atual].linha;
             let simbolosLinhaAtual = this.simbolos.filter((l) => l.linha === linha);
@@ -1065,7 +957,16 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
                 nomeDecorador += simbolo.lexema || '.';
             }
 
-            this.pilhaDecoradores.push(new Decorador(this.hashArquivo, linha, nomeDecorador, parametros));
+            const atributos: {[key: string]: any} = {};
+            for (const parametro of parametros) {
+                if (parametro.nome.lexema in atributos) {
+                    throw this.erro(parametro.nome, `Atributo de decorador declarado duas ou mais vezes: ${parametro.nome.lexema}`);
+                }
+
+                atributos[parametro.nome.lexema] = parametro.valorPadrao;
+            }
+
+            this.pilhaDecoradores.push(new Decorador(this.hashArquivo, linha, nomeDecorador, atributos));
         }
     }
 
@@ -1077,7 +978,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
      * @see resolverDeclaracaoForaDeBloco para as declarações que não podem
      * ocorrer em blocos de escopo elementares.
      */
-    resolverDeclaracao(): any {
+    protected resolverDeclaracao(): any {
         switch (this.simbolos[this.atual].tipo) {
             case tiposDeSimbolos.CHAVE_ESQUERDA:
                 const simboloInicioBloco: SimboloInterface = this.avancarEDevolverAnterior();
@@ -1156,24 +1057,29 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
     protected declaracaoTendoComo(): TendoComo {
         const simboloTendo = this.simbolos[this.atual - 1];
         const expressaoInicializacao = this.expressao();
-        this.consumir(tiposDeSimbolos.COMO, "Esperado palavra reservada 'como' após expressão de inicialização de variável, em declaração 'tendo'.");
-        const simboloNomeVariavel = this.consumir(tiposDeSimbolos.IDENTIFICADOR, "Esperado nome do identificador em declaração 'tendo'.");
-        this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado chave esquerda para abertura de bloco em declaração 'tendo'.");
+        this.consumir(
+            tiposDeSimbolos.COMO,
+            "Esperado palavra reservada 'como' após expressão de inicialização de variável, em declaração 'tendo'."
+        );
+        const simboloNomeVariavel = this.consumir(
+            tiposDeSimbolos.IDENTIFICADOR,
+            "Esperado nome do identificador em declaração 'tendo'."
+        );
+        this.consumir(
+            tiposDeSimbolos.CHAVE_ESQUERDA,
+            "Esperado chave esquerda para abertura de bloco em declaração 'tendo'."
+        );
         const blocoCorpo = this.blocoEscopo();
         return new TendoComo(
             simboloTendo.linha,
             simboloTendo.hashArquivo,
             simboloNomeVariavel,
             expressaoInicializacao,
-            new Bloco(
-                simboloTendo.linha,
-                simboloTendo.hashArquivo,
-                blocoCorpo
-            )
+            new Bloco(simboloTendo.linha, simboloTendo.hashArquivo, blocoCorpo)
         );
     }
 
-    protected declaracaoDesestruturacaoVariavel(): Declaracao[] {
+    protected declaracaoDesestruturacaoVariavel(): Var[] {
         const identificadores: SimboloInterface[] = [];
 
         do {
@@ -1191,11 +1097,12 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         // como prefixo o nome do inicializador, e o sufixo o nome de cada propriedade.
         const retornos = [];
         for (let identificador of identificadores) {
-            retornos.push(
-                new Var(identificador, new AcessoMetodoOuPropriedade(this.hashArquivo, inicializador, identificador))
-            );
+            const declaracaoVar = new Var(identificador, new AcessoMetodoOuPropriedade(this.hashArquivo, inicializador, identificador));
+            declaracaoVar.decoradores = Array.from(this.pilhaDecoradores);
+            retornos.push(declaracaoVar);
         }
 
+        this.pilhaDecoradores = [];
         return retornos;
     }
 
@@ -1203,9 +1110,9 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
      * Caso símbolo atual seja `var`, devolve uma declaração de variável.
      * @returns Um Construto do tipo Var.
      */
-    protected declaracaoDeVariaveis(): any {
+    protected declaracaoDeVariaveis(): Var[] {
         const identificadores: SimboloInterface[] = [];
-        let retorno: Declaracao[] = [];
+        const retorno: Var[] = [];
         let tipo: any = null;
 
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_ESQUERDA)) {
@@ -1223,10 +1130,19 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
 
         if (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
             // Inicialização de variáveis sem valor.
-            for (let [indice, identificador] of identificadores.entries()) {
-                retorno.push(new Var(identificador, null, tipo));
+            for (let identificador of identificadores.values()) {
+                retorno.push(
+                    new Var(
+                        identificador, 
+                        null, 
+                        tipo, 
+                        Array.from(this.pilhaDecoradores)
+                    )
+                );
             }
+
             this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
+            this.pilhaDecoradores = [];
             return retorno;
         }
 
@@ -1237,22 +1153,29 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
 
         if (identificadores.length !== inicializadores.length) {
             throw this.erro(
-                this.simboloAtual(),
+                this.simbolos[this.atual],
                 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.'
             );
         }
 
         for (let [indice, identificador] of identificadores.entries()) {
             tipo = inicializadores[indice] instanceof Tupla ? tipoDeDadosDelegua.TUPLA : tipo;
-            retorno.push(new Var(identificador, inicializadores[indice], tipo));
+            retorno.push(
+                new Var(
+                    identificador, 
+                    inicializadores[indice], 
+                    tipo,
+                    Array.from(this.pilhaDecoradores)
+                )
+            );
         }
 
         this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
-
+        this.pilhaDecoradores = [];
         return retorno;
     }
 
-    protected declaracaoDesestruturacaoConstante(): Declaracao[] {
+    protected declaracaoDesestruturacaoConstante(): Const[] {
         const identificadores: SimboloInterface[] = [];
 
         do {
@@ -1268,11 +1191,15 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         const inicializador = this.expressao();
         // TODO: Para cada variável dos identificadores, emitir um `AcessoMetodoOuPropriedade` usando
         // como prefixo o nome do inicializador, e o sufixo o nome de cada propriedade.
-        const retornos = [];
+        const retornos: Const[] = [];
         for (let identificador of identificadores) {
-            retornos.push(
-                new Const(identificador, new AcessoMetodoOuPropriedade(this.hashArquivo, inicializador, identificador))
+            const declaracaoConst = new Const(
+                identificador, 
+                new AcessoMetodoOuPropriedade(this.hashArquivo, inicializador, identificador)
             );
+
+            declaracaoConst.decoradores = Array.from(this.pilhaDecoradores);
+            retornos.push(declaracaoConst);
         }
 
         return retornos;
@@ -1282,7 +1209,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
      * Caso símbolo atual seja `const, constante ou fixo`, devolve uma declaração de const.
      * @returns Um Construto do tipo Const.
      */
-    declaracaoDeConstantes(): any {
+    declaracaoDeConstantes(): Const[] {
         const identificadores: SimboloInterface[] = [];
         let tipo: any = null;
 
@@ -1308,36 +1235,39 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
 
         if (identificadores.length !== inicializadores.length) {
             throw this.erro(
-                this.simboloAtual(),
+                this.simbolos[this.atual],
                 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.'
             );
         }
 
-        let retorno: Declaracao[] = [];
+        let retorno: Const[] = [];
         for (let [indice, identificador] of identificadores.entries()) {
-            retorno.push(new Const(identificador, inicializadores[indice], tipo));
+            retorno.push(new Const(identificador, inicializadores[indice], tipo, Array.from(this.pilhaDecoradores)));
         }
 
+        this.pilhaDecoradores = [];
         this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
 
         return retorno;
     }
 
-    funcao(tipo: string): FuncaoDeclaracao {
+    protected funcao(tipo: string): FuncaoDeclaracao {
         let simbolo: SimboloInterface;
         switch (this.simbolos[this.atual].tipo) {
             case tiposDeSimbolos.CONSTRUTOR:
                 simbolo = this.avancarEDevolverAnterior();
-                this.pilhaDecoradores = [];
                 break;
             default:
                 simbolo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, `Esperado nome de ${tipo}.`);
                 break;
         }
-        return new FuncaoDeclaracao(simbolo, this.corpoDaFuncao(tipo), null, this.pilhaDecoradores);
+
+        const decoradores = Array.from(this.pilhaDecoradores);
+        this.pilhaDecoradores = []
+        return new FuncaoDeclaracao(simbolo, this.corpoDaFuncao(tipo), null, decoradores);
     }
 
-    logicaComumParametros(): ParametroInterface[] {
+    protected logicaComumParametros(): ParametroInterface[] {
         const parametros: ParametroInterface[] = [];
 
         do {
@@ -1361,7 +1291,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
                 parametro.tipoDado = {
                     nome: this.simbolos[this.atual - 2].lexema,
                     tipo: tipoDadoParametro,
-                    tipoInvalido: !tipoDadoParametro ? this.simboloAtual().lexema : null,
+                    tipoInvalido: !tipoDadoParametro ? this.simbolos[this.atual].lexema : null,
                 };
                 this.avancarEDevolverAnterior();
             }
@@ -1372,7 +1302,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return parametros;
     }
 
-    corpoDaFuncao(tipo: string): FuncaoConstruto {
+    override corpoDaFuncao(tipo: string): FuncaoConstruto {
         // O parêntese esquerdo é considerado o símbolo inicial para
         // fins de pragma.
         const parenteseEsquerdo = this.consumir(
@@ -1400,9 +1330,9 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return new FuncaoConstruto(this.hashArquivo, Number(parenteseEsquerdo.linha), parametros, corpo, tipoRetorno);
     }
 
-    declaracaoDeClasse(): Classe {
+    override declaracaoDeClasse(): Classe {
         const simbolo: SimboloInterface = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da classe.');
-        const pilhaDecoradoresClasse = this.pilhaDecoradores;
+        const pilhaDecoradoresClasse = Array.from(this.pilhaDecoradores);
 
         let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.HERDA)) {
@@ -1429,7 +1359,6 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
             switch (proximoSimbolo.tipo) {
                 case tiposDeSimbolos.PARENTESE_ESQUERDO:
                     metodos.push(this.funcao('método'));
-                    this.pilhaDecoradores = [];
                     break;
                 case tiposDeSimbolos.DOIS_PONTOS:
                     const nomePropriedade = this.consumir(
@@ -1440,7 +1369,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
                     const tipoPropriedade = this.avancarEDevolverAnterior();
                     this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
                     propriedades.push(
-                        new PropriedadeClasse(nomePropriedade, tipoPropriedade.lexema, this.pilhaDecoradores)
+                        new PropriedadeClasse(nomePropriedade, tipoPropriedade.lexema, Array.from(this.pilhaDecoradores))
                     );
                     this.pilhaDecoradores = [];
                     break;
@@ -1454,15 +1383,23 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
     }
 
     /**
-     * Declarações fora de bloco precisam ser verificadas primeiro porque
-     * não é possível declarar uma classe/função dentro de um bloco `enquanto`,
-     * `fazer ... enquanto`, `para`, `escolha`, etc.
+     * Declarações fora de bloco precisam ser verificadas primeiro por 
+     * uma série de motivos, como, por exemplo: 
+     * 
+     * - Não é possível declarar uma classe/função dentro de um bloco `enquanto`,
+     *   `fazer ... enquanto`, `para`, `escolha`, etc;
+     * - Qualquer declaração pode ter um decorador.
      * @returns Uma função ou classe se o símbolo atual resolver aqui.
      *          O retorno de `resolverDeclaracao()` em caso contrário.
      * @see resolverDeclaracao
+     * @see resolverDecorador
      */
-    resolverDeclaracaoForaDeBloco(): RetornoDeclaracao {
+    override resolverDeclaracaoForaDeBloco(): RetornoDeclaracao {
         try {
+            while (this.verificarTipoSimboloAtual(tiposDeSimbolos.ARROBA)) {
+                this.resolverDecorador();
+            }
+
             if (
                 (this.verificarTipoSimboloAtual(tiposDeSimbolos.FUNCAO) ||
                     this.verificarTipoSimboloAtual(tiposDeSimbolos.FUNÇÃO)) &&
@@ -1489,7 +1426,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
      * Garante que o código não entre em loop infinito.
      * @returns Sempre retorna `void`.
      */
-    sincronizar(): void {
+    protected sincronizar(): void {
         this.avancarEDevolverAnterior();
 
         while (!this.estaNoFinal()) {
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-guarani.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-guarani.ts
index 91666251..2c71bd07 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-guarani.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-guarani.ts
@@ -1,23 +1,26 @@
 import {
-    AcessoIndiceVariavel,
-    AcessoMetodoOuPropriedade,
-    AtribuicaoPorIndice,
-    Atribuir,
-    Binario,
     Construto,
-    DefinirValor,
     FuncaoConstruto,
-    Literal,
-    Variavel,
+    Literal
 } from '../../construtos';
-import { Escreva, Declaracao, Se, Enquanto, Para, Escolha, Fazer } from '../../declaracoes';
+import { Escreva, Declaracao, Se, Enquanto, Para, Escolha, Fazer, Leia } from '../../declaracoes';
 import { RetornoLexador, RetornoAvaliadorSintatico } from '../../interfaces/retornos';
 import { AvaliadorSintaticoBase } from '../avaliador-sintatico-base';
 
 import tiposDeSimbolos from '../../tipos-de-simbolos/guarani';
 import { SimboloInterface } from '../../interfaces';
 
+/**
+ * Este avaliador sintático é produto de uma reunião entre pessoas da
+ * Design Líquido e representantes de comunidades indígenas da América do Sul.
+ * Um dia pode ser terminado para virar um dialeto completo.
+ */
 export class AvaliadorSintaticoGuarani extends AvaliadorSintaticoBase {
+
+    protected declaracaoLeia(): Leia {
+        throw new Error('Method not implemented.');
+    }
+
     primario(): Construto {
         const simboloAtual = this.simbolos[this.atual];
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NUMERO, tiposDeSimbolos.TEXTO)) {
@@ -155,7 +158,6 @@ export class AvaliadorSintaticoGuarani extends AvaliadorSintaticoBase {
     }
 
     expressao(): Construto {
-        // if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.LEIA)) return this.declaracaoLeia();
         return this.atribuir();
     }
 
diff --git a/fontes/avaliador-sintatico/micro-avaliador-sintatico.ts b/fontes/avaliador-sintatico/micro-avaliador-sintatico.ts
index 62c4f8f4..9984151a 100644
--- a/fontes/avaliador-sintatico/micro-avaliador-sintatico.ts
+++ b/fontes/avaliador-sintatico/micro-avaliador-sintatico.ts
@@ -5,64 +5,22 @@ import {
     Binario,
     Chamada,
     Construto,
-    Dicionario,
-    Isto,
     Literal,
     Logico,
-    Super,
     Unario,
-    Variavel,
-    Vetor,
+    Variavel
 } from '../construtos';
 import { Declaracao } from '../declaracoes';
 import { SimboloInterface } from '../interfaces';
 import { RetornoAvaliadorSintatico, RetornoLexador } from '../interfaces/retornos';
-import { ErroAvaliadorSintatico } from './erro-avaliador-sintatico';
+import { MicroAvaliadorSintaticoBase } from './micro-avaliador-sintatico-base';
 
 import tiposDeSimbolos from '../tipos-de-simbolos/microgramaticas/delegua';
-import { MicroAvaliadorSintaticoBase } from './micro-avaliador-sintatico-base';
 
 /**
  * O MicroAvaliadorSintatico funciona apenas dentro de interpolações de texto.
  */
 export class MicroAvaliadorSintatico extends MicroAvaliadorSintaticoBase {
-    // simbolos: SimboloInterface[];
-    // erros: ErroAvaliadorSintatico[];
-    // atual: number;
-    // linha: number;
-
-    avancarEDevolverAnterior(): SimboloInterface {
-        if (this.atual < this.simbolos.length) this.atual += 1;
-        return this.simbolos[this.atual - 1];
-    }
-
-    verificarTipoSimboloAtual(tipo: string): boolean {
-        if (this.atual === this.simbolos.length) return false;
-        return this.simbolos[this.atual].tipo === tipo;
-    }
-
-    verificarSeSimboloAtualEIgualA(...argumentos: string[]): boolean {
-        for (let i = 0; i < argumentos.length; i++) {
-            const tipoAtual = argumentos[i];
-            if (this.verificarTipoSimboloAtual(tipoAtual)) {
-                this.avancarEDevolverAnterior();
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    erro(simbolo: SimboloInterface, mensagemDeErro: string): ErroAvaliadorSintatico {
-        const excecao = new ErroAvaliadorSintatico(simbolo, mensagemDeErro);
-        this.erros.push(excecao);
-        return excecao;
-    }
-
-    consumir(tipo: string, mensagemDeErro: string): SimboloInterface {
-        if (this.verificarTipoSimboloAtual(tipo)) return this.avancarEDevolverAnterior();
-        throw this.erro(this.simbolos[this.atual], mensagemDeErro);
-    }
 
     primario(): Construto {
         const simboloAtual = this.simbolos[this.atual];
@@ -202,7 +160,7 @@ export class MicroAvaliadorSintatico extends MicroAvaliadorSintaticoBase {
         return expressao;
     }
 
-    unario(): Construto {
+    override unario(): Construto {
         if (
             this.verificarSeSimboloAtualEIgualA(
                 tiposDeSimbolos.NEGACAO,
@@ -220,50 +178,7 @@ export class MicroAvaliadorSintatico extends MicroAvaliadorSintaticoBase {
         return this.chamar();
     }
 
-    exponenciacao(): Construto {
-        let expressao = this.unario();
-
-        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.EXPONENCIACAO)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.unario();
-            expressao = new Binario(-1, expressao, operador, direito);
-        }
-
-        return expressao;
-    }
-
-    multiplicar(): Construto {
-        let expressao = this.exponenciacao();
-
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.DIVISAO,
-                tiposDeSimbolos.DIVISAO_INTEIRA,
-                tiposDeSimbolos.MODULO,
-                tiposDeSimbolos.MULTIPLICACAO
-            )
-        ) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.exponenciacao();
-            expressao = new Binario(-1, expressao, operador, direito);
-        }
-
-        return expressao;
-    }
-
-    adicaoOuSubtracao(): Construto {
-        let expressao = this.multiplicar();
-
-        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUBTRACAO, tiposDeSimbolos.ADICAO)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.multiplicar();
-            expressao = new Binario(-1, expressao, operador, direito);
-        }
-
-        return expressao;
-    }
-
-    bitShift(): Construto {
+    protected bitShift(): Construto {
         let expressao = this.adicaoOuSubtracao();
 
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.MENOR_MENOR, tiposDeSimbolos.MAIOR_MAIOR)) {
@@ -275,7 +190,7 @@ export class MicroAvaliadorSintatico extends MicroAvaliadorSintaticoBase {
         return expressao;
     }
 
-    bitE(): Construto {
+    protected bitE(): Construto {
         let expressao = this.bitShift();
 
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.BIT_AND)) {
@@ -287,7 +202,7 @@ export class MicroAvaliadorSintatico extends MicroAvaliadorSintaticoBase {
         return expressao;
     }
 
-    bitOu(): Construto {
+    protected bitOu(): Construto {
         let expressao = this.bitE();
 
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.BIT_OR, tiposDeSimbolos.BIT_XOR)) {
@@ -299,7 +214,7 @@ export class MicroAvaliadorSintatico extends MicroAvaliadorSintaticoBase {
         return expressao;
     }
 
-    comparar(): Construto {
+    override comparar(): Construto {
         let expressao = this.bitOu();
 
         while (
@@ -318,19 +233,7 @@ export class MicroAvaliadorSintatico extends MicroAvaliadorSintaticoBase {
         return expressao;
     }
 
-    comparacaoIgualdade(): Construto {
-        let expressao = this.comparar();
-
-        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DIFERENTE, tiposDeSimbolos.IGUAL_IGUAL)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.comparar();
-            expressao = new Binario(-1, expressao, operador, direito);
-        }
-
-        return expressao;
-    }
-
-    em(): Construto {
+    protected em(): Construto {
         let expressao = this.comparacaoIgualdade();
 
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.EM)) {
@@ -342,7 +245,7 @@ export class MicroAvaliadorSintatico extends MicroAvaliadorSintaticoBase {
         return expressao;
     }
 
-    e(): Construto {
+    override e(): Construto {
         let expressao = this.em();
 
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.E)) {
@@ -354,22 +257,6 @@ export class MicroAvaliadorSintatico extends MicroAvaliadorSintaticoBase {
         return expressao;
     }
 
-    ou(): Construto {
-        let expressao = this.e();
-
-        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.OU)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.e();
-            expressao = new Logico(-1, expressao, operador, direito);
-        }
-
-        return expressao;
-    }
-
-    declaracao(): Declaracao | Construto {
-        return this.ou();
-    }
-
     analisar(retornoLexador: RetornoLexador<SimboloInterface>, linha: number): RetornoAvaliadorSintatico<Declaracao> {
         this.erros = [];
         this.atual = 0;
diff --git a/fontes/bibliotecas/biblioteca-global.ts b/fontes/bibliotecas/biblioteca-global.ts
index b6261c21..8b9fe3af 100644
--- a/fontes/bibliotecas/biblioteca-global.ts
+++ b/fontes/bibliotecas/biblioteca-global.ts
@@ -3,7 +3,7 @@ import { ObjetoDeleguaClasse } from '../estruturas/objeto-delegua-classe';
 import { FuncaoPadrao } from '../estruturas/funcao-padrao';
 import { DescritorTipoClasse } from '../estruturas/descritor-tipo-classe';
 import { VariavelInterface } from '../interfaces';
-import { InterpretadorInterface } from "../interfaces";
+import { InterpretadorInterface } from '../interfaces';
 import { DeleguaFuncao } from '../estruturas';
 import { Deceto, Dupla, Noneto, Octeto, Quarteto, Quinteto, Septeto, Sexteto, Trio, Tupla } from '../construtos';
 
@@ -11,9 +11,7 @@ import { Deceto, Dupla, Noneto, Octeto, Quarteto, Quinteto, Septeto, Sexteto, Tr
  * Retorna um número aleatório entre 0 e 1.
  * @returns {Promise<number>} Número real.
  */
-export async function aleatorio(
-    interpretador: InterpretadorInterface
-): Promise<number> {
+export async function aleatorio(interpretador: InterpretadorInterface): Promise<number> {
     return Promise.resolve(Math.random());
 }
 
@@ -26,14 +24,12 @@ export async function aleatorio(
  */
 export async function aleatorioEntre(
     interpretador: InterpretadorInterface,
-    minimo: VariavelInterface | number, 
+    minimo: VariavelInterface | number,
     maximo: VariavelInterface | number
 ): Promise<number> {
     // eslint-disable-next-line prefer-rest-params
     if (arguments.length <= 0) {
-        return Promise.reject(
-            new ErroEmTempoDeExecucao(this.simbolo, 'A função recebe ao menos um parâmetro.')
-        );
+        return Promise.reject(new ErroEmTempoDeExecucao(this.simbolo, 'A função recebe ao menos um parâmetro.'));
     }
 
     const valorMinimo = minimo.hasOwnProperty('valor') ? (minimo as VariavelInterface).valor : minimo;
@@ -55,9 +51,7 @@ export async function aleatorioEntre(
     const valorMaximo = maximo.hasOwnProperty('valor') ? (maximo as VariavelInterface).valor : maximo;
 
     if (typeof valorMinimo !== 'number' || typeof valorMaximo !== 'number') {
-        return Promise.reject(
-            new ErroEmTempoDeExecucao(this.simbolo, 'Os dois parâmetros devem ser do tipo número.')
-        );
+        return Promise.reject(new ErroEmTempoDeExecucao(this.simbolo, 'Os dois parâmetros devem ser do tipo número.'));
     }
 
     return Promise.resolve(Math.floor(Math.random() * (valorMaximo - valorMinimo)) + valorMinimo);
@@ -72,7 +66,7 @@ export async function aleatorioEntre(
  */
 export async function algum(
     interpretador: InterpretadorInterface,
-    vetor: VariavelInterface | any, 
+    vetor: VariavelInterface | any,
     funcaoPesquisa: VariavelInterface | any
 ): Promise<boolean> {
     const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
@@ -116,7 +110,7 @@ export async function algum(
  */
 export async function encontrar(
     interpretador: InterpretadorInterface,
-    vetor: VariavelInterface | any, 
+    vetor: VariavelInterface | any,
     funcaoPesquisa: VariavelInterface | any
 ): Promise<any> {
     const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
@@ -160,7 +154,7 @@ export async function encontrar(
  */
 export async function encontrarIndice(
     interpretador: InterpretadorInterface,
-    vetor: VariavelInterface | any, 
+    vetor: VariavelInterface | any,
     funcaoPesquisa: VariavelInterface | any
 ): Promise<number> {
     const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
@@ -197,14 +191,14 @@ export async function encontrarIndice(
 /**
  * Encontrar o último elemento de um vetor cuja função de pesquisa retorne
  * verdadeiro na avaliação de cada elemento.
- * @param {InterpretadorInterface} interpretador A instância do interpretador. 
- * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript. 
- * @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa. 
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
+ * @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.
  * @returns {Promise<number>} O número correspondente ao índice se o elemento for encontrado, ou nulo em caso contrário.
  */
 export async function encontrarUltimo(
     interpretador: InterpretadorInterface,
-    vetor: VariavelInterface | any, 
+    vetor: VariavelInterface | any,
     funcaoPesquisa: VariavelInterface | any
 ): Promise<number> {
     const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
@@ -239,15 +233,15 @@ export async function encontrarUltimo(
 }
 
 /**
- * 
- * @param {InterpretadorInterface} interpretador A instância do interpretador. 
- * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript. 
- * @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.  
+ *
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
+ * @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.
  * @returns {Promise<number>} O número correspondente ao índice se o elemento for encontrado, ou nulo em caso contrário.
  */
 export async function encontrarUltimoIndice(
     interpretador: InterpretadorInterface,
-    vetor: VariavelInterface | any, 
+    vetor: VariavelInterface | any,
     funcaoPesquisa: VariavelInterface | any
 ): Promise<number> {
     const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
@@ -282,15 +276,15 @@ export async function encontrarUltimoIndice(
 }
 
 /**
- * 
- * @param interpretador 
- * @param vetor 
- * @param funcaoFiltragem 
- * @returns 
+ *
+ * @param interpretador
+ * @param vetor
+ * @param funcaoFiltragem
+ * @returns
  */
 export async function filtrarPor(
     interpretador: InterpretadorInterface,
-    vetor: VariavelInterface | any, 
+    vetor: VariavelInterface | any,
     funcaoFiltragem: VariavelInterface | any
 ) {
     if (vetor === null || vetor === undefined)
@@ -302,9 +296,7 @@ export async function filtrarPor(
         );
 
     const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
-    const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor')
-        ? funcaoFiltragem.valor
-        : funcaoFiltragem;
+    const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor') ? funcaoFiltragem.valor : funcaoFiltragem;
     if (!Array.isArray(valorVetor)) {
         return Promise.reject(
             new ErroEmTempoDeExecucao(
@@ -327,7 +319,7 @@ export async function filtrarPor(
     for (let indice = 0; indice < valorVetor.length; ++indice) {
         const deveRetornarValor = await valorFuncaoFiltragem.chamar(interpretador, [valorVetor[indice]]);
         if (deveRetornarValor === false) continue;
-        
+
         resultados.push(valorVetor[indice]);
     }
 
@@ -335,15 +327,15 @@ export async function filtrarPor(
 }
 
 /**
- * 
- * @param {InterpretadorInterface} interpretador A instância do interpretador.  
- * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.  
- * @param valor 
- * @returns 
+ *
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
+ * @param valor
+ * @returns
  */
 export async function incluido(
     interpretador: InterpretadorInterface,
-    vetor: VariavelInterface | any, 
+    vetor: VariavelInterface | any,
     valor: VariavelInterface | any
 ): Promise<boolean> {
     const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
@@ -369,15 +361,12 @@ export async function incluido(
 }
 
 /**
- * 
+ *
  * @param {InterpretadorInterface} interpretador A instância do interpretador.
- * @param numero 
- * @returns 
+ * @param numero
+ * @returns
  */
-export async function inteiro(
-    interpretador: InterpretadorInterface,
-    numero: VariavelInterface | any
-) {
+export async function inteiro(interpretador: InterpretadorInterface, numero: VariavelInterface | any) {
     if (numero === null || numero === undefined) return Promise.resolve(0);
 
     const valor = numero.hasOwnProperty('valor') ? numero.valor : numero;
@@ -404,15 +393,15 @@ export async function inteiro(
 }
 
 /**
- * 
- * @param interpretador 
- * @param vetor 
- * @param funcaoMapeamento 
- * @returns 
+ *
+ * @param interpretador
+ * @param vetor
+ * @param funcaoMapeamento
+ * @returns
  */
 export async function mapear(
     interpretador: InterpretadorInterface,
-    vetor: VariavelInterface | any, 
+    vetor: VariavelInterface | any,
     funcaoMapeamento: VariavelInterface | any
 ): Promise<any[]> {
     if (vetor === null || vetor === undefined)
@@ -425,9 +414,7 @@ export async function mapear(
 
     const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
 
-    const valorFuncaoMapeamento = funcaoMapeamento.hasOwnProperty('valor')
-        ? funcaoMapeamento.valor
-        : funcaoMapeamento;
+    const valorFuncaoMapeamento = funcaoMapeamento.hasOwnProperty('valor') ? funcaoMapeamento.valor : funcaoMapeamento;
 
     if (!Array.isArray(valorVetor)) {
         return Promise.reject(
@@ -456,9 +443,9 @@ export async function mapear(
 }
 
 /**
- * 
- * @param vetor 
- * @returns 
+ *
+ * @param vetor
+ * @returns
  */
 export async function ordenar(
     interpretador: InterpretadorInterface,
@@ -494,15 +481,15 @@ export async function ordenar(
 }
 
 /**
- * 
- * @param interpretador 
- * @param vetor 
- * @param funcaoFiltragem 
- * @returns 
+ *
+ * @param interpretador
+ * @param vetor
+ * @param funcaoFiltragem
+ * @returns
  */
 export async function paraCada(
     interpretador: InterpretadorInterface,
-    vetor: VariavelInterface | any, 
+    vetor: VariavelInterface | any,
     funcaoFiltragem: VariavelInterface | any
 ): Promise<any> {
     if (vetor === null || vetor === undefined)
@@ -514,9 +501,7 @@ export async function paraCada(
         );
 
     const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
-    const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor')
-        ? funcaoFiltragem.valor
-        : funcaoFiltragem;
+    const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor') ? funcaoFiltragem.valor : funcaoFiltragem;
     if (!Array.isArray(valorVetor)) {
         return Promise.reject(
             new ErroEmTempoDeExecucao(
@@ -541,15 +526,15 @@ export async function paraCada(
 }
 
 /**
- * 
- * @param interpretador 
- * @param vetor 
- * @param funcaoFiltragem 
- * @returns 
+ *
+ * @param interpretador
+ * @param vetor
+ * @param funcaoFiltragem
+ * @returns
  */
 export async function primeiroEmCondicao(
     interpretador: InterpretadorInterface,
-    vetor: VariavelInterface | any, 
+    vetor: VariavelInterface | any,
     funcaoFiltragem: VariavelInterface | any
 ) {
     if (vetor === null || vetor === undefined)
@@ -562,9 +547,7 @@ export async function primeiroEmCondicao(
 
     const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
 
-    const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor')
-        ? funcaoFiltragem.valor
-        : funcaoFiltragem;
+    const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor') ? funcaoFiltragem.valor : funcaoFiltragem;
     if (!Array.isArray(valorVetor)) {
         return Promise.reject(
             new ErroEmTempoDeExecucao(
@@ -594,15 +577,12 @@ export async function primeiroEmCondicao(
 }
 
 /**
- * 
- * @param interpretador 
- * @param numero 
- * @returns 
+ *
+ * @param interpretador
+ * @param numero
+ * @returns
  */
-export async function real(
-    interpretador: InterpretadorInterface,
-    numero: VariavelInterface | any
-): Promise<number> {
+export async function real(interpretador: InterpretadorInterface, numero: VariavelInterface | any): Promise<number> {
     if (numero === null || numero === undefined) return Promise.resolve(parseFloat('0'));
 
     const valor = numero.hasOwnProperty('valor') ? numero.valor : numero;
@@ -619,12 +599,12 @@ export async function real(
 }
 
 /**
- * 
- * @param interpretador 
- * @param vetor 
- * @param funcaoReducao 
- * @param padrao 
- * @returns 
+ *
+ * @param interpretador
+ * @param vetor
+ * @param funcaoReducao
+ * @param padrao
+ * @returns
  */
 export async function reduzir(
     interpretador: InterpretadorInterface,
@@ -670,14 +650,11 @@ export async function reduzir(
 }
 
 /**
- * 
- * @param objeto 
- * @returns 
+ *
+ * @param objeto
+ * @returns
  */
-export async function tamanho(
-    interpretador: InterpretadorInterface,
-    objeto: any
-) {
+export async function tamanho(interpretador: InterpretadorInterface, objeto: any) {
     const valorObjeto = objeto.hasOwnProperty('valor') ? objeto.valor : objeto;
 
     if (typeof valorObjeto === 'number') {
@@ -715,26 +692,21 @@ export async function tamanho(
 }
 
 /**
- * 
- * @param interpretador 
- * @param valorOuVariavel 
- * @returns 
+ *
+ * @param interpretador
+ * @param valorOuVariavel
+ * @returns
  */
-export async function texto(
-    interpretador: InterpretadorInterface,
-    valorOuVariavel: VariavelInterface | any
-) {
-    return Promise.resolve(
-        `${valorOuVariavel.hasOwnProperty('valor') ? valorOuVariavel.valor : valorOuVariavel}`
-    );
+export async function texto(interpretador: InterpretadorInterface, valorOuVariavel: VariavelInterface | any) {
+    return Promise.resolve(`${valorOuVariavel.hasOwnProperty('valor') ? valorOuVariavel.valor : valorOuVariavel}`);
 }
 
 /**
- * 
- * @param interpretador 
- * @param vetor 
- * @param funcaoCondicional 
- * @returns 
+ *
+ * @param interpretador
+ * @param vetor
+ * @param funcaoCondicional
+ * @returns
  */
 export async function todosEmCondicao(
     interpretador: InterpretadorInterface,
@@ -779,42 +751,28 @@ export async function todosEmCondicao(
 }
 
 /**
- * Transforma um vetor de elementos em uma tupla de N elementos, sendo N a 
+ * Transforma um vetor de elementos em uma tupla de N elementos, sendo N a
  * largura do vetor.
- * @param interpretador 
- * @param vetor 
- * @returns 
+ * @param interpretador
+ * @param vetor
+ * @returns
  */
-export async function tupla(
-    interpretador: InterpretadorInterface,
-    vetor: VariavelInterface | any[], 
-): Promise<Tupla> {
-    const valorVetor: any[] = !Array.isArray(vetor) && vetor.hasOwnProperty('valor') ? 
-        vetor.valor : 
-        vetor;
+export async function tupla(interpretador: InterpretadorInterface, vetor: VariavelInterface | any[]): Promise<Tupla> {
+    const valorVetor: any[] = !Array.isArray(vetor) && vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
 
     if (!Array.isArray(valorVetor)) {
         return Promise.reject(
-            new ErroEmTempoDeExecucao(
-                this.simbolo,
-                'Argumento de função nativa `tupla` não parece ser um vetor.'
-            )
+            new ErroEmTempoDeExecucao(this.simbolo, 'Argumento de função nativa `tupla` não parece ser um vetor.')
         );
     }
 
     switch (valorVetor.length) {
         case 2:
-            return Promise.resolve(
-                new Dupla(valorVetor[0], valorVetor[1])
-            );
+            return Promise.resolve(new Dupla(valorVetor[0], valorVetor[1]));
         case 3:
-            return Promise.resolve(
-                new Trio(valorVetor[0], valorVetor[1], valorVetor[2])
-            );
+            return Promise.resolve(new Trio(valorVetor[0], valorVetor[1], valorVetor[2]));
         case 4:
-            return Promise.resolve(
-                new Quarteto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3])
-            );
+            return Promise.resolve(new Quarteto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3]));
         case 5:
             return Promise.resolve(
                 new Quinteto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4])
@@ -825,19 +783,57 @@ export async function tupla(
             );
         case 7:
             return Promise.resolve(
-                new Septeto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6])
+                new Septeto(
+                    valorVetor[0],
+                    valorVetor[1],
+                    valorVetor[2],
+                    valorVetor[3],
+                    valorVetor[4],
+                    valorVetor[5],
+                    valorVetor[6]
+                )
             );
         case 8:
             return Promise.resolve(
-                new Octeto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6], valorVetor[7])
+                new Octeto(
+                    valorVetor[0],
+                    valorVetor[1],
+                    valorVetor[2],
+                    valorVetor[3],
+                    valorVetor[4],
+                    valorVetor[5],
+                    valorVetor[6],
+                    valorVetor[7]
+                )
             );
         case 9:
             return Promise.resolve(
-                new Noneto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6], valorVetor[7], valorVetor[8])
+                new Noneto(
+                    valorVetor[0],
+                    valorVetor[1],
+                    valorVetor[2],
+                    valorVetor[3],
+                    valorVetor[4],
+                    valorVetor[5],
+                    valorVetor[6],
+                    valorVetor[7],
+                    valorVetor[8]
+                )
             );
         case 10:
             return Promise.resolve(
-                new Deceto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6], valorVetor[7], valorVetor[8], valorVetor[9])
+                new Deceto(
+                    valorVetor[0],
+                    valorVetor[1],
+                    valorVetor[2],
+                    valorVetor[3],
+                    valorVetor[4],
+                    valorVetor[5],
+                    valorVetor[6],
+                    valorVetor[7],
+                    valorVetor[8],
+                    valorVetor[9]
+                )
             );
         case 1:
         default:
@@ -848,4 +844,4 @@ export async function tupla(
                 )
             );
     }
-}
\ No newline at end of file
+}
diff --git a/fontes/bibliotecas/primitivas-vetor.ts b/fontes/bibliotecas/primitivas-vetor.ts
index 9fd99606..03c9322f 100644
--- a/fontes/bibliotecas/primitivas-vetor.ts
+++ b/fontes/bibliotecas/primitivas-vetor.ts
@@ -22,14 +22,12 @@ export default {
     ): Promise<any> => {
         let elementos = [];
 
-        if(excluirQuantidade || excluirQuantidade === 0){
+        if (excluirQuantidade || excluirQuantidade === 0) {
             elementos = !items.length
-            ? vetor.splice(inicio, excluirQuantidade)
-            : vetor.splice(inicio, excluirQuantidade, ...items);
+                ? vetor.splice(inicio, excluirQuantidade)
+                : vetor.splice(inicio, excluirQuantidade, ...items);
         } else {
-            elementos = !items.length
-            ? vetor.splice(inicio)
-            : vetor.splice(inicio, ...items);
+            elementos = !items.length ? vetor.splice(inicio) : vetor.splice(inicio, ...items);
         }
         return Promise.resolve(elementos);
     },
diff --git a/fontes/construtos/acesso-indice-variavel.ts b/fontes/construtos/acesso-indice-variavel.ts
index b6828262..1b0211a3 100644
--- a/fontes/construtos/acesso-indice-variavel.ts
+++ b/fontes/construtos/acesso-indice-variavel.ts
@@ -14,9 +14,9 @@ export class AcessoIndiceVariavel<TTipoSimbolo extends string = string> implemen
     indice: any;
 
     constructor(
-        hashArquivo: number, 
-        entidadeChamada: Construto, 
-        indice: any, 
+        hashArquivo: number,
+        entidadeChamada: Construto,
+        indice: any,
         simboloFechamento: SimboloInterface<TTipoSimbolo>
     ) {
         this.linha = entidadeChamada.linha;
diff --git a/fontes/construtos/binario.ts b/fontes/construtos/binario.ts
index c2e54e57..20cc4523 100644
--- a/fontes/construtos/binario.ts
+++ b/fontes/construtos/binario.ts
@@ -10,10 +10,10 @@ import { Construto } from './construto';
  * - `*` (Multiplicação);
  * - `/` (Divisão);
  * - `%` (Módulo);
- * 
+ *
  * Algumas outras operações podem ser suportadas de dialeto para dialeto,
  * como por exemplo:
- * 
+ *
  * - `+=` (Adição com Atribuição);
  * - `-=` (Subtração com Atribuição);
  * - `*=` (Multiplicação com Atribuição);
@@ -31,12 +31,7 @@ export class Binario<TTipoSimbolo extends string = string> implements Construto
     operador: SimboloInterface<TTipoSimbolo>;
     direita: Construto;
 
-    constructor(
-        hashArquivo: number, 
-        esquerda: any, 
-        operador: SimboloInterface<TTipoSimbolo>, 
-        direita: any
-    ) {
+    constructor(hashArquivo: number, esquerda: any, operador: SimboloInterface<TTipoSimbolo>, direita: any) {
         this.linha = esquerda.linha;
         this.hashArquivo = hashArquivo;
 
diff --git a/fontes/construtos/chamada.ts b/fontes/construtos/chamada.ts
index 8507dcc7..b6d4c699 100644
--- a/fontes/construtos/chamada.ts
+++ b/fontes/construtos/chamada.ts
@@ -11,10 +11,16 @@ export class Chamada implements Construto {
     hashArquivo: number;
 
     entidadeChamada: Construto;
-    argumentos: any[];
+    argumentos: Construto[];
+    // TODO: Estudar retirar isso.
     parentese: any;
 
-    constructor(hashArquivo: number, entidadeChamada: Construto, parentese: any, argumentos: any[]) {
+    constructor(
+        hashArquivo: number, 
+        entidadeChamada: Construto, 
+        parentese: any, 
+        argumentos: Construto[]
+    ) {
         this.id = uuidv4();
         this.linha = entidadeChamada.linha;
         this.hashArquivo = hashArquivo;
diff --git a/fontes/construtos/comentario.ts b/fontes/construtos/comentario.ts
index 72331cc6..9ca8bf0e 100644
--- a/fontes/construtos/comentario.ts
+++ b/fontes/construtos/comentario.ts
@@ -1,5 +1,5 @@
-import { VisitanteComumInterface } from "../interfaces";
-import { Construto } from "./construto";
+import { VisitanteComumInterface } from '../interfaces';
+import { Construto } from './construto';
 
 /**
  * Como construto, um comentário é normalmente útil para formatadores de código.
diff --git a/fontes/construtos/constante.ts b/fontes/construtos/constante.ts
index da5e7555..5bb5da5a 100644
--- a/fontes/construtos/constante.ts
+++ b/fontes/construtos/constante.ts
@@ -2,7 +2,7 @@ import { VisitanteComumInterface, SimboloInterface, VariavelInterface } from '..
 import { Construto } from './construto';
 
 /**
- * O construto de constante. 
+ * O construto de constante.
  */
 export class Constante<TTipoSimbolo extends string = string> implements Construto {
     linha: number;
@@ -10,10 +10,7 @@ export class Constante<TTipoSimbolo extends string = string> implements Construt
 
     simbolo: SimboloInterface<TTipoSimbolo>;
 
-    constructor(
-        hashArquivo: number, 
-        simbolo: SimboloInterface<TTipoSimbolo>
-    ) {
+    constructor(hashArquivo: number, simbolo: SimboloInterface<TTipoSimbolo>) {
         this.linha = Number(simbolo.linha);
         this.hashArquivo = hashArquivo;
 
diff --git a/fontes/construtos/decorador.ts b/fontes/construtos/decorador.ts
index 67b7d692..f7cac50d 100644
--- a/fontes/construtos/decorador.ts
+++ b/fontes/construtos/decorador.ts
@@ -2,25 +2,20 @@ import { VisitanteComumInterface } from '../interfaces';
 import { Construto } from './construto';
 
 /**
- * Um decorador é um construto especial que, em código, existe antes de uma declaração, e 
+ * Um decorador é um construto especial que, em código, existe antes de uma declaração, e
  * na avaliação sintática, é colocado juntamente com a próxima declaração.
  */
 export class Decorador implements Construto {
     linha: number;
     hashArquivo: number;
     nome: string;
-    parametros?: any[];
+    atributos: {[key: string]: any};
 
-    constructor(
-        hashArquivo: number, 
-        linha: number, 
-        nome: string, 
-        parametros?: any[]
-    ) {
+    constructor(hashArquivo: number, linha: number, nome: string, atributos: {[key: string]: any}) {
         this.linha = linha;
         this.hashArquivo = hashArquivo;
         this.nome = nome;
-        this.parametros = parametros;
+        this.atributos = atributos;
     }
 
     async aceitar(visitante: VisitanteComumInterface): Promise<any> {
diff --git a/fontes/construtos/definir-valor.ts b/fontes/construtos/definir-valor.ts
index 539555a0..964c5bb0 100644
--- a/fontes/construtos/definir-valor.ts
+++ b/fontes/construtos/definir-valor.ts
@@ -10,10 +10,10 @@ export class DefinirValor<TTipoSimbolo extends string = string> implements Const
     valor: any;
 
     constructor(
-        hashArquivo: number, 
-        linha: number, 
-        objeto: Construto, 
-        nome: SimboloInterface<TTipoSimbolo>, 
+        hashArquivo: number,
+        linha: number,
+        objeto: Construto,
+        nome: SimboloInterface<TTipoSimbolo>,
         valor: any
     ) {
         this.linha = linha;
diff --git a/fontes/construtos/expressao-regular.ts b/fontes/construtos/expressao-regular.ts
index 6bee20ac..28e59796 100644
--- a/fontes/construtos/expressao-regular.ts
+++ b/fontes/construtos/expressao-regular.ts
@@ -8,11 +8,7 @@ export class ExpressaoRegular<TTipoSimbolo extends string = string> implements C
 
     simbolo: SimboloInterface<TTipoSimbolo>;
 
-    constructor(
-        hashArquivo: number, 
-        simbolo: SimboloInterface<TTipoSimbolo>, 
-        valor: any
-    ) {
+    constructor(hashArquivo: number, simbolo: SimboloInterface<TTipoSimbolo>, valor: any) {
         this.linha = Number(simbolo.linha);
         this.hashArquivo = hashArquivo;
         this.valor = valor;
diff --git a/fontes/construtos/fim-para.ts b/fontes/construtos/fim-para.ts
index e72c6de3..983a578c 100644
--- a/fontes/construtos/fim-para.ts
+++ b/fontes/construtos/fim-para.ts
@@ -4,13 +4,13 @@ import { Binario } from './binario';
 import { Construto } from './construto';
 
 /**
- * Construto especial para algumas linguagens como VisuAlg, que combina a 
- * avaliação da condição de continuação com o incremento. 
- * 
+ * Construto especial para algumas linguagens como VisuAlg, que combina a
+ * avaliação da condição de continuação com o incremento.
+ *
  * No caso específico do VisuAlg, ao final da última execução do bloco `para`,
  * o incremento não deve acontecer.
  *
- * Considerando como o depurador executa, o efeito visualnusando apenas as 
+ * Considerando como o depurador executa, o efeito visualnusando apenas as
  * declarações já existentes causava umansérie de comportamentos estranhos.
  */
 export class FimPara implements Construto {
diff --git a/fontes/construtos/logico.ts b/fontes/construtos/logico.ts
index 04c619ed..0fa6e5d8 100644
--- a/fontes/construtos/logico.ts
+++ b/fontes/construtos/logico.ts
@@ -10,9 +10,9 @@ export class Logico<TTipoSimbolo extends string = string> implements Construto {
     direita: Construto;
 
     constructor(
-        hashArquivo: number, 
-        esquerda: Construto, 
-        operador: SimboloInterface<TTipoSimbolo>, 
+        hashArquivo: number,
+        esquerda: Construto,
+        operador: SimboloInterface<TTipoSimbolo>,
         direita: Construto
     ) {
         this.linha = esquerda.linha;
diff --git a/fontes/construtos/qual-tipo.ts b/fontes/construtos/qual-tipo.ts
index 74269d72..640ca3e5 100644
--- a/fontes/construtos/qual-tipo.ts
+++ b/fontes/construtos/qual-tipo.ts
@@ -10,11 +10,7 @@ export class QualTipo<TTipoSimbolo extends string = string> implements Construto
 
     simbolo: SimboloInterface<TTipoSimbolo>;
 
-    constructor(
-        hashArquivo: number, 
-        simbolo: SimboloInterface<TTipoSimbolo>, 
-        valor: any
-    ) {
+    constructor(hashArquivo: number, simbolo: SimboloInterface<TTipoSimbolo>, valor: any) {
         this.linha = Number(simbolo.linha);
         this.hashArquivo = hashArquivo;
         this.valor = valor;
diff --git a/fontes/construtos/super.ts b/fontes/construtos/super.ts
index 3b86ed04..3524b4f8 100644
--- a/fontes/construtos/super.ts
+++ b/fontes/construtos/super.ts
@@ -9,8 +9,8 @@ export class Super<TTipoSimbolo extends string = string> implements Construto {
     metodo: SimboloInterface<TTipoSimbolo>;
 
     constructor(
-        hashArquivo: number, 
-        simboloChave: SimboloInterface<TTipoSimbolo>, 
+        hashArquivo: number,
+        simboloChave: SimboloInterface<TTipoSimbolo>,
         metodo: SimboloInterface<TTipoSimbolo>
     ) {
         this.linha = Number(simboloChave.linha);
diff --git a/fontes/construtos/tipo-de.ts b/fontes/construtos/tipo-de.ts
index ce87d29e..4fd0c8e3 100644
--- a/fontes/construtos/tipo-de.ts
+++ b/fontes/construtos/tipo-de.ts
@@ -8,11 +8,7 @@ export class TipoDe<TTipoSimbolo extends string = string> implements Construto {
 
     simbolo: SimboloInterface<TTipoSimbolo>;
 
-    constructor(
-        hashArquivo: number, 
-        simbolo: SimboloInterface<TTipoSimbolo>, 
-        valor: any
-    ) {
+    constructor(hashArquivo: number, simbolo: SimboloInterface<TTipoSimbolo>, valor: any) {
         this.linha = Number(simbolo.linha);
         this.hashArquivo = hashArquivo;
         this.valor = valor;
diff --git a/fontes/construtos/variavel.ts b/fontes/construtos/variavel.ts
index a4bfe086..2936b073 100644
--- a/fontes/construtos/variavel.ts
+++ b/fontes/construtos/variavel.ts
@@ -7,10 +7,7 @@ export class Variavel<TTipoSimbolo extends string = string> implements Construto
 
     simbolo: SimboloInterface<TTipoSimbolo>;
 
-    constructor(
-        hashArquivo: number, 
-        simbolo: SimboloInterface<TTipoSimbolo>
-    ) {
+    constructor(hashArquivo: number, simbolo: SimboloInterface<TTipoSimbolo>) {
         this.linha = Number(simbolo.linha);
         this.hashArquivo = hashArquivo;
 
diff --git a/fontes/declaracoes/const.ts b/fontes/declaracoes/const.ts
index 7ba28f16..421ba65a 100644
--- a/fontes/declaracoes/const.ts
+++ b/fontes/declaracoes/const.ts
@@ -1,4 +1,4 @@
-import { Construto } from '../construtos';
+import { Construto, Decorador } from '../construtos';
 import { VisitanteComumInterface, SimboloInterface } from '../interfaces';
 import { TipoDadosElementar } from '../tipo-dados-elementar';
 import { Declaracao } from './declaracao';
@@ -11,8 +11,13 @@ export class Const extends Declaracao {
     inicializador: Construto;
     tipo: TipoDadosElementar;
 
-    constructor(simbolo: SimboloInterface, inicializador: Construto, tipo: TipoDadosElementar = undefined) {
-        super(Number(simbolo.linha), simbolo.hashArquivo);
+    constructor(
+        simbolo: SimboloInterface, 
+        inicializador: Construto, 
+        tipo: TipoDadosElementar = undefined,
+        decoradores: Decorador[] = []
+    ) {
+        super(Number(simbolo.linha), simbolo.hashArquivo, decoradores);
         this.simbolo = simbolo;
         this.inicializador = inicializador;
         this.tipo = tipo;
diff --git a/fontes/declaracoes/declaracao.ts b/fontes/declaracoes/declaracao.ts
index be374ccc..acc2e2e9 100644
--- a/fontes/declaracoes/declaracao.ts
+++ b/fontes/declaracoes/declaracao.ts
@@ -1,17 +1,20 @@
+import { Decorador } from '../construtos';
 import { VisitanteComumInterface } from '../interfaces';
 
 export class Declaracao {
     linha: number;
     hashArquivo: number;
     assinaturaMetodo: string;
+    decoradores: Decorador[];
 
-    constructor(linha: number, hashArquivo: number) {
+    constructor(linha: number, hashArquivo: number, decoradores: Decorador[] = [], assinaturaMetodo: string = '<principal>') {
         this.linha = linha;
         this.hashArquivo = hashArquivo;
+        this.decoradores = decoradores;
         // TODO: Por ora, todos os testes são feitos num script só.
         // Quando iniciarem os testes em múltiplos arquivos e módulos,
         // pensar numa forma melhor de preencher isso.
-        this.assinaturaMetodo = '<principal>';
+        this.assinaturaMetodo = assinaturaMetodo;
     }
 
     async aceitar(visitante: VisitanteComumInterface): Promise<any> {
diff --git a/fontes/declaracoes/expressao.ts b/fontes/declaracoes/expressao.ts
index e84f5699..e30776b7 100644
--- a/fontes/declaracoes/expressao.ts
+++ b/fontes/declaracoes/expressao.ts
@@ -1,12 +1,15 @@
-import { Construto } from '../construtos';
+import { Construto, Decorador } from '../construtos';
 import { VisitanteComumInterface } from '../interfaces';
 import { Declaracao } from './declaracao';
 
 export class Expressao extends Declaracao {
     expressao: Construto;
 
-    constructor(expressao: Construto) {
-        super(expressao.linha, expressao.hashArquivo);
+    constructor(
+        expressao: Construto,
+        decoradores: Decorador[] = []
+    ) {
+        super(expressao.linha, expressao.hashArquivo, decoradores);
         this.expressao = expressao;
     }
 
diff --git a/fontes/declaracoes/tendo-como.ts b/fontes/declaracoes/tendo-como.ts
index 3bea2fd8..24ca1c2a 100644
--- a/fontes/declaracoes/tendo-como.ts
+++ b/fontes/declaracoes/tendo-como.ts
@@ -13,7 +13,13 @@ export class TendoComo extends Declaracao {
     inicializacaoVariavel: Construto;
     corpo: Bloco;
 
-    constructor(linha: number, hashArquivo: number, simboloVariavel: SimboloInterface, inicializacaoVariavel: Construto, corpo: Bloco) {
+    constructor(
+        linha: number,
+        hashArquivo: number,
+        simboloVariavel: SimboloInterface,
+        inicializacaoVariavel: Construto,
+        corpo: Bloco
+    ) {
         super(linha, hashArquivo);
         this.simboloVariavel = simboloVariavel;
         this.inicializacaoVariavel = inicializacaoVariavel;
diff --git a/fontes/declaracoes/var.ts b/fontes/declaracoes/var.ts
index 9379c485..d4742c97 100644
--- a/fontes/declaracoes/var.ts
+++ b/fontes/declaracoes/var.ts
@@ -1,4 +1,4 @@
-import { Construto } from '../construtos';
+import { Construto, Decorador } from '../construtos';
 import { VisitanteComumInterface, SimboloInterface } from '../interfaces';
 import { TipoDadosElementar } from '../tipo-dados-elementar';
 import { Declaracao } from './declaracao';
@@ -13,8 +13,13 @@ export class Var extends Declaracao {
     referencia: boolean;
     desestruturacao: boolean;
 
-    constructor(simbolo: SimboloInterface, inicializador: Construto, tipo: TipoDadosElementar = undefined) {
-        super(Number(simbolo.linha), simbolo.hashArquivo);
+    constructor(
+        simbolo: SimboloInterface, 
+        inicializador: Construto, 
+        tipo: TipoDadosElementar = undefined, 
+        decoradores: Decorador[] = []
+    ) {
+        super(Number(simbolo.linha), simbolo.hashArquivo, decoradores);
         this.simbolo = simbolo;
         this.inicializador = inicializador;
         this.tipo = tipo;
diff --git a/fontes/estruturas/chamavel.ts b/fontes/estruturas/chamavel.ts
index 245f8050..165b0684 100644
--- a/fontes/estruturas/chamavel.ts
+++ b/fontes/estruturas/chamavel.ts
@@ -8,7 +8,11 @@ export abstract class Chamavel {
         return this.valorAridade;
     }
 
-    async chamar(visitante?: VisitanteComumInterface, argumentos?: ArgumentoInterface[], simbolo?: SimboloInterface): Promise<any> {
+    async chamar(
+        visitante?: VisitanteComumInterface,
+        argumentos?: ArgumentoInterface[],
+        simbolo?: SimboloInterface
+    ): Promise<any> {
         return Promise.reject(new Error('Este método não deveria ser chamado.'));
     }
 }
diff --git a/fontes/estruturas/classe-padrao.ts b/fontes/estruturas/classe-padrao.ts
index 53a315ed..a2a8b6c0 100644
--- a/fontes/estruturas/classe-padrao.ts
+++ b/fontes/estruturas/classe-padrao.ts
@@ -8,9 +8,9 @@ export class ClassePadrao extends Chamavel {
     nome: string;
     // TypeScript não tem exatamente um tipo de construtor para classe.
     // O tipo abaixo é o mais próximo que existe desse tipo.
-    funcaoDeClasse: { new(...args: any[]): any; };
+    funcaoDeClasse: { new (...args: any[]): any };
 
-    constructor(nome: string, funcaoDeClasse: { new(...args: any[]): any; }) {
+    constructor(nome: string, funcaoDeClasse: { new (...args: any[]): any }) {
         super();
         this.nome = nome;
         this.funcaoDeClasse = funcaoDeClasse;
diff --git a/fontes/estruturas/delegua-funcao.ts b/fontes/estruturas/delegua-funcao.ts
index 00dd8652..a508d3f8 100644
--- a/fontes/estruturas/delegua-funcao.ts
+++ b/fontes/estruturas/delegua-funcao.ts
@@ -51,7 +51,7 @@ export class DeleguaFuncao extends Chamavel {
                 parametro.tipoDado && parametro.tipoDado.tipo ? `: ${parametro.tipoDado.tipo}, ` : ', '
             }`;
         }
-        
+
         if (this.declaracao.parametros.length > 0) {
             parametros = `argumentos=<${parametros.slice(0, -2)}>`;
         }
@@ -126,10 +126,7 @@ export class DeleguaFuncao extends Chamavel {
 
             // TODO: Apenass Potigol usa isso até então.
             // Estudar mover isso para o dialeto.
-            if (
-                this.instancia.classe.dialetoRequerExpansaoPropriedadesEspacoVariaveis && 
-                this.nome !== 'construtor'
-            ) {
+            if (this.instancia.classe.dialetoRequerExpansaoPropriedadesEspacoVariaveis && this.nome !== 'construtor') {
                 for (let [nomeCampo, valorCampo] of Object.entries(this.instancia.propriedades)) {
                     ambiente.valores[nomeCampo] = {
                         valor: valorCampo,
diff --git a/fontes/estruturas/descritor-tipo-classe.ts b/fontes/estruturas/descritor-tipo-classe.ts
index 46d5cf42..53b935cc 100644
--- a/fontes/estruturas/descritor-tipo-classe.ts
+++ b/fontes/estruturas/descritor-tipo-classe.ts
@@ -6,7 +6,7 @@ import { DeleguaFuncao } from './delegua-funcao';
 import { ObjetoDeleguaClasse } from './objeto-delegua-classe';
 
 /**
- * Descritor de tipo de classe. Quando uma declaração de classe é visitada, o que 
+ * Descritor de tipo de classe. Quando uma declaração de classe é visitada, o que
  * vai para a pilha de escopos de execução é esta estrutura. Quando uma nova instância
  * de classe é criada, a referência para a instância é implementada aqui.
  */
diff --git a/fontes/estruturas/funcao-padrao.ts b/fontes/estruturas/funcao-padrao.ts
index a823611a..c6b39f55 100644
--- a/fontes/estruturas/funcao-padrao.ts
+++ b/fontes/estruturas/funcao-padrao.ts
@@ -2,7 +2,7 @@ import { SimboloInterface, VisitanteComumInterface } from '../interfaces';
 import { Chamavel } from './chamavel';
 
 /**
- * Uma `FuncaoPadrao` normalmente é uma função em JavaScript que representa um 
+ * Uma `FuncaoPadrao` normalmente é uma função em JavaScript que representa um
  * método de uma biblioteca global, mas que pode ser usada para outros casos.
  */
 export class FuncaoPadrao extends Chamavel {
diff --git a/fontes/formatadores/formatador-delegua.ts b/fontes/formatadores/formatador-delegua.ts
index ae2cd671..7ad73928 100644
--- a/fontes/formatadores/formatador-delegua.ts
+++ b/fontes/formatadores/formatador-delegua.ts
@@ -85,14 +85,16 @@ export class FormatadorDelegua implements VisitanteComumInterface {
         if (declaracao.multilinha) {
             this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}/* `;
 
-            for (let linhaConteudo of (declaracao.conteudo as string[])) {
-                this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}  ${linhaConteudo.replace(/\s+/g, " ")}${this.quebraLinha}`;
+            for (let linhaConteudo of declaracao.conteudo as string[]) {
+                this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}  ${linhaConteudo.replace(/\s+/g, ' ')}${
+                    this.quebraLinha
+                }`;
             }
 
             this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)} */${this.quebraLinha}`;
         } else {
             this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}// `;
-            this.codigoFormatado += (declaracao.conteudo as string).replace(/\s+/g, " ");
+            this.codigoFormatado += (declaracao.conteudo as string).replace(/\s+/g, ' ');
             this.codigoFormatado += `${this.quebraLinha}`;
         }
     }
diff --git a/fontes/interfaces/avaliador-sintatico-interface.ts b/fontes/interfaces/avaliador-sintatico-interface.ts
index 2abcf4ef..0bb3a006 100644
--- a/fontes/interfaces/avaliador-sintatico-interface.ts
+++ b/fontes/interfaces/avaliador-sintatico-interface.ts
@@ -1,26 +1,5 @@
 import { ErroAvaliadorSintatico } from '../avaliador-sintatico/erro-avaliador-sintatico';
 import { RetornoAvaliadorSintatico } from './retornos/retorno-avaliador-sintatico';
-import { Construto, FuncaoConstruto } from '../construtos';
-import {
-    Classe,
-    Const,
-    Continua,
-    Enquanto,
-    Escolha,
-    Escreva,
-    Expressao,
-    Fazer,
-    FuncaoDeclaracao as FuncaoDeclaracao,
-    Importar,
-    Leia,
-    Para,
-    ParaCada,
-    Retorna,
-    Se,
-    Sustar,
-    Tente,
-    Var,
-} from '../declaracoes';
 import { RetornoLexador } from './retornos/retorno-lexador';
 
 export interface AvaliadorSintaticoInterface<TSimbolo, TDeclaracao> {
@@ -30,48 +9,5 @@ export interface AvaliadorSintaticoInterface<TSimbolo, TDeclaracao> {
     atual: number;
     blocos: number;
 
-    consumir(tipo: any, mensagemDeErro: string): any;
-    erro(simbolo: TSimbolo, mensagemDeErro: string): ErroAvaliadorSintatico;
-    verificarTipoSimboloAtual(tipo: string): boolean;
-    verificarTipoProximoSimbolo(tipo: string): boolean;
-    estaNoFinal(): boolean;
-    avancarEDevolverAnterior(): any;
-    verificarSeSimboloAtualEIgualA(...argumentos: any[]): boolean;
-    primario(): any;
-    finalizarChamada(entidadeChamada: Construto): Construto;
-    chamar(): Construto;
-    unario(): Construto;
-    exponenciacao(): Construto;
-    multiplicar(): Construto;
-    adicaoOuSubtracao(): Construto;
-    bitShift(): Construto;
-    bitE(): Construto;
-    bitOu(): Construto;
-    comparar(): Construto;
-    comparacaoIgualdade(): Construto;
-    em(): Construto;
-    e(): Construto;
-    ou(): Construto;
-    blocoEscopo(): any[];
-    expressao(): Construto;
-    declaracaoEnquanto(): Enquanto;
-    declaracaoEscreva(): Escreva;
-    declaracaoExpressao(): Expressao;
-    declaracaoLeia(): Leia;
-    declaracaoPara(): Para | ParaCada;
-    declaracaoSe(): Se;
-    declaracaoSustar(): Sustar;
-    declaracaoContinua(): Continua;
-    declaracaoRetorna(): Retorna;
-    declaracaoEscolha(): Escolha;
-    declaracaoImportar(): Importar;
-    declaracaoTente(): Tente;
-    declaracaoFazer(): Fazer;
-    resolverDeclaracao(): any;
-    declaracaoDeVariavel(): Var;
-    funcao(tipo: string): FuncaoDeclaracao;
-    corpoDaFuncao(tipo: string): FuncaoConstruto;
-    declaracaoDeClasse(): Classe;
-    resolverDeclaracaoForaDeBloco(): any;
     analisar(retornoLexador: RetornoLexador<TSimbolo>, hashArquivo: number): RetornoAvaliadorSintatico<TDeclaracao>;
 }
diff --git a/fontes/interfaces/formatador-comum-interface.ts b/fontes/interfaces/formatador-comum-interface.ts
index 2818419b..dd4e1e24 100644
--- a/fontes/interfaces/formatador-comum-interface.ts
+++ b/fontes/interfaces/formatador-comum-interface.ts
@@ -1,5 +1,5 @@
-import { Declaracao } from "../declaracoes/declaracao";
-import { VisitanteComumInterface } from "./visitante-comum-interface";
+import { Declaracao } from '../declaracoes/declaracao';
+import { VisitanteComumInterface } from './visitante-comum-interface';
 
 export interface FormatadorComumInterface extends VisitanteComumInterface {
     indentacaoAtual: number;
diff --git a/fontes/interfaces/retornos/retorno-execucao-interface.ts b/fontes/interfaces/retornos/retorno-execucao-interface.ts
index 8e853f08..864967e2 100644
--- a/fontes/interfaces/retornos/retorno-execucao-interface.ts
+++ b/fontes/interfaces/retornos/retorno-execucao-interface.ts
@@ -1,4 +1,4 @@
-import { ErroInterpretador } from "../erros/erro-interpretador";
+import { ErroInterpretador } from '../erros/erro-interpretador';
 
 export interface RetornoExecucaoInterface {
     erros: Array<ErroInterpretador>;
diff --git a/fontes/interfaces/variavel-interface.ts b/fontes/interfaces/variavel-interface.ts
index 4bd650c3..4b002d02 100644
--- a/fontes/interfaces/variavel-interface.ts
+++ b/fontes/interfaces/variavel-interface.ts
@@ -1,8 +1,8 @@
-import { TIPO_NATIVO, TipoInferencia } from "../interpretador";
+import { TIPO_NATIVO, TipoInferencia } from '../interpretador';
 
 export interface VariavelInterface {
     valor: any;
-    tipo: TipoInferencia | TIPO_NATIVO
+    tipo: TipoInferencia | TIPO_NATIVO;
     subtipo?: 'texto' | 'número' | 'longo' | 'lógico';
     imutavel: boolean;
     nomeReferencia?: string;
diff --git a/fontes/interpretador/comum.ts b/fontes/interpretador/comum.ts
index 79ebff72..2e7ac7de 100644
--- a/fontes/interpretador/comum.ts
+++ b/fontes/interpretador/comum.ts
@@ -1,111 +1,55 @@
-import { PilhaEscoposExecucaoInterface } from "../interfaces/pilha-escopos-execucao-interface";
+import { PilhaEscoposExecucaoInterface } from '../interfaces/pilha-escopos-execucao-interface';
 
-import { FuncaoPadrao } from "../estruturas/funcao-padrao";
+import { FuncaoPadrao } from '../estruturas/funcao-padrao';
 
 import * as bibliotecaGlobal from '../bibliotecas/biblioteca-global';
 
 export function carregarBibliotecasGlobais(pilhaEscoposExecucao: PilhaEscoposExecucaoInterface) {
-    pilhaEscoposExecucao.definirVariavel(
-        'aleatorio',
-        new FuncaoPadrao(1, bibliotecaGlobal.aleatorio)
-    );
+    pilhaEscoposExecucao.definirVariavel('aleatorio', new FuncaoPadrao(1, bibliotecaGlobal.aleatorio));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'aleatorioEntre',
-        new FuncaoPadrao(2, bibliotecaGlobal.aleatorioEntre)
-    );
+    pilhaEscoposExecucao.definirVariavel('aleatorioEntre', new FuncaoPadrao(2, bibliotecaGlobal.aleatorioEntre));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'algum',
-        new FuncaoPadrao(2, bibliotecaGlobal.algum)
-    );
+    pilhaEscoposExecucao.definirVariavel('algum', new FuncaoPadrao(2, bibliotecaGlobal.algum));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'encontrar',
-        new FuncaoPadrao(2, bibliotecaGlobal.encontrar)
-    );
+    pilhaEscoposExecucao.definirVariavel('encontrar', new FuncaoPadrao(2, bibliotecaGlobal.encontrar));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'encontrarIndice',
-        new FuncaoPadrao(2, bibliotecaGlobal.encontrarIndice)
-    );
+    pilhaEscoposExecucao.definirVariavel('encontrarIndice', new FuncaoPadrao(2, bibliotecaGlobal.encontrarIndice));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'encontrarUltimo',
-        new FuncaoPadrao(2, bibliotecaGlobal.encontrarUltimo)
-    );
+    pilhaEscoposExecucao.definirVariavel('encontrarUltimo', new FuncaoPadrao(2, bibliotecaGlobal.encontrarUltimo));
 
     pilhaEscoposExecucao.definirVariavel(
         'encontrarUltimoIndice',
         new FuncaoPadrao(2, bibliotecaGlobal.encontrarUltimoIndice)
     );
 
-    pilhaEscoposExecucao.definirVariavel(
-        'filtrarPor',
-        new FuncaoPadrao(2, bibliotecaGlobal.filtrarPor)
-    );
+    pilhaEscoposExecucao.definirVariavel('filtrarPor', new FuncaoPadrao(2, bibliotecaGlobal.filtrarPor));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'incluido',
-        new FuncaoPadrao(2, bibliotecaGlobal.incluido)
-    );
+    pilhaEscoposExecucao.definirVariavel('incluido', new FuncaoPadrao(2, bibliotecaGlobal.incluido));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'inteiro',
-        new FuncaoPadrao(1, bibliotecaGlobal.inteiro)
-    );
+    pilhaEscoposExecucao.definirVariavel('inteiro', new FuncaoPadrao(1, bibliotecaGlobal.inteiro));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'mapear',
-        new FuncaoPadrao(2, bibliotecaGlobal.mapear)
-    );
+    pilhaEscoposExecucao.definirVariavel('mapear', new FuncaoPadrao(2, bibliotecaGlobal.mapear));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'ordenar',
-        new FuncaoPadrao(1, bibliotecaGlobal.ordenar)
-    );
+    pilhaEscoposExecucao.definirVariavel('ordenar', new FuncaoPadrao(1, bibliotecaGlobal.ordenar));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'paraCada',
-        new FuncaoPadrao(2, bibliotecaGlobal.paraCada)
-    );
+    pilhaEscoposExecucao.definirVariavel('paraCada', new FuncaoPadrao(2, bibliotecaGlobal.paraCada));
 
     pilhaEscoposExecucao.definirVariavel(
         'primeiroEmCondicao',
         new FuncaoPadrao(2, bibliotecaGlobal.primeiroEmCondicao)
     );
 
-    pilhaEscoposExecucao.definirVariavel(
-        'real',
-        new FuncaoPadrao(1, bibliotecaGlobal.real)
-    );
+    pilhaEscoposExecucao.definirVariavel('real', new FuncaoPadrao(1, bibliotecaGlobal.real));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'reduzir',
-        new FuncaoPadrao(3, bibliotecaGlobal.reduzir)
-    );
+    pilhaEscoposExecucao.definirVariavel('reduzir', new FuncaoPadrao(3, bibliotecaGlobal.reduzir));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'tamanho',
-        new FuncaoPadrao(1, bibliotecaGlobal.tamanho)
-    );
+    pilhaEscoposExecucao.definirVariavel('tamanho', new FuncaoPadrao(1, bibliotecaGlobal.tamanho));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'texto',
-        new FuncaoPadrao(1, bibliotecaGlobal.texto)
-    );
+    pilhaEscoposExecucao.definirVariavel('texto', new FuncaoPadrao(1, bibliotecaGlobal.texto));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'todos', new FuncaoPadrao(2, bibliotecaGlobal.todosEmCondicao)
-    );
+    pilhaEscoposExecucao.definirVariavel('todos', new FuncaoPadrao(2, bibliotecaGlobal.todosEmCondicao));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'todosEmCondicao', 
-        new FuncaoPadrao(2, bibliotecaGlobal.todosEmCondicao)
-    );
+    pilhaEscoposExecucao.definirVariavel('todosEmCondicao', new FuncaoPadrao(2, bibliotecaGlobal.todosEmCondicao));
 
-    pilhaEscoposExecucao.definirVariavel(
-        'tupla', 
-        new FuncaoPadrao(1, bibliotecaGlobal.tupla)
-    );
+    pilhaEscoposExecucao.definirVariavel('tupla', new FuncaoPadrao(1, bibliotecaGlobal.tupla));
 }
diff --git a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
index a5135f64..478b34d3 100644
--- a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
+++ b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
@@ -254,7 +254,8 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
             ? 'número'
             : String(NaN);
         const tiposNumericos = ['inteiro', 'numero', 'número', 'real'];
-        if (tiposNumericos.includes(tipoDireita.toLowerCase()) && tiposNumericos.includes(tipoEsquerda.toLowerCase())) return;
+        if (tiposNumericos.includes(tipoDireita.toLowerCase()) && tiposNumericos.includes(tipoEsquerda.toLowerCase()))
+            return;
         throw new ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
     }
 
diff --git a/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts b/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts
index 86fbe8f3..7fc40b25 100644
--- a/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts
+++ b/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts
@@ -90,7 +90,7 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
         };
         this.pilhaEscoposExecucao.empilhar(escopoExecucao);
     }
-    
+
     visitarDeclaracaoComentario(declaracao: Comentario): Promise<any> {
         return Promise.resolve();
     }
@@ -182,7 +182,8 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
             ? 'número'
             : String(NaN);
         const tiposNumericos = ['inteiro', 'numero', 'número', 'real'];
-        if (tiposNumericos.includes(tipoDireita.toLowerCase()) && tiposNumericos.includes(tipoEsquerda.toLowerCase())) return;
+        if (tiposNumericos.includes(tipoDireita.toLowerCase()) && tiposNumericos.includes(tipoEsquerda.toLowerCase()))
+            return;
         throw new ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
     }
 
@@ -390,7 +391,7 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
     visitarDeclaracaoEnquanto(declaracao: Enquanto): never {
         throw new Error('Método não implementado');
     }
-    
+
     visitarDeclaracaoImportar(declaracao: Importar): never {
         throw new Error('Método não implementado');
     }
diff --git a/fontes/interpretador/inferenciador.ts b/fontes/interpretador/inferenciador.ts
index 7ca354ce..413e04ef 100644
--- a/fontes/interpretador/inferenciador.ts
+++ b/fontes/interpretador/inferenciador.ts
@@ -1,8 +1,24 @@
-import { Simbolo } from "../lexador";
+import { Simbolo } from '../lexador';
 import tipoDeDadosPrimitivos from '../tipos-de-dados/primitivos';
 import tipoDeDadosDelegua from '../tipos-de-dados/delegua';
 import tiposDeSimbolos from '../tipos-de-simbolos/delegua';
-export type TipoInferencia = "texto" | "cadeia" | "inteiro" | "real" | "vazio" | "caracter" | "número" | "longo" | "vetor" | "dicionário" | "nulo" | "lógico" | "função" | "símbolo" | "objeto" | "módulo";
+export type TipoInferencia =
+    | 'texto'
+    | 'cadeia'
+    | 'inteiro'
+    | 'real'
+    | 'vazio'
+    | 'caracter'
+    | 'número'
+    | 'longo'
+    | 'vetor'
+    | 'dicionário'
+    | 'nulo'
+    | 'lógico'
+    | 'função'
+    | 'símbolo'
+    | 'objeto'
+    | 'módulo';
 
 export enum TIPO_NATIVO {
     ESCREVA = '<palavra reservada escreva ajuda="palavra reservada usada para apresentar informações">',
@@ -15,10 +31,12 @@ export enum TIPO_NATIVO {
     INTEIRO = '<palavra reservada inteiro ajuda="palavra reservada usada para definir variáveis do tipo inteiro">',
     TEXTO = '<palavra reservada texto ajuda="palavra reservada usada para definir variáveis do tipo texto">',
     BOOLEANO = '<palavra reservada booleano ajuda="palavra reservada usada para definir variáveis do tipo booleano">',
-    VAZIO = '<palavra reservada vazio ajuda="palavra reservada usada para definir funções que não retornam valores">'
+    VAZIO = '<palavra reservada vazio ajuda="palavra reservada usada para definir funções que não retornam valores">',
 }
 
-export function inferirTipoVariavel(variavel: string | number | Array<any> | boolean | null | undefined): TipoInferencia | TIPO_NATIVO {
+export function inferirTipoVariavel(
+    variavel: string | number | Array<any> | boolean | null | undefined
+): TipoInferencia | TIPO_NATIVO {
     const tipo = typeof variavel;
     switch (tipo) {
         case 'string':
@@ -38,18 +56,19 @@ export function inferirTipoVariavel(variavel: string | number | Array<any> | boo
             if (variavel.constructor.name === 'DeleguaModulo') return 'módulo';
             if (variavel.constructor.name === 'Classe') return 'objeto';
             if (variavel.constructor.name === 'Simbolo') {
-                if (typeof variavel === "object") {
+                if (typeof variavel === 'object') {
                     const simbolo = variavel as Simbolo;
-                    if (simbolo.tipo === tiposDeSimbolos.ESCREVA) return TIPO_NATIVO.ESCREVA
-                    if (simbolo.tipo === tiposDeSimbolos.FUNCAO || simbolo.tipo === tiposDeSimbolos.FUNÇÃO) return TIPO_NATIVO.FUNCAO
-                    if (simbolo.tipo === tiposDeSimbolos.LEIA) return TIPO_NATIVO.LEIA
-                    if (simbolo.tipo === tiposDeSimbolos.SE) return TIPO_NATIVO.SE
-                    if (simbolo.tipo === tiposDeSimbolos.ENQUANTO) return TIPO_NATIVO.ENQUANTO
-                    if (simbolo.tipo === tiposDeSimbolos.PARA) return TIPO_NATIVO.PARA
-                    if (simbolo.tipo === tiposDeSimbolos.RETORNA) return TIPO_NATIVO.RETORNA
-                    if (simbolo.tipo === tipoDeDadosPrimitivos.TEXTO) return TIPO_NATIVO.TEXTO
-                    if (simbolo.tipo === tipoDeDadosPrimitivos.BOOLEANO) return TIPO_NATIVO.BOOLEANO
-                    if (simbolo.tipo === tipoDeDadosDelegua.VAZIO) return TIPO_NATIVO.VAZIO
+                    if (simbolo.tipo === tiposDeSimbolos.ESCREVA) return TIPO_NATIVO.ESCREVA;
+                    if (simbolo.tipo === tiposDeSimbolos.FUNCAO || simbolo.tipo === tiposDeSimbolos.FUNÇÃO)
+                        return TIPO_NATIVO.FUNCAO;
+                    if (simbolo.tipo === tiposDeSimbolos.LEIA) return TIPO_NATIVO.LEIA;
+                    if (simbolo.tipo === tiposDeSimbolos.SE) return TIPO_NATIVO.SE;
+                    if (simbolo.tipo === tiposDeSimbolos.ENQUANTO) return TIPO_NATIVO.ENQUANTO;
+                    if (simbolo.tipo === tiposDeSimbolos.PARA) return TIPO_NATIVO.PARA;
+                    if (simbolo.tipo === tiposDeSimbolos.RETORNA) return TIPO_NATIVO.RETORNA;
+                    if (simbolo.tipo === tipoDeDadosPrimitivos.TEXTO) return TIPO_NATIVO.TEXTO;
+                    if (simbolo.tipo === tipoDeDadosPrimitivos.BOOLEANO) return TIPO_NATIVO.BOOLEANO;
+                    if (simbolo.tipo === tipoDeDadosDelegua.VAZIO) return TIPO_NATIVO.VAZIO;
                 }
             }
             return 'dicionário';
diff --git a/fontes/interpretador/interpretador-base.ts b/fontes/interpretador/interpretador-base.ts
index 5607f19a..2acaa760 100644
--- a/fontes/interpretador/interpretador-base.ts
+++ b/fontes/interpretador/interpretador-base.ts
@@ -135,7 +135,7 @@ export class InterpretadorBase implements InterpretadorInterface {
         tipoDeDadosDelegua.INTEIRO,
         tipoDeDadosDelegua.NUMERO,
         tipoDeDadosDelegua.NÚMERO,
-        tipoDeDadosDelegua.REAL
+        tipoDeDadosDelegua.REAL,
     ];
 
     constructor(
@@ -232,12 +232,12 @@ export class InterpretadorBase implements InterpretadorInterface {
         const match = texto.match(/^([\/~@;%#'])(.*?)\1([gimsuy]*)$/);
         return match
             ? new RegExp(
-                match[2],
-                match[3]
-                    .split('')
-                    .filter((char, pos, flagArr) => flagArr.indexOf(char) === pos)
-                    .join('')
-            )
+                  match[2],
+                  match[3]
+                      .split('')
+                      .filter((char, pos, flagArr) => flagArr.indexOf(char) === pos)
+                      .join('')
+              )
             : new RegExp(texto);
     }
 
@@ -524,13 +524,13 @@ export class InterpretadorBase implements InterpretadorInterface {
         const tipoDireita: string = direita.tipo
             ? direita.tipo
             : typeof direita === tipoDeDadosPrimitivos.NUMERO
-                ? tipoDeDadosDelegua.NUMERO
-                : String(NaN);
+            ? tipoDeDadosDelegua.NUMERO
+            : String(NaN);
         const tipoEsquerda: string = esquerda.tipo
             ? esquerda.tipo
             : typeof esquerda === tipoDeDadosPrimitivos.NUMERO
-                ? tipoDeDadosDelegua.NUMERO
-                : String(NaN);
+            ? tipoDeDadosDelegua.NUMERO
+            : String(NaN);
 
         if (this.tiposNumericos.includes(tipoDireita) && this.tiposNumericos.includes(tipoEsquerda)) return;
 
@@ -551,7 +551,6 @@ export class InterpretadorBase implements InterpretadorInterface {
                 return Math.pow(valorEsquerdo, valorDireito);
 
             case tiposDeSimbolos.MAIOR:
-
                 if (this.tiposNumericos.includes(tipoEsquerdo) && this.tiposNumericos.includes(tipoDireito)) {
                     return Number(valorEsquerdo) > Number(valorDireito);
                 }
@@ -580,10 +579,7 @@ export class InterpretadorBase implements InterpretadorInterface {
 
             case tiposDeSimbolos.ADICAO:
             case tiposDeSimbolos.MAIS_IGUAL:
-                if (
-                    this.tiposNumericos.includes(tipoEsquerdo) &&
-                    this.tiposNumericos.includes(tipoDireito)
-                ) {
+                if (this.tiposNumericos.includes(tipoEsquerdo) && this.tiposNumericos.includes(tipoDireito)) {
                     return Number(valorEsquerdo) + Number(valorDireito);
                 }
 
@@ -663,9 +659,7 @@ export class InterpretadorBase implements InterpretadorInterface {
 
         for (const argumento of expressao.argumentos) {
             const valorResolvido: any = await this.avaliar(argumento);
-            argumentosResolvidos.push(
-                valorResolvido?.hasOwnProperty('valor') ? valorResolvido.valor : valorResolvido
-            );
+            argumentosResolvidos.push(valorResolvido?.hasOwnProperty('valor') ? valorResolvido.valor : valorResolvido);
         }
 
         return await entidadeChamada.chamar(this, argumentosResolvidos);
@@ -676,7 +670,7 @@ export class InterpretadorBase implements InterpretadorInterface {
         for (let i = 0; i < expressao.argumentos.length; i++) {
             const variavelArgumento = expressao.argumentos[i];
             const nomeArgumento = variavelArgumento.hasOwnProperty('simbolo')
-                ? variavelArgumento.simbolo.lexema
+                ? (variavelArgumento as Variavel).simbolo.lexema
                 : undefined;
 
             argumentos.push({
@@ -699,9 +693,7 @@ export class InterpretadorBase implements InterpretadorInterface {
         }
 
         if (entidadeChamada instanceof DescritorTipoClasse) {
-            return entidadeChamada.metodos.construtor
-                ? entidadeChamada.metodos.construtor.declaracao.parametros
-                : [];
+            return entidadeChamada.metodos.construtor ? entidadeChamada.metodos.construtor.declaracao.parametros : [];
         }
 
         return [];
@@ -835,7 +827,7 @@ export class InterpretadorBase implements InterpretadorInterface {
         let indice: any = null;
 
         if (expressao.indice) {
-            indice =  await this.avaliar(expressao.indice);
+            indice = await this.avaliar(expressao.indice);
         }
 
         this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valorResolvido, indice);
@@ -1367,12 +1359,12 @@ export class InterpretadorBase implements InterpretadorInterface {
             }
 
             return objeto[valorIndice];
-        } 
+        }
 
         if (objeto instanceof Vetor) {
             return objeto.valores[valorIndice];
         }
-        
+
         if (
             objeto.constructor === Object ||
             objeto instanceof ObjetoDeleguaClasse ||
@@ -1381,8 +1373,8 @@ export class InterpretadorBase implements InterpretadorInterface {
             objeto instanceof DeleguaModulo
         ) {
             return objeto[valorIndice] || null;
-        } 
-        
+        }
+
         if (typeof objeto === tipoDeDadosPrimitivos.TEXTO) {
             if (!Number.isInteger(valorIndice)) {
                 return Promise.reject(
@@ -1674,8 +1666,7 @@ export class InterpretadorBase implements InterpretadorInterface {
         }
 
         if (objeto instanceof RetornoQuebra) {
-            if (typeof objeto.valor === 'boolean')
-                return objeto.valor ? 'verdadeiro' : 'falso';
+            if (typeof objeto.valor === 'boolean') return objeto.valor ? 'verdadeiro' : 'falso';
         }
 
         if (objeto instanceof Date) {
@@ -1692,7 +1683,7 @@ export class InterpretadorBase implements InterpretadorInterface {
                 retornoVetor += typeof elemento === 'string' ? `'${elemento}', ` : `${this.paraTexto(elemento)}, `;
             }
 
-            if(retornoVetor.length > 1){
+            if (retornoVetor.length > 1) {
                 retornoVetor = retornoVetor.slice(0, -2);
             }
             retornoVetor += ']';
@@ -1715,7 +1706,7 @@ export class InterpretadorBase implements InterpretadorInterface {
         }
         if (typeof objeto === tipoDeDadosPrimitivos.OBJETO) {
             for (const obj in objeto) {
-                let valor = objeto[obj]
+                let valor = objeto[obj];
                 if (typeof valor === tipoDeDadosPrimitivos.BOOLEANO) {
                     valor = valor ? 'verdadeiro' : 'falso';
 
diff --git a/fontes/interpretador/interpretador-com-depuracao.ts b/fontes/interpretador/interpretador-com-depuracao.ts
index c6497bde..88e00900 100644
--- a/fontes/interpretador/interpretador-com-depuracao.ts
+++ b/fontes/interpretador/interpretador-com-depuracao.ts
@@ -1,4 +1,4 @@
-import _ from "lodash";
+import _ from 'lodash';
 
 import { EspacoVariaveis } from '../espaco-variaveis';
 import { Bloco, Declaracao, Enquanto, Escreva, Leia, LeiaMultiplo, Para, Retorna, Var } from '../declaracoes';
@@ -210,7 +210,7 @@ export class InterpretadorComDepuracao extends InterpretadorBase implements Inte
         // cada execução do bloco precisa de uma inicialização diferente.
         const cloneDeclaracao = _.cloneDeep(declaracao) as Para;
         const corpoExecucao = cloneDeclaracao.corpo as Bloco;
-        
+
         const declaracaoInicializador = Array.isArray(cloneDeclaracao.inicializador)
             ? declaracao.inicializador[0]
             : declaracao.inicializador;
@@ -227,7 +227,10 @@ export class InterpretadorComDepuracao extends InterpretadorBase implements Inte
         const escopoAtual = this.pilhaEscoposExecucao.topoDaPilha();
         switch (this.comando) {
             case 'proximo':
-                if (cloneDeclaracao.condicao !== null && this.eVerdadeiro(await this.avaliar(cloneDeclaracao.condicao))) {
+                if (
+                    cloneDeclaracao.condicao !== null &&
+                    this.eVerdadeiro(await this.avaliar(cloneDeclaracao.condicao))
+                ) {
                     escopoAtual.emLacoRepeticao = true;
 
                     const resultadoBloco = this.executarBloco(corpoExecucao.declaracoes);
@@ -239,7 +242,10 @@ export class InterpretadorComDepuracao extends InterpretadorBase implements Inte
             default:
                 let retornoExecucao: any;
                 while (!(retornoExecucao instanceof Quebra) && !this.pontoDeParadaAtivo) {
-                    if (cloneDeclaracao.condicao !== null && !this.eVerdadeiro(await this.avaliar(cloneDeclaracao.condicao))) {
+                    if (
+                        cloneDeclaracao.condicao !== null &&
+                        !this.eVerdadeiro(await this.avaliar(cloneDeclaracao.condicao))
+                    ) {
                         break;
                     }
 
diff --git a/fontes/interpretador/pilha-escopos-execucao.ts b/fontes/interpretador/pilha-escopos-execucao.ts
index cc833a46..0b886dff 100644
--- a/fontes/interpretador/pilha-escopos-execucao.ts
+++ b/fontes/interpretador/pilha-escopos-execucao.ts
@@ -63,9 +63,9 @@ export class PilhaEscoposExecucao implements PilhaEscoposExecucaoInterface {
 
         let tipoConstante;
         if (constante && constante.hasOwnProperty('tipo')) {
-            tipoConstante = constante.tipo
+            tipoConstante = constante.tipo;
         } else if (tipo) {
-            tipoConstante = tipo
+            tipoConstante = tipo;
         } else {
             tipoConstante = inferirTipoVariavel(valor);
         }
@@ -81,8 +81,8 @@ export class PilhaEscoposExecucao implements PilhaEscoposExecucaoInterface {
             let subtipo = '';
             if (valor instanceof Array) {
                 // TODO: verificar tipo lógico e outros possíveis subtipos
-                let numeros = valor.some(v => typeof v === 'number')
-                let textos = valor.some(v => typeof v === 'string')
+                let numeros = valor.some((v) => typeof v === 'number');
+                let textos = valor.some((v) => typeof v === 'string');
                 if (numeros && textos) subtipo = tipoDeDadosDelegua.QUALQUER;
                 else if (numeros) subtipo = tipoDeDadosDelegua.NUMERO;
                 else subtipo = tipoDeDadosDelegua.TEXTO;
@@ -98,9 +98,9 @@ export class PilhaEscoposExecucao implements PilhaEscoposExecucaoInterface {
 
         let tipoVariavel;
         if (variavel && variavel.hasOwnProperty('tipo')) {
-            tipoVariavel = variavel.tipo
+            tipoVariavel = variavel.tipo;
         } else if (tipo) {
-            tipoVariavel = tipo
+            tipoVariavel = tipo;
         } else {
             tipoVariavel = inferirTipoVariavel(valor);
         }
@@ -116,8 +116,8 @@ export class PilhaEscoposExecucao implements PilhaEscoposExecucaoInterface {
             let subtipo = '';
             if (valor instanceof Array) {
                 // TODO: verificar tipo lógico e outros possíveis subtipos
-                let numeros = valor.some(v => typeof v === 'number')
-                let textos = valor.some(v => typeof v === 'string')
+                let numeros = valor.some((v) => typeof v === 'number');
+                let textos = valor.some((v) => typeof v === 'string');
                 if (numeros && textos) subtipo = tipoDeDadosDelegua.QUALQUER;
                 else if (numeros) subtipo = tipoDeDadosDelegua.NUMERO;
                 else subtipo = tipoDeDadosDelegua.TEXTO;
@@ -151,7 +151,9 @@ export class PilhaEscoposExecucao implements PilhaEscoposExecucaoInterface {
                         `Constante '${simbolo.lexema}' não pode receber novos valores.`
                     );
                 }
-                const tipo = (variavel && variavel.hasOwnProperty('tipo') ? variavel.tipo : inferirTipoVariavel(valor)).toLowerCase() as TipoInferencia;
+                const tipo = (
+                    variavel && variavel.hasOwnProperty('tipo') ? variavel.tipo : inferirTipoVariavel(valor)
+                ).toLowerCase() as TipoInferencia;
 
                 const valorResolvido = this.converterValor(tipo, valor);
 
@@ -159,7 +161,7 @@ export class PilhaEscoposExecucao implements PilhaEscoposExecucaoInterface {
                     if (variavel.valor instanceof Array) {
                         variavel.valor[indice] = valorResolvido;
                     } else {
-                        throw new ErroEmTempoDeExecucao(simbolo, "Variável não é um vetor.");
+                        throw new ErroEmTempoDeExecucao(simbolo, 'Variável não é um vetor.');
                     }
                 } else {
                     ambiente.valores[simbolo.lexema] = {
diff --git a/fontes/lexador/lexador.ts b/fontes/lexador/lexador.ts
index f8f1d5e8..088eaf18 100644
--- a/fontes/lexador/lexador.ts
+++ b/fontes/lexador/lexador.ts
@@ -128,7 +128,7 @@ export class Lexador implements LexadorInterface<SimboloInterface> {
                 for (let linha of linhas) {
                     this.adicionarSimbolo(tiposDeSimbolos.LINHA_COMENTARIO, linha.trim());
                 }
-                
+
                 // Remove o asterisco da última linha
                 let lexemaUltimaLinha = this.simbolos[this.simbolos.length - 1].lexema;
                 lexemaUltimaLinha = lexemaUltimaLinha.substring(0, lexemaUltimaLinha.length - 1);
diff --git a/fontes/tradutores/tradutor-assemblyscript.ts b/fontes/tradutores/tradutor-assemblyscript.ts
index 8ba39138..9d270918 100644
--- a/fontes/tradutores/tradutor-assemblyscript.ts
+++ b/fontes/tradutores/tradutor-assemblyscript.ts
@@ -594,7 +594,7 @@ export class TradutorAssemblyScript {
         let resultado = '';
         if (comentario.multilinha) {
             resultado += `/*`;
-            for (let linhaComentario of (comentario.conteudo as string[])) {
+            for (let linhaComentario of comentario.conteudo as string[]) {
                 resultado += `${linhaComentario}\n`;
             }
             resultado += `*/`;
diff --git a/fontes/tradutores/tradutor-javascript.ts b/fontes/tradutores/tradutor-javascript.ts
index 90030dc0..c15ab26b 100644
--- a/fontes/tradutores/tradutor-javascript.ts
+++ b/fontes/tradutores/tradutor-javascript.ts
@@ -193,7 +193,7 @@ export class TradutorJavaScript implements TradutorInterface<Declaracao> {
         if (!retorno.endsWith('length')) {
             resultado += '(';
         }
-        
+
         for (let parametro of chamada.argumentos) {
             resultado += this.dicionarioConstrutos[parametro.constructor.name](parametro) + ', ';
         }
@@ -205,7 +205,7 @@ export class TradutorJavaScript implements TradutorInterface<Declaracao> {
         if (!retorno.endsWith('length')) {
             resultado += ')';
         }
-        
+
         return resultado;
     }
 
@@ -213,7 +213,7 @@ export class TradutorJavaScript implements TradutorInterface<Declaracao> {
         let resultado = '';
         if (comentario.multilinha) {
             resultado += `/*`;
-            for (let linhaComentario of (comentario.conteudo as string[])) {
+            for (let linhaComentario of comentario.conteudo as string[]) {
                 resultado += `${linhaComentario}\n`;
             }
             resultado += `*/`;
diff --git a/fontes/tradutores/tradutor-python.ts b/fontes/tradutores/tradutor-python.ts
index 14d5b7e9..606f9cee 100644
--- a/fontes/tradutores/tradutor-python.ts
+++ b/fontes/tradutores/tradutor-python.ts
@@ -215,7 +215,7 @@ export class TradutorPython implements TradutorInterface<Declaracao> {
         let resultado = '';
         if (comentario.multilinha) {
             resultado += `'''`;
-            for (let linhaComentario of (comentario.conteudo as string[])) {
+            for (let linhaComentario of comentario.conteudo as string[]) {
                 resultado += `${linhaComentario}\n`;
             }
             resultado += `'''`;
diff --git a/package.json b/package.json
index 66921ae4..ed1fd10c 100644
--- a/package.json
+++ b/package.json
@@ -7,15 +7,15 @@
     "scripts": {
         "copiar-arquivos-pacote": "yarn copyfiles -V ./bin/delegua ./bin/delegua.cmd ./dist && yarn copyfiles -V ./package.json ./dist/bin && yarn copyfiles -V ./README.md ./dist",
         "empacotar": "yarn rimraf ./dist && tsc && yarn umd && yarn copiar-arquivos-pacote",
-        "gerar-documentacao-tecnica": "typedoc --out docs fontes/index.ts",
+        "gerar-documentacao-tecnica": "yarn typedoc --out docs fontes/index.ts",
         "publicar-docs": "yarn gerar-documentacao-tecnica && yarn copyfiles -V ./recursos/**/* ./docs && yarn gh-pages -d docs",
         "publicar-npm": "npm publish ./dist --access public",
-        "testes-unitarios": "jest --coverage",
-        "testes-unitarios:insignias": "jest-coverage-badges --output ./recursos/imagens",
-        "observar-testes-unitarios": "jest --watchAll",
-        "observar-testes-unitarios-com-coverage": "jest --coverage --watchAll",
-        "lint": "eslint . --ext .ts",
-        "deixar-codigo-bonito": "prettier --config .prettierrc --write fontes/**/*.ts",
+        "testes-unitarios": "yarn jest --coverage",
+        "testes-unitarios:insignias": "yarn jest-coverage-badges --output ./recursos/imagens",
+        "observar-testes-unitarios": "yarn jest --watchAll",
+        "observar-testes-unitarios-com-coverage": "yarn jest --coverage --watchAll",
+        "lint": "yarn eslint . --ext .ts",
+        "deixar-codigo-bonito": "yarn prettier --config .prettierrc --write fontes/**/*.ts",
         "umd": "yarn browserify dist/index.js --s Delegua -o dist/umd/delegua.js",
         "umd:rollup": "yarn rollup fontes/index.ts --config rollup.config.ts --configPlugin @rollup/plugin-typescript"
     },
@@ -87,7 +87,7 @@
         "rollup-plugin-polyfill-node": "^0.13.0",
         "ts-jest": "^29.0.5",
         "ts-node": "^10.9.1",
-        "typedoc": "^0.23.22",
+        "typedoc": "^0.26.11",
         "typescript": "^5.6.3"
     },
     "dependencies": {
diff --git a/testes/avaliador-sintatico.test.ts b/testes/avaliador-sintatico.test.ts
index 4d97fe57..468605e0 100644
--- a/testes/avaliador-sintatico.test.ts
+++ b/testes/avaliador-sintatico.test.ts
@@ -1,7 +1,7 @@
 import { Lexador } from '../fontes/lexador';
 import { AvaliadorSintatico } from '../fontes/avaliador-sintatico';
-import { Bloco, TendoComo } from '../fontes/declaracoes';
-import { Chamada } from '../fontes/construtos';
+import { Bloco, Classe, Expressao, TendoComo } from '../fontes/declaracoes';
+import { Chamada, Literal } from '../fontes/construtos';
 
 describe('Avaliador sintático', () => {
     describe('analisar()', () => {
@@ -137,15 +137,15 @@ describe('Avaliador sintático', () => {
             });
 
             describe('Decoradores', () => {
-                it('Sucesso - decorador de classe simples', () => {
+                it('Decoradores de classe simples, empilhados', () => {
                     const retornoLexador = lexador.mapear(
                         [
                             '@meu.decorador1',
                             '@meu.decorador2',
                             'classe Teste {',
-                            'testeFuncao() {',
-                            'escreva("olá")',
-                            '}',
+                            '    testeFuncao() {',
+                            '        escreva("olá")',
+                            '    }',
                             '}',
                         ],
                         -1
@@ -154,17 +154,24 @@ describe('Avaliador sintático', () => {
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    const declaracao = retornoAvaliadorSintatico.declaracoes[0];
+                    expect(declaracao).toBeInstanceOf(Classe);
+                    const decoradores = (declaracao as Classe).decoradores;
+                    expect(decoradores).toHaveLength(2);
+                    expect(decoradores[0].nome).toBe("@meu.decorador1");
+                    expect(decoradores[1].nome).toBe("@meu.decorador2");
                 });
 
-                it('Sucesso - decorador de classe com parametros', () => {
+                it('Decorador de classe com parametros', () => {
                     const retornoLexador = lexador.mapear(
                         [
                             '@decorador1(atributo1="123", atributo2=4)',
                             'classe Teste {',
-                            '@decorador2(atributo1="123", atributo2=4)',
-                            'testeFuncao() {',
-                            'escreva("olá")',
-                            '}',
+                            '    @decorador2(atributo3="567", atributo4=8)',
+                            '    testeFuncao() {',
+                            '        escreva("olá")',
+                            '    }',
                             '}',
                         ],
                         -1
@@ -173,17 +180,45 @@ describe('Avaliador sintático', () => {
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    const declaracao = retornoAvaliadorSintatico.declaracoes[0];
+                    expect(declaracao).toBeInstanceOf(Classe);
+
+                    const classe = declaracao as Classe;
+                    const decoradores = classe.decoradores;
+                    expect(decoradores).toHaveLength(1);
+
+                    const decorador1 = decoradores[0];
+                    expect(decorador1.nome).toBe("@decorador1");
+                    expect('atributo1' in decorador1.atributos).toBe(true);
+                    expect('atributo2' in decorador1.atributos).toBe(true);
+                    expect(decorador1.atributos['atributo1']).toBeInstanceOf(Literal);
+                    expect(decorador1.atributos['atributo2']).toBeInstanceOf(Literal);
+                    expect(decorador1.atributos['atributo1'].valor).toBe("123");
+                    expect(decorador1.atributos['atributo2'].valor).toBe(4);
+
+                    expect(classe.metodos).toHaveLength(1);
+                    const metodo = classe.metodos[0];
+                    expect(metodo.decoradores).toHaveLength(1);
+                    const decorador2 = metodo.decoradores[0];
+                    expect(decorador2.nome).toBe("@decorador2");
+                    expect('atributo3' in decorador2.atributos).toBe(true);
+                    expect('atributo4' in decorador2.atributos).toBe(true);
+                    expect(decorador2.atributos['atributo3']).toBeInstanceOf(Literal);
+                    expect(decorador2.atributos['atributo4']).toBeInstanceOf(Literal);
+                    expect(decorador2.atributos['atributo3'].valor).toBe("567");
+                    expect(decorador2.atributos['atributo4'].valor).toBe(8);
                 });
 
-                it('Sucesso - decorador de classe/método', () => {
+                it('Decorador de classe/método pontuado, sem atributos', () => {
                     const retornoLexador = lexador.mapear(
                         [
                             '@meu.decorador1',
                             'classe Teste {',
-                            '@meu.decorador2',
-                            'testeFuncao() {',
-                            'escreva("olá")',
-                            '}',
+                            '    @meu.decorador2',
+                            '    testeFuncao() {',
+                            '        escreva("olá")',
+                            '    }',
                             '}',
                         ],
                         -1
@@ -192,19 +227,35 @@ describe('Avaliador sintático', () => {
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    const declaracao = retornoAvaliadorSintatico.declaracoes[0];
+                    expect(declaracao).toBeInstanceOf(Classe);
+
+                    const classe = declaracao as Classe;
+                    const decoradores = classe.decoradores;
+                    expect(decoradores).toHaveLength(1);
+
+                    const decorador1 = decoradores[0];
+                    expect(decorador1.nome).toBe("@meu.decorador1");
+                    expect(Object.entries(decorador1.atributos)).toHaveLength(0);
+
+                    expect(classe.metodos).toHaveLength(1);
+                    const metodo = classe.metodos[0];
+                    expect(metodo.decoradores).toHaveLength(1);
+                    const decorador2 = metodo.decoradores[0];
+                    expect(decorador2.nome).toBe("@meu.decorador2");
+                    expect(Object.entries(decorador2.atributos)).toHaveLength(0);
                 });
 
-                it('Sucesso - decorador de classe/método/propriedade', () => {
+                it('Decorador de propriedade', () => {
                     const retornoLexador = lexador.mapear(
                         [
-                            '@meu.decorador1',
                             'classe Teste {',
-                            '@meu.decorador3',
-                            'propriedade1: texto',
-                            '@meu.decorador2',
-                            'testeFuncao() {',
-                            'escreva("olá")',
-                            '}',
+                            '    @meu.decorador',
+                            '    propriedade1: texto',
+                            '    testeFuncao() {',
+                            '        escreva("olá")',
+                            '    }',
                             '}',
                         ],
                         -1
@@ -213,6 +264,76 @@ describe('Avaliador sintático', () => {
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    const declaracao = retornoAvaliadorSintatico.declaracoes[0];
+                    expect(declaracao).toBeInstanceOf(Classe);
+
+                    const classe = declaracao as Classe;
+                    expect(classe.propriedades).toHaveLength(1);
+                    const propriedade = classe.propriedades[0];
+                    expect(propriedade.decoradores).toHaveLength(1);
+                    const decorador = propriedade.decoradores[0];
+                    expect(decorador.nome).toBe("@meu.decorador");
+                    expect(Object.entries(decorador.atributos)).toHaveLength(0);
+                });
+
+                it('Decorador de chamadas de métodos', () => {
+                    const retornoLexador = lexador.mapear(
+                        [
+                            '@rest.documentacao(',
+                            '    sumario = "Um exemplo de rota GET.", ',
+                            '    descricao = "Uma descrição mais detalhada sobre como a rota GET funciona.", ',
+                            '    idOperacao = "lerArtigos",',
+                            '    etiquetas = ["artigos"]',
+                            ')',
+                            '@rest.resposta(',
+                            '    codigo = 200, ',
+                            '    descricao = "Devolvido com sucesso", ',
+                            '    formatos = ["application/json", "application/xml"]',
+                            ')',
+                            'liquido.rotaGet(funcao(requisicao, resposta) {',
+                            '    resposta.json([{',
+                            '        "id": 1,',
+                            '        "titulo": "teste 1",',
+                            '        "descricao": "descricao 1"',
+                            '    }])',
+                            '})'
+                        ],
+                        -1
+                    );
+
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    const declaracao = retornoAvaliadorSintatico.declaracoes[0];
+                    expect(declaracao).toBeInstanceOf(Expressao);
+
+                    expect(declaracao.decoradores).toHaveLength(2);
+                    const decoradorRestDocumentacao = declaracao.decoradores[0];
+                    expect(decoradorRestDocumentacao.nome).toBe('@rest.documentacao');
+                    expect(Object.entries(decoradorRestDocumentacao.atributos)).toHaveLength(4);
+                    expect('sumario' in decoradorRestDocumentacao.atributos).toBe(true);
+                    expect(decoradorRestDocumentacao.atributos['sumario'].valor).toBe('Um exemplo de rota GET.');
+                    expect('descricao' in decoradorRestDocumentacao.atributos).toBe(true);
+                    expect(decoradorRestDocumentacao.atributos['descricao'].valor).toBe('Uma descrição mais detalhada sobre como a rota GET funciona.');
+                    expect('idOperacao' in decoradorRestDocumentacao.atributos).toBe(true);
+                    expect(decoradorRestDocumentacao.atributos['idOperacao'].valor).toBe('lerArtigos');
+                    expect('etiquetas' in decoradorRestDocumentacao.atributos).toBe(true);
+                    expect(decoradorRestDocumentacao.atributos['etiquetas'].valores).toHaveLength(1);
+                    expect(decoradorRestDocumentacao.atributos['etiquetas'].valores[0].valor).toBe('artigos');
+
+                    const decoradorRestResposta = declaracao.decoradores[1];
+                    expect(decoradorRestResposta.nome).toBe('@rest.resposta');
+                    expect(Object.entries(decoradorRestResposta.atributos)).toHaveLength(3);
+                    expect('codigo' in decoradorRestResposta.atributos).toBe(true);
+                    expect(decoradorRestResposta.atributos['codigo'].valor).toBe(200);
+                    expect('descricao' in decoradorRestResposta.atributos).toBe(true);
+                    expect(decoradorRestResposta.atributos['descricao'].valor).toBe('Devolvido com sucesso');
+                    expect('formatos' in decoradorRestResposta.atributos).toBe(true);
+                    expect(decoradorRestResposta.atributos['formatos'].valores).toHaveLength(2);
+                    expect(decoradorRestResposta.atributos['formatos'].valores[0].valor).toBe('application/json');
+                    expect(decoradorRestResposta.atributos['formatos'].valores[1].valor).toBe('application/xml');
                 });
             });
 
diff --git a/yarn.lock b/yarn.lock
index e178bc2e..a4e76edc 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1759,6 +1759,48 @@
   resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.17.2.tgz#5a2d08b81e8064b34242d5cc9973ef8dd1e60503"
   integrity sha512-TGGO7v7qOq4CYmSBVEYpI1Y5xDuCEnbVC5Vth8mOsW0gDSzxNrVERPc790IGHsrT2dQSimgMr9Ub3Y1Jci5/8w==
 
+"@shikijs/core@1.23.1":
+  version "1.23.1"
+  resolved "https://registry.yarnpkg.com/@shikijs/core/-/core-1.23.1.tgz#911473e672e4f2d15ca36b28b28179c0959aa7af"
+  integrity sha512-NuOVgwcHgVC6jBVH5V7iblziw6iQbWWHrj5IlZI3Fqu2yx9awH7OIQkXIcsHsUmY19ckwSgUMgrqExEyP5A0TA==
+  dependencies:
+    "@shikijs/engine-javascript" "1.23.1"
+    "@shikijs/engine-oniguruma" "1.23.1"
+    "@shikijs/types" "1.23.1"
+    "@shikijs/vscode-textmate" "^9.3.0"
+    "@types/hast" "^3.0.4"
+    hast-util-to-html "^9.0.3"
+
+"@shikijs/engine-javascript@1.23.1":
+  version "1.23.1"
+  resolved "https://registry.yarnpkg.com/@shikijs/engine-javascript/-/engine-javascript-1.23.1.tgz#0f634bea22cb14f471835b7b5f1da66bc34bd359"
+  integrity sha512-i/LdEwT5k3FVu07SiApRFwRcSJs5QM9+tod5vYCPig1Ywi8GR30zcujbxGQFJHwYD7A5BUqagi8o5KS+LEVgBg==
+  dependencies:
+    "@shikijs/types" "1.23.1"
+    "@shikijs/vscode-textmate" "^9.3.0"
+    oniguruma-to-es "0.4.1"
+
+"@shikijs/engine-oniguruma@1.23.1":
+  version "1.23.1"
+  resolved "https://registry.yarnpkg.com/@shikijs/engine-oniguruma/-/engine-oniguruma-1.23.1.tgz#c6c34c9152cf90c1ee75fcdbd124253c8ad0635f"
+  integrity sha512-KQ+lgeJJ5m2ISbUZudLR1qHeH3MnSs2mjFg7bnencgs5jDVPeJ2NVDJ3N5ZHbcTsOIh0qIueyAJnwg7lg7kwXQ==
+  dependencies:
+    "@shikijs/types" "1.23.1"
+    "@shikijs/vscode-textmate" "^9.3.0"
+
+"@shikijs/types@1.23.1":
+  version "1.23.1"
+  resolved "https://registry.yarnpkg.com/@shikijs/types/-/types-1.23.1.tgz#2386d49258be03e7b40fea1f28fda952739ad93d"
+  integrity sha512-98A5hGyEhzzAgQh2dAeHKrWW4HfCMeoFER2z16p5eJ+vmPeF6lZ/elEne6/UCU551F/WqkopqRsr1l2Yu6+A0g==
+  dependencies:
+    "@shikijs/vscode-textmate" "^9.3.0"
+    "@types/hast" "^3.0.4"
+
+"@shikijs/vscode-textmate@^9.3.0":
+  version "9.3.0"
+  resolved "https://registry.yarnpkg.com/@shikijs/vscode-textmate/-/vscode-textmate-9.3.0.tgz#b2f1776e488c1d6c2b6cd129bab62f71bbc9c7ab"
+  integrity sha512-jn7/7ky30idSkd/O5yDBfAnVt+JJpepofP/POZ1iMOxK59cOfqIgg/Dj0eFsjOTMw+4ycJN0uhZH/Eb0bs/EUA==
+
 "@sinclair/typebox@^0.25.16":
   version "0.25.23"
   resolved "https://registry.yarnpkg.com/@sinclair/typebox/-/typebox-0.25.23.tgz#1c15b0d2b872d89cc0f47c7243eacb447df8b8bd"
@@ -1877,6 +1919,13 @@
   dependencies:
     "@types/node" "*"
 
+"@types/hast@^3.0.0", "@types/hast@^3.0.4":
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/@types/hast/-/hast-3.0.4.tgz#1d6b39993b82cea6ad783945b0508c25903e15aa"
+  integrity sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==
+  dependencies:
+    "@types/unist" "*"
+
 "@types/http-cache-semantics@^4.0.1":
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/@types/http-cache-semantics/-/http-cache-semantics-4.0.1.tgz#0ea7b61496902b95890dc4c3a116b60cb8dae812"
@@ -1919,6 +1968,13 @@
   resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.14.194.tgz#b71eb6f7a0ff11bff59fc987134a093029258a76"
   integrity sha512-r22s9tAS7imvBt2lyHC9B8AGwWnXaYb1tY09oyLkXDs4vArpYJzw09nj8MLx5VfciBPGIb+ZwG0ssYnEPJxn/g==
 
+"@types/mdast@^4.0.0":
+  version "4.0.4"
+  resolved "https://registry.yarnpkg.com/@types/mdast/-/mdast-4.0.4.tgz#7ccf72edd2f1aa7dd3437e180c64373585804dd6"
+  integrity sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==
+  dependencies:
+    "@types/unist" "*"
+
 "@types/node@*":
   version "18.14.0"
   resolved "https://registry.yarnpkg.com/@types/node/-/node-18.14.0.tgz#94c47b9217bbac49d4a67a967fdcdeed89ebb7d0"
@@ -1946,6 +2002,11 @@
   resolved "https://registry.yarnpkg.com/@types/stack-utils/-/stack-utils-2.0.1.tgz#20f18294f797f2209b5f65c8e3b5c8e8261d127c"
   integrity sha512-Hl219/BT5fLAaz6NDkSuhzasy49dwQS/DSdu4MdggFB8zcXv7vflBI3xp7FEmkmdDkBUI2bPUNeMttp2knYdxw==
 
+"@types/unist@*", "@types/unist@^3.0.0":
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/@types/unist/-/unist-3.0.3.tgz#acaab0f919ce69cce629c2d4ed2eb4adc1b6c20c"
+  integrity sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==
+
 "@types/yargs-parser@*":
   version "21.0.0"
   resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-21.0.0.tgz#0c60e537fa790f5f9472ed2776c2b71ec117351b"
@@ -2042,6 +2103,11 @@
     "@typescript-eslint/types" "5.52.0"
     eslint-visitor-keys "^3.3.0"
 
+"@ungap/structured-clone@^1.0.0":
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/@ungap/structured-clone/-/structured-clone-1.2.0.tgz#756641adb587851b5ccb3e095daf27ae581c8406"
+  integrity sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==
+
 JSONStream@^1.0.3:
   version "1.3.5"
   resolved "https://registry.yarnpkg.com/JSONStream/-/JSONStream-1.3.5.tgz#3208c1f08d3a4d99261ab64f92302bc15e111ca0"
@@ -2137,11 +2203,6 @@ ansi-regex@^6.0.1:
   resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-6.0.1.tgz#3183e38fae9a65d7cb5e53945cd5897d0260a06a"
   integrity sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==
 
-ansi-sequence-parser@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/ansi-sequence-parser/-/ansi-sequence-parser-1.1.0.tgz#4d790f31236ac20366b23b3916b789e1bde39aed"
-  integrity sha512-lEm8mt52to2fT8GhciPCGeCXACSz2UwIN4X2e2LJSnZ5uAbn2/dsYdOmUXq0AtWS5cpAupysIneExOgH0Vd2TQ==
-
 ansi-styles@^3.2.1:
   version "3.2.1"
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
@@ -2730,6 +2791,11 @@ caniuse-lite@^1.0.30001663:
   resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001669.tgz#fda8f1d29a8bfdc42de0c170d7f34a9cf19ed7a3"
   integrity sha512-DlWzFDJqstqtIVx1zeSpIMLjunf5SmwOw0N2Ck/QSQdS8PLS4+9HrLaYei4w8BIAL7IB/UEDu889d8vhCTPA0w==
 
+ccount@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/ccount/-/ccount-2.0.1.tgz#17a3bf82302e0870d6da43a01311a8bc02a3ecf5"
+  integrity sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==
+
 chalk@5.1.2:
   version "5.1.2"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-5.1.2.tgz#d957f370038b75ac572471e83be4c5ca9f8e8c45"
@@ -2762,6 +2828,16 @@ char-regex@^1.0.2:
   resolved "https://registry.yarnpkg.com/char-regex/-/char-regex-1.0.2.tgz#d744358226217f981ed58f479b1d6bcc29545dcf"
   integrity sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==
 
+character-entities-html4@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/character-entities-html4/-/character-entities-html4-2.1.0.tgz#1f1adb940c971a4b22ba39ddca6b618dc6e56b2b"
+  integrity sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==
+
+character-entities-legacy@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz#76bc83a90738901d7bc223a9e93759fdd560125b"
+  integrity sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==
+
 chardet@^0.7.0:
   version "0.7.0"
   resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.7.0.tgz#90094849f0937f2eedc2425d0d28a9e5f0cbad9e"
@@ -2874,6 +2950,11 @@ combine-source-map@^0.8.0, combine-source-map@~0.8.0:
     lodash.memoize "~3.0.3"
     source-map "~0.5.3"
 
+comma-separated-tokens@^2.0.0:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz#4e89c9458acb61bc8fef19f4529973b2392839ee"
+  integrity sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==
+
 commander@^2.18.0, commander@^2.20.0:
   version "2.20.3"
   resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
@@ -3185,6 +3266,11 @@ deps-sort@^2.0.1:
     subarg "^1.0.0"
     through2 "^2.0.0"
 
+dequal@^2.0.0:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/dequal/-/dequal-2.0.3.tgz#2644214f1997d39ed0ee0ece72335490a7ac67be"
+  integrity sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==
+
 des.js@^1.0.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/des.js/-/des.js-1.1.0.tgz#1d37f5766f3bbff4ee9638e871a8768c173b81da"
@@ -3207,6 +3293,13 @@ detective@^5.2.0:
     defined "^1.0.0"
     minimist "^1.2.6"
 
+devlop@^1.0.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/devlop/-/devlop-1.1.0.tgz#4db7c2ca4dc6e0e834c30be70c94bbc976dc7018"
+  integrity sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==
+  dependencies:
+    dequal "^2.0.0"
+
 diff-sequences@^29.4.3:
   version "29.4.3"
   resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-29.4.3.tgz#9314bc1fabe09267ffeca9cbafc457d8499a13f2"
@@ -3302,6 +3395,11 @@ emittery@^0.13.1:
   resolved "https://registry.yarnpkg.com/emittery/-/emittery-0.13.1.tgz#c04b8c3457490e0847ae51fced3af52d338e3dad"
   integrity sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==
 
+emoji-regex-xs@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/emoji-regex-xs/-/emoji-regex-xs-1.0.0.tgz#e8af22e5d9dbd7f7f22d280af3d19d2aab5b0724"
+  integrity sha512-LRlerrMYoIDrT6jgpeZ2YYl/L8EulRTt5hQcYjy5AInh7HWXKimpqx68aknBFpGL2+/IcogTcaydJEgaTmOpDg==
+
 emoji-regex@^8.0.0:
   version "8.0.0"
   resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
@@ -3312,6 +3410,11 @@ emoji-regex@^9.2.2:
   resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72"
   integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==
 
+entities@^4.4.0:
+  version "4.5.0"
+  resolved "https://registry.yarnpkg.com/entities/-/entities-4.5.0.tgz#5d268ea5e7113ec74c4d033b79ea5a35a488fb48"
+  integrity sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==
+
 error-ex@^1.3.1:
   version "1.3.2"
   resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf"
@@ -4211,6 +4314,30 @@ hasown@^2.0.0:
   dependencies:
     function-bind "^1.1.2"
 
+hast-util-to-html@^9.0.3:
+  version "9.0.3"
+  resolved "https://registry.yarnpkg.com/hast-util-to-html/-/hast-util-to-html-9.0.3.tgz#a9999a0ba6b4919576a9105129fead85d37f302b"
+  integrity sha512-M17uBDzMJ9RPCqLMO92gNNUDuBSq10a25SDBI08iCCxmorf4Yy6sYHK57n9WAbRAAaU+DuR4W6GN9K4DFZesYg==
+  dependencies:
+    "@types/hast" "^3.0.0"
+    "@types/unist" "^3.0.0"
+    ccount "^2.0.0"
+    comma-separated-tokens "^2.0.0"
+    hast-util-whitespace "^3.0.0"
+    html-void-elements "^3.0.0"
+    mdast-util-to-hast "^13.0.0"
+    property-information "^6.0.0"
+    space-separated-tokens "^2.0.0"
+    stringify-entities "^4.0.0"
+    zwitch "^2.0.4"
+
+hast-util-whitespace@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz#7778ed9d3c92dd9e8c5c8f648a49c21fc51cb621"
+  integrity sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==
+  dependencies:
+    "@types/hast" "^3.0.0"
+
 hmac-drbg@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/hmac-drbg/-/hmac-drbg-1.0.1.tgz#d2745701025a6c775a6c545793ed502fc0c649a1"
@@ -4225,6 +4352,11 @@ html-escaper@^2.0.0:
   resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453"
   integrity sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==
 
+html-void-elements@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/html-void-elements/-/html-void-elements-3.0.0.tgz#fc9dbd84af9e747249034d4d62602def6517f1d7"
+  integrity sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==
+
 htmlescape@^1.1.0:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/htmlescape/-/htmlescape-1.1.1.tgz#3a03edc2214bca3b66424a3e7959349509cb0351"
@@ -5274,11 +5406,6 @@ json5@^2.2.2, json5@^2.2.3:
   resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.3.tgz#78cd6f1a19bdc12b73db5ad0c61efd66c1e29283"
   integrity sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==
 
-jsonc-parser@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/jsonc-parser/-/jsonc-parser-3.2.0.tgz#31ff3f4c2b9793f89c67212627c51c6394f88e76"
-  integrity sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w==
-
 jsonfile@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-4.0.0.tgz#8771aae0799b64076b76640fca058f9c10e33ecb"
@@ -5344,6 +5471,13 @@ lines-and-columns@^1.1.6:
   resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632"
   integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==
 
+linkify-it@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/linkify-it/-/linkify-it-5.0.0.tgz#9ef238bfa6dc70bd8e7f9572b52d369af569b421"
+  integrity sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==
+  dependencies:
+    uc.micro "^2.0.0"
+
 locate-path@^5.0.0:
   version "5.0.0"
   resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0"
@@ -5451,10 +5585,17 @@ makeerror@1.0.12:
   dependencies:
     tmpl "1.0.5"
 
-marked@^4.2.12:
-  version "4.2.12"
-  resolved "https://registry.yarnpkg.com/marked/-/marked-4.2.12.tgz#d69a64e21d71b06250da995dcd065c11083bebb5"
-  integrity sha512-yr8hSKa3Fv4D3jdZmtMMPghgVt6TWbk86WQaWhDloQjRSQhMMYCAro7jP7VDJrjjdV8pxVxMssXS8B8Y5DZ5aw==
+markdown-it@^14.1.0:
+  version "14.1.0"
+  resolved "https://registry.yarnpkg.com/markdown-it/-/markdown-it-14.1.0.tgz#3c3c5992883c633db4714ccb4d7b5935d98b7d45"
+  integrity sha512-a54IwgWPaeBCAAsv13YgmALOF1elABB08FxO9i+r4VFk5Vl4pKokRPeX8u5TCgSsPi6ec1otfLjdOpVcgbpshg==
+  dependencies:
+    argparse "^2.0.1"
+    entities "^4.4.0"
+    linkify-it "^5.0.0"
+    mdurl "^2.0.0"
+    punycode.js "^2.3.1"
+    uc.micro "^2.1.0"
 
 md5.js@^1.3.4:
   version "1.3.5"
@@ -5465,6 +5606,26 @@ md5.js@^1.3.4:
     inherits "^2.0.1"
     safe-buffer "^5.1.2"
 
+mdast-util-to-hast@^13.0.0:
+  version "13.2.0"
+  resolved "https://registry.yarnpkg.com/mdast-util-to-hast/-/mdast-util-to-hast-13.2.0.tgz#5ca58e5b921cc0a3ded1bc02eed79a4fe4fe41f4"
+  integrity sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA==
+  dependencies:
+    "@types/hast" "^3.0.0"
+    "@types/mdast" "^4.0.0"
+    "@ungap/structured-clone" "^1.0.0"
+    devlop "^1.0.0"
+    micromark-util-sanitize-uri "^2.0.0"
+    trim-lines "^3.0.0"
+    unist-util-position "^5.0.0"
+    unist-util-visit "^5.0.0"
+    vfile "^6.0.0"
+
+mdurl@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/mdurl/-/mdurl-2.0.0.tgz#80676ec0433025dd3e17ee983d0fe8de5a2237e0"
+  integrity sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w==
+
 merge-stream@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60"
@@ -5475,6 +5636,38 @@ merge2@^1.3.0, merge2@^1.4.1:
   resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
   integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
 
+micromark-util-character@^2.0.0:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-character/-/micromark-util-character-2.1.1.tgz#2f987831a40d4c510ac261e89852c4e9703ccda6"
+  integrity sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==
+  dependencies:
+    micromark-util-symbol "^2.0.0"
+    micromark-util-types "^2.0.0"
+
+micromark-util-encode@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz#0d51d1c095551cfaac368326963cf55f15f540b8"
+  integrity sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==
+
+micromark-util-sanitize-uri@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz#ab89789b818a58752b73d6b55238621b7faa8fd7"
+  integrity sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==
+  dependencies:
+    micromark-util-character "^2.0.0"
+    micromark-util-encode "^2.0.0"
+    micromark-util-symbol "^2.0.0"
+
+micromark-util-symbol@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz#e5da494e8eb2b071a0d08fb34f6cefec6c0a19b8"
+  integrity sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==
+
+micromark-util-types@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-types/-/micromark-util-types-2.0.1.tgz#a3edfda3022c6c6b55bfb049ef5b75d70af50709"
+  integrity sha512-534m2WhVTddrcKVepwmVEVnUAmtrx9bfIjNoQHRqfnvdaHQiFytEhJoTgpWJvDEXCO5gLTQh3wYC1PgOJA4NSQ==
+
 micromatch@^4.0.4:
   version "4.0.5"
   resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.5.tgz#bc8999a7cbbf77cdc89f132f6e467051b49090c6"
@@ -5547,10 +5740,10 @@ minimatch@^5.0.1:
   dependencies:
     brace-expansion "^2.0.1"
 
-minimatch@^6.1.6:
-  version "6.2.0"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-6.2.0.tgz#2b70fd13294178c69c04dfc05aebdb97a4e79e42"
-  integrity sha512-sauLxniAmvnhhRjFwPNnJKaPFYyddAgbYdeUpHULtCT/GhzdCx/MDNy+Y40lBxTQUrMzDE8e0S43Z5uqfO0REg==
+minimatch@^9.0.5:
+  version "9.0.5"
+  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-9.0.5.tgz#d74f9dd6b57d83d8e98cfb82133b03978bc929e5"
+  integrity sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==
   dependencies:
     brace-expansion "^2.0.1"
 
@@ -5758,6 +5951,15 @@ onetime@^6.0.0:
   dependencies:
     mimic-fn "^4.0.0"
 
+oniguruma-to-es@0.4.1:
+  version "0.4.1"
+  resolved "https://registry.yarnpkg.com/oniguruma-to-es/-/oniguruma-to-es-0.4.1.tgz#112fbcd5fafe4f635983425a6db88f3e2de37107"
+  integrity sha512-rNcEohFz095QKGRovP/yqPIKc+nP+Sjs4YTHMv33nMePGKrq/r2eu9Yh4646M5XluGJsUnmwoXuiXE69KDs+fQ==
+  dependencies:
+    emoji-regex-xs "^1.0.0"
+    regex "^5.0.0"
+    regex-recursion "^4.2.1"
+
 open@8.4.0:
   version "8.4.0"
   resolved "https://registry.yarnpkg.com/open/-/open-8.4.0.tgz#345321ae18f8138f82565a910fdc6b39e8c244f8"
@@ -6121,6 +6323,11 @@ prompts@^2.0.1:
     kleur "^3.0.3"
     sisteransi "^1.0.5"
 
+property-information@^6.0.0:
+  version "6.5.0"
+  resolved "https://registry.yarnpkg.com/property-information/-/property-information-6.5.0.tgz#6212fbb52ba757e92ef4fb9d657563b933b7ffec"
+  integrity sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig==
+
 proto-list@~1.2.1:
   version "1.2.4"
   resolved "https://registry.yarnpkg.com/proto-list/-/proto-list-1.2.4.tgz#212d5bfe1318306a420f6402b8e26ff39647a849"
@@ -6162,6 +6369,11 @@ public-encrypt@^4.0.0:
     randombytes "^2.0.1"
     safe-buffer "^5.1.2"
 
+punycode.js@^2.3.1:
+  version "2.3.1"
+  resolved "https://registry.yarnpkg.com/punycode.js/-/punycode.js-2.3.1.tgz#6b53e56ad75588234e79f4affa90972c7dd8cdb7"
+  integrity sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA==
+
 punycode@^1.3.2, punycode@^1.4.1:
   version "1.4.1"
   resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e"
@@ -6348,6 +6560,25 @@ regenerator-transform@^0.15.1:
   dependencies:
     "@babel/runtime" "^7.8.4"
 
+regex-recursion@^4.2.1:
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/regex-recursion/-/regex-recursion-4.2.1.tgz#024ee28593b8158e568307b99bf1b7a3d5ea31e9"
+  integrity sha512-QHNZyZAeKdndD1G3bKAbBEKOSSK4KOHQrAJ01N1LJeb0SoH4DJIeFhp0uUpETgONifS4+P3sOgoA1dhzgrQvhA==
+  dependencies:
+    regex-utilities "^2.3.0"
+
+regex-utilities@^2.3.0:
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/regex-utilities/-/regex-utilities-2.3.0.tgz#87163512a15dce2908cf079c8960d5158ff43280"
+  integrity sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng==
+
+regex@^5.0.0:
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/regex/-/regex-5.0.2.tgz#291d960467e6499a79ceec022d20a4e0df67c54f"
+  integrity sha512-/pczGbKIQgfTMRV0XjABvc5RzLqQmwqxLHdQao2RTXPk+pmTXB2P0IaUHYdYyk412YLwUIkaeMd5T+RzVgTqnQ==
+  dependencies:
+    regex-utilities "^2.3.0"
+
 regexp.prototype.flags@^1.4.3:
   version "1.4.3"
   resolved "https://registry.yarnpkg.com/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz#87cab30f80f66660181a3bb7bf5981a872b367ac"
@@ -6686,15 +6917,17 @@ shelljs@0.8.5:
     interpret "^1.0.0"
     rechoir "^0.6.2"
 
-shiki@^0.14.1:
-  version "0.14.1"
-  resolved "https://registry.yarnpkg.com/shiki/-/shiki-0.14.1.tgz#9fbe082d0a8aa2ad63df4fbf2ee11ec924aa7ee1"
-  integrity sha512-+Jz4nBkCBe0mEDqo1eKRcCdjRtrCjozmcbTUjbPTX7OOJfEbTZzlUWlZtGe3Gb5oV1/jnojhG//YZc3rs9zSEw==
+shiki@^1.16.2:
+  version "1.23.1"
+  resolved "https://registry.yarnpkg.com/shiki/-/shiki-1.23.1.tgz#02f149e8f2592509e701f3a806fd4f3dd64d17e9"
+  integrity sha512-8kxV9TH4pXgdKGxNOkrSMydn1Xf6It8lsle0fiqxf7a1149K1WGtdOu3Zb91T5r1JpvRPxqxU3C2XdZZXQnrig==
   dependencies:
-    ansi-sequence-parser "^1.1.0"
-    jsonc-parser "^3.2.0"
-    vscode-oniguruma "^1.7.0"
-    vscode-textmate "^8.0.0"
+    "@shikijs/core" "1.23.1"
+    "@shikijs/engine-javascript" "1.23.1"
+    "@shikijs/engine-oniguruma" "1.23.1"
+    "@shikijs/types" "1.23.1"
+    "@shikijs/vscode-textmate" "^9.3.0"
+    "@types/hast" "^3.0.4"
 
 side-channel@^1.0.4:
   version "1.0.4"
@@ -6793,6 +7026,11 @@ source-map@~0.5.3:
   resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"
   integrity sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==
 
+space-separated-tokens@^2.0.0:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz#1ecd9d2350a3844572c3f4a312bceb018348859f"
+  integrity sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==
+
 sprintf-js@~1.0.2:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
@@ -6914,6 +7152,14 @@ string_decoder@~1.1.1:
   dependencies:
     safe-buffer "~5.1.0"
 
+stringify-entities@^4.0.0:
+  version "4.0.4"
+  resolved "https://registry.yarnpkg.com/stringify-entities/-/stringify-entities-4.0.4.tgz#b3b79ef5f277cc4ac73caeb0236c5ba939b3a4f3"
+  integrity sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==
+  dependencies:
+    character-entities-html4 "^2.0.0"
+    character-entities-legacy "^3.0.0"
+
 strip-ansi@^6.0.0, strip-ansi@^6.0.1:
   version "6.0.1"
   resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
@@ -7078,6 +7324,11 @@ tr46@~0.0.3:
   resolved "https://registry.yarnpkg.com/tr46/-/tr46-0.0.3.tgz#8184fd347dac9cdc185992f3a6622e14b9d9ab6a"
   integrity sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==
 
+trim-lines@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/trim-lines/-/trim-lines-3.0.1.tgz#d802e332a07df861c48802c04321017b1bd87338"
+  integrity sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==
+
 trim-repeated@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/trim-repeated/-/trim-repeated-1.0.0.tgz#e3646a2ea4e891312bf7eace6cfb05380bc01c21"
@@ -7205,21 +7456,27 @@ typedarray@^0.0.6:
   resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
   integrity sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==
 
-typedoc@^0.23.22:
-  version "0.23.25"
-  resolved "https://registry.yarnpkg.com/typedoc/-/typedoc-0.23.25.tgz#5f8f1850fd044c4d15d453117affddf11a265610"
-  integrity sha512-O1he153qVyoCgJYSvIyY3bPP1wAJTegZfa6tL3APinSZhJOf8CSd8F/21M6ex8pUY/fuY6n0jAsT4fIuMGA6sA==
+typedoc@^0.26.11:
+  version "0.26.11"
+  resolved "https://registry.yarnpkg.com/typedoc/-/typedoc-0.26.11.tgz#124b43a5637b7f3237b8c721691b44738c5c9dc9"
+  integrity sha512-sFEgRRtrcDl2FxVP58Ze++ZK2UQAEvtvvH8rRlig1Ja3o7dDaMHmaBfvJmdGnNEFaLTpQsN8dpvZaTqJSu/Ugw==
   dependencies:
     lunr "^2.3.9"
-    marked "^4.2.12"
-    minimatch "^6.1.6"
-    shiki "^0.14.1"
+    markdown-it "^14.1.0"
+    minimatch "^9.0.5"
+    shiki "^1.16.2"
+    yaml "^2.5.1"
 
 typescript@^5.6.3:
   version "5.6.3"
   resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.6.3.tgz#5f3449e31c9d94febb17de03cc081dd56d81db5b"
   integrity sha512-hjcS1mhfuyi4WW8IWtjP7brDrG2cuDZukyrYrSauoXGNgx0S7zceP07adYkJycEr56BOUTNPzbInooiN3fn1qw==
 
+uc.micro@^2.0.0, uc.micro@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/uc.micro/-/uc.micro-2.1.0.tgz#f8d3f7d0ec4c3dea35a7e3c8efa4cb8b45c9e7ee"
+  integrity sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A==
+
 umd@^3.0.0:
   version "3.0.3"
   resolved "https://registry.yarnpkg.com/umd/-/umd-3.0.3.tgz#aa9fe653c42b9097678489c01000acb69f0b26cf"
@@ -7281,6 +7538,44 @@ unique-string@^3.0.0:
   dependencies:
     crypto-random-string "^4.0.0"
 
+unist-util-is@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/unist-util-is/-/unist-util-is-6.0.0.tgz#b775956486aff107a9ded971d996c173374be424"
+  integrity sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw==
+  dependencies:
+    "@types/unist" "^3.0.0"
+
+unist-util-position@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/unist-util-position/-/unist-util-position-5.0.0.tgz#678f20ab5ca1207a97d7ea8a388373c9cf896be4"
+  integrity sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==
+  dependencies:
+    "@types/unist" "^3.0.0"
+
+unist-util-stringify-position@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz#449c6e21a880e0855bf5aabadeb3a740314abac2"
+  integrity sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==
+  dependencies:
+    "@types/unist" "^3.0.0"
+
+unist-util-visit-parents@^6.0.0:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/unist-util-visit-parents/-/unist-util-visit-parents-6.0.1.tgz#4d5f85755c3b8f0dc69e21eca5d6d82d22162815"
+  integrity sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw==
+  dependencies:
+    "@types/unist" "^3.0.0"
+    unist-util-is "^6.0.0"
+
+unist-util-visit@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/unist-util-visit/-/unist-util-visit-5.0.0.tgz#a7de1f31f72ffd3519ea71814cccf5fd6a9217d6"
+  integrity sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==
+  dependencies:
+    "@types/unist" "^3.0.0"
+    unist-util-is "^6.0.0"
+    unist-util-visit-parents "^6.0.0"
+
 universal-user-agent@^6.0.0:
   version "6.0.0"
   resolved "https://registry.yarnpkg.com/universal-user-agent/-/universal-user-agent-6.0.0.tgz#3381f8503b251c0d9cd21bc1de939ec9df5480ee"
@@ -7394,6 +7689,22 @@ v8-to-istanbul@^9.0.1:
     "@types/istanbul-lib-coverage" "^2.0.1"
     convert-source-map "^1.6.0"
 
+vfile-message@^4.0.0:
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/vfile-message/-/vfile-message-4.0.2.tgz#c883c9f677c72c166362fd635f21fc165a7d1181"
+  integrity sha512-jRDZ1IMLttGj41KcZvlrYAaI3CfqpLpfpf+Mfig13viT6NKvRzWZ+lXz0Y5D60w6uJIBAOGq9mSHf0gktF0duw==
+  dependencies:
+    "@types/unist" "^3.0.0"
+    unist-util-stringify-position "^4.0.0"
+
+vfile@^6.0.0:
+  version "6.0.3"
+  resolved "https://registry.yarnpkg.com/vfile/-/vfile-6.0.3.tgz#3652ab1c496531852bf55a6bac57af981ebc38ab"
+  integrity sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==
+  dependencies:
+    "@types/unist" "^3.0.0"
+    vfile-message "^4.0.0"
+
 vm-browserify@^1.0.0:
   version "1.1.2"
   resolved "https://registry.yarnpkg.com/vm-browserify/-/vm-browserify-1.1.2.tgz#78641c488b8e6ca91a75f511e7a3b32a86e5dda0"
@@ -7407,16 +7718,6 @@ vm2@^3.9.8:
     acorn "^8.7.0"
     acorn-walk "^8.2.0"
 
-vscode-oniguruma@^1.7.0:
-  version "1.7.0"
-  resolved "https://registry.yarnpkg.com/vscode-oniguruma/-/vscode-oniguruma-1.7.0.tgz#439bfad8fe71abd7798338d1cd3dc53a8beea94b"
-  integrity sha512-L9WMGRfrjOhgHSdOYgCt/yRMsXzLDJSL7BPrOZt73gU0iWO4mpqzqQzOz5srxqTvMBaR0XZTSrVWo4j55Rc6cA==
-
-vscode-textmate@^8.0.0:
-  version "8.0.0"
-  resolved "https://registry.yarnpkg.com/vscode-textmate/-/vscode-textmate-8.0.0.tgz#2c7a3b1163ef0441097e0b5d6389cd5504b59e5d"
-  integrity sha512-AFbieoL7a5LMqcnOF04ji+rpXadgOXnZsxQr//r83kLPr7biP7am3g9zbaZIaBGwBRWeSvoMD4mgPdX3e4NWBg==
-
 walker@^1.0.8:
   version "1.0.8"
   resolved "https://registry.yarnpkg.com/walker/-/walker-1.0.8.tgz#bd498db477afe573dc04185f011d3ab8a8d7653f"
@@ -7585,6 +7886,11 @@ yallist@^4.0.0:
   resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
   integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
 
+yaml@^2.5.1:
+  version "2.6.1"
+  resolved "https://registry.yarnpkg.com/yaml/-/yaml-2.6.1.tgz#42f2b1ba89203f374609572d5349fb8686500773"
+  integrity sha512-7r0XPzioN/Q9kXBro/XPnA6kznR73DHq+GXh5ON7ZozRO6aMjbmiBuKste2wslTFkC5d1dw0GooOCepZXJ2SAg==
+
 yargs-parser@21.1.1, yargs-parser@^21.0.1, yargs-parser@^21.1.1:
   version "21.1.1"
   resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.1.1.tgz#9096bceebf990d21bb31fa9516e0ede294a77d35"
@@ -7630,3 +7936,8 @@ yocto-queue@^0.1.0:
   version "0.1.0"
   resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b"
   integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==
+
+zwitch@^2.0.4:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/zwitch/-/zwitch-2.0.4.tgz#c827d4b0acb76fc3e685a4c6ec2902d51070e9d7"
+  integrity sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==