@designliquido/foles 0.9.5 → 0.10.0

package/testes/modificadores/metodos.test.js

@@ -7,137 +7,43 @@ const avaliador_sintatico_1 = require("../../fontes/avaliador-sintatico");
 const importador_1 = require("../../fontes/importador");
 const lexador_1 = require("../../fontes/lexador");
 const foles_1 = __importDefault(require("../../fontes/tipos-de-simbolos/foles"));
-const serializadores_1 = require("../../fontes/serializadores");
+const resolvedores_1 = require("../../fontes/resolvedores");
 const metodos_1 = require("../listas/metodos");
 const declaracoes_1 = require("../../fontes/declaracoes");
 const seletor_valor_1 = require("../../fontes/valores/seletor-valor");
+const contador_1 = require("../../fontes/valores/metodos/foles/contador");
 describe('Testando Seletores que recebem MÉTODOS como valor', () => {
-    describe('Testes Unitários', () => {
-        let lexador;
-        let importador;
-        let avaliador;
-        let tradutor;
-        beforeEach(() => {
-            lexador = new lexador_1.Lexador();
-            importador = new importador_1.Importador(lexador);
-            avaliador = new avaliador_sintatico_1.AvaliadorSintatico(importador);
-            tradutor = new serializadores_1.Serializador();
-        });
-        it('Atribuindo Método "borrar()"', () => {
-            for (let index = 0; index < metodos_1.MetodoBorrar.length; index += 1) {
-                const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodoBorrar[index]}: borrar(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // 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: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
-                    // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
-                    // TODO @Vitor: Alterei um caso para você. 
-                    // Os demais podem seguir a mesma lógica.
-                    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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoBorrar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir borrar para blur
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoBorrar[index]]);
-                    expect(resultadoTradutor).toContain(`blur(${valoresAceitos[valIndex]});`);
-                }
-            }
-        });
-        it('Atribuindo Método "brilho()"', () => {
-            for (let index = 0; index < metodos_1.MetodoBrilho.length; index += 1) {
-                const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodoBrilho[index]}: brilho(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // 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: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoBrilho[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir brilho para brightness
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoBrilho[index]]);
-                    expect(resultadoTradutor).toContain(`brightness(${valoresAceitos[valIndex]});`);
-                }
-            }
-        });
-        it('Atribuindo Método "calcular()"', () => {
-            for (let index = 0; index < metodos_1.MetodoCalcular.length; index += 1) {
+    let lexador;
+    let importador;
+    let avaliador;
+    let resolvedor;
+    beforeEach(() => {
+        lexador = new lexador_1.Lexador();
+        importador = new importador_1.Importador(lexador);
+        avaliador = new avaliador_sintatico_1.AvaliadorSintatico(importador);
+        resolvedor = new resolvedores_1.Resolvedor();
+    });
+    it('Atribuindo Método "anotação()" com valor numérico - caso de sucesso', () => {
+        const formasAceitas = ['anotação', 'anotacao'];
+        const valoresAceitos = ['1', '2', '12', '20'];
+        for (let valIndex = 0; valIndex < formasAceitas.length; valIndex += 1) {
+            for (let index = 0; index < valoresAceitos.length; index += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "lmht {",
-                    `${metodos_1.MetodoCalcular[index]}: calcular(100px - 80px);`,
+                    `variacao-fonte-alternativa: ${formasAceitas[valIndex]}(${valoresAceitos[index]});`,
                     "}"
                 ]);
-                // O Lexador deve montar um objeto de comprimento 14 sem retornar nenhum erro
-                expect(resultadoLexador.simbolos).toHaveLength(14);
+                // 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: foles_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar números e quantificadores no mapeamento
+                // 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: foles_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                 ]));
                 // Avaliador Sintático
                 const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
@@ -147,78 +53,49 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoCalcular[index]]);
-                // Tradutor
-                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoCalcular[index]]);
-                expect(resultadoTradutor).toContain('calc(100px - 80px);');
-            }
-        });
-        it('Atribuindo Método "contraste()"', () => {
-            for (let index = 0; index < metodos_1.MetodoContraste.length; index += 1) {
-                const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodoContraste[index]}: contraste(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // 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: foles_1.default.METODO }),
-                    ]));
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoContraste[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoContraste[index]]);
-                    expect(resultadoTradutor).toContain(`contrast(${valoresAceitos[valIndex]});`);
-                }
+                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('font-variant-alternates');
+                expect(resultadoResolvedor).toContain(`annotation(${valoresAceitos[index]});`);
             }
