@designliquido/foles 0.6.2 → 0.7.0

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

@@ -50,6 +50,30 @@ class AvaliadorSintatico {
             case "#":
                 const codigoHEX = this.consumir(foles_1.default.IDENTIFICADOR, "Esperado código HEX válido após #'.");
                 return new seletor_valor_1.SeletorValor('hex', [codigoHEX.lexema]);
+            case "borrar":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'borrar'.");
+                const valorBorrar = this.avancarEDevolverAnterior();
+                let quantificadorBorrar;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorBorrar = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorBorrar = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'borrar'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorBorrar, quantificadorBorrar]);
+            case "brilho":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'brilho'.");
+                const valorBrilho = this.avancarEDevolverAnterior();
+                let quantificadorBrilho;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorBrilho = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorBrilho = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'brilho'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorBrilho, quantificadorBrilho]);
             case "calcular":
                 this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'calcular'.");
                 const valorCalc1 = this.avancarEDevolverAnterior();
@@ -71,23 +95,86 @@ class AvaliadorSintatico {
                 }
                 this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'contraste'.");
                 return new seletor_valor_1.SeletorValor(lexema, [valorContraste, quantificadorContraste]);
-            case "curva-cúbica" || "curva-cubica":
-                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'cubic-bezier'.");
+            case "curva-cúbica":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'curva-cúbica'.");
                 const parametro1 = this.avancarEDevolverAnterior();
-                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método cubic-bezier.");
+                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método curva-cúbica.");
                 const parametro2 = this.avancarEDevolverAnterior();
-                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método cubic-bezier.");
+                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método curva-cúbica.");
                 const parametro3 = this.avancarEDevolverAnterior();
-                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após terceiro argumento do método cubic-bezier.");
+                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após terceiro argumento do método curva-cúbica.");
                 const parametro4 = this.avancarEDevolverAnterior();
-                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após quarto argumento do método cubic-bezier.");
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após quarto argumento do método curva-cúbica.");
                 return new seletor_valor_1.SeletorValor(lexema, [parametro1, parametro2, parametro3, parametro4]);
-            case "encaixar-conteúdo" || "encaixar-conteudo":
+            case "curva-cubica":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'curva-cúbica'.");
+                const parametro1cc = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método curva-cúbica.");
+                const parametro2cc = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método curva-cúbica.");
+                const parametro3cc = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após terceiro argumento do método curva-cúbica.");
+                const parametro4cc = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após quarto argumento do método curva-cúbica.");
+                return new seletor_valor_1.SeletorValor(lexema, [parametro1cc, parametro2cc, parametro3cc, parametro4cc]);
+            case "encaixar-conteudo":
                 this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'encaixar-conteúdo'.");
                 const valorFit = this.avancarEDevolverAnterior();
                 const quantificadorFit = this.avancarEDevolverAnterior();
                 this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método encaixar-conteúdo.");
                 return new seletor_valor_1.SeletorValor(lexema, [valorFit['lexema'], quantificadorFit['lexema']]);
+            case "encaixar-conteúdo":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'encaixar-conteúdo'.");
+                const valorFit1 = this.avancarEDevolverAnterior();
+                const quantificadorFit1 = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método encaixar-conteúdo.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorFit1['lexema'], quantificadorFit1['lexema']]);
+            case "escala-cinza":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'escala-cinza'.");
+                const valorEscala = this.avancarEDevolverAnterior();
+                let quantificadorEscala;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorEscala = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorEscala = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'escala-cinza'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorEscala, quantificadorEscala]);
+            case "escalamento":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'escalamento'.");
+                const valorScale1 = this.avancarEDevolverAnterior();
+                let valorScale2;
+                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                    this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método escalamento.");
+                    valorScale2 = this.avancarEDevolverAnterior();
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método escalamento.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorScale1, valorScale2]);
+            case "escalamento-3d":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'escalamento-3d'.");
+                const valorScale3d1 = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método escalamento-3d.");
+                const valorScale3d2 = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método escalamento-3d.");
+                const valorScale3d3 = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método escalamento-3d.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorScale3d1, valorScale3d2, valorScale3d3]);
+            case "escalamento-eixo-z":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'escalamento-eixo-z'.");
+                const valorScaleZ = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método escalamento-eixo-z.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorScaleZ]);
+            case "escalamento-horizontal":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'escalamento-horizontal'.");
+                const valorScaleX = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método escalamento-horizontal.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorScaleX]);
+            case "escalamento-vertical":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'escalamento-vertical'.");
+                const valorScaleY = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método escalamento-vertical.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorScaleY]);
             case "gradiente-linear":
                 this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'gradiente-linear'.");
                 const valorAngulo = this.avancarEDevolverAnterior();
