@designliquido/foles 0.9.5 → 0.10.0

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

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AvaliadorSintaticoReverso = void 0;
 const declaracoes_1 = require("../declaracoes");
-const lexador_1 = require("../lexador");
 const erro_avaliador_sintatico_1 = require("./erro-avaliador-sintatico");
 const seletor_reverso_modificador_1 = require("../modificadores/superclasse/seletor-reverso-modificador");
 const seletor_estruturas_html_1 = require("../estruturas/seletor-estruturas-html");
@@ -119,6 +118,11 @@ class AvaliadorSintaticoReverso {
     // TODO: Implementar lógica para resolver método
     resolverMetodo(lexema) {
         switch (lexema) {
+            case "annotation":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'annotation'.");
+                const valorAnotacao = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método annotation.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorAnotacao]);
             case "blur":
                 this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'blur'.");
                 const valorBorrar = this.avancarEDevolverAnterior();
@@ -130,10 +134,7 @@ class AvaliadorSintaticoReverso {
                     quantificadorBorrar = null;
                 }
                 this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'blur'.");
-                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [
-                    valorBorrar,
-                    quantificadorBorrar,
-                ]);
+                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();
@@ -145,10 +146,7 @@ class AvaliadorSintaticoReverso {
                     quantificadorBrilho = null;
                 }
                 this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'brightness'.");
-                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [
-                    valorBrilho,
-                    quantificadorBrilho,
-                ]);
+                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();
@@ -164,6 +162,31 @@ class AvaliadorSintaticoReverso {
                     valorCalc2,
                     quantificadorCalc2,
                 ]);
+            case "character-variant":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'character-variant'.");
+                const valorVariarCaractere = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método character-variant.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorVariarCaractere]);
+            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 "contrast":
                 this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'contrast'.");
                 const valorContraste = this.avancarEDevolverAnterior();
@@ -179,22 +202,69 @@ class AvaliadorSintaticoReverso {
                     valorContraste,
                     quantificadorContraste,
                 ]);
+            case "counter":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'counter'.");
+                const nomeCounter = this.avancarEDevolverAnterior();
+                let estiloCounter = null;
+                if (this.simbolos[this.atual].tipo === "VIRGULA") {
+                    this.consumir(css_1.default.VIRGULA, "Esperada vírgula após primeiro parâmetro do método 'counter'.");
+                    estiloCounter = this.avancarEDevolverAnterior();
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'counter'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [
+                    nomeCounter,
+                    estiloCounter,
+                ]);
             case "cubic-bezier":
                 this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'cubic-bezier'.");
-                const parametro1 = this.avancarEDevolverAnterior();
+                const parametro1cubic = this.avancarEDevolverAnterior();
                 this.consumir(css_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método cubic-bezier.");
-                const parametro2 = this.avancarEDevolverAnterior();
+                const parametro2cubic = this.avancarEDevolverAnterior();
                 this.consumir(css_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método cubic-bezier.");
-                const parametro3 = this.avancarEDevolverAnterior();
+                const parametro3cubic = this.avancarEDevolverAnterior();
                 this.consumir(css_1.default.VIRGULA, "Esperado vírgula após terceiro argumento do método cubic-bezier.");
-                const parametro4 = this.avancarEDevolverAnterior();
+                const parametro4cubic = 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,
+                    parametro1cubic,
+                    parametro2cubic,
+                    parametro3cubic,
+                    parametro4cubic,
                 ]);
+            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 "fit-content":
                 this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'fit-content'.");
                 const valorFit = this.avancarEDevolverAnterior();
@@ -219,17 +289,48 @@ class AvaliadorSintaticoReverso {
                     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();
+            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 "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 segundo argumento do método scale.");
-                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorScale1, valorScale2], true);
-            case "scale3d":
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorRotacao, quantificadorRotacao]);
+            }
+            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.");
@@ -242,21 +343,32 @@ class AvaliadorSintaticoReverso {
                     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":
+            }
+            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 "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":
+            }
+            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();
@@ -313,33 +425,7 @@ class AvaliadorSintaticoReverso {
                     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":
+            case "skew": {
                 this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'skew'.");
                 const valorInclinar1 = this.avancarEDevolverAnterior();
                 let quantificadorInclinar1;
@@ -367,7 +453,8 @@ class AvaliadorSintaticoReverso {
                     valorInclinar2,
                     quantificadorInclinar2,
                 ]);
-            case "skewX":
+            }
+            case "skewX": {
                 this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'skewX'.");
                 const valorInclinarX = this.avancarEDevolverAnterior();
                 let quantificadorInclinarX;
@@ -382,7 +469,8 @@ class AvaliadorSintaticoReverso {
                     valorInclinarX,
                     quantificadorInclinarX,
                 ]);
-            case "skewY":
+            }
+            case "skewY": {
                 this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'skewY'.");
                 const valorInclinarY = this.avancarEDevolverAnterior();
                 let quantificadorInclinarY;
@@ -397,6 +485,7 @@ class AvaliadorSintaticoReverso {
                     valorInclinarY,
                     quantificadorInclinarY,
                 ]);
+            }
             case "invert":
                 this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'invert'.");
                 const valorInverter = this.avancarEDevolverAnterior();
@@ -461,16 +550,10 @@ class AvaliadorSintaticoReverso {
                 }
                 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"],
-                    ]);
+                    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,
-                    ]);
+                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'.");
@@ -484,16 +567,11 @@ class AvaliadorSintaticoReverso {
                 }
                 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 "ornaments":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'ornaments'.");
+                const valorOrnaments = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método ornaments.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorOrnaments]);
             case "perspective":
                 this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'perspective'.");
                 const valorPerspectivar = this.avancarEDevolverAnterior();
