@designliquido/foles 0.10.0 → 0.11.1

package/testes/modificadores/metodos-reversos.test.js

@@ -11,16 +11,69 @@ const css_1 = __importDefault(require("../../fontes/tipos-de-simbolos/css"));
 const metodos_css_1 = require("../listas/metodos-css");
 const declaracoes_1 = require("../../fontes/declaracoes");
 const seletor_valor_reverso_1 = require("../../fontes/valores/seletor-valor-reverso");
+const lexador_1 = require("../../fontes/lexador");
+const contador_1 = require("../../fontes/valores/metodos/foles/contador");
 describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
     let lexador;
     let importador;
     let avaliadorSintatico;
-    let serializador;
+    let resolvedor;
     beforeEach(() => {
         lexador = new lexador_reverso_1.LexadorReverso();
         importador = new importador_1.Importador(lexador);
         avaliadorSintatico = new avaliador_sintatico_reverso_1.AvaliadorSintaticoReverso(importador);
-        serializador = new resolvedores_1.ResolvedorReverso();
+        resolvedor = new resolvedores_1.ResolvedorReverso();
+    });
+    it('Atribuindo Método "annotation()" com valor numérico - caso de sucesso', () => {
+        const valoresAceitos = ['1', '2', '12', '20'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `font-variant-alternates: annotation(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            // O Lexador não deve encontrar erros
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto de comprimento 10, incluindo mapeamento de valores numéricos
+            expect(resultadoLexador.simbolos).toHaveLength(10);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
+            expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
+            const primeiroResultado = resultadoAvaliadorSintatico[0];
+            expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
+            const primeiroResultadoTipado = primeiroResultado;
+            expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
+            expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual('font-variant-alternates');
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            // O Resolvedor deve resolver de acordo e traduzir anotação para annotation
+            expect(resultadoResolvedor).toContain('variacao-fonte-alternativa');
+            expect(resultadoResolvedor).toContain(`anotação(${valoresAceitos[index]});`);
+        }
+    });
+    it('Atribuindo Método "annotation()" com valor numérico - caso de falha', () => {
+        const valoresAceitos = ['0', '100', '300'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `font-variant-alternates: annotation(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow('O valor da função annotation() deve estar entre 1 e 99');
+        }
     });
     it('Atribuindo Método "blur()"', () => {
         for (let index = 0; index < metodos_css_1.MetodoBorrar.length; index += 1) {
@@ -63,7 +116,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoBorrar[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBorrar[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir blur para borrar
                 expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBorrar[index]]);
                 expect(resultadoTradutor).toContain(`borrar(${valoresAceitos[valIndex]});`);
@@ -111,7 +164,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoBrilho[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBrilho[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir brightness para brilho
                 expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBrilho[index]]);
                 expect(resultadoTradutor).toContain(`brilho(${valoresAceitos[valIndex]});`);
@@ -148,11 +201,62 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
             expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoCalcular[index]);
             // Tradutor deve serializar de acordo e traduzir calc para calcular
-            const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+            const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
             expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoCalcular[index]]);
             expect(resultadoTradutor).toContain('calcular(100px - 80px);');
         }
     });
+    it('Atribuindo Método "character-variant()" - caso de sucesso', () => {
+        const valoresAceitos = ['1', '2', '12', '20'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `font-variant-alternates: character-variant(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            // O Lexador não deve encontrar erros
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto de comprimento 10, incluindo mapeamento de valores numéricos
+            expect(resultadoLexador.simbolos).toHaveLength(10);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
+            expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
+            const primeiroResultado = resultadoAvaliadorSintatico[0];
+            expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
+            const primeiroResultadoTipado = primeiroResultado;
+            expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
+            expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual('font-variant-alternates');
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            // O Resolvedor deve resolver de acordo e traduzir character-variant para character-variant
+            expect(resultadoResolvedor).toContain('variacao-fonte-alternativa');
+            expect(resultadoResolvedor).toContain(`variar-caractere(${valoresAceitos[index]});`);
+        }
+    });
+    it('Atribuindo Método "character-variant()" - caso de falha', () => {
+        const valoresAceitos = ['0', '210', '100'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `font-variant-alternates: character-variant(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow('O valor da função character-variant() deve estar entre 1 e 99');
+        }
+    });
     it('Atribuindo Método "contrast()"', () => {
         for (let index = 0; index < metodos_css_1.MetodoContraste.length; index += 1) {
             const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
@@ -194,12 +298,109 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoContraste[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoContraste[index]]);
                 // Tradutor deve serializar de acordo e traduzir contrast para contraste
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoContraste[index]]);
                 expect(resultadoTradutor).toContain(`contraste(${valoresAceitos[valIndex]});`);
             }
         }
     });
