@designliquido/foles 0.9.4 → 0.9.6

package/execucao.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
 const exportador_1 = require("./fontes/exportador");
 const foles_1 = require("./fontes/foles");
-const commander_1 = require("commander");
 const principal = () => {
     const analisadorArgumentos = new commander_1.Command();
     let nomeArquivo;
@@ -10,8 +10,9 @@ const principal = () => {
         .helpOption('-?, --ajuda', 'Exibe a ajuda para o comando.')
         .argument('[arquivos...]', 'Nomes dos arquivos (opcional)')
         .option('-a, --aninhamento', 'Gera CSS com aninhamento. Não recomendado usar se o CSS executar em navegadores antigos.', false)
-        .option('-m, --mapas', 'Gera CSS com mapas de fontes.', true)
         .option('-c, --console', 'Escreve a saída da tradução em console.', null)
+        .option('-m, --mapas', 'Gera CSS com mapas de fontes.', true)
+        .option('-v, --versao', 'Imprime o número da versão atual de FolEs', false)
         .action((arquivos) => {
         if (arquivos.length > 0) {
             nomeArquivo = arquivos[0];
@@ -19,6 +20,12 @@ const principal = () => {
     });
     analisadorArgumentos.parse();
     const opcoes = analisadorArgumentos.opts();
+    if (opcoes.versao) {
+        const informacoesPacote = require('./package.json');
+        const versao = informacoesPacote.version;
+        console.log(versao);
+        return;
+    }
     if (!nomeArquivo) {
         console.error('Favor informar nome do arquivo a ser traduzido.');
         process.exit(70);

package/execucao.js.map

@@ -1 +1 @@
-{"version":3,"file":"execucao.js","sourceRoot":"","sources":["../execucao.ts"],"names":[],"mappings":";;AAAA,oDAAiD;AACjD,0CAAuC;AACvC,yCAAoC;AAEpC,MAAM,SAAS,GAAG,GAAG,EAAE;IACnB,MAAM,oBAAoB,GAAG,IAAI,mBAAO,EAAE,CAAC;IAC3C,IAAI,WAAmB,CAAC;IAExB,oBAAoB;SACf,UAAU,CAAC,aAAa,EAAE,+BAA+B,CAAC;SAC1D,QAAQ,CAAC,eAAe,EAAE,+BAA+B,CAAC;SAC1D,MAAM,CACH,mBAAmB,EACnB,0FAA0F,EAC1F,KAAK,CACR;SACA,MAAM,CACH,aAAa,EACb,+BAA+B,EAC/B,IAAI,CACP;SACA,MAAM,CACH,eAAe,EACf,yCAAyC,EACzC,IAAI,CACP;SACA,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE;QACjB,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtB,WAAW,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;QAC9B,CAAC;IACL,CAAC,CAAC,CAAC;IAEP,oBAAoB,CAAC,KAAK,EAAE,CAAC;IAC7B,MAAM,MAAM,GAAG,oBAAoB,CAAC,IAAI,EAAE,CAAC;IAE3C,IAAI,CAAC,WAAW,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,iDAAiD,CAAC,CAAC;QACjE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACrB,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,aAAK,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAC5C,IAAI,iBAAyB,CAAC;IAE9B,IAAI,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QAChC,iBAAiB,GAAG,KAAK,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC;IAC5D,CAAC;SAAM,IAAI,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACrC,iBAAiB,GAAG,KAAK,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC;IAC9D,CAAC;SAAM,CAAC;QACJ,OAAO,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACrD,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACrB,CAAC;IAED,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACjB,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;QAC/B,OAAO;IACX,CAAC;IAED,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;QACf,MAAM,cAAc,GAAG,KAAK,CAAC,wBAAwB,CAAC,WAAW,CAAC,CAAC;QACnE,MAAM,UAAU,GAAG,IAAI,uBAAU,EAAE,CAAC;QACpC,IAAI,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAChC,UAAU,CAAC,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;QAClF,CAAC;aAAM,CAAC;YACJ,UAAU,CAAC,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;QACpF,CAAC;IACL,CAAC;AACL,CAAC,CAAA;AAED,SAAS,EAAE,CAAC"}
+{"version":3,"file":"execucao.js","sourceRoot":"","sources":["../execucao.ts"],"names":[],"mappings":";;AAAA,yCAAoC;AAEpC,oDAAiD;AACjD,0CAAuC;AAEvC,MAAM,SAAS,GAAG,GAAG,EAAE;IACnB,MAAM,oBAAoB,GAAG,IAAI,mBAAO,EAAE,CAAC;IAC3C,IAAI,WAAmB,CAAC;IAExB,oBAAoB;SACf,UAAU,CAAC,aAAa,EAAE,+BAA+B,CAAC;SAC1D,QAAQ,CAAC,eAAe,EAAE,+BAA+B,CAAC;SAC1D,MAAM,CACH,mBAAmB,EACnB,0FAA0F,EAC1F,KAAK,CACR;SACA,MAAM,CACH,eAAe,EACf,yCAAyC,EACzC,IAAI,CACP;SACA,MAAM,CACH,aAAa,EACb,+BAA+B,EAC/B,IAAI,CACP;SACA,MAAM,CACH,cAAc,EACd,2CAA2C,EAC3C,KAAK,CACR;SACA,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE;QACjB,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtB,WAAW,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;QAC9B,CAAC;IACL,CAAC,CAAC,CAAC;IAEP,oBAAoB,CAAC,KAAK,EAAE,CAAC;IAC7B,MAAM,MAAM,GAAG,oBAAoB,CAAC,IAAI,EAAE,CAAC;IAE3C,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;QAChB,MAAM,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;QACpD,MAAM,MAAM,GAAG,iBAAiB,CAAC,OAAO,CAAC;QACzC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACpB,OAAO;IACX,CAAC;IAED,IAAI,CAAC,WAAW,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,iDAAiD,CAAC,CAAC;QACjE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACrB,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,aAAK,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAC5C,IAAI,iBAAyB,CAAC;IAE9B,IAAI,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QAChC,iBAAiB,GAAG,KAAK,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC;IAC5D,CAAC;SAAM,IAAI,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACrC,iBAAiB,GAAG,KAAK,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC;IAC9D,CAAC;SAAM,CAAC;QACJ,OAAO,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACrD,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACrB,CAAC;IAED,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACjB,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;QAC/B,OAAO;IACX,CAAC;IAED,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;QACf,MAAM,cAAc,GAAG,KAAK,CAAC,wBAAwB,CAAC,WAAW,CAAC,CAAC;QACnE,MAAM,UAAU,GAAG,IAAI,uBAAU,EAAE,CAAC;QACpC,IAAI,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAChC,UAAU,CAAC,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;QAClF,CAAC;aAAM,CAAC;YACJ,UAAU,CAAC,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;QACpF,CAAC;IACL,CAAC;AACL,CAAC,CAAA;AAED,SAAS,EAAE,CAAC"}

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

@@ -119,6 +119,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();
@@ -164,6 +169,30 @@ 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,6 +208,19 @@ 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();
@@ -195,6 +237,39 @@ class AvaliadorSintaticoReverso {
                     parametro3,
                     parametro4,
                 ]);
+            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,44 +294,62 @@ 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();
                 }
-                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.");
+                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, [
-                    valorScale3d1,
-                    valorScale3d2,
-                    valorScale3d3,
+                    valorRotacao,
+                    quantificadorRotacao,
+                ]);
+            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 "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();
@@ -313,124 +406,6 @@ 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":
-                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();
@@ -484,16 +459,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();
@@ -506,39 +476,6 @@ 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;
@@ -590,6 +527,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();
@@ -620,21 +581,6 @@ 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();
@@ -665,6 +611,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 +664,99 @@ 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();