@designliquido/foles 0.8.0 → 0.8.2

package/fontes/avaliador-sintatico/avaliador-sintatico-reverso.js

@@ -12,6 +12,7 @@ const seletor_estruturas_html_1 = require("../estruturas/seletor-estruturas-html
 const css_1 = __importDefault(require("../tipos-de-simbolos/css"));
 const seletores_1 = require("../seletores");
 const hexadecimal_cor_1 = require("../valores/metodos/foles/hexadecimal-cor");
+const seletor_valor_reverso_1 = require("../valores/seletor-valor-reverso");
 /**
  * O avaliador sintático reverso avalia símbolos de arquivos CSS,
  * transformando-os em estruturas de alto nível prontas para
@@ -129,7 +130,7 @@ class AvaliadorSintaticoReverso {
                     quantificadorBorrar = null;
                 }
                 this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'blur'.");
-                return new seletor_reverso_modificador_1.SeletorReversoModificador(lexema, valorBorrar, quantificadorBorrar.length !== 0 ? quantificadorBorrar : null);
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorBorrar, quantificadorBorrar]);
             case "brightness":
                 this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'brightness'.");
                 const valorBrilho = this.avancarEDevolverAnterior();
@@ -141,7 +142,536 @@ class AvaliadorSintaticoReverso {
                     quantificadorBrilho = null;
                 }
                 this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'brightness'.");
-                return new seletor_reverso_modificador_1.SeletorReversoModificador(lexema, valorBrilho, quantificadorBrilho.length !== 0 ? quantificadorBrilho : null);
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorBrilho, quantificadorBrilho]);
+            case "calc":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'calc'.");
+                const valorCalc1 = this.avancarEDevolverAnterior();
+                const quantificadorCalc1 = this.avancarEDevolverAnterior();
+                const operadorCalc = this.avancarEDevolverAnterior();
+                const valorCalc2 = this.avancarEDevolverAnterior();
+                const quantificadorCalc2 = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'calc'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorCalc1, quantificadorCalc1, operadorCalc, valorCalc2, quantificadorCalc2]);
+            case "contrast":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'contrast'.");
+                const valorContraste = this.avancarEDevolverAnterior();
+                let quantificadorContraste;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorContraste = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorContraste = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'contrast'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorContraste, quantificadorContraste]);
+            case "cubic-bezier":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'cubic-bezier'.");
+                const parametro1 = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método cubic-bezier.");
+                const parametro2 = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método cubic-bezier.");
+                const parametro3 = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após terceiro argumento do método cubic-bezier.");
+                const parametro4 = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após quarto argumento do método curva-cúbica.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [parametro1, parametro2, parametro3, parametro4]);
+            case "fit-content":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'fit-content'.");
+                const valorFit = this.avancarEDevolverAnterior();
+                const quantificadorFit = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método fit-content.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorFit['lexema'], quantificadorFit['lexema']]);
+            case "grayscale":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'grayscale'.");
+                const valorEscala = this.avancarEDevolverAnterior();
+                let quantificadorEscala;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorEscala = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorEscala = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'grayscale'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorEscala, quantificadorEscala]);
+            case "scale":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'scale'.");
+                const valorScale1 = this.avancarEDevolverAnterior();
+                let valorScale2;
+                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                    this.consumir(css_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método scale.");
+                    valorScale2 = this.avancarEDevolverAnterior();
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método scale.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorScale1, valorScale2], true);
+            case "scale3d":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'scale3d'.");
+                const valorScale3d1 = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método scale3d.");
+                const valorScale3d2 = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método scale3d.");
+                const valorScale3d3 = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método scale3d.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorScale3d1, valorScale3d2, valorScale3d3]);
+            case "scaleZ":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'scaleZ'.");
+                const valorScaleZ = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método scaleZ.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorScaleZ]);
+            case "scaleX":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'scaleX'.");
+                const valorScaleX = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método scaleX.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorScaleX]);
+            case "scaleY":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'scaleY'.");
+                const valorScaleY = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método scaleY.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorScaleY]);
+            case "linear-gradient":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'linear-gradient'.");
+                const valorAngulo = this.avancarEDevolverAnterior();
+                let quantificadorAngulo;
+                if (valorAngulo.tipo === 'QUALITATIVO') {
+                    switch (valorAngulo.lexema) {
+                        case 'superior':
+                            valorAngulo.lexema = '0';
+                            valorAngulo.tipo = 'NUMERO';
+                            quantificadorAngulo = {
+                                tipo: 'QUANTIFICADOR',
+                                lexema: 'deg',
+                            };
+                            break;
+                        case 'direita':
+                            valorAngulo.lexema = '90';
+                            valorAngulo.tipo = 'NUMERO';
+                            quantificadorAngulo = {
+                                tipo: 'QUANTIFICADOR',
+                                lexema: 'deg',
+                            };
+                            break;
+                        case 'inferior':
+                            valorAngulo.lexema = '180';
+                            valorAngulo.tipo = 'NUMERO';
+                            quantificadorAngulo = {
+                                tipo: 'QUANTIFICADOR',
+                                lexema: 'deg',
+                            };
+                            break;
+                        case 'esquerda':
+                            valorAngulo.lexema = '270';
+                            valorAngulo.tipo = 'NUMERO';
+                            quantificadorAngulo = {
+                                tipo: 'QUANTIFICADOR',
+                                lexema: 'deg',
+                            };
+                            break;
+                        default:
+                            break;
+                    }
+                }
+                else {
+                    quantificadorAngulo = this.avancarEDevolverAnterior();
+                }
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método linear-gradient.");
+                const cor1 = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método linear-gradient.");
+                const cor2 = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'linear-gradient'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorAngulo, quantificadorAngulo, cor1, cor2]);
+            case "hsl":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'hsl'.");
+                const HdeHSL = this.avancarEDevolverAnterior();
+                const SdeHSL = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.QUANTIFICADOR, "Esperado símbolo percentual após argumento de saturação (S) no método 'hsl'.");
+                const LdeHSL = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.QUANTIFICADOR, "Esperado símbolo percentual após argumento de luminosidade (L) no método 'hsl'.");
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'hsl'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [HdeHSL, SdeHSL, LdeHSL]);
+            case "hsla":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'hsla'.");
+                const HdeHSLA = this.avancarEDevolverAnterior();
+                const SdeHSLA = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.QUANTIFICADOR, "Esperado símbolo percentual após argumento de saturação (S) no método 'hsla'.");
+                const LdeHSLA = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.QUANTIFICADOR, "Esperado símbolo percentual após argumento de luminosidade (L) no método 'hsla'.");
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumentos de método 'hsla'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [HdeHSLA, SdeHSLA, LdeHSLA]);
+            case "skew":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'skew'.");
+                const valorInclinar1 = this.avancarEDevolverAnterior();
+                let quantificadorInclinar1;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorInclinar1 = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorInclinar1 = null;
+                }
+                let valorInclinar2;
+                let quantificadorInclinar2;
+                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                    this.consumir(css_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'skew'.");
+                    valorInclinar2 = this.avancarEDevolverAnterior();
+                    quantificadorInclinar2 = this.avancarEDevolverAnterior();
+                }
+                else {
+                    valorInclinar2 = null;
+                    quantificadorInclinar2 = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'skew'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorInclinar1, quantificadorInclinar1, valorInclinar2, quantificadorInclinar2]);
+            case "skewX":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'skewX'.");
+                const valorInclinarX = this.avancarEDevolverAnterior();
+                let quantificadorInclinarX;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorInclinarX = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorInclinarX = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'skewX'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorInclinarX, quantificadorInclinarX]);
+            case "skewY":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'skewY'.");
+                const valorInclinarY = this.avancarEDevolverAnterior();
+                let quantificadorInclinarY;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorInclinarY = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorInclinarY = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'skewY'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorInclinarY, quantificadorInclinarY]);
+            case "invert":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'invert'.");
+                const valorInverter = this.avancarEDevolverAnterior();
+                let quantificadorInverter;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorInverter = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorInverter = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'invert'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorInverter, quantificadorInverter]);
+            case "clamp":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'clamp'.");
+                const valorMin = this.avancarEDevolverAnterior();
+                const quantificadorMin = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'clamp'.");
+                const valorMed = this.avancarEDevolverAnterior();
+                const quantificadorMed = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método 'clamp'.");
+                const valorMax = this.avancarEDevolverAnterior();
+                const quantificadorMax = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método clamp.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorMin, quantificadorMin, valorMed, quantificadorMed, valorMax, quantificadorMax]);
+            case "linear":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'linear'.");
+                const valor1 = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método linear.");
+                const valor2 = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método linear.");
+                const valor3 = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após terceiro argumento do método linear.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valor1, valor2, valor3]);
+            case "minmax":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'minmax'.");
+                const valor01 = this.avancarEDevolverAnterior();
+                let parametro01 = null;
+                if (Number(valor01['lexema'])) {
+                    const quantificador01 = this.avancarEDevolverAnterior();
+                    parametro01 = `${valor01['lexema']}${quantificador01['lexema']}`;
+                }
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método minmax.");
+                const valor02 = this.avancarEDevolverAnterior();
+                let parametro02 = null;
+                if (Number(valor02['lexema'])) {
+                    const quantificador02 = this.avancarEDevolverAnterior();
+                    parametro02 = `${valor02['lexema']}${quantificador02['lexema']}`;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método minmax.");
+                if (parametro01 !== null) {
+                    return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [parametro01, valor02['lexema']]);
+                }
+                else if (parametro02 !== null) {
+                    return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valor01['lexema'], parametro02]);
+                }
+            case "opacity":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'opacity'.");
+                const valorOpaco = this.avancarEDevolverAnterior();
+                let quantificadorOpaco;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorOpaco = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorOpaco = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'opacity'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorOpaco, quantificadorOpaco], true);
+            case "steps":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'steps'.");
+                const valorNumerico = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método steps.");
+                const termoSalto = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método steps.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorNumerico, termoSalto]);
+            case "perspective":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'perspective'.");
+                const valorPerspectivar = this.avancarEDevolverAnterior();
+                let quantificadorPerspectivar;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorPerspectivar = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorPerspectivar = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'perspective'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorPerspectivar, quantificadorPerspectivar], true);
+            case "drop-shadow":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'drop-shadow'.");
+                let corSombra = null;
+                if (this.simbolos[this.atual].tipo === 'QUALITATIVO') {
+                    corSombra = this.avancarEDevolverAnterior();
+                }
+                const valorSombra1 = this.avancarEDevolverAnterior();
+                const quantificadorSombra1 = this.avancarEDevolverAnterior();
+                const valorSombra2 = this.avancarEDevolverAnterior();
+                const quantificadorSombra2 = this.avancarEDevolverAnterior();
+                let valorSombra3;
+                let quantificadorSombra3;
+                if (this.simbolos[this.atual].tipo === 'NUMERO') {
+                    valorSombra3 = this.avancarEDevolverAnterior();
+                    quantificadorSombra3 = this.avancarEDevolverAnterior();
+                }
+                else {
+                    valorSombra3 = null;
+                    quantificadorSombra3 = null;
+                }
+                if (this.simbolos[this.atual].tipo === 'QUALITATIVO') {
+                    corSombra = this.avancarEDevolverAnterior();
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'drop-shadow'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorSombra1, quantificadorSombra1, valorSombra2, quantificadorSombra2, valorSombra3, quantificadorSombra3, corSombra]);
+            case "ray":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'ray'.");
+                let posicaoRaio;
+                if (this.simbolos[this.atual].tipo === 'QUALITATIVO') {
+                    posicaoRaio = this.avancarEDevolverAnterior();
+                }
+                else {
+                    posicaoRaio = null;
+                }
+                const numeroRaio = this.avancarEDevolverAnterior();
+                const quantificadorRaio = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumentos de método 'ray'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [posicaoRaio, numeroRaio, quantificadorRaio]);
+            case "rgb":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rgb'.");
+                const vermelho = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após argumento de cor vermelha.");
+                const verde = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após argumento de cor verde.");
+                const azul = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumentos de método 'rgb'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [vermelho, verde, azul]);
+            case "rgba":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rgba'.");
+                const vermelhoRgba = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após argumento de cor vermelha.");
+                const verdeRgba = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperado vírgula após argumento de cor verde.");
+                const azulRgba = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumentos de método 'rgba'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [vermelhoRgba, verdeRgba, azulRgba]);
+            case "rotate":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotate'.");
+                const valorRotacionar = this.avancarEDevolverAnterior();
+                let quantificadorRotacionar;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorRotacionar = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorRotacionar = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotate'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorRotacionar, quantificadorRotacionar], true);
+            case "rotateZ":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotateZ'.");
+                const valorRotacionarZ = this.avancarEDevolverAnterior();
+                let quantificadorRotacionarZ;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorRotacionarZ = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorRotacionarZ = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotateZ'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorRotacionarZ, quantificadorRotacionarZ]);
+            case "rotateX":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotateX'.");
+                const valorRotacionarX = this.avancarEDevolverAnterior();
+                let quantificadorRotacionarX;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorRotacionarX = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorRotacionarX = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotateX'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorRotacionarX, quantificadorRotacionarX]);
+            case "hue-rotate":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'hue-rotate'.");
+                const valorRotacao = this.avancarEDevolverAnterior();
+                let quantificadorRotacao;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorRotacao = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorRotacao = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'hue-rotate'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorRotacao, quantificadorRotacao]);
+            case "rotateY":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotateY'.");
+                const valorRotacionarY = this.avancarEDevolverAnterior();
+                let quantificadorRotacionarY;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorRotacionarY = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorRotacionarY = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotateY'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorRotacionarY, quantificadorRotacionarY]);
+            case "saturate":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'saturate'.");
+                const valorSaturar = this.avancarEDevolverAnterior();
+                let quantificadorSaturar;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorSaturar = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorSaturar = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'saturate'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorSaturar, quantificadorSaturar]);
+            case "sepia":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'sepia'.");
+                const valorSepia = this.avancarEDevolverAnterior();
+                let quantificadorSepia;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorSepia = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorSepia = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'sepia'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorSepia, quantificadorSepia]);
+            case "translate":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translate'.");
+                const valorTranslacao1 = this.avancarEDevolverAnterior();
+                let quantificadorTranlacao1;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorTranlacao1 = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorTranlacao1 = null;
+                }
+                let valorTranslacao2;
+                let quantificadorTranlacao2;
+                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                    this.consumir(css_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'translate'.");
+                    valorTranslacao2 = this.avancarEDevolverAnterior();
+                    quantificadorTranlacao2 = this.avancarEDevolverAnterior();
+                }
+                else {
+                    valorTranslacao2 = null;
+                    quantificadorTranlacao2 = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorTranslacao1, quantificadorTranlacao1, valorTranslacao2, quantificadorTranlacao2], true);
+            case "translate3d":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translate3d'.");
+                const valorTranslacao3d1 = this.avancarEDevolverAnterior();
+                let quantificadorTranlacao3d1;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorTranlacao3d1 = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorTranlacao3d1 = null;
+                }
+                let valorTranslacao3d2;
+                let quantificadorTranlacao3d2;
+                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                    this.consumir(css_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'translate3d'.");
+                    valorTranslacao3d2 = this.avancarEDevolverAnterior();
+                    if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                        quantificadorTranlacao3d2 = this.avancarEDevolverAnterior();
+                    }
+                    else {
+                        quantificadorTranlacao3d2 = null;
+                    }
+                }
+                else {
+                    valorTranslacao3d2 = null;
+                    quantificadorTranlacao3d2 = null;
+                }
+                let valorTranslacao3d3;
+                let quantificadorTranlacao3d3;
+                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                    this.consumir(css_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'translate3d'.");
+                    valorTranslacao3d3 = this.avancarEDevolverAnterior();
+                    if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                        quantificadorTranlacao3d3 = this.avancarEDevolverAnterior();
+                    }
+                    else {
+                        quantificadorTranlacao3d3 = null;
+                    }
+                }
+                else {
+                    valorTranslacao3d3 = null;
+                    quantificadorTranlacao3d3 = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translate3d'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorTranslacao3d1, quantificadorTranlacao3d1, valorTranslacao3d2, quantificadorTranlacao3d2, valorTranslacao3d3, quantificadorTranlacao3d3]);
+            case "translateX":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translateX'.");
+                const valorTranslaçaoX = this.avancarEDevolverAnterior();
+                let quantificadorTranslaçaoX;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorTranslaçaoX = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorTranslaçaoX = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translateX'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorTranslaçaoX, quantificadorTranslaçaoX]);
+            case "translateY":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translateY'.");
+                const valorTranslaçaoY = this.avancarEDevolverAnterior();
+                let quantificadorTranslaçaoY;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorTranslaçaoY = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorTranslaçaoY = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translateY'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorTranslaçaoY, quantificadorTranslaçaoY]);
+            case "translateZ":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translateZ'.");
+                const valorTranslaçaoZ = this.avancarEDevolverAnterior();
+                let quantificadorTranslaçaoZ;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorTranslaçaoZ = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorTranslaçaoZ = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translateZ'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorTranslaçaoZ, quantificadorTranslaçaoZ]);
         }
     }
     valorModificador() {
@@ -151,6 +681,8 @@ class AvaliadorSintaticoReverso {
                 return this.resolverCor();
             case css_1.default.METODO:
                 return this.resolverMetodo(valorModificador.lexema);
+            case css_1.default.IDENTIFICADOR:
+                return this.resolverMetodo(valorModificador.lexema);
             default:
                 return valorModificador;
         }