+    it('Atribuindo Método "counter()" com parâmetro único', () => {
+        const valoresAceitos = ['contador1', 'meu-contador', 'contador-personalizado'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `content: counter(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            // O Lexador deve montar um objeto de comprimento 10 sem retornar erros
+            expect(resultadoLexador.simbolos).toHaveLength(10);
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O Lexador deve mapear METODO e IDENTIFICADOR no processo
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.IDENTIFICADOR }),
+                expect.objectContaining({ tipo: css_1.default.METODO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            // O Avaliador deve montar um objeto com o devido nome CSS
+            expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
+            const primeiroResultado = resultadoAvaliadorSintatico[0];
+            expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
+            const primeiroResultadoTipado = primeiroResultado;
+            expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
+            expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual('content');
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            expect(resultadoResolvedor).toContain('conteudo');
+            expect(resultadoResolvedor).toContain('contador');
+            expect(resultadoResolvedor).toContain(valoresAceitos[index]);
+        }
+    });
+    it('Atribuindo Método "counter()" com dois parâmetros', () => {
+        const nomeSimbolo = new lexador_1.Simbolo('IDENTIFICADOR', 'contador', 'any', 1, 2, 3);
+        const estiloSimbolo = new lexador_1.Simbolo('IDENTIFICADOR', 'romano-maiusculo', 'any', 1, 2, 3);
+        const instanciaContador = new contador_1.Contador(nomeSimbolo, estiloSimbolo);
+        const estilosAceitos = [];
+        Object.values(instanciaContador.estilosAceitos).forEach((valor) => estilosAceitos.push(valor));
+        const estilosTraduzidos = [];
+        Object.keys(instanciaContador.estilosAceitos).forEach((valor) => estilosTraduzidos.push(valor));
+        for (let index = 0; index < estilosAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `content: counter(contador1, ${estilosAceitos[index]});`,
+                "}"
+            ]);
+            // O Lexador deve montar um objeto de comprimento 12 sem retornar erros
+            expect(resultadoLexador.simbolos).toHaveLength(12);
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O Lexador deve mapear METODO e IDENTIFICADOR no processo
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.IDENTIFICADOR }),
+                expect.objectContaining({ tipo: css_1.default.METODO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            // O Avaliador deve montar um objeto com o devido nome CSS
+            expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
+            const primeiroResultado = resultadoAvaliadorSintatico[0];
+            expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
+            const primeiroResultadoTipado = primeiroResultado;
+            expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
+            expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual('content');
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            expect(resultadoResolvedor).toContain('conteudo');
+            expect(resultadoResolvedor).toContain('contador');
+            expect(resultadoResolvedor).toContain('contador1');
+        }
+    });
+    it('Caso de Falha - Método "counter()" com valor de estilo inválido', () => {
+        const nomeSimbolo = new lexador_1.Simbolo('IDENTIFICADOR', 'contador', 'any', 1, 2, 3);
+        const estiloSimbolo = new lexador_1.Simbolo('IDENTIFICADOR', 'romano-maiusculo', 'any', 1, 2, 3);
+        const instanciaContador = new contador_1.Contador(nomeSimbolo, estiloSimbolo);
+        const estilosAceitos = [];
+        Object.keys(instanciaContador.estilosAceitos).forEach((valor) => estilosAceitos.push(valor));
+        for (let index = 0; index < estilosAceitos.length; index += 1) {
+            const estiloErroDigitacao = estilosAceitos[index].replace(/./, "x");
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `content: counter(contador1, ${estiloErroDigitacao});`,
+                "}"
+            ]);
+            // O Lexador deve montar um objeto de comprimento 12 sem retornar erros
+            expect(resultadoLexador.simbolos).toHaveLength(12);
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O Avaliador Sintático também deve retornar o seu objeto sem retornar erros
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            // O Resolvedor deve retornar o erro de estilo inválido uma vez que não consegue traduzir o valor
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow(`Valor de estilo ${estiloErroDigitacao} inválido para a função counter().`);
+        }
+    });
     it('Atribuindo Método "cubic-bezier()"', () => {
         for (let index = 0; index < metodos_css_1.MetodoCurvaCubica.length; index += 1) {
             // Lexador
@@ -229,7 +430,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
             expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoCurvaCubica[index]);
             // Tradutor
-            const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+            const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
             expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoCurvaCubica[index]]);
             expect(resultadoTradutor).toContain('curva-cubica(0.42, 0, 1, 1);');
         }
@@ -264,7 +465,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
             expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoEncaixarConteudo[index]);
             // Tradutor
-            const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+            const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
             expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoEncaixarConteudo[index]]);
             expect(resultadoTradutor).toContain('encaixar-conteudo(200px)');
         }
@@ -310,7 +511,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoEscalaCinza[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoEscalaCinza[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir grayscale para escala-cinza
                 expect(resultadoTradutor).toContain(`escala-cinza(${valoresAceitos[valIndex]});`);
             }
@@ -344,7 +545,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosEscalamento[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir scale para escalamento
                 expect(resultadoTradutor).toContain(`escalamento(${valoresAceitos[valIndex]});`);
             }
@@ -376,7 +577,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosEscalamento[index]);
             expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
             // Tradutor
-            const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+            const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
             // O Tradutor deve serializar de acordo e traduzir scale para escalamento
             expect(resultadoTradutor).toContain(`escalamento(1.3, 0.4);`);
         }
@@ -411,7 +612,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosEscalamento[index]);
             expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
             // Tradutor
-            const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+            const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
             // O Tradutor deve serializar de acordo e traduzir scale3d para escalamento-3d 
             expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
             expect(resultadoTradutor).toContain(`escalamento-3d(0.5, 1, 1.7);`);
@@ -449,7 +650,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosEscalamento[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir scaleZ para escalamento-eixo-z
                 expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
                 expect(resultadoTradutor).toContain(`escalamento-eixo-z(${valoresAceitos[valIndex]});`);
@@ -488,7 +689,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosEscalamento[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir scaleX para escalamento-horizontal
                 expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
                 expect(resultadoTradutor).toContain(`escalamento-horizontal(${valoresAceitos[valIndex]});`);
@@ -527,7 +728,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosEscalamento[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir scaleY para escalamento-vertical
                 expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
                 expect(resultadoTradutor).toContain(`escalamento-vertical(${valoresAceitos[valIndex]});`);
@@ -564,7 +765,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
             expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoGradienteLinear[index]);
             // Tradutor
-            const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+            const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
             expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoGradienteLinear[index]]);
             expect(resultadoTradutor).toContain('gradiente-linear(90deg, verde, amarelo);');
         }
@@ -610,7 +811,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosInclinar[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir skew para inclinar
                 expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
                 expect(resultadoTradutor).toContain(`inclinar(${valoresAceitos[valIndex]});`);
@@ -648,7 +849,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosInclinar[index]);
             expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
             // Tradutor
-            const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+            const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
             // O Tradutor deve serializar de acordo e traduzir skew para inclinar
             expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
             expect(resultadoTradutor).toContain(`inclinar(15deg, 15deg);`);
@@ -695,7 +896,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosInclinar[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir skewX para inclinar-horizontal
                 expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
             }
@@ -742,7 +943,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosInclinar[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir skewY para inclinar-vertical 
                 expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
                 expect(resultadoTradutor).toContain(`inclinar-vertical(${valoresAceitos[valIndex]});`);
@@ -790,7 +991,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoInverter[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoInverter[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir invert para inverter
                 expect(resultadoTradutor).toContain(`inverter(${valoresAceitos[valIndex]});`);
             }
@@ -827,7 +1028,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoLimitar[index]);
             expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoLimitar[index]]);
             // Tradutor
-            const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+            const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
             expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoLimitar[index]]);
             expect(resultadoTradutor).toContain('limitar(10vw, 20em, 100vw);');
         }
@@ -861,7 +1062,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
             expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoLinear[index]);
             // Tradutor
-            const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+            const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
             expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoLinear[index]]);
             expect(resultadoTradutor).toContain('linear(0, 0.25, 1);');
         }
@@ -897,7 +1098,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoMinMax[index]);
             expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoMinMax[index]]);
             // Tradutor
-            const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+            const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
             expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoMinMax[index]]);
             expect(resultadoTradutor).toContain('minmax(100px, conteudo-máximo);');
         }
@@ -933,7 +1134,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoMinMax[index]);
             expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoMinMax[index]]);
             // Tradutor
-            const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+            const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
             expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoMinMax[index]]);
             expect(resultadoTradutor).toContain('minmax(conteudo-mínimo, 100px);');
         }
@@ -979,12 +1180,96 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoOpacar[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoOpacar[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir opacity para opacar
                 expect(resultadoTradutor).toContain(`opacar(${valoresAceitos[valIndex]});`);
             }
         }
     });
+    it('Atribuindo Método "ornaments()" com valor numérico - caso de sucesso', () => {
+        const valoresAceitos = ['1', '2', '12', '20'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `font-variant-alternates: ornaments(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            // O Lexador não deve encontrar erros
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto de comprimento 10, incluindo mapeamento de valores numéricos
+            expect(resultadoLexador.simbolos).toHaveLength(10);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
+            expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
+            const primeiroResultado = resultadoAvaliadorSintatico[0];
+            expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
+            const primeiroResultadoTipado = primeiroResultado;
+            expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
+            expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual('font-variant-alternates');
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            // O Resolvedor deve resolver de acordo e traduzir ornamentos para ornaments
+            expect(resultadoResolvedor).toContain('variacao-fonte-alternativa');
+            expect(resultadoResolvedor).toContain(`ornamentos(${valoresAceitos[index]});`);
+        }
+    });
+    it('Atribuindo Método "ornaments()" com valor string - caso de sucesso', () => {
+        const valoresAceitos = ['Arial', 'Courier'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `font-variant-alternates: ornaments(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            // O Lexador deve montar um objeto de comprimento 10, incluindo mapeamento dos valores
+            expect(resultadoLexador.simbolos).toHaveLength(10);
+            // O Lexador não deve encontrar erros
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.METODO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
+            expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
+            const primeiroResultado = resultadoAvaliadorSintatico[0];
+            expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
+            const primeiroResultadoTipado = primeiroResultado;
+            expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
+            expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual('font-variant-alternates');
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            // O Resolvedor deve resolver de acordo e traduzir ornamentos para ornaments, assim como o valor
+            expect(resultadoResolvedor).toContain('variacao-fonte-alternativa');
+            expect(resultadoResolvedor).toContain(`ornamentos("${valoresAceitos[index]}");`);
+        }
+    });
+    it('Atribuindo Método "ornaments()" com valor numérico - caso de falha', () => {
+        const valoresAceitos = ['0', '100', '300'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `font-variant-alternates: ornaments(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow('O valor da função ornaments() deve estar entre 1 e 99');
+        }
+    });
     it('Atribuindo Método "perspective()"', () => {
         for (let index = 0; index < metodos_css_1.MetodoPerspectivar.length; index += 1) {
             const valoresAceitos = ['800px', '6.5cm', '0.1', '0', '1', '1.75'];
@@ -1028,7 +1313,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoPerspectivar[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoPerspectivar[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir perspective para perspectivar
                 expect(resultadoTradutor).toContain(`perspectivar(${valoresAceitos[valIndex]});`);
             }
@@ -1063,11 +1348,163 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
             expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoPassos[index]);
             // Tradutor deve serializar de acordo e traduzir steps para passos, assim como o termo de salto
-            const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+            const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
             expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoPassos[index]]);
             expect(resultadoTradutor).toContain('passos(2, salto-inicial);');
         }
     });