-        });
-        it('Atribuindo Método "curva-cúbica" (cubic-bezier)', () => {
-            for (let index = 0; index < metodos_1.MetodoCurvaCubica.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "anotação()" 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([
+                "lmht {",
+                `variacao-fonte-alternativa: anotação(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow('O valor da função anotação() deve estar entre 1 e 99');
+        }
+    });
+    it('Atribuindo Método "anotação()" com valor string - caso de sucesso', () => {
+        const formasAceitas = ['anotação', 'anotacao'];
+        const valoresAceitos = ['floral', 'ruby', 'circle'];
+        for (let valIndex = 0; valIndex < formasAceitas.length; valIndex += 1) {
+            for (let index = 0; index < valoresAceitos.length; index += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "lmht {",
-                    `${metodos_1.MetodoCurvaCubica[index]}: curva-cúbica(0.42, 0.0, 1.0, 1.0);`,
+                    `variacao-fonte-alternativa: ${formasAceitas[valIndex]}('${valoresAceitos[index]}');`,
                     "}"
                 ]);
-                // O Lexador deve montar um objeto de comprimento 16 sem retornar nenhum erro
-                expect(resultadoLexador.simbolos).toHaveLength(16);
+                // 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: foles_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar números no mapeamento
-                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                ]));
+                // O Lexador deve montar um objeto de comprimento 10
+                expect(resultadoLexador.simbolos).toHaveLength(10);
                 // Avaliador Sintático
                 const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
                 // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
@@ -227,174 +104,87 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoCurvaCubica[index]]);
-                // // // // Tradutor
-                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoCurvaCubica[index]]);
-                expect(resultadoTradutor).toContain('cubic-bezier(0.42, 0, 1, 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 e conter o valor string
+                expect(resultadoResolvedor).toContain('font-variant-alternates');
+                expect(resultadoResolvedor).toContain(`annotation('${valoresAceitos[index]}');`);
             }
-        });
-        it('Atribuindo Método "encaixar-conteúdo" (fit-content)', () => {
-            for (let index = 0; index < metodos_1.MetodoEncaixarConteudo.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "anotação()" com valor string - caso de falha', () => {
+        const valoresAceitos = ['--valorPersonalizado', 'herdar', 'inicial'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `variacao-fonte-alternativa: anotação(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow(`Modificador ou variável 'variação-fonte-alternativa' com valor personalizado ${valoresAceitos[index]} inválido. O valor deve seguir as regras de sintaxe de uma identificação personalizada (<custom-indent>).`);
+        }
+    });
+    it('Atribuindo Método "borrar()"', () => {
+        for (let index = 0; index < metodos_1.MetodoBorrar.length; index += 1) {
+            const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "lmht {",
-                    `${metodos_1.MetodoEncaixarConteudo[index]}: encaixar-conteúdo(200px);`,
+                    `${metodos_1.MetodoBorrar[index]}: borrar(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
-                // O Lexador deve montar um objeto de comprimento 11 sem retornar nenhum erro
-                expect(resultadoLexador.simbolos).toHaveLength(11);
+                // 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: foles_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar número e quantificador no mapeamento
-                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                ]));
-                // Avaliador Sintático
-                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoEncaixarConteudo[index]]);
-                // // // Tradutor
-                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoEncaixarConteudo[index]]);
-                expect(resultadoTradutor).toContain('fit-content(200px)');
-            }
-        });
-        it('Atribuindo Método "escala-cinza()"', () => {
-            for (let index = 0; index < metodos_1.MetodoEscalaCinza.length; index += 1) {
-                const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodoEscalaCinza[index]}: escala-cinza(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoEscalaCinza[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir escala-cinza para grayscale
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoEscalaCinza[index]]);
-                    expect(resultadoTradutor).toContain(`grayscale(${valoresAceitos[valIndex]});`);
                 }
-            }
-        });
-        it('Atribuindo Método "escalamento()"', () => {
-            for (let index = 0; index < metodos_1.MetodosEscalamento.length; index += 1) {
-                const valoresAceitos = ['0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosEscalamento[index]}: escalamento(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // 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: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 10
+                else {
                     expect(resultadoLexador.simbolos).toHaveLength(10);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                         expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                     ]));
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir escalamento para scale
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
-                    expect(resultadoTradutor).toContain(`scale(${valoresAceitos[valIndex]});`);
                 }
-            }
-        });
-        it('Atribuindo Método "escalamento()" com múltiplos valores', () => {
-            for (let index = 0; index < metodos_1.MetodosEscalamento.length; index += 1) {
-                // Lexador
-                const resultadoLexador = lexador.mapear([
-                    "lmht {",
-                    `${metodos_1.MetodosEscalamento[index]}: escalamento(1.3, 0.4);`,
-                    "}"
-                ]);
-                // 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: foles_1.default.METODO }),
-                ]));
-                // O Lexador deve montar um objeto de comprimento 12
-                expect(resultadoLexador.simbolos).toHaveLength(12);
-                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                ]));
                 // Avaliador Sintático
                 const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
                 // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
+                // TODO @Vitor: Alterei um caso para você. 
+                // Os demais podem seguir a mesma lógica.
                 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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
-                // Tradutor
-                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                // O Tradutor deve serializar de acordo e traduzir escalamento para scale
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
-                expect(resultadoTradutor).toContain(`scale(1.3, 0.4);`);
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoBorrar[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir borrar para blur
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoBorrar[index]]);
+                expect(resultadoResolvedor).toContain(`blur(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "escalamento-3d()"', () => {
-            for (let index = 0; index < metodos_1.MetodosEscalamento.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "brilho()"', () => {
+        for (let index = 0; index < metodos_1.MetodoBrilho.length; index += 1) {
+            const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "lmht {",
-                    `${metodos_1.MetodosEscalamento[index]}: escalamento-3d(0.5, 1, 1.7);`,
+                    `${metodos_1.MetodoBrilho[index]}: brilho(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
                 // O Lexador não deve encontrar erros
@@ -403,11 +193,20 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: foles_1.default.METODO }),
                 ]));
-                // O Lexador deve montar um objeto de comprimento 14
-                expect(resultadoLexador.simbolos).toHaveLength(14);
-                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
                 // Avaliador Sintático
                 const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
                 // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
@@ -416,148 +215,193 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
-                // Tradutor
-                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                // O Tradutor deve serializar de acordo e traduzir escalamento-3d para scale3d
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
-                expect(resultadoTradutor).toContain(`scale3d(0.5, 1, 1.7);`);
-            }
-        });
-        it('Atribuindo Método "escalamento-eixo-z()"', () => {
-            for (let index = 0; index < metodos_1.MetodosEscalamento.length; index += 1) {
-                const valoresAceitos = ['0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosEscalamento[index]}: escalamento-eixo-z(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // 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: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 10
-                    expect(resultadoLexador.simbolos).toHaveLength(10);
-                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                    ]));
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir escalamento-eixo-z para scaleZ
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
-                    expect(resultadoTradutor).toContain(`scaleZ(${valoresAceitos[valIndex]});`);
-                }
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoBrilho[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir brilho para brightness
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoBrilho[index]]);
+                expect(resultadoResolvedor).toContain(`brightness(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "escalamento-horizontal()"', () => {
-            for (let index = 0; index < metodos_1.MetodosEscalamento.length; index += 1) {
-                const valoresAceitos = ['0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosEscalamento[index]}: escalamento-horizontal(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // 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: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 10
-                    expect(resultadoLexador.simbolos).toHaveLength(10);
+        }
+    });
+    it('Atribuindo Método "calcular()"', () => {
+        for (let index = 0; index < metodos_1.MetodoCalcular.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodoCalcular[index]}: calcular(100px - 80px);`,
+                "}"
+            ]);
+            // O Lexador deve montar um objeto de comprimento 14 sem retornar nenhum erro
+            expect(resultadoLexador.simbolos).toHaveLength(14);
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar números e quantificadores no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoCalcular[index]]);
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoCalcular[index]]);
+            expect(resultadoResolvedor).toContain('calc(100px - 80px);');
+        }
+    });
+    it('Atribuindo Método "conjunto-estilos()" - 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([
+                "lmht {",
+                `variacao-fonte-alternativa: conjunto-estilos(${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: foles_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto contendo valores numéricos
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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 escalamento-vertical para scaleY
+            expect(resultadoResolvedor).toContain('font-variant-alternates');
+            expect(resultadoResolvedor).toContain(`styleset(${valoresAceitos[index]});`);
+        }
+    });
+    it('Atribuindo Método "conjunto-estilos()" - 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([
+                "lmht {",
+                `variacao-fonte-alternativa: conjunto-estilos(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow('Os valores da função conjunto-estilos() devem estar entre 1 e 20');
+        }
+    });
+    it('Atribuindo Método "contador()"', () => {
+        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));
+        const estilosTraduzidos = [];
+        Object.values(instanciaContador.estilosAceitos).forEach((valor) => estilosTraduzidos.push(valor));
+        for (let index = 0; index < estilosAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `conteúdo: contador(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: foles_1.default.IDENTIFICADOR }),
+                expect.objectContaining({ tipo: foles_1.default.METODO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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('content');
+            expect(resultadoResolvedor).toContain(`counter(contador1, ${estilosTraduzidos[index]});`);
+        }
+    });
+    it('Caso de Falha - Método "contador()" 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([
+                "lmht {",
+                `conteúdo: contador(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 = avaliador.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 contador().`);
+        }
+    });
+    it('Atribuindo Método "contraste()"', () => {
+        for (let index = 0; index < metodos_1.MetodoContraste.length; index += 1) {
+            const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodoContraste[index]}: contraste(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                         expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                     ]));
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir escalamento-horizontal para scaleX
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
-                    expect(resultadoTradutor).toContain(`scaleX(${valoresAceitos[valIndex]});`);
                 }
-            }
-        });
-        it('Atribuindo Método "escalamento-vertical()"', () => {
-            for (let index = 0; index < metodos_1.MetodosEscalamento.length; index += 1) {
-                const valoresAceitos = ['0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosEscalamento[index]}: escalamento-vertical(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // 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: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 10
+                else {
                     expect(resultadoLexador.simbolos).toHaveLength(10);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                         expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                     ]));
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir escalamento-vertical para scaleY
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
-                    expect(resultadoTradutor).toContain(`scaleY(${valoresAceitos[valIndex]});`);
                 }
-            }
-        });
-        it('Atribuindo Método "gradiente-linear()" com valor de ângulo deg', () => {
-            for (let index = 0; index < metodos_1.MetodoGradienteLinear.length; index += 1) {
-                // Lexador
-                const resultadoLexador = lexador.mapear([
-                    "lmht {",
-                    `${metodos_1.MetodoGradienteLinear[index]}: gradiente-linear(90deg, verde, amarelo);`,
-                    "}"
-                ]);
-                // O Lexador deve montar um objeto de comprimento 15 sem retornar nenhum erro
-                expect(resultadoLexador.simbolos).toHaveLength(15);
+                // 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: foles_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar número e quantificador no mapeamento
-                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                ]));
                 // Avaliador Sintático
                 const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
                 // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
