@designliquido/foles 0.9.6 → 0.11.0

package/README.md

@@ -724,4 +724,10 @@ Alguns sites são fundamentais para entender a implementação feita aqui:
 
 - https://sokra.github.io/source-map-visualization/#custom
 - https://evanw.github.io/source-map-visualization
-- https://lachlan-miller.me/articles/decoding-variable-length-quantity-vlq-for-source-maps
+- https://lachlan-miller.me/articles/decoding-variable-length-quantity-vlq-for-source-maps
+
+## Quem já Contribuiu
+
+<a href="https://github.com/DesignLiquido/FolEs/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=DesignLiquido/FolEs" />
+</a>

package/fontes/avaliador-sintatico/avaliador-sintatico-reverso.d.ts

@@ -3,7 +3,9 @@ import { Simbolo } from "../lexador";
 import { ErroAvaliadorSintatico } from "./erro-avaliador-sintatico";
 import { Modificador } from "../modificadores";
 import { Seletor } from "../seletores";
-import { AvaliadorSintaticoInterface, ImportadorInterface } from "../interfaces";
+import { AvaliadorSintaticoInterface, ImportadorInterface, SimboloInterface } from "../interfaces";
+import { Valor } from "../valores/valor";
+import { ValorNumerico } from "../valores";
 /**
  * O avaliador sintático reverso avalia símbolos de arquivos CSS,
  * transformando-os em estruturas de alto nível prontas para
@@ -32,7 +34,8 @@ export declare class AvaliadorSintaticoReverso implements AvaliadorSintaticoInte
     protected resolverSeletores(espacoReservado?: string): Seletor[];
     private resolverCor;
     private resolverMetodo;
-    private valorModificador;
+    protected valorNumerico(nomeModificador: string, valorModificador: SimboloInterface, ponto: boolean): ValorNumerico;
+    protected valoresModificador(nomeModificador: string): Array<Valor>;
     private resolverModificador;
     resolverModificadorEDeclaracoesAninhadas(): {
         modificadores: Modificador[];

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");
@@ -13,6 +12,10 @@ 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");
+const valores_1 = require("../valores");
+const referencia_variavel_1 = require("../valores/referencia-variavel");
+const gerais_1 = require("../modificadores/atributos/gerais");
+const valores_personalizados_1 = require("../../testes/listas/valores-personalizados");
 /**
  * O avaliador sintático reverso avalia símbolos de arquivos CSS,
  * transformando-os em estruturas de alto nível prontas para
@@ -100,14 +103,14 @@ class AvaliadorSintaticoReverso {
                 case css_1.default.TAG:
                     seletores.push(this.seletorPorEstrutura());
                     break;
-                case css_1.default.IDENTIFICADOR:
-                    throw new Error("Não deveria cair aqui.");
                 case css_1.default.PONTO:
                     seletores.push(this.seletorPorNomeDeClasse());
                     break;
                 case css_1.default.CERQUILHA:
                     seletores.push(this.seletorPorId());
                     break;
+                case css_1.default.IDENTIFICADOR:
+                    throw new Error("Não deveria cair aqui.");
             }
         } while (this.simbolos[this.atual].tipo === css_1.default.VIRGULA);
         return seletores;
@@ -135,10 +138,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();
@@ -150,10 +150,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();
@@ -174,7 +171,7 @@ class AvaliadorSintaticoReverso {
                 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":
+            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();
@@ -193,6 +190,7 @@ class AvaliadorSintaticoReverso {
                     valorMax,
                     quantificadorMax,
                 ]);
+            }
             case "contrast":
                 this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'contrast'.");
                 const valorContraste = this.avancarEDevolverAnterior();
@@ -223,21 +221,21 @@ class AvaliadorSintaticoReverso {
                 ]);
             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":
+            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") {
@@ -270,6 +268,7 @@ class AvaliadorSintaticoReverso {
                     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();
@@ -294,7 +293,7 @@ class AvaliadorSintaticoReverso {
                     valorEscala,
                     quantificadorEscala,
                 ]);
-            case "hsl":
+            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();
@@ -307,7 +306,8 @@ class AvaliadorSintaticoReverso {
                     SdeHSL,
                     LdeHSL,
                 ]);
-            case "hsla":
+            }
+            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();
@@ -320,7 +320,8 @@ class AvaliadorSintaticoReverso {
                     SdeHSLA,
                     LdeHSLA,
                 ]);
-            case "hue-rotate":
+            }
+            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;
@@ -330,12 +331,24 @@ class AvaliadorSintaticoReverso {
                 else {
                     quantificadorRotacao = null;
                 }
-                this.consumir(css_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'hue-rotate'.");
+                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, [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.");
+                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, [
-                    valorRotacao,
-                    quantificadorRotacao,
+                    valorScale3d1,
+                    valorScale3d2,
+                    valorScale3d3,
                 ]);
-            case "invert":
+            }
+            case "invert": {
                 this.consumir(css_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'invert'.");
                 const valorInverter = this.avancarEDevolverAnterior();
                 let quantificadorInverter;
@@ -346,10 +359,20 @@ class AvaliadorSintaticoReverso {
                     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,
-                ]);
+                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": {
+                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();
@@ -406,6 +429,101 @@ class AvaliadorSintaticoReverso {
                     cor1,
                     cor2,
                 ]);
+            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();
@@ -436,16 +554,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'.");
@@ -476,6 +588,39 @@ class AvaliadorSintaticoReverso {
                 }
                 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;
@@ -581,6 +726,21 @@ class AvaliadorSintaticoReverso {
                     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();
@@ -746,7 +906,11 @@ class AvaliadorSintaticoReverso {
                     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]);
+                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();
@@ -885,34 +1049,78 @@ 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;
+    valorNumerico(nomeModificador, valorModificador, ponto) {
+        let literalNumero = Number(valorModificador.lexema);
+        if (ponto) {
+            literalNumero = literalNumero / Math.pow(10, valorModificador.lexema.length);
+        }
+        let quantificadorNumero;
+        if (this.verificarTipoSimboloAtual(css_1.default.QUANTIFICADOR)) {
+            const simboloQuantificadorNumero = this.avancarEDevolverAnterior();
+            quantificadorNumero = simboloQuantificadorNumero.lexema;
         }
+        const valorNumerico = new valores_1.ValorNumerico(nomeModificador, literalNumero, quantificadorNumero);
+        return valorNumerico;
+    }
+    valoresModificador(nomeModificador) {
+        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.BARRA:
+                    valoresResolvidos.push(new valores_1.ValorAbreviacao());
+                    break;
+                case css_1.default.CIFRAO:
+                    const nomeVariavel = this.avancarEDevolverAnterior();
+                    const referenciaVariavel = new referencia_variavel_1.ReferenciaVariavel(nomeVariavel.lexema);
+                    valoresResolvidos.push(referenciaVariavel);
+                    break;
+                case css_1.default.METODO:
+                    const metodo = this.resolverMetodo(valorModificador.lexema);
+                    valoresResolvidos.push(metodo);
+                    break;
+                case css_1.default.NUMERO:
+                    const valorNumerico = this.valorNumerico(nomeModificador, valorModificador, false);
+                    valoresResolvidos.push(valorNumerico);
+                    break;
+                case css_1.default.PONTO:
+                    const simboloNumero = this.consumir(css_1.default.NUMERO, "Esperado número após ponto para valor de modificador.");
+                    const valorNumericoComecadoPorPonto = this.valorNumerico(nomeModificador, simboloNumero, true);
+                    valoresResolvidos.push(valorNumericoComecadoPorPonto);
+                    break;
+                case css_1.default.QUALITATIVO:
+                    const valorQualitativo = new valores_1.ValorQualitativo(valorModificador.lexema);
+                    valoresResolvidos.push(valorQualitativo);
+                    break;
+                case css_1.default.TEXTO:
+                    const valorTexto = new valores_1.ValorTexto(valorModificador.lexema);
+                    valoresResolvidos.push(valorTexto);
+                    break;
+                case css_1.default.VIRGULA:
+                    const valorVirgula = new valores_1.ValorVirgula();
+                    valoresResolvidos.push(valorVirgula);
+                    break;
+                default:
+                    if (valorModificador.lexema in gerais_1.valoresGerais) {
+                        valoresResolvidos.push(new valores_1.ValorQualitativo(valorModificador.lexema));
+                        break;
+                    }
+                    if (valores_personalizados_1.ModificadoresValorPersonalizado.includes(nomeModificador)) {
+                        valoresResolvidos.push(new valores_1.ValorQualitativo(valorModificador.lexema));
+                        break;
+                    }
+                    throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(valorModificador, `Modificador ou variável '${nomeModificador}' com valor '${valorModificador.lexema || valorModificador.tipo}' inválido.`);
+            }
+        }
+        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(modificador.lexema);
+        const classeModificadora = new seletor_reverso_modificador_1.SeletorReversoModificador(modificador.lexema, valoresModificador, {
             linha: modificador.linha,
             colunaInicial: modificador.colunaInicial,
             colunaFinal: modificador.colunaFinal,