@@ -590,6 +668,30 @@ class AvaliadorSintaticoReverso {
                 }
                 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 "rotate3d":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotate3d'.");
+                const valor1Rotacionar3d = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperada vírgula após primeiro parâmetro do método 'rotate3d'.");
+                const valor2Rotacionar3d = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperada vírgula após segundo parâmetro do método 'rotate3d'.");
+                const valor3Rotacionar3d = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.VIRGULA, "Esperada vírgula após terceiro parâmetro do método 'rotate3d'.");
+                const valor4Rotacionar3d = this.avancarEDevolverAnterior();
+                let quantificadorRotacionar3d;
+                if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
+                    quantificadorRotacionar3d = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorRotacionar3d = null;
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotate3d'.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [
+                    valor1Rotacionar3d,
+                    valor2Rotacionar3d,
+                    valor3Rotacionar3d,
+                    valor4Rotacionar3d,
+                    quantificadorRotacionar3d,
+                ]);
             case "rotateZ":
                 this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotateZ'.");
                 const valorRotacionarZ = this.avancarEDevolverAnterior();
@@ -665,6 +767,44 @@ class AvaliadorSintaticoReverso {
                     valorSaturar,
                     quantificadorSaturar,
                 ]);
+            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 "sepia":
                 this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'sepia'.");
                 const valorSepia = this.avancarEDevolverAnterior();
@@ -680,6 +820,103 @@ class AvaliadorSintaticoReverso {
                     valorSepia,
                     quantificadorSepia,
                 ]);
+            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 "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 "styleset":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'styleset'.");
+                const valor1ConjuntoEstilos = this.avancarEDevolverAnterior();
+                let valor2ConjuntoEstilos;
+                if (this.simbolos[this.atual].tipo === "VIRGULA") {
+                    this.consumir(css_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método styleset.");
+                    valor2ConjuntoEstilos = this.avancarEDevolverAnterior();
+                }
+                let valor3ConjuntoEstilos;
+                if (this.simbolos[this.atual].tipo === "VIRGULA") {
+                    this.consumir(css_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método styleset.");
+                    valor3ConjuntoEstilos = this.avancarEDevolverAnterior();
+                }
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método styleset.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [
+                    valor1ConjuntoEstilos,
+                    valor2ConjuntoEstilos,
+                    valor3ConjuntoEstilos
+                ]);
+            case "stylistic":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'stylistic'.");
+                const valorEstilistico = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método stylistic.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorEstilistico]);
+            case "swash":
+                this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'swash'.");
+                const valorEspirrar = this.avancarEDevolverAnterior();
+                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método swash.");
+                return new seletor_valor_reverso_1.SeletorValorReverso(lexema, [valorEspirrar]);
             case "translate":
                 this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translate'.");
                 const valorTranslacao1 = this.avancarEDevolverAnterior();
@@ -808,34 +1045,34 @@ class AvaliadorSintaticoReverso {
                 ]);
         }
     }
-    valorModificador() {
-        const valorModificador = this.avancarEDevolverAnterior();
-        switch (valorModificador.tipo) {
-            case css_1.default.CERQUILHA:
-                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;
+    valoresModificador() {
+        const valoresResolvidos = [];
+        while (this.atual < this.simbolos.length &&
+            this.simbolos[this.atual].tipo !== css_1.default.PONTO_E_VIRGULA) {
+            const valorModificador = this.avancarEDevolverAnterior();
+            switch (valorModificador.tipo) {
+                case css_1.default.CERQUILHA:
+                    valoresResolvidos.push(this.resolverCor());
+                    break;
+                case css_1.default.METODO:
+                    valoresResolvidos.push(this.resolverMetodo(valorModificador.lexema));
+                    break;
+                case css_1.default.IDENTIFICADOR:
+                    valoresResolvidos.push(this.resolverMetodo(valorModificador.lexema));
+                    break;
+                default:
+                    valoresResolvidos.push(valorModificador);
+                    break;
+            }
         }
+        this.consumir(css_1.default.PONTO_E_VIRGULA, "Esperado ponto-e-vírgula após declaração de valores de modificador.");
+        return valoresResolvidos;
     }
     resolverModificador() {
         const modificador = this.consumir(css_1.default.IDENTIFICADOR, "Esperado nome do atributo de identificação.");
-        this.consumir(css_1.default.DOIS_PONTOS, `Esperado ':' após declaração de modificador '${modificador.lexema}'.`);
-        const valorModificador = this.valorModificador();
-        let quantificador;
-        if (valorModificador instanceof lexador_1.Simbolo &&
-            valorModificador.tipo === css_1.default.NUMERO) {
-            quantificador = this.avancarEDevolverAnterior();
-        }
-        this.consumir(css_1.default.PONTO_E_VIRGULA, `Esperado ';' após declaração de valor de modificador '${modificador.lexema}'.`);
-        const classeModificadora = new seletor_reverso_modificador_1.SeletorReversoModificador(modificador.lexema, valorModificador instanceof lexador_1.Simbolo
-            ? valorModificador.lexema
-            : valorModificador, quantificador && quantificador.hasOwnProperty("lexema")
-            ? quantificador.lexema
-            : quantificador, {
+        this.consumir(css_1.default.DOIS_PONTOS, `Esperado ':' após declaração de Modificador ou variável '${modificador.lexema}'.`);
+        const valoresModificador = this.valoresModificador();
+        const classeModificadora = new seletor_reverso_modificador_1.SeletorReversoModificador(modificador.lexema, valoresModificador, {
             linha: modificador.linha,
             colunaInicial: modificador.colunaInicial,
             colunaFinal: modificador.colunaFinal,