@@ -566,33 +410,113 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
-                // Tradutor
-                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
-                expect(resultadoTradutor).toContain('linear-gradient(90deg, green, yellow);');
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoContraste[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoContraste[index]]);
+                expect(resultadoResolvedor).toContain(`contrast(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "gradiente-linear()" com valor de ângulo graus', () => {
-            for (let index = 0; index < metodos_1.MetodoGradienteLinear.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "curva-cúbica" (cubic-bezier)', () => {
+        for (let index = 0; index < metodos_1.MetodoCurvaCubica.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodoCurvaCubica[index]}: curva-cúbica(0.42, 0.0, 1.0, 1.0);`,
+                "}"
+            ]);
+            // O Lexador deve montar um objeto de comprimento 16 sem retornar nenhum erro
+            expect(resultadoLexador.simbolos).toHaveLength(16);
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar números no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoCurvaCubica[index]]);
+            // // // // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoCurvaCubica[index]]);
+            expect(resultadoResolvedor).toContain('cubic-bezier(0.42, 0, 1, 1);');
+        }
+    });
+    it('Atribuindo Método "encaixar-conteúdo" (fit-content)', () => {
+        for (let index = 0; index < metodos_1.MetodoEncaixarConteudo.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodoEncaixarConteudo[index]}: encaixar-conteúdo(200px);`,
+                "}"
+            ]);
+            // O Lexador deve montar um objeto de comprimento 11 sem retornar nenhum erro
+            expect(resultadoLexador.simbolos).toHaveLength(11);
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar número e quantificador no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoEncaixarConteudo[index]]);
+            // // // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoEncaixarConteudo[index]]);
+            expect(resultadoResolvedor).toContain('fit-content(200px)');
+        }
+    });
+    it('Atribuindo Método "escala-cinza()"', () => {
+        for (let index = 0; index < metodos_1.MetodoEscalaCinza.length; index += 1) {
+            const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "lmht {",
-                    `${metodos_1.MetodoGradienteLinear[index]}: gradiente-linear(90graus, verde, amarelo);`,
+                    `${metodos_1.MetodoEscalaCinza[index]}: escala-cinza(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
-                // O Lexador deve montar um objeto de comprimento 15 sem retornar nenhum erro
-                expect(resultadoLexador.simbolos).toHaveLength(15);
+                // 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: foles_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar número e quantificador no mapeamento
-                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
                 // Avaliador Sintático
                 const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
                 // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
@@ -601,123 +525,23 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
-                // Tradutor
-                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
-                expect(resultadoTradutor).toContain('linear-gradient(90deg, green, yellow);');
-            }
-        });
-        it('Atribuindo Método "gradiente-linear()" com valor de posição', () => {
-            for (let index = 0; index < metodos_1.MetodoGradienteLinear.length; index += 1) {
-                const posicoes = ['superior', 'inferior', 'direita', 'esquerda'];
-                for (let posIndex = 0; posIndex < posicoes.length; posIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodoGradienteLinear[index]}: gradiente-linear(${posicoes[posIndex]}, azul, vermelho);`,
-                        "}"
-                    ]);
-                    // O Lexador deve montar um objeto de comprimento 14 sem retornar nenhum erro
-                    expect(resultadoLexador.simbolos).toHaveLength(14);
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
-                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador também deve encontrar um qualitativo no mapeamento, referente à posição
-                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.QUALITATIVO }),
-                    ]));
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
-                    switch (posicoes[posIndex]) {
-                        case 'superior':
-                            expect(resultadoTradutor).toContain('linear-gradient(0deg, blue, red);');
-                            break;
-                        case 'direita':
-                            expect(resultadoTradutor).toContain('linear-gradient(90deg, blue, red);');
-                            break;
-                        case 'inferior':
-                            expect(resultadoTradutor).toContain('linear-gradient(180deg, blue, red);');
-                            break;
-                        case 'esquerda':
-                            expect(resultadoTradutor).toContain('linear-gradient(270deg, blue, red);');
-                            break;
-                        default:
-                            break;
-                    }
-                }
-            }
-        });
-        it('Atribuindo Método "inclinar()"', () => {
-            for (let index = 0; index < metodos_1.MetodosInclinar.length; index += 1) {
-                const valoresAceitos = ['90graus', '18deg', '3.142rad', '0', '1'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosInclinar[index]}: inclinar(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // 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: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 2) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir inclinar para skew
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
-                    if (valIndex !== 0) {
-                        expect(resultadoTradutor).toContain(`skew(${valoresAceitos[valIndex]});`);
-                    }
-                    else {
-                        expect(resultadoTradutor).toContain(`skew(90deg);`);
-                    }
-                }
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoEscalaCinza[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir escala-cinza para grayscale
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoEscalaCinza[index]]);
+                expect(resultadoResolvedor).toContain(`grayscale(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "inclinar() com múltiplos valores"', () => {
-            for (let index = 0; index < metodos_1.MetodosInclinar.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "escalamento()"', () => {
+        for (let index = 0; index < metodos_1.MetodosEscalamento.length; index += 1) {
+            const valoresAceitos = ['0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "lmht {",
-                    `${metodos_1.MetodosInclinar[index]}: inclinar(15graus, 15graus);`,
+                    `${metodos_1.MetodosEscalamento[index]}: escalamento(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
                 // O Lexador não deve encontrar erros
@@ -726,11 +550,10 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: foles_1.default.METODO }),
                 ]));
-                // O Lexador deve montar um objeto de comprimento 14
-                expect(resultadoLexador.simbolos).toHaveLength(14);
+                // O Lexador deve montar um objeto de comprimento 10
+                expect(resultadoLexador.simbolos).toHaveLength(10);
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                 ]));
                 // Avaliador Sintático
                 const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
@@ -740,184 +563,105 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
-                // Tradutor
-                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                // O Tradutor deve serializar de acordo e traduzir inclinar para skew
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
-                expect(resultadoTradutor).toContain(`skew(15deg, 15deg);`);
-            }
-        });
-        it('Atribuindo Método "inclinar-horizontal()"', () => {
-            for (let index = 0; index < metodos_1.MetodosInclinar.length; index += 1) {
-                const valoresAceitos = ['180graus', '18deg', '3.142rad', '0', '1'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosInclinar[index]}: inclinar-horizontal(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // 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: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 2) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir inclinar-horizontal para skewX
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
-                    if (valIndex !== 0) {
-                        expect(resultadoTradutor).toContain(`skewX(${valoresAceitos[valIndex]});`);
-                    }
-                    else {
-                        expect(resultadoTradutor).toContain(`skewX(180deg);`);
-                    }
-                }
-            }
-        });
-        it('Atribuindo Método "inclinar-vertical()"', () => {
-            for (let index = 0; index < metodos_1.MetodosInclinar.length; index += 1) {
-                const valoresAceitos = ['180graus', '18deg', '3.142rad', '0', '1'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosInclinar[index]}: inclinar-vertical(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // 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: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 2) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir inclinar-vertical para skewY
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
-                    if (valIndex !== 0) {
-                        expect(resultadoTradutor).toContain(`skewY(${valoresAceitos[valIndex]});`);
-                    }
-                    else {
-                        expect(resultadoTradutor).toContain(`skewY(180deg);`);
-                    }
-                }
-            }
-        });
-        it('Atribuindo Método "inverter()"', () => {
-            for (let index = 0; index < metodos_1.MetodoInverter.length; index += 1) {
-                const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodoInverter[index]}: inverter(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // 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: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoInverter[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir inverter para invert
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoInverter[index]]);
-                    expect(resultadoTradutor).toContain(`invert(${valoresAceitos[valIndex]});`);
-                }
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir escalamento para scale
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
+                expect(resultadoResolvedor).toContain(`scale(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "limitar" (clamp)', () => {
-            for (let index = 0; index < metodos_1.MetodoLimitar.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "escalamento()" com múltiplos valores', () => {
+        for (let index = 0; index < metodos_1.MetodosEscalamento.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodosEscalamento[index]}: escalamento(1.3, 0.4);`,
+                "}"
+            ]);
+            // 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: foles_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto de comprimento 12
+            expect(resultadoLexador.simbolos).toHaveLength(12);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            // O Resolvedor deve resolver de acordo e traduzir escalamento para scale
+            expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
+            expect(resultadoResolvedor).toContain(`scale(1.3, 0.4);`);
+        }
+    });
+    it('Atribuindo Método "escalamento-3d()"', () => {
+        for (let index = 0; index < metodos_1.MetodosEscalamento.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodosEscalamento[index]}: escalamento-3d(0.5, 1, 1.7);`,
+                "}"
+            ]);
+            // 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: foles_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto de comprimento 14
+            expect(resultadoLexador.simbolos).toHaveLength(14);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            // O Resolvedor deve resolver de acordo e traduzir escalamento-3d para scale3d
+            expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
+            expect(resultadoResolvedor).toContain(`scale3d(0.5, 1, 1.7);`);
+        }
+    });
+    it('Atribuindo Método "escalamento-eixo-z()"', () => {
+        for (let index = 0; index < metodos_1.MetodosEscalamento.length; index += 1) {
+            const valoresAceitos = ['0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "lmht {",
-                    `${metodos_1.MetodoLimitar[index]}: limitar(10vw, 20em, 100vw);`,
+                    `${metodos_1.MetodosEscalamento[index]}: escalamento-eixo-z(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
-                // O Lexador deve montar um objeto de comprimento 17 sem retornar nenhum erro
-                expect(resultadoLexador.simbolos).toHaveLength(17);
+                // 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: foles_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar números e quantificadores no mapeamento
+                // O Lexador deve montar um objeto de comprimento 10
+                expect(resultadoLexador.simbolos).toHaveLength(10);
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                 ]));
                 // Avaliador Sintático
                 const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
@@ -927,29 +671,33 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoLimitar[index]]);
-                // Tradutor
-                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoLimitar[index]]);
-                expect(resultadoTradutor).toContain('clamp(10vw, 20em, 100vw);');
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir escalamento-eixo-z para scaleZ
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
+                expect(resultadoResolvedor).toContain(`scaleZ(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "linear()"', () => {
-            for (let index = 0; index < metodos_1.MetodoLinear.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "escalamento-horizontal()"', () => {
+        for (let index = 0; index < metodos_1.MetodosEscalamento.length; index += 1) {
+            const valoresAceitos = ['0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "lmht {",
-                    `${metodos_1.MetodoLinear[index]}: linear(0, 0.25, 1);`,
+                    `${metodos_1.MetodosEscalamento[index]}: escalamento-horizontal(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
-                // O Lexador deve montar um objeto de comprimento 14 sem retornar nenhum erro
-                expect(resultadoLexador.simbolos).toHaveLength(14);
+                // 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: foles_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar números no mapeamento
+                // O Lexador deve montar um objeto de comprimento 10
+                expect(resultadoLexador.simbolos).toHaveLength(10);
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                 ]));
@@ -961,32 +709,35 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoLinear[index]]);
-                // // // // Tradutor
-                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoLinear[index]]);
-                expect(resultadoTradutor).toContain('linear(0, 0.25, 1);');
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir escalamento-horizontal para scaleX
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
+                expect(resultadoResolvedor).toContain(`scaleX(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "minmax()"', () => {
-            for (let index = 0; index < metodos_1.MetodoMinMax.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "escalamento-vertical()"', () => {
+        for (let index = 0; index < metodos_1.MetodosEscalamento.length; index += 1) {
+            const valoresAceitos = ['0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "lmht {",
-                    `${metodos_1.MetodoMinMax[index]}: minmax(100px, conteúdo-máximo);`,
+                    `${metodos_1.MetodosEscalamento[index]}: escalamento-vertical(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
-                // O Lexador deve montar um objeto de comprimento 13 sem retornar nenhum erro
-                expect(resultadoLexador.simbolos).toHaveLength(13);
+                // 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: foles_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar número e quantificador no mapeamento
+                // O Lexador deve montar um objeto de comprimento 10
+                expect(resultadoLexador.simbolos).toHaveLength(10);
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                 ]));
                 // Avaliador Sintático
                 const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
@@ -996,78 +747,206 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoMinMax[index]]);
-                // // // // Tradutor
-                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoMinMax[index]]);
-                expect(resultadoTradutor).toContain('minmax(100px, max-content);');
-            }
-        });
-        it('Atribuindo Método "opacar()"', () => {
-            for (let index = 0; index < metodos_1.MetodoOpacar.length; index += 1) {
-                const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodoOpacar[index]}: opacar(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // 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: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoOpacar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir opacar para opacity
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoOpacar[index]]);
-                    expect(resultadoTradutor).toContain(`opacity(${valoresAceitos[valIndex]});`);
-                }
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir escalamento-vertical para scaleY
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
+                expect(resultadoResolvedor).toContain(`scaleY(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "passos" (steps)', () => {
-            for (let index = 0; index < metodos_1.MetodoPassos.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "espirrar()" - caso de sucesso', () => {
+        const valoresAceitos = ['1', '2', '12', '20'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `variacao-fonte-alternativa: espirrar(${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: foles_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: foles_1.default.NUMERO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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('font-variant-alternates');
+            expect(resultadoResolvedor).toContain(`swash(${valoresAceitos[index]});`);
+        }
+    });
+    it('Atribuindo Método "espirrar()" - caso de falha', () => {
+        const valoresAceitos = ['0', '100', '300'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `variacao-fonte-alternativa: espirrar(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow('O valor da função espirrar() deve estar entre 1 e 99');
+        }
+    });
+    it('Atribuindo Método "estilistico()" - caso de sucesso', () => {
+        const valoresAceitos = ['1', '2', '12', '20'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `variacao-fonte-alternativa: estilistico(${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: foles_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: foles_1.default.NUMERO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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('font-variant-alternates');
+            expect(resultadoResolvedor).toContain(`stylistic(${valoresAceitos[index]});`);
+        }
+    });
+    it('Atribuindo Método "estilistico()" - caso de falha', () => {
+        const valoresAceitos = ['0', '21', '30'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `variacao-fonte-alternativa: estilistico(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow('O valor da função estilistico() deve estar entre 1 e 20');
+        }
+    });
+    it('Atribuindo Método "gradiente-linear()" com valor de ângulo deg', () => {
+        for (let index = 0; index < metodos_1.MetodoGradienteLinear.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodoGradienteLinear[index]}: gradiente-linear(90deg, verde, amarelo);`,
+                "}"
+            ]);
+            // O Lexador deve montar um objeto de comprimento 15 sem retornar nenhum erro
+            expect(resultadoLexador.simbolos).toHaveLength(15);
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar número e quantificador no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
+            expect(resultadoResolvedor).toContain('linear-gradient(90deg, green, yellow);');
+        }
+    });
+    it('Atribuindo Método "gradiente-linear()" com valor de ângulo graus', () => {
+        for (let index = 0; index < metodos_1.MetodoGradienteLinear.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodoGradienteLinear[index]}: gradiente-linear(90graus, verde, amarelo);`,
+                "}"
+            ]);
+            // O Lexador deve montar um objeto de comprimento 15 sem retornar nenhum erro
+            expect(resultadoLexador.simbolos).toHaveLength(15);
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar número e quantificador no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
+            expect(resultadoResolvedor).toContain('linear-gradient(90deg, green, yellow);');
+        }
+    });
+    it('Atribuindo Método "gradiente-linear()" com valor de posição', () => {
+        for (let index = 0; index < metodos_1.MetodoGradienteLinear.length; index += 1) {
+            const posicoes = ['superior', 'inferior', 'direita', 'esquerda'];
+            for (let posIndex = 0; posIndex < posicoes.length; posIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "lmht {",
-                    `${metodos_1.MetodoPassos[index]}: passos(2, salto-inicial);`,
+                    `${metodos_1.MetodoGradienteLinear[index]}: gradiente-linear(${posicoes[posIndex]}, azul, vermelho);`,
                     "}"
                 ]);
-                // O Lexador deve montar um objeto de comprimento 12 sem retornar nenhum erro
-                expect(resultadoLexador.simbolos).toHaveLength(12);
+                // O Lexador deve montar um objeto de comprimento 14 sem retornar nenhum erro
+                expect(resultadoLexador.simbolos).toHaveLength(14);
                 expect(resultadoLexador.erros).toHaveLength(0);
                 // O valor recebido deve ser mapeado como METODO
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: foles_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar número e qualitativo no mapeamento
+                // O Lexador também deve encontrar um qualitativo no mapeamento, referente à posição
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                     expect.objectContaining({ tipo: foles_1.default.QUALITATIVO }),
                 ]));
                 // Avaliador Sintático
@@ -1078,188 +957,125 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoPassos[index]]);
-                // // // // Tradutor
-                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoPassos[index]]);
-                expect(resultadoTradutor).toContain('steps(2, jump-start);');
-            }
-        });
-        it('Atribuindo Método "perspectivar()"', () => {
-            for (let index = 0; index < metodos_1.MetodoPerspectivar.length; index += 1) {
-                const valoresAceitos = ['800px', '6.5cm', '0.1', '0', '1', '1.75', 'nenhuma'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodoPerspectivar[index]}: perspectivar(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // 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: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else if (valIndex !== 6) {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.IDENTIFICADOR }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoPerspectivar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir perspectivar para perspective
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoPerspectivar[index]]);
-                    expect(resultadoTradutor).toContain(`perspective(${valoresAceitos[valIndex]});`);
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
+                switch (posicoes[posIndex]) {
+                    case 'superior':
+                        expect(resultadoResolvedor).toContain('linear-gradient(0deg, blue, red);');
+                        break;
+                    case 'direita':
+                        expect(resultadoResolvedor).toContain('linear-gradient(90deg, blue, red);');
+                        break;
+                    case 'inferior':
+                        expect(resultadoResolvedor).toContain('linear-gradient(180deg, blue, red);');
+                        break;
+                    case 'esquerda':
+                        expect(resultadoResolvedor).toContain('linear-gradient(270deg, blue, red);');
+                        break;
+                    default:
+                        break;
                 }
             }
-        });
-        it('Atribuindo Método "projetar-sombra()" com valores de comprimento somente', () => {
-            for (let index = 0; index < metodos_1.MetodoProjetarSombra.length; index += 1) {
-                const comprimentos = ['15px 15px', '15px 15px 15px', '0.5rem 0.5rem', '0.5rem 0.5rem 1rem'];
-                for (let posIndex = 0; posIndex < comprimentos.length; posIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodoProjetarSombra[index]}: projetar-sombra(${comprimentos[posIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador deve montar um objeto de acordo, sem retornar nenhum erro
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
-                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador também deve sempre encontrar valores e quantificadores na operação
+        }
+    });
+    it('Atribuindo Método "inclinar()"', () => {
+        for (let index = 0; index < metodos_1.MetodosInclinar.length; index += 1) {
+            const valoresAceitos = ['90graus', '18deg', '3.142rad', '0', '1'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosInclinar[index]}: inclinar(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 2) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                         expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                         expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                     ]));
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoProjetarSombra[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir projetar-sombra para drop-shadow  
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoProjetarSombra[index]]);
-                    expect(resultadoTradutor).toContain(`drop-shadow(${comprimentos[posIndex]});`);
                 }
-            }
-        });
-        it('Atribuindo Método "projetar-sombra()" com valores de cor e de comprimento', () => {
-            for (let index = 0; index < metodos_1.MetodoProjetarSombra.length; index += 1) {
-                const comprimentos = ['15px 15px vermelho', '15px 15px 15px vermelho', 'vermelho 0.5rem 0.5rem', 'vermelho 0.5rem 0.5rem 1rem'];
-                for (let posIndex = 0; posIndex < comprimentos.length; posIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodoProjetarSombra[index]}: projetar-sombra(${comprimentos[posIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador deve montar um objeto de acordo, sem retornar nenhum erro
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
-                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador também deve sempre encontrar valores e quantificadores na operação
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                         expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                     ]));
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoProjetarSombra[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir vermelho para red
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoProjetarSombra[index]]);
-                    expect(resultadoTradutor).toContain('red');
                 }
-            }
-        });
-        it('Atribuindo Método "raio()" com valores de posição e número/quantificador', () => {
-            for (let index = 0; index < metodos_1.MetodoRaio.length; index += 1) {
-                const valoresAceitos = ['lado-mais-próximo', 'lado-mais-proximo', 'canto-mais-próximo', 'canto-mais-proximo', 'lado-mais-distante', 'canto-mais-distante', 'lados', 'conter'];
-                const traducaoValoresAceitos = ['closest-side', 'closest-side', 'closest-corner', 'closest-corner', 'farthest-side', 'farthest-corner', 'sides', 'contain'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodoRaio[index]}: raio(${valoresAceitos[valIndex]} 200graus);`,
-                        "}"
-                    ]);
-                    // 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: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 12
-                    expect(resultadoLexador.simbolos).toHaveLength(12);
-                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                    ]));
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRaio[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir raio para ray
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRaio[index]]);
-                    expect(resultadoTradutor).toContain(`ray(${traducaoValoresAceitos[valIndex]} 200deg);`);
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir inclinar para skew
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
+                if (valIndex !== 0) {
+                    expect(resultadoResolvedor).toContain(`skew(${valoresAceitos[valIndex]});`);
+                }
+                else {
+                    expect(resultadoResolvedor).toContain(`skew(90deg);`);
                 }
             }
-        });
-        it('Atribuindo Método "raio()" com somente número/quantificador', () => {
-            for (let index = 0; index < metodos_1.MetodoRaio.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "inclinar() com múltiplos valores"', () => {
+        for (let index = 0; index < metodos_1.MetodosInclinar.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodosInclinar[index]}: inclinar(15graus, 15graus);`,
+                "}"
+            ]);
+            // 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: foles_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto de comprimento 14
+            expect(resultadoLexador.simbolos).toHaveLength(14);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            // O Resolvedor deve resolver de acordo e traduzir inclinar para skew
+            expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
+            expect(resultadoResolvedor).toContain(`skew(15deg, 15deg);`);
+        }
+    });
+    it('Atribuindo Método "inclinar-horizontal()"', () => {
+        for (let index = 0; index < metodos_1.MetodosInclinar.length; index += 1) {
+            const valoresAceitos = ['180graus', '18deg', '3.142rad', '0', '1'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "lmht {",
-                    `${metodos_1.MetodoRaio[index]}: raio(200graus);`,
+                    `${metodos_1.MetodosInclinar[index]}: inclinar-horizontal(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
                 // O Lexador não deve encontrar erros
@@ -1268,12 +1084,20 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: foles_1.default.METODO }),
                 ]));
-                // O Lexador deve montar um objeto de comprimento 11
-                expect(resultadoLexador.simbolos).toHaveLength(11);
-                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 2) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
                 // Avaliador Sintático
                 const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
                 // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
@@ -1282,436 +1106,474 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRaio[index]]);
-                // Tradutor
-                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                // O Tradutor deve serializar de acordo e traduzir raio para ray
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRaio[index]]);
-                expect(resultadoTradutor).toContain(`ray(200deg);`);
-            }
-        });
-        it('Atribuindo Método "rotacionar()"', () => {
-            for (let index = 0; index < metodos_1.MetodosRotacionar.length; index += 1) {
-                const valoresAceitos = ['45graus', '45deg', '3.142rad', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosRotacionar[index]}: rotacionar(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // 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: foles_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 2) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir rotacionar para rotate
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
-                    if (valIndex !== 0) {
-                        expect(resultadoTradutor).toContain(`rotate(${valoresAceitos[valIndex]});`);
-                    }
-                    else {
-                        expect(resultadoTradutor).toContain(`rotate(45deg);`);
-                    }
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir inclinar-horizontal para skewX
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
+                if (valIndex !== 0) {
+                    expect(resultadoResolvedor).toContain(`skewX(${valoresAceitos[valIndex]});`);
+                }
+                else {
+                    expect(resultadoResolvedor).toContain(`skewX(180deg);`);
                 }
             }
-        });
-        it('Atribuindo Método "rotacionar-eixo-z()"', () => {
-            for (let index = 0; index < metodos_1.MetodosRotacionar.length; index += 1) {
-                const valoresAceitos = ['45graus', '45deg', '3.142rad', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosRotacionar[index]}: rotacionar-eixo-z(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // 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: foles_1.default.METODO }),
+        }
+    });
+    it('Atribuindo Método "inclinar-vertical()"', () => {
+        for (let index = 0; index < metodos_1.MetodosInclinar.length; index += 1) {
+            const valoresAceitos = ['180graus', '18deg', '3.142rad', '0', '1'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosInclinar[index]}: inclinar-vertical(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 2) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 2) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir rotacionar-eixo-z para rotateZ
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
-                    if (valIndex !== 0) {
-                        expect(resultadoTradutor).toContain(`rotateZ(${valoresAceitos[valIndex]});`);
-                    }
-                    else {
-                        expect(resultadoTradutor).toContain(`rotateZ(45deg);`);
-                    }
                 }
-            }
-        });
-        it('Atribuindo Método "rotacionar-horizontal()"', () => {
-            for (let index = 0; index < metodos_1.MetodosRotacionar.length; index += 1) {
-                const valoresAceitos = ['45graus', '45deg', '3.142rad', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosRotacionar[index]}: rotacionar-horizontal(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 2) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir rotacionar-horizontal para rotateX
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
-                    if (valIndex !== 0) {
-                        expect(resultadoTradutor).toContain(`rotateX(${valoresAceitos[valIndex]});`);
-                    }
-                    else {
-                        expect(resultadoTradutor).toContain(`rotateX(45deg);`);
-                    }
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir inclinar-vertical para skewY
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
+                if (valIndex !== 0) {
+                    expect(resultadoResolvedor).toContain(`skewY(${valoresAceitos[valIndex]});`);
+                }
+                else {
+                    expect(resultadoResolvedor).toContain(`skewY(180deg);`);
                 }
             }
-        });
-        it('Atribuindo Método "rotacionar-matiz()"', () => {
-            for (let index = 0; index < metodos_1.MetodoRotacionarMatiz.length; index += 1) {
-                const valoresAceitos = ['90graus', '100px', '100%', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodoRotacionarMatiz[index]}: rotacionar-matiz(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+        }
+    });
+    it('Atribuindo Método "inverter()"', () => {
+        for (let index = 0; index < metodos_1.MetodoInverter.length; index += 1) {
+            const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodoInverter[index]}: inverter(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 2) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRotacionarMatiz[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir rotacionar-matiz para hue-rotate
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRotacionarMatiz[index]]);
-                    if (valIndex !== 0) {
-                        expect(resultadoTradutor).toContain(`hue-rotate(${valoresAceitos[valIndex]});`);
-                    }
-                    else {
-                        expect(resultadoTradutor).toContain(`hue-rotate(90deg);`);
-                    }
                 }
-            }
-        });
-        it('Atribuindo Método "rotacionar-vertical()"', () => {
-            for (let index = 0; index < metodos_1.MetodosRotacionar.length; index += 1) {
-                const valoresAceitos = ['45graus', '45deg', '3.142rad', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosRotacionar[index]}: rotacionar-vertical(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 2) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir rotacionar-vertical para rotateY
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
-                    if (valIndex !== 0) {
-                        expect(resultadoTradutor).toContain(`rotateY(${valoresAceitos[valIndex]});`);
-                    }
-                    else {
-                        expect(resultadoTradutor).toContain(`rotateY(45deg);`);
-                    }
                 }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoInverter[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir inverter para invert
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoInverter[index]]);
+                expect(resultadoResolvedor).toContain(`invert(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "saturar()"', () => {
-            for (let index = 0; index < metodos_1.MetodoSaturar.length; index += 1) {
-                const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodoSaturar[index]}: saturar(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+        }
+    });
+    it('Atribuindo Método "limitar" (clamp)', () => {
+        for (let index = 0; index < metodos_1.MetodoLimitar.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodoLimitar[index]}: limitar(10vw, 20em, 100vw);`,
+                "}"
+            ]);
+            // O Lexador deve montar um objeto de comprimento 17 sem retornar nenhum erro
+            expect(resultadoLexador.simbolos).toHaveLength(17);
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar números e quantificadores no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoLimitar[index]]);
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoLimitar[index]]);
+            expect(resultadoResolvedor).toContain('clamp(10vw, 20em, 100vw);');
+        }
+    });
+    it('Atribuindo Método "linear()"', () => {
+        for (let index = 0; index < metodos_1.MetodoLinear.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodoLinear[index]}: linear(0, 0.25, 1);`,
+                "}"
+            ]);
+            // O Lexador deve montar um objeto de comprimento 14 sem retornar nenhum erro
+            expect(resultadoLexador.simbolos).toHaveLength(14);
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar números no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoLinear[index]]);
+            // // // // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoLinear[index]]);
+            expect(resultadoResolvedor).toContain('linear(0, 0.25, 1);');
+        }
+    });
+    it('Atribuindo Método "minmax()"', () => {
+        for (let index = 0; index < metodos_1.MetodoMinMax.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodoMinMax[index]}: minmax(100px, conteúdo-máximo);`,
+                "}"
+            ]);
+            // O Lexador deve montar um objeto de comprimento 13 sem retornar nenhum erro
+            expect(resultadoLexador.simbolos).toHaveLength(13);
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar número e quantificador no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoMinMax[index]]);
+            // // // // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoMinMax[index]]);
+            expect(resultadoResolvedor).toContain('minmax(100px, max-content);');
+        }
+    });
+    it('Atribuindo Método "opacar()"', () => {
+        for (let index = 0; index < metodos_1.MetodoOpacar.length; index += 1) {
+            const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodoOpacar[index]}: opacar(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoSaturar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir saturar para saturate
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoSaturar[index]]);
-                    expect(resultadoTradutor).toContain(`saturate(${valoresAceitos[valIndex]});`);
                 }
-            }
-        });
-        it('Atribuindo Método "sepia()"', () => {
-            for (let index = 0; index < metodos_1.MetodoSepia.length; index += 1) {
-                const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodoSepia[index]}: sepia(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoSepia[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir sépia para sepia
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoSepia[index]]);
-                    expect(resultadoTradutor).toContain(`sepia(${valoresAceitos[valIndex]});`);
                 }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoOpacar[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir opacar para opacity
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoOpacar[index]]);
+                expect(resultadoResolvedor).toContain(`opacity(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "translação()"', () => {
-            for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
-                const valoresAceitos = ['270graus', '18deg', '3.142rad', '0', '1'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosTranslacao[index]}: translação(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+        }
+    });
+    it('Atribuindo Método "ornamentos()" 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([
+                "lmht {",
+                `variacao-fonte-alternativa: ornamentos(${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: foles_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: foles_1.default.NUMERO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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('font-variant-alternates');
+            expect(resultadoResolvedor).toContain(`ornaments(${valoresAceitos[index]});`);
+        }
+    });
+    it('Atribuindo Método "ornamentos()" 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([
+                "lmht {",
+                `variacao-fonte-alternativa: ornamentos(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow('O valor da função ornamentos() deve estar entre 1 e 99');
+        }
+    });
+    it('Atribuindo Método "ornamentos()" com valor string - caso de sucesso', () => {
+        const valoresAceitos = ['floral', 'ruby', 'circle'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `variacao-fonte-alternativa: ornamentos('${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: foles_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto de comprimento 10
+            expect(resultadoLexador.simbolos).toHaveLength(10);
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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 e conter o valor string
+            expect(resultadoResolvedor).toContain('font-variant-alternates');
+            expect(resultadoResolvedor).toContain(`ornaments('${valoresAceitos[index]}');`);
+        }
+    });
+    it('Atribuindo Método "ornamentos()" com valor string - caso de falha', () => {
+        const valoresAceitos = ['--valorPersonalizado', 'herdar', 'inicial'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `variacao-fonte-alternativa: ornamentos(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow(`Modificador ou variável 'variação-fonte-alternativa' com valor personalizado ${valoresAceitos[index]} inválido. O valor deve seguir as regras de sintaxe de uma identificação personalizada (<custom-indent>).`);
+        }
+    });
+    it('Atribuindo Método "passos" (steps)', () => {
+        for (let index = 0; index < metodos_1.MetodoPassos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodoPassos[index]}: passos(2, salto-inicial);`,
+                "}"
+            ]);
+            // O Lexador deve montar um objeto de comprimento 12 sem retornar nenhum erro
+            expect(resultadoLexador.simbolos).toHaveLength(12);
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar número e qualitativo no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                expect.objectContaining({ tipo: foles_1.default.QUALITATIVO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoPassos[index]]);
+            // // // // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoPassos[index]]);
+            expect(resultadoResolvedor).toContain('steps(2, jump-start);');
+        }
+    });
+    it('Atribuindo Método "perspectivar()"', () => {
+        for (let index = 0; index < metodos_1.MetodoPerspectivar.length; index += 1) {
+            const valoresAceitos = ['800px', '6.5cm', '0.1', '0', '1', '1.75', 'nenhuma'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodoPerspectivar[index]}: perspectivar(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else if (valIndex !== 6) {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
+                        expect.objectContaining({ tipo: foles_1.default.IDENTIFICADOR }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 2) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir translação para translate
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    if (valIndex !== 0) {
-                        expect(resultadoTradutor).toContain(`translate(${valoresAceitos[valIndex]});`);
-                    }
-                    else {
-                        expect(resultadoTradutor).toContain(`translate(270deg);`);
-                    }
                 }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoPerspectivar[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir perspectivar para perspective
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoPerspectivar[index]]);
+                expect(resultadoResolvedor).toContain(`perspective(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "translacao() com múltiplos valores"', () => {
-            for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "projetar-sombra()" com valores de comprimento somente', () => {
+        for (let index = 0; index < metodos_1.MetodoProjetarSombra.length; index += 1) {
+            const comprimentos = ['15px 15px', '15px 15px 15px', '0.5rem 0.5rem', '0.5rem 0.5rem 1rem'];
+            for (let posIndex = 0; posIndex < comprimentos.length; posIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "lmht {",
-                    `${metodos_1.MetodosTranslacao[index]}: translacao(100graus, 100graus);`,
+                    `${metodos_1.MetodoProjetarSombra[index]}: projetar-sombra(${comprimentos[posIndex]});`,
                     "}"
                 ]);
-                // O Lexador não deve encontrar erros
+                // O Lexador deve montar um objeto de acordo, sem retornar nenhum erro
                 expect(resultadoLexador.erros).toHaveLength(0);
                 // O valor recebido deve ser mapeado como METODO
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: foles_1.default.METODO }),
                 ]));