@@ -161,24 +248,65 @@ class AvaliadorSintatico {
                 this.consumir(foles_1.default.QUANTIFICADOR, "Esperado símbolo percentual após argumento de luminosidade (L) no método 'hsla'.");
                 this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumentos de método 'hsla'.");
                 return new seletor_valor_1.SeletorValor(lexema, [HdeHSLA, SdeHSLA, LdeHSLA]);
-            case "rgb":
-                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rgb'.");
-                const vermelho = this.avancarEDevolverAnterior();
-                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após argumento de cor vermelha.");
-                const verde = this.avancarEDevolverAnterior();
-                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após argumento de cor verde.");
-                const azul = this.avancarEDevolverAnterior();
-                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumentos de método 'rgb'.");
-                return new seletor_valor_1.SeletorValor(lexema, [vermelho, verde, azul]);
-            case "rgba":
-                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rgba'.");
-                const vermelhoRgba = this.avancarEDevolverAnterior();
-                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após argumento de cor vermelha.");
-                const verdeRgba = this.avancarEDevolverAnterior();
-                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após argumento de cor verde.");
-                const azulRgba = this.avancarEDevolverAnterior();
-                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumentos de método 'rgba'.");
-                return new seletor_valor_1.SeletorValor(lexema, [vermelhoRgba, verdeRgba, azulRgba]);
+            case "inclinar":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'inclinar'.");
+                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(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'inclinar'.");
+                    valorInclinar2 = this.avancarEDevolverAnterior();
+                    quantificadorInclinar2 = this.avancarEDevolverAnterior();
+                }
+                else {
+                    valorInclinar2 = null;
+                    quantificadorInclinar2 = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'inclinar'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorInclinar1, quantificadorInclinar1, valorInclinar2, quantificadorInclinar2]);
+            case "inclinar-horizontal":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'inclinar-horizontal'.");
+                const valorInclinarX = this.avancarEDevolverAnterior();
+                let quantificadorInclinarX;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorInclinarX = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorInclinarX = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'inclinar-horizontal'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorInclinarX, quantificadorInclinarX]);
+            case "inclinar-vertical":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'inclinar-vertical'.");
+                const valorInclinarY = this.avancarEDevolverAnterior();
+                let quantificadorInclinarY;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorInclinarY = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorInclinarY = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'inclinar-vertical'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorInclinarY, quantificadorInclinarY]);
+            case "inverter":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'inverter'.");
+                const valorInverter = this.avancarEDevolverAnterior();
+                let quantificadorInverter;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorInverter = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorInverter = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'inverter'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorInverter, quantificadorInverter]);
             case "limitar":
                 this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'limitar'.");
                 const valorMin = this.avancarEDevolverAnterior();
@@ -222,6 +350,18 @@ class AvaliadorSintatico {
                 else if (parametro02 !== null) {
                     return new seletor_valor_1.SeletorValor(lexema, [valor01['lexema'], parametro02]);
                 }
+            case "opacar":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'opacar'.");
+                const valorOpaco = this.avancarEDevolverAnterior();
+                let quantificadorOpaco;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorOpaco = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorOpaco = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'opacar'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorOpaco, quantificadorOpaco]);
             case "passos":
                 this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'passos'.");
                 const valorNumerico = this.avancarEDevolverAnterior();