+    it('Atribuindo Método "styleset()" - caso de sucesso', () => {
+        const valoresAceitos = ['1', '1, 2', '6, 12, 18'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `font-variant-alternates: styleset(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            // O Lexador não deve encontrar erros
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto contendo valores numéricos
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
+            expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
+            const primeiroResultado = resultadoAvaliadorSintatico[0];
+            expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
+            const primeiroResultadoTipado = primeiroResultado;
+            expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
+            expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual('font-variant-alternates');
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            // O Resolvedor deve resolver de acordo e traduzir de acordo
+            expect(resultadoResolvedor).toContain('variacao-fonte-alternativa');
+            expect(resultadoResolvedor).toContain(`conjunto-estilos(${valoresAceitos[index]});`);
+        }
+    });
+    it('Atribuindo Método "styleset()" - caso de falha', () => {
+        const valoresAceitos = ['0', '1, 21, 12', '3, 13, 30'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `font-variant-alternates: styleset(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow('Os valores da função styleset() devem estar entre 1 e 20');
+        }
+    });
+    it('Atribuindo Método "stylistic()" - caso de sucesso', () => {
+        const valoresAceitos = ['1', '2', '12', '20'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `font-variant-alternates: stylistic(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            // O Lexador não deve encontrar erros
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto de comprimento 10, incluindo mapeamento de valores numéricos
+            expect(resultadoLexador.simbolos).toHaveLength(10);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
+            expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
+            const primeiroResultado = resultadoAvaliadorSintatico[0];
+            expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
+            const primeiroResultadoTipado = primeiroResultado;
+            expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
+            expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual('font-variant-alternates');
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            // O Resolvedor deve resolver de acordo e traduzir estilístico para stylistic
+            expect(resultadoResolvedor).toContain('variacao-fonte-alternativa');
+            expect(resultadoResolvedor).toContain(`estilístico(${valoresAceitos[index]});`);
+        }
+    });
+    it('Atribuindo Método "stylistic()" - caso de falha', () => {
+        const valoresAceitos = ['0', '21', '30'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `font-variant-alternates: stylistic(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow('O valor da função stylistic() deve estar entre 1 e 20');
+        }
+    });
+    it('Atribuindo Método "swash()" - caso de sucesso', () => {
+        const valoresAceitos = ['1', '2', '12', '20'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `font-variant-alternates: swash(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            // O Lexador não deve encontrar erros
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto de comprimento 10, incluindo mapeamento de valores numéricos
+            expect(resultadoLexador.simbolos).toHaveLength(10);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
+            expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
+            const primeiroResultado = resultadoAvaliadorSintatico[0];
+            expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
+            const primeiroResultadoTipado = primeiroResultado;
+            expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
+            expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual('font-variant-alternates');
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            // O Resolvedor deve resolver de acordo e traduzir espirrar para swash
+            expect(resultadoResolvedor).toContain('variacao-fonte-alternativa');
+            expect(resultadoResolvedor).toContain(`espirrar(${valoresAceitos[index]});`);
+        }
+    });
+    it('Atribuindo Método "swash()" - caso de falha', () => {
+        const valoresAceitos = ['0', '100', '300'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `font-variant-alternates: swash(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow('O valor da função swash() deve estar entre 1 e 99');
+        }
+    });
     it('Atribuindo Método "drop-shadow()" com valores de comprimento', () => {
         for (let index = 0; index < metodos_css_1.MetodoProjetarSombra.length; index += 1) {
             const comprimentos = ['15px 15px', '15px 15px 15px', '0.5rem 0.5rem', '0.5rem 0.5rem 1rem'];
@@ -1100,7 +1537,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoProjetarSombra[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoProjetarSombra[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir drop-shadow para projetar-sombra  
                 expect(resultadoTradutor).toContain(`projetar-sombra(${comprimentos[posIndex]});`);
             }
@@ -1143,7 +1580,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoProjetarSombra[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoProjetarSombra[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir red para vermelho
                 expect(resultadoTradutor).toContain('vermelho');
             }
@@ -1183,7 +1620,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoRaio[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoRaio[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir ray para raio
                 expect(resultadoTradutor).toContain(`raio(${traducaoValoresAceitos[valIndex]} 200deg);`);
             }
@@ -1220,7 +1657,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoRaio[index]);
             expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoRaio[index]]);
             // Tradutor
-            const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+            const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
             // O Tradutor deve serializar de acordo e traduzir ray para raio
             expect(resultadoTradutor).toContain(`raio(200deg);`);
         }
@@ -1262,7 +1699,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosRotacionar[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosRotacionar[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir rotate para rotacionar
                 expect(resultadoTradutor).toContain(`rotacionar(${valoresAceitos[valIndex]});`);
             }
@@ -1308,7 +1745,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual('transform');
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir rotate3d para rotacionar-3d  
                 expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosRotacionar[index]]);
                 expect(resultadoTradutor).toContain(`rotacionar-3d(${valoresAceitos[valIndex]});`);
@@ -1333,7 +1770,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
             // Serializador não deve aceitar 'px' como quantificador válido
             expect(() => {
-                serializador.resolver(resultadoAvaliadorSintatico);
+                resolvedor.resolver(resultadoAvaliadorSintatico);
             }).toThrow();
         }
     });
@@ -1378,7 +1815,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosRotacionar[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosRotacionar[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir rotateX para rotacionar-horizontal
                 expect(resultadoTradutor).toContain(`rotacionar-horizontal(${valoresAceitos[valIndex]});`);
             }
@@ -1425,7 +1862,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosRotacionar[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosRotacionar[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir rotateY para rotacionar-vertical
                 expect(resultadoTradutor).toContain(`rotacionar-vertical(${valoresAceitos[valIndex]});`);
             }
@@ -1472,7 +1909,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosRotacionar[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosRotacionar[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir rotateZ para rotacionar-eixo-z
                 expect(resultadoTradutor).toContain(`rotacionar-eixo-z(${valoresAceitos[valIndex]});`);
             }
@@ -1519,7 +1956,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoRotacionarMatiz[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoRotacionarMatiz[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir hue-rotate para rotacionar-matiz
                 expect(resultadoTradutor).toContain(`rotacionar-matiz(${valoresAceitos[valIndex]});`);
             }
@@ -1566,7 +2003,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoSaturar[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoSaturar[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir saturate para saturar
                 expect(resultadoTradutor).toContain(`saturar(${valoresAceitos[valIndex]});`);
             }
@@ -1613,7 +2050,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoSepia[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoSepia[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir sépia para sepia
                 expect(resultadoTradutor).toContain(`sepia(${valoresAceitos[valIndex]});`);
             }
@@ -1656,7 +2093,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosTranslacao[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosTranslacao[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir translate para translação
                 expect(resultadoTradutor).toContain(`translação(${valoresAceitos[valIndex]});`);
             }
@@ -1688,7 +2125,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
             expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosTranslacao[index]);
             // Tradutor
-            const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+            const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
             // O Tradutor deve serializar de acordo e traduzir translate para translação
             expect(resultadoTradutor).toContain(`translação(100deg, 100deg);`);
         }
@@ -1734,7 +2171,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosTranslacao[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosTranslacao[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir translateX para translacao-horizontal 
                 expect(resultadoTradutor).toContain(`translacao-horizontal(${valoresAceitos[valIndex]});`);
             }
@@ -1781,7 +2218,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosTranslacao[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosTranslacao[index]]);
                 // Serialização
-                const resultadoSerializacao = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoSerializacao = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O serializador deve serializar de acordo e traduzir translateY para translacao-vertical
                 expect(resultadoSerializacao).toContain(`translacao-vertical(${valoresAceitos[valIndex]});`);
             }
@@ -1828,7 +2265,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosTranslacao[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosTranslacao[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir translateZ para translação-eixo-z
                 expect(resultadoTradutor).toContain(`translacao-eixo-z(${valoresAceitos[valIndex]});`);
             }
@@ -1864,7 +2301,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
             expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
             expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosTranslacao[index]);
             // Tradutor
-            const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+            const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
             // O Tradutor deve serializar de acordo e traduzir translate3d para translação-3d
             expect(resultadoTradutor).toContain(`translacao-3d(5ch, 0.4in, 5px);`);
         }
@@ -1940,7 +2377,7 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosTranslacao[index]);
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosTranslacao[index]]);
                 // Tradutor
-                const resultadoTradutor = serializador.resolver(resultadoAvaliadorSintatico);
+                const resultadoTradutor = resolvedor.resolver(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir translate3d para translacao-3d
                 if (valIndex !== 8) {
                     expect(resultadoTradutor).toContain(`translacao-3d(${valoresAceitos[valIndex]});`);