-                // O Lexador deve montar um objeto de comprimento 14
-                expect(resultadoLexador.simbolos).toHaveLength(14);
+                // O Lexador também deve sempre encontrar valores e quantificadores na operação
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                     expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
@@ -1724,20 +1586,62 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                // Tradutor
-                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                // O Tradutor deve serializar de acordo e traduzir translacao para translate
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                expect(resultadoTradutor).toContain(`translate(100deg, 100deg);`);
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoProjetarSombra[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir projetar-sombra para drop-shadow  
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoProjetarSombra[index]]);
+                expect(resultadoResolvedor).toContain(`drop-shadow(${comprimentos[posIndex]});`);
+            }
+        }
+    });
+    it('Atribuindo Método "projetar-sombra()" com valores de cor e de comprimento', () => {
+        for (let index = 0; index < metodos_1.MetodoProjetarSombra.length; index += 1) {
+            const comprimentos = ['15px 15px vermelho', '15px 15px 15px vermelho', 'vermelho 0.5rem 0.5rem', 'vermelho 0.5rem 0.5rem 1rem'];
+            for (let posIndex = 0; posIndex < comprimentos.length; posIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodoProjetarSombra[index]}: projetar-sombra(${comprimentos[posIndex]});`,
+                    "}"
+                ]);
+                // O Lexador deve montar um objeto de acordo, sem retornar nenhum erro
+                expect(resultadoLexador.erros).toHaveLength(0);
+                // O valor recebido deve ser mapeado como METODO
+                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                    expect.objectContaining({ tipo: foles_1.default.METODO }),
+                ]));
+                // O Lexador também deve sempre encontrar valores e quantificadores na operação
+                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                    expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                ]));
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoProjetarSombra[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir vermelho para red
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoProjetarSombra[index]]);
+                expect(resultadoResolvedor).toContain('red');
             }
-        });
-        it('Atribuindo Método "translação-3d()"', () => {
-            for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "raio()" com valores de posição e número/quantificador', () => {
+        for (let index = 0; index < metodos_1.MetodoRaio.length; index += 1) {
+            const valoresAceitos = ['lado-mais-próximo', 'lado-mais-proximo', 'canto-mais-próximo', 'canto-mais-proximo', 'lado-mais-distante', 'canto-mais-distante', 'lados', 'conter'];
+            const traducaoValoresAceitos = ['closest-side', 'closest-side', 'closest-corner', 'closest-corner', 'farthest-side', 'farthest-corner', 'sides', 'contain'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "lmht {",
-                    `${metodos_1.MetodosTranslacao[index]}: translacao-3d(5ch, 0.4in, 5em);`,
+                    `${metodos_1.MetodoRaio[index]}: raio(${valoresAceitos[valIndex]} 200graus);`,
                     "}"
                 ]);
                 // O Lexador não deve encontrar erros
@@ -1746,8 +1650,8 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: foles_1.default.METODO }),
                 ]));
-                // O Lexador deve montar um objeto de comprimento 17
-                expect(resultadoLexador.simbolos).toHaveLength(17);
+                // O Lexador deve montar um objeto de comprimento 12
+                expect(resultadoLexador.simbolos).toHaveLength(12);
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                     expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
@@ -1760,433 +1664,1072 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                // Tradutor
-                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                // O Tradutor deve serializar de acordo e traduzir translação-3d para translate3d
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                expect(resultadoTradutor).toContain(`translate3d(5ch, 0.4in, 5em);`);
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRaio[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir raio para ray
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRaio[index]]);
+                expect(resultadoResolvedor).toContain(`ray(${traducaoValoresAceitos[valIndex]} 200deg);`);
             }
-        });
-        it('Atribuindo Método "translação-3d() cobrindo todos os casos"', () => {
-            for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
-                const valoresAceitos = [
-                    '0',
-                    '0, 62px, 135px',
-                    '2.7rem, 0, 1rem',
-                    '5ch, 0.4in, 0',
-                    '0, 0, 135px',
-                    '0, 2.7rem, 0',
-                    '5ch, 0, 0',
-                    '42px, 62px, 135px',
-                    '0, 0, 0',
-                ];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosTranslacao[index]}: translação-3d(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+        }
+    });
+    it('Atribuindo Método "raio()" com somente número/quantificador', () => {
+        for (let index = 0; index < metodos_1.MetodoRaio.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodoRaio[index]}: raio(200graus);`,
+                "}"
+            ]);
+            // 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: foles_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto de comprimento 11
+            expect(resultadoLexador.simbolos).toHaveLength(11);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRaio[index]]);
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            // O Resolvedor deve resolver de acordo e traduzir raio para ray
+            expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRaio[index]]);
+            expect(resultadoResolvedor).toContain(`ray(200deg);`);
+        }
+    });
+    it('Atribuindo Método "rotacionar()"', () => {
+        for (let index = 0; index < metodos_1.MetodosRotacionar.length; index += 1) {
+            const valoresAceitos = ['45graus', '45deg', '3.142rad', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosRotacionar[index]}: rotacionar(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 2) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0) {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    else if (valIndex === 1 || valIndex === 2 || valIndex === 3) {
-                        expect(resultadoLexador.simbolos).toHaveLength(16);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else if (valIndex === 4 || valIndex === 5 || valIndex === 6) {
-                        expect(resultadoLexador.simbolos).toHaveLength(15);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else if (valIndex === 7) {
-                        expect(resultadoLexador.simbolos).toHaveLength(17);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(14);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir translação-3d para translate3d
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    if (valIndex !== 8) {
-                        expect(resultadoTradutor).toContain(`translate3d(${valoresAceitos[valIndex]});`);
-                    }
-                    else {
-                        expect(resultadoTradutor).toContain(`translate3d(0);`);
-                    }
                 }
-            }
-        });
-        it('Atribuindo Método "translação-eixo-z()"', () => {
-            for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
-                const valoresAceitos = ['42px', '3ch', '0'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosTranslacao[index]}: translação-eixo-z(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir translação-eixo-z para translateZ
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    expect(resultadoTradutor).toContain(`translateZ(${valoresAceitos[valIndex]});`);
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir rotacionar para rotate
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
+                if (valIndex !== 0) {
+                    expect(resultadoResolvedor).toContain(`rotate(${valoresAceitos[valIndex]});`);
+                }
+                else {
+                    expect(resultadoResolvedor).toContain(`rotate(45deg);`);
                 }
             }
-        });
-        it('Atribuindo Método "translacao-eixo-z()"', () => {
-            for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
-                const valoresAceitos = ['42px', '3ch', '0'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosTranslacao[index]}: translacao-eixo-z(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+        }
+    });
+    it('Atribuindo Método "rotacionar-3d()" - caso de sucesso', () => {
+        for (let index = 0; index < metodos_1.MetodosRotacionar.length; index += 1) {
+            const valoresAceitos = ['0, 0, 0, 0', '1, 2, 0, 45deg', '1, 1, 1, 90graus'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosRotacionar[index]}: rotacionar-3d(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 17 caso haja quantificador e 16 caso não haja
+                if (valIndex > 0) {
+                    expect(resultadoLexador.simbolos).toHaveLength(17);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir translacao-eixo-z para translateZ
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    expect(resultadoTradutor).toContain(`translateZ(${valoresAceitos[valIndex]});`);
                 }
-            }
-        });
-        it('Atribuindo Método "translação-horizontal()"', () => {
-            for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
-                const valoresAceitos = ['42px', '3ch', '0'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosTranslacao[index]}: translação-horizontal(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(16);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir translação-horizontal para translateX
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    expect(resultadoTradutor).toContain(`translateX(${valoresAceitos[valIndex]});`);
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir rotacionar-3d para rotate3d
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
+                if (valIndex < 2) {
+                    expect(resultadoResolvedor).toContain(`rotate3d(${valoresAceitos[valIndex]});`);
+                }
+                else {
+                    expect(resultadoResolvedor).toContain(`rotate3d(1, 1, 1, 90deg);`);
                 }
             }
-        });
-        it('Atribuindo Método "translacao-horizontal()"', () => {
-            for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
-                const valoresAceitos = ['42px', '3ch', '0'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosTranslacao[index]}: translacao-horizontal(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+        }
+    });
+    it('Atribuindo Método "rotacionar-3d()" - caso de falha', () => {
+        for (let index = 0; index < metodos_1.MetodosRotacionar.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodosRotacionar[index]}: rotacionar-3d(1, 1, 1, 20px);`,
+                "}"
+            ]);
+            // 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: foles_1.default.METODO }),
+            ]));
+            // Avaliador Sintático 
+            const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
+            // Resolvedor não deve aceitar 'px' como quantificador válido
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow();
+        }
+    });
+    it('Atribuindo Método "rotacionar-eixo-z()"', () => {
+        for (let index = 0; index < metodos_1.MetodosRotacionar.length; index += 1) {
+            const valoresAceitos = ['45graus', '45deg', '3.142rad', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosRotacionar[index]}: rotacionar-eixo-z(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 2) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir translação-horizontal para translateX
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    expect(resultadoTradutor).toContain(`translateX(${valoresAceitos[valIndex]});`);
                 }
-            }
-        });
-        it('Atribuindo Método "translação-vertical()"', () => {
-            for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
-                const valoresAceitos = ['42px', '3ch', '0'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosTranslacao[index]}: translação-vertical(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir translação-vertical para translateY
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    expect(resultadoTradutor).toContain(`translateY(${valoresAceitos[valIndex]});`);
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir rotacionar-eixo-z para rotateZ
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
+                if (valIndex !== 0) {
+                    expect(resultadoResolvedor).toContain(`rotateZ(${valoresAceitos[valIndex]});`);
+                }
+                else {
+                    expect(resultadoResolvedor).toContain(`rotateZ(45deg);`);
                 }
             }
-        });
-        it('Atribuindo Método "translacao-vertical()"', () => {
-            for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
-                const valoresAceitos = ['42px', '3ch', '0'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosTranslacao[index]}: translacao-vertical(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+        }
+    });
+    it('Atribuindo Método "rotacionar-horizontal()"', () => {
+        for (let index = 0; index < metodos_1.MetodosRotacionar.length; index += 1) {
+            const valoresAceitos = ['45graus', '45deg', '3.142rad', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosRotacionar[index]}: rotacionar-horizontal(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 2) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir translação-vertical para translateY
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    expect(resultadoTradutor).toContain(`translateY(${valoresAceitos[valIndex]});`);
                 }
-            }
-        });
-        it('Caso de Falha - Atribuindo método inexistente', () => {
-            for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
-                const valoresAceitos = ['42px', '3ch', '0'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "lmht {",
-                        `${metodos_1.MetodosTranslacao[index]}: translacao-vertical(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: foles_1.default.METODO }),
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex === 0 || valIndex === 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: foles_1.default.NUMERO }),
-                        ]));
-                    }
-                    // Avaliador Sintático
-                    const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir translação-vertical para translateY
-                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
-                    expect(resultadoTradutor).toContain(`translateY(${valoresAceitos[valIndex]});`);
                 }