@@ -229,6 +369,376 @@ class AvaliadorSintatico {
                 const termoSalto = this.avancarEDevolverAnterior();
                 this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método passos.");
                 return new seletor_valor_1.SeletorValor(lexema, [valorNumerico, termoSalto]);
+            case "perspectivar":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'perspectivar'.");
+                const valorPerspectivar = this.avancarEDevolverAnterior();
+                let quantificadorPerspectivar;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorPerspectivar = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorPerspectivar = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'perspectivar'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorPerspectivar, quantificadorPerspectivar]);
+            case "projetar-sombra":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'projetar-sombra'.");
+                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(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'projetar-sombra'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorSombra1, quantificadorSombra1, valorSombra2, quantificadorSombra2, valorSombra3, quantificadorSombra3, corSombra]);
+            case "raio":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'raio'.");
+                let posicaoRaio;
+                if (this.simbolos[this.atual].tipo === 'QUALITATIVO') {
+                    posicaoRaio = this.avancarEDevolverAnterior();
+                }
+                else {
+                    posicaoRaio = null;
+                }
+                const numeroRaio = this.avancarEDevolverAnterior();
+                const quantificadorRaio = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumentos de método 'raio'.");
+                return new seletor_valor_1.SeletorValor(lexema, [posicaoRaio, numeroRaio, quantificadorRaio]);
+            case "rgb":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rgb'.");
+                const vermelho = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após argumento de cor vermelha.");
+                const verde = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após argumento de cor verde.");
+                const azul = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumentos de método 'rgb'.");
+                return new seletor_valor_1.SeletorValor(lexema, [vermelho, verde, azul]);
+            case "rgba":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rgba'.");
+                const vermelhoRgba = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após argumento de cor vermelha.");
+                const verdeRgba = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após argumento de cor verde.");
+                const azulRgba = this.avancarEDevolverAnterior();
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumentos de método 'rgba'.");
+                return new seletor_valor_1.SeletorValor(lexema, [vermelhoRgba, verdeRgba, azulRgba]);
+            case "rotacionar":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotacionar'.");
+                const valorRotacionar = this.avancarEDevolverAnterior();
+                let quantificadorRotacionar;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorRotacionar = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorRotacionar = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotacionar'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorRotacionar, quantificadorRotacionar]);
+            case "rotacionar-eixo-z":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotacionar-eixo-z'.");
+                const valorRotacionarZ = this.avancarEDevolverAnterior();
+                let quantificadorRotacionarZ;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorRotacionarZ = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorRotacionarZ = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotacionar-eixo-z'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorRotacionarZ, quantificadorRotacionarZ]);
+            case "rotacionar-horizontal":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotacionar-horizontal'.");
+                const valorRotacionarX = this.avancarEDevolverAnterior();
+                let quantificadorRotacionarX;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorRotacionarX = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorRotacionarX = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotacionar-horizontal'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorRotacionarX, quantificadorRotacionarX]);
+            case "rotacionar-matiz":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotacionar-matiz'.");
+                const valorRotacao = this.avancarEDevolverAnterior();
+                let quantificadorRotacao;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorRotacao = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorRotacao = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotacionar-matiz'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorRotacao, quantificadorRotacao]);
+            case "rotacionar-vertical":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotacionar-vertical'.");
+                const valorRotacionarY = this.avancarEDevolverAnterior();
+                let quantificadorRotacionarY;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorRotacionarY = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorRotacionarY = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotacionar-vertical'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorRotacionarY, quantificadorRotacionarY]);
+            case "saturar":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'saturar'.");
+                const valorSaturar = this.avancarEDevolverAnterior();
+                let quantificadorSaturar;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorSaturar = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorSaturar = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'saturar'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorSaturar, quantificadorSaturar]);
+            case "sepia":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'sepia'.");
+                const valorSepia = this.avancarEDevolverAnterior();
+                let quantificadorSepia;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorSepia = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorSepia = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'sepia'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorSepia, quantificadorSepia]);
+            case "sépia":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'sépia'.");
+                const valorSépia = this.avancarEDevolverAnterior();
+                let quantificadorSépia;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorSépia = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorSépia = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'sépia'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorSépia, quantificadorSépia]);
+            case "translação":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação'.");
+                const valorTranslacao1 = this.avancarEDevolverAnterior();
+                let quantificadorTranlacao1;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorTranlacao1 = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorTranlacao1 = null;
+                }
+                let valorTranslacao2;
+                let quantificadorTranlacao2;
+                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                    this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'translação'.");
+                    valorTranslacao2 = this.avancarEDevolverAnterior();
+                    quantificadorTranlacao2 = this.avancarEDevolverAnterior();
+                }
+                else {
+                    valorTranslacao2 = null;
+                    quantificadorTranlacao2 = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorTranslacao1, quantificadorTranlacao1, valorTranslacao2, quantificadorTranlacao2]);
+            case "translacao":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação'.");
+                const valorTranslacao01 = this.avancarEDevolverAnterior();
+                let quantificadorTranlacao01;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorTranlacao01 = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorTranlacao01 = null;
+                }
+                let valorTranslacao02;
+                let quantificadorTranlacao02;
+                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                    this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'translação'.");
+                    valorTranslacao02 = this.avancarEDevolverAnterior();
+                    quantificadorTranlacao02 = this.avancarEDevolverAnterior();
+                }
+                else {
+                    valorTranslacao02 = null;
+                    quantificadorTranlacao02 = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorTranslacao01, quantificadorTranlacao01, valorTranslacao02, quantificadorTranlacao02]);
+            case "translação-3d":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-3d'.");
+                const valorTranslacao3d1 = this.avancarEDevolverAnterior();
+                let quantificadorTranlacao3d1;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorTranlacao3d1 = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorTranlacao3d1 = null;
+                }
+                let valorTranslacao3d2;
+                let quantificadorTranlacao3d2;
+                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                    this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'translação-3d'.");
+                    valorTranslacao3d2 = this.avancarEDevolverAnterior();
+                    if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                        quantificadorTranlacao3d2 = this.avancarEDevolverAnterior();
+                    }
+                    else {
+                        quantificadorTranlacao3d2 = null;
+                    }
+                }
+                else {
+                    valorTranslacao3d2 = null;
+                    quantificadorTranlacao3d2 = null;
+                }
+                let valorTranslacao3d3;
+                let quantificadorTranlacao3d3;
+                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                    this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'translação-3d'.");
+                    valorTranslacao3d3 = this.avancarEDevolverAnterior();
+                    if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                        quantificadorTranlacao3d3 = this.avancarEDevolverAnterior();
+                    }
+                    else {
+                        quantificadorTranlacao3d3 = null;
+                    }
+                }
+                else {
+                    valorTranslacao3d3 = null;
+                    quantificadorTranlacao3d3 = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-3d'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorTranslacao3d1, quantificadorTranlacao3d1, valorTranslacao3d2, quantificadorTranlacao3d2, valorTranslacao3d3, quantificadorTranlacao3d3]);
+            case "translacao-3d":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-3d'.");
+                const valorTranslacao3d01 = this.avancarEDevolverAnterior();
+                let quantificadorTranlacao3d01;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorTranlacao3d01 = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorTranlacao3d01 = null;
+                }
+                let valorTranslacao3d02;
+                let quantificadorTranlacao3d02;
+                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                    this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'translação-3d'.");
+                    valorTranslacao3d02 = this.avancarEDevolverAnterior();
+                    if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                        quantificadorTranlacao3d02 = this.avancarEDevolverAnterior();
+                    }
+                    else {
+                        quantificadorTranlacao3d02 = null;
+                    }
+                }
+                else {
+                    valorTranslacao3d02 = null;
+                    quantificadorTranlacao3d02 = null;
+                }
+                let valorTranslacao3d03;
+                let quantificadorTranlacao3d03;
+                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                    this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'translação-3d'.");
+                    valorTranslacao3d03 = this.avancarEDevolverAnterior();
+                    if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                        quantificadorTranlacao3d03 = this.avancarEDevolverAnterior();
+                    }
+                    else {
+                        quantificadorTranlacao3d03 = null;
+                    }
+                }
+                else {
+                    valorTranslacao3d03 = null;
+                    quantificadorTranlacao3d03 = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-3d'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorTranslacao3d01, quantificadorTranlacao3d01, valorTranslacao3d02, quantificadorTranlacao3d02, valorTranslacao3d03, quantificadorTranlacao3d03]);
+            case "translação-eixo-z":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-eixo-z'.");
+                const valorTranslaçaoZ = this.avancarEDevolverAnterior();
+                let quantificadorTranslaçaoZ;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorTranslaçaoZ = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorTranslaçaoZ = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-eixo-z'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorTranslaçaoZ, quantificadorTranslaçaoZ]);
+            case "translacao-eixo-z":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-eixo-z'.");
+                const valorTranslacaoZ = this.avancarEDevolverAnterior();
+                let quantificadorTranslacaoZ;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorTranslacaoZ = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorTranslacaoZ = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-eixo-z'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorTranslacaoZ, quantificadorTranslacaoZ]);
+            case "translação-horizontal":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-horizontal'.");
+                const valorTranslaçaoX = this.avancarEDevolverAnterior();
+                let quantificadorTranslaçaoX;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorTranslaçaoX = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorTranslaçaoX = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-horizontal'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorTranslaçaoX, quantificadorTranslaçaoX]);
+            case "translacao-horizontal":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-horizontal'.");
+                const valorTranslacaoX = this.avancarEDevolverAnterior();
+                let quantificadorTranslacaoX;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorTranslacaoX = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorTranslacaoX = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-horizontal'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorTranslacaoX, quantificadorTranslacaoX]);
+            case "translação-vertical":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-vertical'.");
+                const valorTranslaçaoY = this.avancarEDevolverAnterior();
+                let quantificadorTranslaçaoY;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorTranslaçaoY = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorTranslaçaoY = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-vertical'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorTranslaçaoY, quantificadorTranslaçaoY]);
+            case "translacao-vertical":
+                this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-vertical'.");
+                const valorTranslacaoY = this.avancarEDevolverAnterior();
+                let quantificadorTranslacaoY;
+                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                    quantificadorTranslacaoY = this.avancarEDevolverAnterior();
+                }
+                else {
+                    quantificadorTranslacaoY = null;
+                }
+                this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-vertical'.");
+                return new seletor_valor_1.SeletorValor(lexema, [valorTranslacaoY, quantificadorTranslacaoY]);
             case "url":
                 this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'url'.");
                 const url = this.validacaoUrl();