@designliquido/foles 0.9.3 → 0.9.4

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

@@ -12,133 +12,46 @@ const metodos_css_1 = require("../listas/metodos-css");
 const declaracoes_1 = require("../../fontes/declaracoes");
 const seletor_valor_reverso_1 = require("../../fontes/valores/seletor-valor-reverso");
 describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
-    describe('Testes Unitários', () => {
-        let lexador;
-        let importador;
-        let avaliador;
-        let tradutor;
-        beforeEach(() => {
-            lexador = new lexador_reverso_1.LexadorReverso();
-            importador = new importador_1.Importador(lexador);
-            avaliador = new avaliador_sintatico_reverso_1.AvaliadorSintaticoReverso(importador);
-            tradutor = new serializadores_1.SerializadorReverso();
-        });
-        it('Atribuindo Método "blur()"', () => {
-            for (let index = 0; index < metodos_css_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([
-                        "div {",
-                        `${metodos_css_1.MetodoBorrar[index]}: blur(${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: css_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: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodoBorrar[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBorrar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir blur para borrar
-                    expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBorrar[index]]);
-                    expect(resultadoTradutor).toContain(`borrar(${valoresAceitos[valIndex]});`);
-                }
-            }
-        });
-        it('Atribuindo Método "brightness()"', () => {
-            for (let index = 0; index < metodos_css_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([
-                        "div {",
-                        `${metodos_css_1.MetodoBrilho[index]}: brightness(${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: css_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: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodoBrilho[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBrilho[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir brightness para brilho
-                    expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBrilho[index]]);
-                    expect(resultadoTradutor).toContain(`brilho(${valoresAceitos[valIndex]});`);
-                }
-            }
-        });
-        it('Atribuindo Método "calc()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodoCalcular.length; index += 1) {
+    let lexador;
+    let importador;
+    let avaliador;
+    let tradutor;
+    beforeEach(() => {
+        lexador = new lexador_reverso_1.LexadorReverso();
+        importador = new importador_1.Importador(lexador);
+        avaliador = new avaliador_sintatico_reverso_1.AvaliadorSintaticoReverso(importador);
+        tradutor = new serializadores_1.SerializadorReverso();
+    });
+    it('Atribuindo Método "blur()"', () => {
+        for (let index = 0; index < metodos_css_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([
                     "div {",
-                    `${metodos_css_1.MetodoCalcular[index]}: calc(100px - 80px);`,
+                    `${metodos_css_1.MetodoBorrar[index]}: blur(${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: css_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar números e quantificadores no mapeamento
-                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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
@@ -147,79 +60,46 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoCalcular[index]);
-                // Tradutor deve serializar de acordo e traduzir calc para calcular
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoBorrar[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBorrar[index]]);
+                // Tradutor
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoCalcular[index]]);
-                expect(resultadoTradutor).toContain('calcular(100px - 80px);');
-            }
-        });
-        it('Atribuindo Método "contrast()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodoContraste.length; index += 1) {
-                const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodoContraste[index]}: contrast(${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: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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: css_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_css_1.MetodoContraste[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoContraste[index]]);
-                    // Tradutor deve serializar de acordo e traduzir contrast para contraste
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoContraste[index]]);
-                    expect(resultadoTradutor).toContain(`contraste(${valoresAceitos[valIndex]});`);
-                }
+                // O Tradutor deve serializar de acordo e traduzir blur para borrar
+                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBorrar[index]]);
+                expect(resultadoTradutor).toContain(`borrar(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "cubic-bezier()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodoCurvaCubica.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "brightness()"', () => {
+        for (let index = 0; index < metodos_css_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([
                     "div {",
-                    `${metodos_css_1.MetodoCurvaCubica[index]}: cubic-bezier(0.42, 0.0, 1.0, 1.0);`,
+                    `${metodos_css_1.MetodoBrilho[index]}: brightness(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
-                // 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: css_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar números no mapeamento
-                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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
@@ -228,33 +108,81 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoCurvaCubica[index]);
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoBrilho[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBrilho[index]]);
                 // Tradutor
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoCurvaCubica[index]]);
-                expect(resultadoTradutor).toContain('curva-cubica(0.42, 0, 1, 1);');
+                // O Tradutor deve serializar de acordo e traduzir brightness para brilho
+                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBrilho[index]]);
+                expect(resultadoTradutor).toContain(`brilho(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "fit-content()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodoEncaixarConteudo.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "calc()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodoCalcular.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `${metodos_css_1.MetodoCalcular[index]}: calc(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: css_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar números e quantificadores no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                expect.objectContaining({ tipo: css_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_css_1.MetodoCalcular[index]);
+            // Tradutor deve serializar de acordo e traduzir calc para calcular
+            const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+            expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoCalcular[index]]);
+            expect(resultadoTradutor).toContain('calcular(100px - 80px);');
+        }
+    });
+    it('Atribuindo Método "contrast()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodoContraste.length; index += 1) {
+            const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "div {",
-                    `${metodos_css_1.MetodoEncaixarConteudo[index]}: fit-content(200px);`,
+                    `${metodos_css_1.MetodoContraste[index]}: contrast(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
-                // O Lexador deve montar um objeto de comprimento 11 sem retornar nenhum erro
-                expect(resultadoLexador.simbolos).toHaveLength(11);
+                // 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: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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: css_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar número e quantificador no mapeamento
-                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: css_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
@@ -263,106 +191,145 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoEncaixarConteudo[index]);
-                // Tradutor
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoContraste[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoContraste[index]]);
+                // Tradutor deve serializar de acordo e traduzir contrast para contraste
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoEncaixarConteudo[index]]);
-                expect(resultadoTradutor).toContain('encaixar-conteudo(200px)');
+                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoContraste[index]]);
+                expect(resultadoTradutor).toContain(`contraste(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "grayscale()"', () => {
-            for (let index = 0; index < metodos_css_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([
-                        "div {",
-                        `${metodos_css_1.MetodoEscalaCinza[index]}: grayscale(${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 "cubic-bezier()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodoCurvaCubica.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `${metodos_css_1.MetodoCurvaCubica[index]}: cubic-bezier(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: css_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar números no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_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_css_1.MetodoCurvaCubica[index]);
+            // Tradutor
+            const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+            expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoCurvaCubica[index]]);
+            expect(resultadoTradutor).toContain('curva-cubica(0.42, 0, 1, 1);');
+        }
+    });
+    it('Atribuindo Método "fit-content()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodoEncaixarConteudo.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `${metodos_css_1.MetodoEncaixarConteudo[index]}: fit-content(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: css_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar número e quantificador no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                expect.objectContaining({ tipo: css_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_css_1.MetodoEncaixarConteudo[index]);
+            // Tradutor
+            const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+            expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoEncaixarConteudo[index]]);
+            expect(resultadoTradutor).toContain('encaixar-conteudo(200px)');
+        }
+    });
+    it('Atribuindo Método "grayscale()"', () => {
+        for (let index = 0; index < metodos_css_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([
+                    "div {",
+                    `${metodos_css_1.MetodoEscalaCinza[index]}: grayscale(${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: css_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: css_1.default.METODO }),
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodoEscalaCinza[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoEscalaCinza[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir grayscale para escala-cinza
-                    expect(resultadoTradutor).toContain(`escala-cinza(${valoresAceitos[valIndex]});`);
                 }
-            }
-        });
-        it('Atribuindo Método "scale()"', () => {
-            for (let index = 0; index < metodos_css_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([
-                        "div {",
-                        `${metodos_css_1.MetodosEscalamento[index]}: scale(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O Lexador deve montar um objeto de comprimento 10
+                else {
                     expect(resultadoLexador.simbolos).toHaveLength(10);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                         expect.objectContaining({ tipo: css_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_css_1.MetodosEscalamento[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir scale para escalamento
-                    expect(resultadoTradutor).toContain(`escalamento(${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_css_1.MetodoEscalaCinza[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoEscalaCinza[index]]);
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                // O Tradutor deve serializar de acordo e traduzir grayscale para escala-cinza
+                expect(resultadoTradutor).toContain(`escala-cinza(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "scale()" com múltiplos valores', () => {
-            for (let index = 0; index < metodos_css_1.MetodosEscalamento.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "scale()"', () => {
+        for (let index = 0; index < metodos_css_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([
                     "div {",
-                    `${metodos_css_1.MetodosEscalamento[index]}: scale(1.3, 0.4);`,
+                    `${metodos_css_1.MetodosEscalamento[index]}: scale(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
                 // O Lexador não deve encontrar erros
                 expect(resultadoLexador.erros).toHaveLength(0);
-                // O Lexador deve montar um objeto de comprimento 12
-                expect(resultadoLexador.simbolos).toHaveLength(12);
+                // O Lexador deve montar um objeto de comprimento 10
+                expect(resultadoLexador.simbolos).toHaveLength(10);
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: css_1.default.NUMERO }),
                 ]));
@@ -379,15 +346,85 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 // Tradutor
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir scale para escalamento
-                expect(resultadoTradutor).toContain(`escalamento(1.3, 0.4);`);
+                expect(resultadoTradutor).toContain(`escalamento(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "scale3d()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodosEscalamento.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "scale()" com múltiplos valores', () => {
+        for (let index = 0; index < metodos_css_1.MetodosEscalamento.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `${metodos_css_1.MetodosEscalamento[index]}: scale(1.3, 0.4);`,
+                "}"
+            ]);
+            // O Lexador não deve encontrar erros
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O Lexador deve montar um objeto de comprimento 12
+            expect(resultadoLexador.simbolos).toHaveLength(12);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_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_css_1.MetodosEscalamento[index]);
+            expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
+            // Tradutor
+            const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+            // O Tradutor deve serializar de acordo e traduzir scale para escalamento
+            expect(resultadoTradutor).toContain(`escalamento(1.3, 0.4);`);
+        }
+    });
+    it('Atribuindo Método "scale3d()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodosEscalamento.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `${metodos_css_1.MetodosEscalamento[index]}: scale3d(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: css_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: css_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_css_1.MetodosEscalamento[index]);
+            expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
+            // Tradutor
+            const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+            // O Tradutor deve serializar de acordo e traduzir scale3d para escalamento-3d 
+            expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
+            expect(resultadoTradutor).toContain(`escalamento-3d(0.5, 1, 1.7);`);
+        }
+    });
+    it('Atribuindo Método "scaleZ()"', () => {
+        for (let index = 0; index < metodos_css_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([
                     "div {",
-                    `${metodos_css_1.MetodosEscalamento[index]}: scale3d(0.5, 1, 1.7);`,
+                    `${metodos_css_1.MetodosEscalamento[index]}: scaleZ(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
                 // O Lexador não deve encontrar erros
@@ -396,8 +433,8 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
                 ]));
@@ -413,147 +450,32 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
                 // Tradutor
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                // O Tradutor deve serializar de acordo e traduzir scale3d para escalamento-3d 
+                // O Tradutor deve serializar de acordo e traduzir scaleZ para escalamento-eixo-z
                 expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
-                expect(resultadoTradutor).toContain(`escalamento-3d(0.5, 1, 1.7);`);
-            }
-        });
-        it('Atribuindo Método "scaleZ()"', () => {
-            for (let index = 0; index < metodos_css_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([
-                        "div {",
-                        `${metodos_css_1.MetodosEscalamento[index]}: scaleZ(${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: css_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: css_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_css_1.MetodosEscalamento[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir scaleZ para escalamento-eixo-z
-                    expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
-                    expect(resultadoTradutor).toContain(`escalamento-eixo-z(${valoresAceitos[valIndex]});`);
-                }
-            }
-        });
-        it('Atribuindo Método "scaleX()"', () => {
-            for (let index = 0; index < metodos_css_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([
-                        "div {",
-                        `${metodos_css_1.MetodosEscalamento[index]}: scaleX(${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: css_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: css_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_css_1.MetodosEscalamento[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir scaleX para escalamento-horizontal
-                    expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
-                    expect(resultadoTradutor).toContain(`escalamento-horizontal(${valoresAceitos[valIndex]});`);
-                }
-            }
-        });
-        it('Atribuindo Método "scaleY()"', () => {
-            for (let index = 0; index < metodos_css_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([
-                        "div {",
-                        `${metodos_css_1.MetodosEscalamento[index]}: scaleY(${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: css_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: css_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_css_1.MetodosEscalamento[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir scaleY para escalamento-vertical
-                    expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
-                    expect(resultadoTradutor).toContain(`escalamento-vertical(${valoresAceitos[valIndex]});`);
-                }
+                expect(resultadoTradutor).toContain(`escalamento-eixo-z(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "linear-gradient()" com valor de ângulo deg', () => {
-            for (let index = 0; index < metodos_css_1.MetodoGradienteLinear.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "scaleX()"', () => {
+        for (let index = 0; index < metodos_css_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([
                     "div {",
-                    `${metodos_css_1.MetodoGradienteLinear[index]}: linear-gradient(90deg, green, yellow);`,
+                    `${metodos_css_1.MetodosEscalamento[index]}: scaleX(${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: css_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: css_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
                 ]));
                 // Avaliador Sintático
                 const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
@@ -563,67 +485,24 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoGradienteLinear[index]);
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosEscalamento[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
                 // Tradutor
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoGradienteLinear[index]]);
-                expect(resultadoTradutor).toContain('gradiente-linear(90deg, verde, amarelo);');
-            }
-        });
-        it('Atribuindo Método "skew()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodosInclinar.length; index += 1) {
-                const valoresAceitos = ['18deg', '3.142rad', '0', '1'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodosInclinar[index]}: skew(${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: css_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodosInclinar[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir skew para inclinar
-                    expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
-                    expect(resultadoTradutor).toContain(`inclinar(${valoresAceitos[valIndex]});`);
-                }
+                // O Tradutor deve serializar de acordo e traduzir scaleX para escalamento-horizontal
+                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
+                expect(resultadoTradutor).toContain(`escalamento-horizontal(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "skew() com múltiplos valores"', () => {
-            for (let index = 0; index < metodos_css_1.MetodosInclinar.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "scaleY()"', () => {
+        for (let index = 0; index < metodos_css_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([
                     "div {",
-                    `${metodos_css_1.MetodosInclinar[index]}: skew(15deg, 15deg);`,
+                    `${metodos_css_1.MetodosEscalamento[index]}: scaleY(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
                 // O Lexador não deve encontrar erros
@@ -632,11 +511,10 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
                 ]));
                 // Avaliador Sintático
                 const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
@@ -646,177 +524,81 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosInclinar[index]);
-                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosEscalamento[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
                 // Tradutor
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                // O Tradutor deve serializar de acordo e traduzir skew para inclinar
-                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
-                expect(resultadoTradutor).toContain(`inclinar(15deg, 15deg);`);
-            }
-        });
-        it('Atribuindo Método "skewX()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodosInclinar.length; index += 1) {
-                const valoresAceitos = ['180deg', '3.142rad', '0', '1'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodosInclinar[index]}: skewX(${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: css_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodosInclinar[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir skewX para inclinar-horizontal
-                    expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
-                }
-            }
-        });
-        it('Atribuindo Método "skewY()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodosInclinar.length; index += 1) {
-                const valoresAceitos = ['180deg', '3.142rad', '0', '1'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodosInclinar[index]}: skewY(${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: css_1.default.METODO }),
-                    ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodosInclinar[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir skewY para inclinar-vertical 
-                    expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
-                    expect(resultadoTradutor).toContain(`inclinar-vertical(${valoresAceitos[valIndex]});`);
-                }
-            }
-        });
-        it('Atribuindo Método "invert()"', () => {
-            for (let index = 0; index < metodos_css_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([
-                        "div {",
-                        `${metodos_css_1.MetodoInverter[index]}: invert(${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: css_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: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodoInverter[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoInverter[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir invert para inverter
-                    expect(resultadoTradutor).toContain(`inverter(${valoresAceitos[valIndex]});`);
-                }
+                // O Tradutor deve serializar de acordo e traduzir scaleY para escalamento-vertical
+                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
+                expect(resultadoTradutor).toContain(`escalamento-vertical(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "clamp()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodoLimitar.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "linear-gradient()" com valor de ângulo deg', () => {
+        for (let index = 0; index < metodos_css_1.MetodoGradienteLinear.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `${metodos_css_1.MetodoGradienteLinear[index]}: linear-gradient(90deg, green, yellow);`,
+                "}"
+            ]);
+            // 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: css_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar número e quantificador no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                expect.objectContaining({ tipo: css_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_css_1.MetodoGradienteLinear[index]);
+            // Tradutor
+            const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+            expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoGradienteLinear[index]]);
+            expect(resultadoTradutor).toContain('gradiente-linear(90deg, verde, amarelo);');
+        }
+    });
+    it('Atribuindo Método "skew()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodosInclinar.length; index += 1) {
+            const valoresAceitos = ['18deg', '3.142rad', '0', '1'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "div {",
-                    `${metodos_css_1.MetodoLimitar[index]}: clamp(10vw, 20em, 100vw);`,
+                    `${metodos_css_1.MetodosInclinar[index]}: skew(${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: css_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar números e quantificadores no mapeamento
-                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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
@@ -825,33 +607,83 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoLimitar[index]);
-                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoLimitar[index]]);
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosInclinar[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
                 // Tradutor
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoLimitar[index]]);
-                expect(resultadoTradutor).toContain('limitar(10vw, 20em, 100vw);');
+                // O Tradutor deve serializar de acordo e traduzir skew para inclinar
+                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
+                expect(resultadoTradutor).toContain(`inclinar(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "linear()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodoLinear.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "skew() com múltiplos valores"', () => {
+        for (let index = 0; index < metodos_css_1.MetodosInclinar.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `${metodos_css_1.MetodosInclinar[index]}: skew(15deg, 15deg);`,
+                "}"
+            ]);
+            // O Lexador não deve encontrar erros
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto de comprimento 14
+            expect(resultadoLexador.simbolos).toHaveLength(14);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                expect.objectContaining({ tipo: css_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_css_1.MetodosInclinar[index]);
+            expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
+            // Tradutor
+            const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+            // O Tradutor deve serializar de acordo e traduzir skew para inclinar
+            expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
+            expect(resultadoTradutor).toContain(`inclinar(15deg, 15deg);`);
+        }
+    });
+    it('Atribuindo Método "skewX()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodosInclinar.length; index += 1) {
+            const valoresAceitos = ['180deg', '3.142rad', '0', '1'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "div {",
-                    `${metodos_css_1.MetodoLinear[index]}: linear(0, 0.25, 1);`,
+                    `${metodos_css_1.MetodosInclinar[index]}: skewX(${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: css_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar números no mapeamento
-                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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
@@ -860,33 +692,45 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoLinear[index]);
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosInclinar[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
                 // Tradutor
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoLinear[index]]);
-                expect(resultadoTradutor).toContain('linear(0, 0.25, 1);');
+                // O Tradutor deve serializar de acordo e traduzir skewX para inclinar-horizontal
+                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
             }
-        });
-        it('Atribuindo Método "minmax()" com valor máximo', () => {
-            for (let index = 0; index < metodos_css_1.MetodoMinMax.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "skewY()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodosInclinar.length; index += 1) {
+            const valoresAceitos = ['180deg', '3.142rad', '0', '1'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "div {",
-                    `${metodos_css_1.MetodoMinMax[index]}: minmax(100px, max-content);`,
+                    `${metodos_css_1.MetodosInclinar[index]}: skewY(${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: css_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar número e quantificador no mapeamento
-                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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
@@ -895,34 +739,46 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoMinMax[index]);
-                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoMinMax[index]]);
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosInclinar[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
                 // Tradutor
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoMinMax[index]]);
-                expect(resultadoTradutor).toContain('minmax(100px, conteudo-máximo);');
+                // O Tradutor deve serializar de acordo e traduzir skewY para inclinar-vertical 
+                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
+                expect(resultadoTradutor).toContain(`inclinar-vertical(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "minmax()" com valor mínimo', () => {
-            for (let index = 0; index < metodos_css_1.MetodoMinMax.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "invert()"', () => {
+        for (let index = 0; index < metodos_css_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([
                     "div {",
-                    `${metodos_css_1.MetodoMinMax[index]}: minmax(min-content, 100px);`,
+                    `${metodos_css_1.MetodoInverter[index]}: invert(${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: css_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar número e quantificador no mapeamento
-                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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
@@ -931,129 +787,187 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoMinMax[index]);
-                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoMinMax[index]]);
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoInverter[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoInverter[index]]);
                 // Tradutor
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoMinMax[index]]);
-                expect(resultadoTradutor).toContain('minmax(conteudo-mínimo, 100px);');
-            }
-        });
-        it('Atribuindo Método "opacity()"', () => {
-            for (let index = 0; index < metodos_css_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([
-                        "div {",
-                        `${metodos_css_1.MetodoOpacar[index]}: opacity(${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: css_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: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodoOpacar[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoOpacar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir opacity para opacar
-                    expect(resultadoTradutor).toContain(`opacar(${valoresAceitos[valIndex]});`);
-                }
-            }
-        });
-        it('Atribuindo Método "perspective()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodoPerspectivar.length; index += 1) {
-                const valoresAceitos = ['800px', '6.5cm', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodoPerspectivar[index]}: perspective(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // 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: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else if (valIndex !== 6) {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodoPerspectivar[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoPerspectivar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir perspective para perspectivar
-                    expect(resultadoTradutor).toContain(`perspectivar(${valoresAceitos[valIndex]});`);
-                }
+                // O Tradutor deve serializar de acordo e traduzir invert para inverter
+                expect(resultadoTradutor).toContain(`inverter(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "steps()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodoPassos.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "clamp()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodoLimitar.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `${metodos_css_1.MetodoLimitar[index]}: clamp(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: css_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar números e quantificadores no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                expect.objectContaining({ tipo: css_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_css_1.MetodoLimitar[index]);
+            expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoLimitar[index]]);
+            // Tradutor
+            const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+            expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoLimitar[index]]);
+            expect(resultadoTradutor).toContain('limitar(10vw, 20em, 100vw);');
+        }
+    });
+    it('Atribuindo Método "linear()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodoLinear.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `${metodos_css_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: css_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar números no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_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_css_1.MetodoLinear[index]);
+            // Tradutor
+            const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+            expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoLinear[index]]);
+            expect(resultadoTradutor).toContain('linear(0, 0.25, 1);');
+        }
+    });
+    it('Atribuindo Método "minmax()" com valor máximo', () => {
+        for (let index = 0; index < metodos_css_1.MetodoMinMax.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `${metodos_css_1.MetodoMinMax[index]}: minmax(100px, max-content);`,
+                "}"
+            ]);
+            // 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: css_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar número e quantificador no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                expect.objectContaining({ tipo: css_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_css_1.MetodoMinMax[index]);
+            expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoMinMax[index]]);
+            // Tradutor
+            const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+            expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoMinMax[index]]);
+            expect(resultadoTradutor).toContain('minmax(100px, conteudo-máximo);');
+        }
+    });
+    it('Atribuindo Método "minmax()" com valor mínimo', () => {
+        for (let index = 0; index < metodos_css_1.MetodoMinMax.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `${metodos_css_1.MetodoMinMax[index]}: minmax(min-content, 100px);`,
+                "}"
+            ]);
+            // 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: css_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar número e quantificador no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                expect.objectContaining({ tipo: css_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_css_1.MetodoMinMax[index]);
+            expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoMinMax[index]]);
+            // Tradutor
+            const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+            expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoMinMax[index]]);
+            expect(resultadoTradutor).toContain('minmax(conteudo-mínimo, 100px);');
+        }
+    });
+    it('Atribuindo Método "opacity()"', () => {
+        for (let index = 0; index < metodos_css_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([
                     "div {",
-                    `${metodos_css_1.MetodoPassos[index]}: steps(2, jump-start);`,
+                    `${metodos_css_1.MetodoOpacar[index]}: opacity(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
-                // O Lexador deve montar um objeto de comprimento 12 sem retornar nenhum erro
-                expect(resultadoLexador.simbolos).toHaveLength(12);
+                // O Lexador não deve encontrar erros
                 expect(resultadoLexador.erros).toHaveLength(0);
                 // O valor recebido deve ser mapeado como METODO
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: css_1.default.METODO }),
                 ]));
-                // O Lexador também deve encontrar número no mapeamento
-                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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
@@ -1062,140 +976,188 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoPassos[index]);
-                // Tradutor deve serializar de acordo e traduzir steps para passos, assim como o termo de salto
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoOpacar[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoOpacar[index]]);
+                // Tradutor
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoPassos[index]]);
-                expect(resultadoTradutor).toContain('passos(2, salto-inicial);');
+                // O Tradutor deve serializar de acordo e traduzir opacity para opacar
+                expect(resultadoTradutor).toContain(`opacar(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "drop-shadow()" com valores de comprimento', () => {
-            for (let index = 0; index < metodos_css_1.MetodoProjetarSombra.length; index += 1) {
-                const comprimentos = ['15px 15px', '15px 15px 15px', '0.5rem 0.5rem', '0.5rem 0.5rem 1rem'];
-                for (let posIndex = 0; posIndex < comprimentos.length; posIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodoProjetarSombra[index]}: drop-shadow(${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: css_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: css_1.default.NUMERO }),
-                        expect.objectContaining({ tipo: css_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_css_1.MetodoProjetarSombra[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoProjetarSombra[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir drop-shadow para projetar-sombra  
-                    expect(resultadoTradutor).toContain(`projetar-sombra(${comprimentos[posIndex]});`);
-                }
-            }
-        });
-        it('Atribuindo Método "drop-shadow()" com valores de cor e de comprimento', () => {
-            for (let index = 0; index < metodos_css_1.MetodoProjetarSombra.length; index += 1) {
-                const comprimentos = [
-                    '15px 15px red',
-                    '15px 15px 15px red',
-                    'red 0.5rem 0.5rem',
-                    'red 0.5rem 0.5rem 1rem',
-                ];
-                for (let posIndex = 0; posIndex < comprimentos.length; posIndex += 1) {
-                    // Lexador                    
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodoProjetarSombra[index]}: drop-shadow(${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: css_1.default.METODO }),
-                    ]));
-                    // O Lexador também deve sempre encontrar valores e quantificadores na operação
+        }
+    });
+    it('Atribuindo Método "perspective()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodoPerspectivar.length; index += 1) {
+            const valoresAceitos = ['800px', '6.5cm', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "div {",
+                    `${metodos_css_1.MetodoPerspectivar[index]}: perspective(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // O Lexador não deve encontrar erros
+                expect(resultadoLexador.erros).toHaveLength(0);
+                // 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: css_1.default.NUMERO }),
                         expect.objectContaining({ tipo: css_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_css_1.MetodoProjetarSombra[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoProjetarSombra[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir red para vermelho
-                    expect(resultadoTradutor).toContain('vermelho');
                 }
-            }
-        });
-        it('Atribuindo Método "ray()" com valores de posição e número/quantificador', () => {
-            for (let index = 0; index < metodos_css_1.MetodoRaio.length; index += 1) {
-                const valoresAceitos = ['closest-side', 'closest-corner', 'farthest-side', 'farthest-corner', 'sides', 'contain'];
-                const traducaoValoresAceitos = ['lado-mais-próximo', 'canto-mais-próximo', 'lado-mais-distante', 'canto-mais-distante', 'lados', 'conter'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodoRaio[index]}: ray(${valoresAceitos[valIndex]} 200deg);`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O valor recebido deve ser mapeado como METODO
+                else if (valIndex !== 6) {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: css_1.default.METODO }),
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 12
-                    expect(resultadoLexador.simbolos).toHaveLength(12);
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                        expect.objectContaining({ tipo: css_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_css_1.MetodoRaio[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoRaio[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir ray para raio
-                    expect(resultadoTradutor).toContain(`raio(${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_css_1.MetodoPerspectivar[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoPerspectivar[index]]);
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                // O Tradutor deve serializar de acordo e traduzir perspective para perspectivar
+                expect(resultadoTradutor).toContain(`perspectivar(${valoresAceitos[valIndex]});`);
+            }
+        }
+    });
+    it('Atribuindo Método "steps()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodoPassos.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `${metodos_css_1.MetodoPassos[index]}: steps(2, jump-start);`,
+                "}"
+            ]);
+            // 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: css_1.default.METODO }),
+            ]));
+            // O Lexador também deve encontrar número no mapeamento
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_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_css_1.MetodoPassos[index]);
+            // Tradutor deve serializar de acordo e traduzir steps para passos, assim como o termo de salto
+            const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+            expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoPassos[index]]);
+            expect(resultadoTradutor).toContain('passos(2, salto-inicial);');
+        }
+    });
+    it('Atribuindo Método "drop-shadow()" com valores de comprimento', () => {
+        for (let index = 0; index < metodos_css_1.MetodoProjetarSombra.length; index += 1) {
+            const comprimentos = ['15px 15px', '15px 15px 15px', '0.5rem 0.5rem', '0.5rem 0.5rem 1rem'];
+            for (let posIndex = 0; posIndex < comprimentos.length; posIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "div {",
+                    `${metodos_css_1.MetodoProjetarSombra[index]}: drop-shadow(${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: css_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: css_1.default.NUMERO }),
+                    expect.objectContaining({ tipo: css_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_css_1.MetodoProjetarSombra[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoProjetarSombra[index]]);
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                // O Tradutor deve serializar de acordo e traduzir drop-shadow para projetar-sombra  
+                expect(resultadoTradutor).toContain(`projetar-sombra(${comprimentos[posIndex]});`);
             }
-        });
-        it('Atribuindo Método "ray()" com somente número/quantificador', () => {
-            for (let index = 0; index < metodos_css_1.MetodoRaio.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "drop-shadow()" com valores de cor e de comprimento', () => {
+        for (let index = 0; index < metodos_css_1.MetodoProjetarSombra.length; index += 1) {
+            const comprimentos = [
+                '15px 15px red',
+                '15px 15px 15px red',
+                'red 0.5rem 0.5rem',
+                'red 0.5rem 0.5rem 1rem',
+            ];
+            for (let posIndex = 0; posIndex < comprimentos.length; posIndex += 1) {
+                // Lexador                    
+                const resultadoLexador = lexador.mapear([
+                    "div {",
+                    `${metodos_css_1.MetodoProjetarSombra[index]}: drop-shadow(${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: css_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: css_1.default.NUMERO }),
+                    expect.objectContaining({ tipo: css_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_css_1.MetodoProjetarSombra[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoProjetarSombra[index]]);
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                // O Tradutor deve serializar de acordo e traduzir red para vermelho
+                expect(resultadoTradutor).toContain('vermelho');
+            }
+        }
+    });
+    it('Atribuindo Método "ray()" com valores de posição e número/quantificador', () => {
+        for (let index = 0; index < metodos_css_1.MetodoRaio.length; index += 1) {
+            const valoresAceitos = ['closest-side', 'closest-corner', 'farthest-side', 'farthest-corner', 'sides', 'contain'];
+            const traducaoValoresAceitos = ['lado-mais-próximo', 'canto-mais-próximo', 'lado-mais-distante', 'canto-mais-distante', 'lados', 'conter'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "div {",
-                    `${metodos_css_1.MetodoRaio[index]}: ray(200deg);`,
+                    `${metodos_css_1.MetodoRaio[index]}: ray(${valoresAceitos[valIndex]} 200deg);`,
                     "}"
                 ]);
                 // O Lexador não deve encontrar erros
@@ -1204,8 +1166,8 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: css_1.default.METODO }),
                 ]));
-                // O Lexador deve montar um objeto de comprimento 11
-                expect(resultadoLexador.simbolos).toHaveLength(11);
+                // O Lexador deve montar um objeto de comprimento 12
+                expect(resultadoLexador.simbolos).toHaveLength(12);
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: css_1.default.NUMERO }),
                     expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
@@ -1223,393 +1185,260 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 // Tradutor
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                 // O Tradutor deve serializar de acordo e traduzir ray para raio
-                expect(resultadoTradutor).toContain(`raio(200deg);`);
+                expect(resultadoTradutor).toContain(`raio(${traducaoValoresAceitos[valIndex]} 200deg);`);
             }
-        });
-        it('Atribuindo Método "rotate()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodosRotacionar.length; index += 1) {
-                const valoresAceitos = ['45deg', '3.142rad', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodosRotacionar[index]}: rotate(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodosRotacionar[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosRotacionar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir rotate para rotacionar
-                    expect(resultadoTradutor).toContain(`rotacionar(${valoresAceitos[valIndex]});`);
+        }
+    });
+    it('Atribuindo Método "ray" com somente número/quantificador', () => {
+        for (let index = 0; index < metodos_css_1.MetodoRaio.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `${metodos_css_1.MetodoRaio[index]}: ray(200deg);`,
+                "}"
+            ]);
+            // O Lexador não deve encontrar erros
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto de comprimento 11
+            expect(resultadoLexador.simbolos).toHaveLength(11);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                expect.objectContaining({ tipo: css_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_css_1.MetodoRaio[index]);
+            expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoRaio[index]]);
+            // Tradutor
+            const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+            // O Tradutor deve serializar de acordo e traduzir ray para raio
+            expect(resultadoTradutor).toContain(`raio(200deg);`);
+        }
+    });
+    it('Atribuindo Método "rotate()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodosRotacionar.length; index += 1) {
+            const valoresAceitos = ['45deg', '3.142rad', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "div {",
+                    `${metodos_css_1.MetodosRotacionar[index]}: rotate(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // O Lexador não deve encontrar erros
+                expect(resultadoLexador.erros).toHaveLength(0);
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    ]));
                 }
-            }
-        });
-        it('Atribuindo Método "rotateX()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodosRotacionar.length; index += 1) {
-                const valoresAceitos = ['45deg', '3.142rad', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodosRotacionar[index]}: rotateX(${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: css_1.default.METODO }),
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodosRotacionar[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosRotacionar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir rotateX para rotacionar-horizontal
-                    expect(resultadoTradutor).toContain(`rotacionar-horizontal(${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_css_1.MetodosRotacionar[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosRotacionar[index]]);
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                // O Tradutor deve serializar de acordo e traduzir rotate para rotacionar
+                expect(resultadoTradutor).toContain(`rotacionar(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "rotateY()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodosRotacionar.length; index += 1) {
-                const valoresAceitos = ['45deg', '3.142rad', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodosRotacionar[index]}: rotateY(${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 "rotateX()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodosRotacionar.length; index += 1) {
+            const valoresAceitos = ['45deg', '3.142rad', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "div {",
+                    `${metodos_css_1.MetodosRotacionar[index]}: rotateX(${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: css_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: css_1.default.METODO }),
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodosRotacionar[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosRotacionar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir rotateY para rotacionar-vertical
-                    expect(resultadoTradutor).toContain(`rotacionar-vertical(${valoresAceitos[valIndex]});`);
                 }
-            }
-        });
-        it('Atribuindo Método "rotateZ()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodosRotacionar.length; index += 1) {
-                const valoresAceitos = ['45deg', '3.142rad', '0.1', '0', '1', '1.75'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodosRotacionar[index]}: rotateZ(${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: css_1.default.METODO }),
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
                     ]));
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodosRotacionar[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosRotacionar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir rotateZ para rotacionar-eixo-z
-                    expect(resultadoTradutor).toContain(`rotacionar-eixo-z(${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_css_1.MetodosRotacionar[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosRotacionar[index]]);
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                // O Tradutor deve serializar de acordo e traduzir rotateX para rotacionar-horizontal
+                expect(resultadoTradutor).toContain(`rotacionar-horizontal(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "hue-rotate()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodoRotacionarMatiz.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([
-                        "div {",
-                        `${metodos_css_1.MetodoRotacionarMatiz[index]}: hue-rotate(${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 "rotateY()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodosRotacionar.length; index += 1) {
+            const valoresAceitos = ['45deg', '3.142rad', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "div {",
+                    `${metodos_css_1.MetodosRotacionar[index]}: rotateY(${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: css_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: css_1.default.METODO }),
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodoRotacionarMatiz[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoRotacionarMatiz[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir hue-rotate para rotacionar-matiz
-                    expect(resultadoTradutor).toContain(`rotacionar-matiz(${valoresAceitos[valIndex]});`);
                 }
-            }
-        });
-        it('Atribuindo Método "saturate()"', () => {
-            for (let index = 0; index < metodos_css_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([
-                        "div {",
-                        `${metodos_css_1.MetodoSaturar[index]}: saturate(${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: css_1.default.METODO }),
+                        expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodoSaturar[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoSaturar[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir saturate para saturar
-                    expect(resultadoTradutor).toContain(`saturar(${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_css_1.MetodosRotacionar[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosRotacionar[index]]);
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                // O Tradutor deve serializar de acordo e traduzir rotateY para rotacionar-vertical
+                expect(resultadoTradutor).toContain(`rotacionar-vertical(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "sepia()"', () => {
-            for (let index = 0; index < metodos_css_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([
-                        "div {",
-                        `${metodos_css_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
+        }
+    });
+    it('Atribuindo Método "rotateZ()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodosRotacionar.length; index += 1) {
+            const valoresAceitos = ['45deg', '3.142rad', '0.1', '0', '1', '1.75'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "div {",
+                    `${metodos_css_1.MetodosRotacionar[index]}: rotateZ(${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: css_1.default.METODO }),
+                ]));
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: css_1.default.METODO }),
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodoSepia[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoSepia[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir sépia para sepia
-                    expect(resultadoTradutor).toContain(`sepia(${valoresAceitos[valIndex]});`);
                 }
-            }
-        });
-        it('Atribuindo Método "translate()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodosTranslacao.length; index += 1) {
-                const valoresAceitos = ['18deg', '3.142rad', '0', '1'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodosTranslacao[index]}: translate(${valoresAceitos[valIndex]});`,
-                        "}"
-                    ]);
-                    // O Lexador não deve encontrar erros
-                    expect(resultadoLexador.erros).toHaveLength(0);
-                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
-                    if (valIndex <= 1) {
-                        expect(resultadoLexador.simbolos).toHaveLength(11);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodosTranslacao[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosTranslacao[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir translate para translação
-                    expect(resultadoTradutor).toContain(`translação(${valoresAceitos[valIndex]});`);
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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_css_1.MetodosRotacionar[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosRotacionar[index]]);
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                // O Tradutor deve serializar de acordo e traduzir rotateZ para rotacionar-eixo-z
+                expect(resultadoTradutor).toContain(`rotacionar-eixo-z(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "translate() com múltiplos valores"', () => {
-            for (let index = 0; index < metodos_css_1.MetodosTranslacao.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "hue-rotate()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodoRotacionarMatiz.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([
                     "div {",
-                    `${metodos_css_1.MetodosTranslacao[index]}: translate(100deg, 100deg);`,
+                    `${metodos_css_1.MetodoRotacionarMatiz[index]}: hue-rotate(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
                 // O Lexador não deve encontrar erros
                 expect(resultadoLexador.erros).toHaveLength(0);
-                // O Lexador deve montar um objeto de comprimento 14
-                expect(resultadoLexador.simbolos).toHaveLength(14);
+                // O valor recebido deve ser mapeado como METODO
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                    expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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
@@ -1618,160 +1447,191 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
-                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosTranslacao[index]);
+                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodoRotacionarMatiz[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoRotacionarMatiz[index]]);
                 // Tradutor
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                // O Tradutor deve serializar de acordo e traduzir translate para translação
-                expect(resultadoTradutor).toContain(`translação(100deg, 100deg);`);
+                // O Tradutor deve serializar de acordo e traduzir hue-rotate para rotacionar-matiz
+                expect(resultadoTradutor).toContain(`rotacionar-matiz(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "translateX()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodosTranslacao.length; index += 1) {
-                const valoresAceitos = ['42px', '3ch', '0'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodosTranslacao[index]}: translateX(${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 "saturate()"', () => {
+        for (let index = 0; index < metodos_css_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([
+                    "div {",
+                    `${metodos_css_1.MetodoSaturar[index]}: saturate(${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: css_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: css_1.default.METODO }),
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodosTranslacao[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosTranslacao[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir translateX para translacao-horizontal 
-                    expect(resultadoTradutor).toContain(`translacao-horizontal(${valoresAceitos[valIndex]});`);
                 }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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_css_1.MetodoSaturar[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoSaturar[index]]);
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                // O Tradutor deve serializar de acordo e traduzir saturate para saturar
+                expect(resultadoTradutor).toContain(`saturar(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "translateY()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodosTranslacao.length; index += 1) {
-                const valoresAceitos = ['42px', '3ch', '0'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodosTranslacao[index]}: translateY(${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 "sepia()"', () => {
+        for (let index = 0; index < metodos_css_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([
+                    "div {",
+                    `${metodos_css_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: css_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: css_1.default.METODO }),
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodosTranslacao[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosTranslacao[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir translateY para translacao-vertical
-                    expect(resultadoTradutor).toContain(`translacao-vertical(${valoresAceitos[valIndex]});`);
                 }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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_css_1.MetodoSepia[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoSepia[index]]);
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                // O Tradutor deve serializar de acordo e traduzir sépia para sepia
+                expect(resultadoTradutor).toContain(`sepia(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "translateZ()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodosTranslacao.length; index += 1) {
-                const valoresAceitos = ['42px', '3ch', '0'];
-                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
-                    // Lexador
-                    const resultadoLexador = lexador.mapear([
-                        "div {",
-                        `${metodos_css_1.MetodosTranslacao[index]}: translateZ(${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 "translate()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodosTranslacao.length; index += 1) {
+            const valoresAceitos = ['18deg', '3.142rad', '0', '1'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "div {",
+                    `${metodos_css_1.MetodosTranslacao[index]}: translate(${valoresAceitos[valIndex]});`,
+                    "}"
+                ]);
+                // O Lexador não deve encontrar erros
+                expect(resultadoLexador.erros).toHaveLength(0);
+                // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                if (valIndex <= 1) {
+                    expect(resultadoLexador.simbolos).toHaveLength(11);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: css_1.default.METODO }),
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(10);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodosTranslacao[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosTranslacao[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir translateZ para translação-eixo-z
-                    expect(resultadoTradutor).toContain(`translacao-eixo-z(${valoresAceitos[valIndex]});`);
                 }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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_css_1.MetodosTranslacao[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosTranslacao[index]]);
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                // O Tradutor deve serializar de acordo e traduzir translate para translação
+                expect(resultadoTradutor).toContain(`translação(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "translate3d()"', () => {
-            for (let index = 0; index < metodos_css_1.MetodosTranslacao.length; index += 1) {
+        }
+    });
+    it('Atribuindo Método "translate() com múltiplos valores"', () => {
+        for (let index = 0; index < metodos_css_1.MetodosTranslacao.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `${metodos_css_1.MetodosTranslacao[index]}: translate(100deg, 100deg);`,
+                "}"
+            ]);
+            // O Lexador não deve encontrar erros
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O Lexador deve montar um objeto de comprimento 14
+            expect(resultadoLexador.simbolos).toHaveLength(14);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                expect.objectContaining({ tipo: css_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_css_1.MetodosTranslacao[index]);
+            // Tradutor
+            const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+            // O Tradutor deve serializar de acordo e traduzir translate para translação
+            expect(resultadoTradutor).toContain(`translação(100deg, 100deg);`);
+        }
+    });
+    it('Atribuindo Método "translateX()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodosTranslacao.length; index += 1) {
+            const valoresAceitos = ['42px', '3ch', '0'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "div {",
-                    `${metodos_css_1.MetodosTranslacao[index]}: translate3d(5ch, 0.4in, 5px);`,
+                    `${metodos_css_1.MetodosTranslacao[index]}: translateX(${valoresAceitos[valIndex]});`,
                     "}"
                 ]);
                 // O Lexador não deve encontrar erros
@@ -1780,12 +1640,67 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                     expect.objectContaining({ tipo: css_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 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: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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_css_1.MetodosTranslacao[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosTranslacao[index]]);
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                // O Tradutor deve serializar de acordo e traduzir translateX para translacao-horizontal 
+                expect(resultadoTradutor).toContain(`translacao-horizontal(${valoresAceitos[valIndex]});`);
+            }
+        }
+    });
+    it('Atribuindo Método "translateY()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodosTranslacao.length; index += 1) {
+            const valoresAceitos = ['42px', '3ch', '0'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "div {",
+                    `${metodos_css_1.MetodosTranslacao[index]}: translateY(${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: css_1.default.NUMERO }),
-                    expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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
@@ -1795,102 +1710,185 @@ describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
                 const primeiroResultadoTipado = primeiroResultado;
                 expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
                 expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_css_1.MetodosTranslacao[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosTranslacao[index]]);
                 // Tradutor
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                // O Tradutor deve serializar de acordo e traduzir translate3d para translação-3d
-                expect(resultadoTradutor).toContain(`translacao-3d(5ch, 0.4in, 5px);`);
+                // O Tradutor deve serializar de acordo e traduzir translateY para translacao-vertical
+                expect(resultadoTradutor).toContain(`translacao-vertical(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Atribuindo Método "translate3d() cobrindo todos os casos"', () => {
-            for (let index = 0; index < metodos_css_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([
-                        "div {",
-                        `${metodos_css_1.MetodosTranslacao[index]}: translate3d(${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 "translateZ()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodosTranslacao.length; index += 1) {
+            const valoresAceitos = ['42px', '3ch', '0'];
+            for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "div {",
+                    `${metodos_css_1.MetodosTranslacao[index]}: translateZ(${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: css_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: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
                     expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                        expect.objectContaining({ tipo: css_1.default.METODO }),
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
                     ]));
-                    // 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: css_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: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else if (valIndex === 7) {
-                        expect(resultadoLexador.simbolos).toHaveLength(17);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_1.default.NUMERO }),
-                            expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
-                        ]));
-                    }
-                    else {
-                        expect(resultadoLexador.simbolos).toHaveLength(14);
-                        expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
-                            expect.objectContaining({ tipo: css_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_css_1.MetodosTranslacao[index]);
-                    expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosTranslacao[index]]);
-                    // Tradutor
-                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                    // O Tradutor deve serializar de acordo e traduzir translate3d para translacao-3d
-                    if (valIndex !== 8) {
-                        expect(resultadoTradutor).toContain(`translacao-3d(${valoresAceitos[valIndex]});`);
-                    }
-                    else {
-                        expect(resultadoTradutor).toContain(`translacao-3d(0);`);
-                    }
                 }
+                // 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_css_1.MetodosTranslacao[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosTranslacao[index]]);
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                // O Tradutor deve serializar de acordo e traduzir translateZ para translação-eixo-z
+                expect(resultadoTradutor).toContain(`translacao-eixo-z(${valoresAceitos[valIndex]});`);
             }
-        });
-        it('Caso de Falha - Erro ao instanciar classe SeletorValorReverso', () => {
-            for (let index = 0; index < metodos_css_1.MetodosCss.length; index += 1) {
-                const metodoIncorreto = metodos_css_1.MetodosCss[index].replace(metodos_css_1.MetodosCss[index][0], '');
-                expect(() => {
-                    new seletor_valor_reverso_1.SeletorValorReverso(metodoIncorreto, []);
-                }).toThrow(`O valor \'${metodoIncorreto}\' não foi encontrado.`);
+        }
+    });
+    it('Atribuindo Método "translate3d()"', () => {
+        for (let index = 0; index < metodos_css_1.MetodosTranslacao.length; index += 1) {
+            // Lexador
+            const resultadoLexador = lexador.mapear([
+                "div {",
+                `${metodos_css_1.MetodosTranslacao[index]}: translate3d(5ch, 0.4in, 5px);`,
+                "}"
+            ]);
+            // O Lexador não deve encontrar erros
+            expect(resultadoLexador.erros).toHaveLength(0);
+            // O valor recebido deve ser mapeado como METODO
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.METODO }),
+            ]));
+            // O Lexador deve montar um objeto de comprimento 17
+            expect(resultadoLexador.simbolos).toHaveLength(17);
+            expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                expect.objectContaining({ tipo: css_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_css_1.MetodosTranslacao[index]);
+            // Tradutor
+            const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+            // O Tradutor deve serializar de acordo e traduzir translate3d para translação-3d
+            expect(resultadoTradutor).toContain(`translacao-3d(5ch, 0.4in, 5px);`);
+        }
+    });
+    it('Atribuindo Método "translate3d() cobrindo todos os casos"', () => {
+        for (let index = 0; index < metodos_css_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([
+                    "div {",
+                    `${metodos_css_1.MetodosTranslacao[index]}: translate3d(${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: css_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: css_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: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_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: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else if (valIndex === 7) {
+                    expect(resultadoLexador.simbolos).toHaveLength(17);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_1.default.NUMERO }),
+                        expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
+                    ]));
+                }
+                else {
+                    expect(resultadoLexador.simbolos).toHaveLength(14);
+                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ tipo: css_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_css_1.MetodosTranslacao[index]);
+                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosTranslacao[index]]);
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                // O Tradutor deve serializar de acordo e traduzir translate3d para translacao-3d
+                if (valIndex !== 8) {
+                    expect(resultadoTradutor).toContain(`translacao-3d(${valoresAceitos[valIndex]});`);
+                }
+                else {
+                    expect(resultadoTradutor).toContain(`translacao-3d(0);`);
+                }
             }
-        });
+        }
+    });
+    it('Caso de Falha - Erro ao instanciar classe SeletorValorReverso', () => {
+        for (let index = 0; index < metodos_css_1.MetodosCss.length; index += 1) {
+            const metodoIncorreto = metodos_css_1.MetodosCss[index].replace(metodos_css_1.MetodosCss[index][0], '');
+            expect(() => {
+                new seletor_valor_reverso_1.SeletorValorReverso(metodoIncorreto, []);
+            }).toThrow(`O valor \'${metodoIncorreto}\' não foi encontrado.`);
+        }
     });
 });
 //# sourceMappingURL=metodos-reversos.test.js.map