-            }
-        });
-        it('Caso de Falha - Erro ao instanciar classe SeletorValor', () => {
-            for (let index = 0; index < metodos_1.MetodosFolEs.length; index += 1) {
-                const metodoIncorreto = metodos_1.MetodosFolEs[index].replace(metodos_1.MetodosFolEs[index][0], '');
-                expect(() => {
-                    new seletor_valor_1.SeletorValor(metodoIncorreto, []);
-                }).toThrow(`O valor \'${metodoIncorreto}\' não foi encontrado.`);
-            }
-        });
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir rotacionar-horizontal para rotateX
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
+                if (valIndex !== 0) {
+                    expect(resultadoResolvedor).toContain(`rotateX(${valoresAceitos[valIndex]});`);
+                }
+                else {
+                    expect(resultadoResolvedor).toContain(`rotateX(45deg);`);
+                }
+            }
+        }
+    });
+    it('Atribuindo Método "rotacionar-matiz()"', () => {
+        for (let index = 0; index < metodos_1.MetodoRotacionarMatiz.length; index += 1) {
+            const valoresAceitos = ['90graus', '100px', '100%', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodoRotacionarMatiz[index]}: rotacionar-matiz(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 2) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRotacionarMatiz[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir rotacionar-matiz para hue-rotate
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRotacionarMatiz[index]]);
+                if (valIndex !== 0) {
+                    expect(resultadoResolvedor).toContain(`hue-rotate(${valoresAceitos[valIndex]});`);
+                }
+                else {
+                    expect(resultadoResolvedor).toContain(`hue-rotate(90deg);`);
+                }
+            }
+        }
+    });
+    it('Atribuindo Método "rotacionar-vertical()"', () => {
+        for (let index = 0; index < metodos_1.MetodosRotacionar.length; index += 1) {
+            const valoresAceitos = ['45graus', '45deg', '3.142rad', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosRotacionar[index]}: rotacionar-vertical(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 2) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir rotacionar-vertical para rotateY
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosRotacionar[index]]);
+                if (valIndex !== 0) {
+                    expect(resultadoResolvedor).toContain(`rotateY(${valoresAceitos[valIndex]});`);
+                }
+                else {
+                    expect(resultadoResolvedor).toContain(`rotateY(45deg);`);
+                }
+            }
+        }
+    });
+    it('Atribuindo Método "saturar()"', () => {
+        for (let index = 0; index < metodos_1.MetodoSaturar.length; index += 1) {
+            const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodoSaturar[index]}: saturar(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoSaturar[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir saturar para saturate
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoSaturar[index]]);
+                expect(resultadoResolvedor).toContain(`saturate(${valoresAceitos[valIndex]});`);
+            }
+        }
+    });
+    it('Atribuindo Método "sepia()"', () => {
+        for (let index = 0; index < metodos_1.MetodoSepia.length; index += 1) {
+            const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodoSepia[index]}: sepia(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoSepia[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir sépia para sepia
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoSepia[index]]);
+                expect(resultadoResolvedor).toContain(`sepia(${valoresAceitos[valIndex]});`);
+            }
+        }
+    });
+    it('Atribuindo Método "translação()"', () => {
+        for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
+            const valoresAceitos = ['270graus', '18deg', '3.142rad', '0', '1'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosTranslacao[index]}: translação(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 2) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir translação para translate
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                if (valIndex !== 0) {
+                    expect(resultadoResolvedor).toContain(`translate(${valoresAceitos[valIndex]});`);
+                }
+                else {
+                    expect(resultadoResolvedor).toContain(`translate(270deg);`);
+                }
+            }
+        }
+    });
+    it('Atribuindo Método "translacao() com múltiplos valores"', () => {
+        for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodosTranslacao[index]}: translacao(100graus, 100graus);`,
+                "}"
+            ]);
+            // 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: foles_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto de comprimento 14
+            expect(resultadoLexador.simbolos).toHaveLength(14);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            // O Resolvedor deve resolver de acordo e traduzir translacao para translate
+            expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+            expect(resultadoResolvedor).toContain(`translate(100deg, 100deg);`);
+        }
+    });
+    it('Atribuindo Método "translação-3d()"', () => {
+        for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `${metodos_1.MetodosTranslacao[index]}: translacao-3d(5ch, 0.4in, 5em);`,
+                "}"
+            ]);
+            // 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: foles_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto de comprimento 17
+            expect(resultadoLexador.simbolos).toHaveLength(17);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+            // Resolvedor
+            const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+            // O Resolvedor deve resolver de acordo e traduzir translação-3d para translate3d
+            expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+            expect(resultadoResolvedor).toContain(`translate3d(5ch, 0.4in, 5em);`);
+        }
+    });
+    it('Atribuindo Método "translação-3d() cobrindo todos os casos"', () => {
+        for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
+            const valoresAceitos = [
+                '0',
+                '0, 62px, 135px',
+                '2.7rem, 0, 1rem',
+                '5ch, 0.4in, 0',
+                '0, 0, 135px',
+                '0, 2.7rem, 0',
+                '5ch, 0, 0',
+                '42px, 62px, 135px',
+                '0, 0, 0',
+            ];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosTranslacao[index]}: translação-3d(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0) {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
+                else if (valIndex === 1 || valIndex === 2 || valIndex === 3) {
+                    expect(resultadoLexador.simbolos).toHaveLength(16);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else if (valIndex === 4 || valIndex === 5 || valIndex === 6) {
+                    expect(resultadoLexador.simbolos).toHaveLength(15);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else if (valIndex === 7) {
+                    expect(resultadoLexador.simbolos).toHaveLength(17);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(14);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir translação-3d para translate3d
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                if (valIndex !== 8) {
+                    expect(resultadoResolvedor).toContain(`translate3d(${valoresAceitos[valIndex]});`);
+                }
+                else {
+                    expect(resultadoResolvedor).toContain(`translate3d(0);`);
+                }
+            }
+        }
+    });
+    it('Atribuindo Método "translação-eixo-z()"', () => {
+        for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
+            const valoresAceitos = ['42px', '3ch', '0'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosTranslacao[index]}: translação-eixo-z(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir translação-eixo-z para translateZ
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                expect(resultadoResolvedor).toContain(`translateZ(${valoresAceitos[valIndex]});`);
+            }
+        }
+    });
+    it('Atribuindo Método "translacao-eixo-z()"', () => {
+        for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
+            const valoresAceitos = ['42px', '3ch', '0'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosTranslacao[index]}: translacao-eixo-z(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir translacao-eixo-z para translateZ
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                expect(resultadoResolvedor).toContain(`translateZ(${valoresAceitos[valIndex]});`);
+            }
+        }
+    });
+    it('Atribuindo Método "translação-horizontal()"', () => {
+        for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
+            const valoresAceitos = ['42px', '3ch', '0'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosTranslacao[index]}: translação-horizontal(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir translação-horizontal para translateX
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                expect(resultadoResolvedor).toContain(`translateX(${valoresAceitos[valIndex]});`);
+            }
+        }
+    });
+    it('Atribuindo Método "translacao-horizontal()"', () => {
+        for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
+            const valoresAceitos = ['42px', '3ch', '0'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosTranslacao[index]}: translacao-horizontal(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir translação-horizontal para translateX
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                expect(resultadoResolvedor).toContain(`translateX(${valoresAceitos[valIndex]});`);
+            }
+        }
+    });
+    it('Atribuindo Método "translação-vertical()"', () => {
+        for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
+            const valoresAceitos = ['42px', '3ch', '0'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosTranslacao[index]}: translação-vertical(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir translação-vertical para translateY
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                expect(resultadoResolvedor).toContain(`translateY(${valoresAceitos[valIndex]});`);
+            }
+        }
+    });
+    it('Atribuindo Método "translacao-vertical"', () => {
+        for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
+            const valoresAceitos = ['42px', '3ch', '0'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosTranslacao[index]}: translacao-vertical(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                // Resolvedor
+                const resultadoResolucao = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir translação-vertical para translateY
+                expect(resultadoResolucao).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                expect(resultadoResolucao).toContain(`translateY(${valoresAceitos[valIndex]});`);
+            }
+        }
+    });
+    it('Atribuindo Método "variar-caractere()" - caso de sucesso', () => {
+        const valoresAceitos = ['1', '2', '12', '20'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `variacao-fonte-alternativa: variar-caractere(${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: foles_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: foles_1.default.NUMERO }),
+            ]));
+            // Avaliador Sintático
+            const resultadoAvaliadorSintatico = avaliador.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 variar-caractere para character-variant
+            expect(resultadoResolvedor).toContain('font-variant-alternates');
+            expect(resultadoResolvedor).toContain(`character-variant(${valoresAceitos[index]});`);
+        }
+    });
+    it('Atribuindo Método "variar-caractere()" - caso de falha', () => {
+        const valoresAceitos = ['0', '210', '100'];
+        for (let index = 0; index < valoresAceitos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "lmht {",
+                `variacao-fonte-alternativa: variar-caractere(${valoresAceitos[index]});`,
+                "}"
+            ]);
+            const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
+            expect(() => {
+                resolvedor.resolver(resultadoAvaliadorSintatico);
+            }).toThrow('O valor da função variar-caractere() deve estar entre 1 e 99');
+        }
+    });
+    it('Caso de Falha - Atribuindo método inexistente', () => {
+        for (let index = 0; index < metodos_1.MetodosTranslacao.length; index += 1) {
+            const valoresAceitos = ['42px', '3ch', '0'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodosTranslacao[index]}: translacao-vertical(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // 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: foles_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex === 0 || valIndex === 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
+                    ]));
+                }
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.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(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                // Resolvedor
+                const resultadoResolvedor = resolvedor.resolver(resultadoAvaliadorSintatico);
+                // O Resolvedor deve resolver de acordo e traduzir translação-vertical para translateY
+                expect(resultadoResolvedor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosTranslacao[index]]);
+                expect(resultadoResolvedor).toContain(`translateY(${valoresAceitos[valIndex]});`);
+            }
+        }
+    });
+    it('Caso de Falha - Erro ao instanciar classe SeletorValor', () => {
+        for (let index = 0; index < metodos_1.MetodosFolEs.length; index += 1) {
+            const metodoIncorreto = metodos_1.MetodosFolEs[index].replace(metodos_1.MetodosFolEs[index][0], '');
+            expect(() => {
+                new seletor_valor_1.SeletorValor(metodoIncorreto, []);
+            }).toThrow(`O valor \'${metodoIncorreto}\' não foi encontrado.`);
+        }
     });
 });
 //# sourceMappingURL=metodos.test.js.map