@designliquido/foles 0.8.2 → 0.9.0

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

@@ -14,11 +14,13 @@ const seletores_1 = require("../seletores");
 const seletor_estruturas_lmht_1 = require("../estruturas/seletor-estruturas-lmht");
 const seletor_espaco_reservado_1 = require("../seletores/seletor-espaco-reservado");
 const valor_numerico_1 = require("../../testes/listas/valor-numerico");
+const declaracao_variavel_1 = require("../declaracoes/declaracao-variavel");
 /**
  * Implementação do avaliador sintático.
  */
 class AvaliadorSintatico {
     constructor(importador) {
+        this.referenciaDeclaracoes = [];
         this.importador = importador;
         this.simbolos = [];
     }
@@ -49,31 +51,37 @@ class AvaliadorSintatico {
         switch (lexema) {
             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]);
+                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') {
+                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]);
+                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') {
+                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]);
+                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();
@@ -82,19 +90,28 @@ class AvaliadorSintatico {
                 const valorCalc2 = this.avancarEDevolverAnterior();
                 const quantificadorCalc2 = this.avancarEDevolverAnterior();
                 this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'calcular'.");
-                return new seletor_valor_1.SeletorValor(lexema, [valorCalc1, quantificadorCalc1, operadorCalc, valorCalc2, quantificadorCalc2]);
+                return new seletor_valor_1.SeletorValor(lexema, [
+                    valorCalc1,
+                    quantificadorCalc1,
+                    operadorCalc,
+                    valorCalc2,
+                    quantificadorCalc2,
+                ]);
             case "contraste":
                 this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'contraste'.");
                 const valorContraste = this.avancarEDevolverAnterior();
                 let quantificadorContraste;
-                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
                     quantificadorContraste = this.avancarEDevolverAnterior();
                 }
                 else {
                     quantificadorContraste = null;
                 }
                 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]);
+                return new seletor_valor_1.SeletorValor(lexema, [
+                    valorContraste,
+                    quantificadorContraste,
+                ]);
             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();
@@ -105,7 +122,12 @@ class AvaliadorSintatico {
                 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 curva-cúbica.");
-                return new seletor_valor_1.SeletorValor(lexema, [parametro1, parametro2, parametro3, parametro4]);
+                return new seletor_valor_1.SeletorValor(lexema, [
+                    parametro1,
+                    parametro2,
+                    parametro3,
+                    parametro4,
+                ]);
             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();
@@ -116,36 +138,50 @@ class AvaliadorSintatico {
                 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]);
+                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']]);
+                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']]);
+                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') {
+                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]);
+                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') {
+                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();
                 }
@@ -159,7 +195,11 @@ class AvaliadorSintatico {
                 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]);
+                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();
@@ -179,38 +219,38 @@ class AvaliadorSintatico {
                 this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'gradiente-linear'.");
                 const valorAngulo = this.avancarEDevolverAnterior();
                 let quantificadorAngulo;
-                if (valorAngulo.tipo === 'QUALITATIVO') {
+                if (valorAngulo.tipo === "QUALITATIVO") {
                     switch (valorAngulo.lexema) {
-                        case 'superior':
-                            valorAngulo.lexema = '0';
-                            valorAngulo.tipo = 'NUMERO';
+                        case "superior":
+                            valorAngulo.lexema = "0";
+                            valorAngulo.tipo = "NUMERO";
                             quantificadorAngulo = {
-                                tipo: 'QUANTIFICADOR',
-                                lexema: 'deg',
+                                tipo: "QUANTIFICADOR",
+                                lexema: "deg",
                             };
                             break;
-                        case 'direita':
-                            valorAngulo.lexema = '90';
-                            valorAngulo.tipo = 'NUMERO';
+                        case "direita":
+                            valorAngulo.lexema = "90";
+                            valorAngulo.tipo = "NUMERO";
                             quantificadorAngulo = {
-                                tipo: 'QUANTIFICADOR',
-                                lexema: 'deg',
+                                tipo: "QUANTIFICADOR",
+                                lexema: "deg",
                             };
                             break;
-                        case 'inferior':
-                            valorAngulo.lexema = '180';
-                            valorAngulo.tipo = 'NUMERO';
+                        case "inferior":
+                            valorAngulo.lexema = "180";
+                            valorAngulo.tipo = "NUMERO";
                             quantificadorAngulo = {
-                                tipo: 'QUANTIFICADOR',
-                                lexema: 'deg',
+                                tipo: "QUANTIFICADOR",
+                                lexema: "deg",
                             };
                             break;
-                        case 'esquerda':
-                            valorAngulo.lexema = '270';
-                            valorAngulo.tipo = 'NUMERO';
+                        case "esquerda":
+                            valorAngulo.lexema = "270";
+                            valorAngulo.tipo = "NUMERO";
                             quantificadorAngulo = {
-                                tipo: 'QUANTIFICADOR',
-                                lexema: 'deg',
+                                tipo: "QUANTIFICADOR",
+                                lexema: "deg",
                             };
                             break;
                         default:
@@ -225,7 +265,12 @@ class AvaliadorSintatico {
                 this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método gradiente-linear.");
                 const cor2 = this.avancarEDevolverAnterior();
                 this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'gradiente-linear'.");
-                return new seletor_valor_1.SeletorValor(lexema, [valorAngulo, quantificadorAngulo, cor1, cor2]);
+                return new seletor_valor_1.SeletorValor(lexema, [
+                    valorAngulo,
+                    quantificadorAngulo,
+                    cor1,
+                    cor2,
+                ]);
             case "hsl":
                 this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'hsl'.");
                 const HdeHSL = this.avancarEDevolverAnterior();
@@ -252,7 +297,7 @@ class AvaliadorSintatico {
                 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') {
+                if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
                     quantificadorInclinar1 = this.avancarEDevolverAnterior();
                 }
                 else {
@@ -260,7 +305,7 @@ class AvaliadorSintatico {
                 }
                 let valorInclinar2;
                 let quantificadorInclinar2;
-                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                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();
@@ -270,43 +315,57 @@ class AvaliadorSintatico {
                     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]);
+                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') {
+                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]);
+                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') {
+                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]);
+                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') {
+                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]);
+                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();
@@ -318,7 +377,14 @@ class AvaliadorSintatico {
                 const valorMax = this.avancarEDevolverAnterior();
                 const quantificadorMax = this.avancarEDevolverAnterior();
                 this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método limitar.");
-                return new seletor_valor_1.SeletorValor(lexema, [valorMin, quantificadorMin, valorMed, quantificadorMed, valorMax, quantificadorMax]);
+                return new seletor_valor_1.SeletorValor(lexema, [
+                    valorMin,
+                    quantificadorMin,
+                    valorMed,
+                    quantificadorMed,
+                    valorMax,
+                    quantificadorMax,
+                ]);
             case "linear":
                 this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'linear'.");
                 const valor1 = this.avancarEDevolverAnterior();
@@ -332,36 +398,45 @@ class AvaliadorSintatico {
                 this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'minmax'.");
                 const valor01 = this.avancarEDevolverAnterior();
                 let parametro01 = null;
-                if (Number(valor01['lexema'])) {
+                if (Number(valor01["lexema"])) {
                     const quantificador01 = this.avancarEDevolverAnterior();
-                    parametro01 = `${valor01['lexema']}${quantificador01['lexema']}`;
+                    parametro01 = `${valor01["lexema"]}${quantificador01["lexema"]}`;
                 }
                 this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método minmax.");
                 const valor02 = this.avancarEDevolverAnterior();
                 let parametro02 = null;
-                if (Number(valor02['lexema'])) {
+                if (Number(valor02["lexema"])) {
                     const quantificador02 = this.avancarEDevolverAnterior();
-                    parametro02 = `${valor02['lexema']}${quantificador02['lexema']}`;
+                    parametro02 = `${valor02["lexema"]}${quantificador02["lexema"]}`;
                 }
                 this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método minmax.");
                 if (parametro01 !== null) {
-                    return new seletor_valor_1.SeletorValor(lexema, [parametro01, valor02['lexema']]);
+                    return new seletor_valor_1.SeletorValor(lexema, [
+                        parametro01,
+                        valor02["lexema"],
+                    ]);
                 }
                 else if (parametro02 !== null) {
-                    return new seletor_valor_1.SeletorValor(lexema, [valor01['lexema'], parametro02]);
+                    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') {
+                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]);
+                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();
@@ -373,18 +448,21 @@ class AvaliadorSintatico {
                 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') {
+                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]);
+                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') {
+                if (this.simbolos[this.atual].tipo === "QUALITATIVO") {
                     corSombra = this.avancarEDevolverAnterior();
                 }
                 const valorSombra1 = this.avancarEDevolverAnterior();
@@ -393,7 +471,7 @@ class AvaliadorSintatico {
                 const quantificadorSombra2 = this.avancarEDevolverAnterior();
                 let valorSombra3;
                 let quantificadorSombra3;
-                if (this.simbolos[this.atual].tipo === 'NUMERO') {
+                if (this.simbolos[this.atual].tipo === "NUMERO") {
                     valorSombra3 = this.avancarEDevolverAnterior();
                     quantificadorSombra3 = this.avancarEDevolverAnterior();
                 }
@@ -401,15 +479,23 @@ class AvaliadorSintatico {
                     valorSombra3 = null;
                     quantificadorSombra3 = null;
                 }
-                if (this.simbolos[this.atual].tipo === 'QUALITATIVO') {
+                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]);
+                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') {
+                if (this.simbolos[this.atual].tipo === "QUALITATIVO") {
                     posicaoRaio = this.avancarEDevolverAnterior();
                 }
                 else {
@@ -418,7 +504,11 @@ class AvaliadorSintatico {
                 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]);
+                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();
@@ -436,108 +526,136 @@ class AvaliadorSintatico {
                 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]);
+                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') {
+                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]);
+                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') {
+                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]);
+                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') {
+                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]);
+                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') {
+                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]);
+                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') {
+                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]);
+                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') {
+                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]);
+                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') {
+                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]);
+                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') {
+                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]);
+                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 quantificadorTranslacao1;
-                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
                     quantificadorTranslacao1 = this.avancarEDevolverAnterior();
                 }
                 else {
@@ -545,7 +663,7 @@ class AvaliadorSintatico {
                 }
                 let valorTranslacao2;
                 let quantificadorTranslacao2;
-                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                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();
                     quantificadorTranslacao2 = this.avancarEDevolverAnterior();
@@ -555,12 +673,17 @@ class AvaliadorSintatico {
                     quantificadorTranslacao2 = 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, quantificadorTranslacao1, valorTranslacao2, quantificadorTranslacao2]);
+                return new seletor_valor_1.SeletorValor(lexema, [
+                    valorTranslacao1,
+                    quantificadorTranslacao1,
+                    valorTranslacao2,
+                    quantificadorTranslacao2,
+                ]);
             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') {
+                if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
                     quantificadorTranlacao01 = this.avancarEDevolverAnterior();
                 }
                 else {
@@ -568,7 +691,7 @@ class AvaliadorSintatico {
                 }
                 let valorTranslacao02;
                 let quantificadorTranlacao02;
-                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                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();
@@ -578,12 +701,17 @@ class AvaliadorSintatico {
                     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]);
+                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') {
+                if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
                     quantificadorTranlacao3d1 = this.avancarEDevolverAnterior();
                 }
                 else {
@@ -591,11 +719,12 @@ class AvaliadorSintatico {
                 }
                 let valorTranslacao3d2;
                 let quantificadorTranlacao3d2;
-                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                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();
+                    if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
+                        quantificadorTranlacao3d2 =
+                            this.avancarEDevolverAnterior();
                     }
                     else {
                         quantificadorTranlacao3d2 = null;
@@ -607,11 +736,12 @@ class AvaliadorSintatico {
                 }
                 let valorTranslacao3d3;
                 let quantificadorTranlacao3d3;
-                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                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();
+                    if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
+                        quantificadorTranlacao3d3 =
+                            this.avancarEDevolverAnterior();
                     }
                     else {
                         quantificadorTranlacao3d3 = null;
@@ -622,24 +752,33 @@ class AvaliadorSintatico {
                     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]);
+                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();
+                if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
+                    quantificadorTranlacao3d01 =
+                        this.avancarEDevolverAnterior();
                 }
                 else {
                     quantificadorTranlacao3d01 = null;
                 }
                 let valorTranslacao3d02;
                 let quantificadorTranlacao3d02;
-                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                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();
+                    if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
+                        quantificadorTranlacao3d02 =
+                            this.avancarEDevolverAnterior();
                     }
                     else {
                         quantificadorTranlacao3d02 = null;
@@ -651,11 +790,12 @@ class AvaliadorSintatico {
                 }
                 let valorTranslacao3d03;
                 let quantificadorTranlacao3d03;
-                if (this.simbolos[this.atual].tipo === 'VIRGULA') {
+                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();
+                    if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
+                        quantificadorTranlacao3d03 =
+                            this.avancarEDevolverAnterior();
                     }
                     else {
                         quantificadorTranlacao3d03 = null;
@@ -666,79 +806,104 @@ class AvaliadorSintatico {
                     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]);
+                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') {
+                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]);
+                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') {
+                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]);
+                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') {
+                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]);
+                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') {
+                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]);
+                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') {
+                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]);
+                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') {
+                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]);
+                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();
@@ -757,12 +922,12 @@ class AvaliadorSintatico {
         }
     }
     validacaoUrlSimbolos(primeiroSimbolo) {
-        if (!['http', 'https'].includes(primeiroSimbolo.lexema.toLowerCase())) {
+        if (!["http", "https"].includes(primeiroSimbolo.lexema.toLowerCase())) {
             throw new Error(`URL inválida. URLs devem começar com 'http' ou 'https'.`);
         }
         this.consumir(foles_1.default.DOIS_PONTOS, `Esperado dois-pontos após '${primeiroSimbolo.lexema}'.`);
-        this.consumir(foles_1.default.BARRA, `Esperado barra após '${primeiroSimbolo.lexema + ':'}'`);
-        this.consumir(foles_1.default.BARRA, `Esperado segunda barra após '${primeiroSimbolo.lexema + ':/'}'`);
+        this.consumir(foles_1.default.BARRA, `Esperado barra após '${primeiroSimbolo.lexema + ":"}'`);
+        this.consumir(foles_1.default.BARRA, `Esperado segunda barra após '${primeiroSimbolo.lexema + ":/"}'`);
         let url = `${primeiroSimbolo.lexema}://`;
         while (this.simbolos[this.atual].tipo !== foles_1.default.PARENTESE_DIREITO) {
             let proximoSimbolo = this.avancarEDevolverAnterior();
@@ -779,7 +944,8 @@ class AvaliadorSintatico {
     }
     valoresModificador() {
         const modificadores = [];
-        while (this.simbolos[this.atual].hasOwnProperty('tipo') && this.simbolos[this.atual].tipo !== foles_1.default.PONTO_E_VIRGULA) {
+        while (this.simbolos[this.atual].hasOwnProperty("tipo") &&
+            this.simbolos[this.atual].tipo !== foles_1.default.PONTO_E_VIRGULA) {
             const valorModificador = this.avancarEDevolverAnterior();
             switch (valorModificador.tipo) {
                 case foles_1.default.METODO:
@@ -793,7 +959,7 @@ class AvaliadorSintatico {
         return modificadores;
     }
     tratarAtribuicaoAbreviada(valoresModificador) {
-        let atribuicaoAbreviada = '';
+        let atribuicaoAbreviada = "";
         for (let i = 0; i < valoresModificador.length; i += 1) {
             if (i === 0) {
                 atribuicaoAbreviada += `${valoresModificador[i].lexema}`;
@@ -804,10 +970,10 @@ class AvaliadorSintatico {
                         atribuicaoAbreviada += `${valoresModificador[i].lexema}`;
                         break;
                     case foles_1.default.VIRGULA:
-                        atribuicaoAbreviada += ',';
+                        atribuicaoAbreviada += ",";
                         break;
                     default:
-                        atribuicaoAbreviada += ' ';
+                        atribuicaoAbreviada += " ";
                         atribuicaoAbreviada += `${valoresModificador[i].lexema}`;
                         break;
                 }
@@ -816,9 +982,9 @@ class AvaliadorSintatico {
         return atribuicaoAbreviada;
     }
     tratarValorNumerico(modificador) {
-        if (!(valor_numerico_1.ValorNumerico.includes(modificador.lexema))) {
+        if (!valor_numerico_1.ValorNumerico.includes(modificador.lexema)) {
             if (valor_numerico_1.ValorNumericoComQuantificador.includes(modificador.lexema)) {
-                if (this.simbolos[this.atual].tipo === 'QUANTIFICADOR') {
+                if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
                     return true;
                 }
                 else {
@@ -839,7 +1005,7 @@ class AvaliadorSintatico {
             return new seletor_pseudoclasse_1.SeletorPseudoclasse(pseudoclasse.lexema, {
                 linha: pseudoclasse.linha,
                 colunaInicial: pseudoclasse.colunaInicial,
-                colunaFinal: pseudoclasse.colunaFinal
+                colunaFinal: pseudoclasse.colunaFinal,
             });
         }
         return pseudoclasse;
@@ -849,7 +1015,7 @@ class AvaliadorSintatico {
         // Aqui não tem problema o espaço reservado usar um nome de estrutura.
         if (![
             foles_1.default.IDENTIFICADOR,
-            foles_1.default.ESTRUTURA
+            foles_1.default.ESTRUTURA,
         ].includes(this.simbolos[this.atual].tipo)) {
             throw this.erro(this.simbolos[this.atual], "Esperado identificador válido para espaço reservado.");
         }
@@ -857,7 +1023,7 @@ class AvaliadorSintatico {
         return new seletor_espaco_reservado_1.SeletorEspacoReservado(nomeEspacoReservado.lexema, {
             linha: simboloSeletor.linha,
             colunaInicial: simboloSeletor.colunaInicial,
-            colunaFinal: simboloSeletor.colunaFinal
+            colunaFinal: simboloSeletor.colunaFinal,
         });
     }
     seletorPorEstrutura() {
@@ -866,7 +1032,7 @@ class AvaliadorSintatico {
         return new seletores_1.SeletorEstrutura(new seletor_estruturas_lmht_1.SeletorEstruturasLmht(simboloSeletor.lexema, {
             linha: simboloSeletor.linha,
             colunaInicial: simboloSeletor.colunaInicial,
-            colunaFinal: simboloSeletor.colunaFinal
+            colunaFinal: simboloSeletor.colunaFinal,
         }), pseudoclasse);
     }
     seletorPorId() {
@@ -876,7 +1042,7 @@ class AvaliadorSintatico {
         return new seletores_1.SeletorId(simboloSeletor.lexema, pseudoclasse, {
             linha: simboloSeletor.linha,
             colunaInicial: simboloSeletor.colunaInicial,
-            colunaFinal: simboloSeletor.colunaFinal
+            colunaFinal: simboloSeletor.colunaFinal,
         });
     }
     seletorPorNomeDeClasse() {
@@ -886,9 +1052,54 @@ class AvaliadorSintatico {
         return new seletores_1.SeletorClasse(simboloSeletor.lexema, pseudoclasse, {
             linha: simboloSeletor.linha,
             colunaInicial: simboloSeletor.colunaInicial,
-            colunaFinal: simboloSeletor.colunaFinal
+            colunaFinal: simboloSeletor.colunaFinal,
         });
     }
+    declaracaoVariavel() {
+        let nomeVariavel;
+        let simboloValorVariavel;
+        let valorVariavel;
+        let quantificadorVariavel;
+        while (this.simbolos[this.atual].tipo !== foles_1.default.PONTO_E_VIRGULA) {
+            this.consumir(foles_1.default.CIFRAO, "Esperado cifrão antes de declaração de variável.");
+            const declaracaoVariavel = this.consumir(foles_1.default.VARIAVEL, "Esperada nomenclatura para declaração de variável.");
+            nomeVariavel = declaracaoVariavel.lexema;
+            this.consumir(foles_1.default.DOIS_PONTOS, "Esperado ':' após declaração de variável.");
+            switch (this.simbolos[this.atual].tipo) {
+                case foles_1.default.IDENTIFICADOR:
+                    simboloValorVariavel = this.consumir(foles_1.default.IDENTIFICADOR, "Esperado nome do modificador após declaração de variável.");
+                    valorVariavel = simboloValorVariavel.lexema;
+                    break;
+                case foles_1.default.QUALITATIVO:
+                    simboloValorVariavel = this.consumir(foles_1.default.QUALITATIVO, "Esperado qualitativo após declaração de variável.");
+                    valorVariavel = simboloValorVariavel.lexema;
+                    break;
+                case foles_1.default.NUMERO:
+                    simboloValorVariavel = this.consumir(foles_1.default.NUMERO, "Esperado valor numérico após declaração de variável");
+                    valorVariavel = simboloValorVariavel.lexema;
+                    if (this.simbolos[this.atual].tipo ===
+                        foles_1.default.QUANTIFICADOR) {
+                        const quantificador = this.consumir(foles_1.default.QUANTIFICADOR, "Esperado quantificador após valor numérico atribuído à variável.");
+                        quantificadorVariavel = quantificador.lexema;
+                    }
+                    break;
+                case foles_1.default.METODO:
+                    this.consumir(foles_1.default.METODO, "Esperada declaração de método no valor atribuído à variável.");
+                    const tratarMetodo = this.resolverMetodo(this.simbolos[this.atual - 1].lexema);
+                    valorVariavel = tratarMetodo;
+                    break;
+                default:
+                    console.log("Não deveria cair aqui!");
+            }
+        }
+        this.consumir(foles_1.default.PONTO_E_VIRGULA, "Esperado ponto e vírgula após atribuição de valor à variável");
+        const variavel = {
+            nome: nomeVariavel,
+            valor: valorVariavel,
+            quantificador: quantificadorVariavel ? quantificadorVariavel : null,
+        };
+        return variavel;
+    }
     /**
      * Resolve os seletores.
      * @param espacoReservado
@@ -916,16 +1127,18 @@ class AvaliadorSintatico {
     resolverModificador() {
         const modificador = this.consumir(foles_1.default.IDENTIFICADOR, "Esperado nome do modificador.");
         this.consumir(foles_1.default.DOIS_PONTOS, "Esperado ':' após nome do modificador.");
-        const valoresModificador = this.valoresModificador();
+        let valoresModificador = this.valoresModificador();
         let quantificador;
         for (const [index, valorModificador] of valoresModificador.entries()) {
-            if (valorModificador.hasOwnProperty('tipo') && valorModificador.tipo === foles_1.default.NUMERO) {
+            if (valorModificador.hasOwnProperty("tipo") &&
+                valorModificador.tipo === foles_1.default.NUMERO) {
                 const tratarValorNumerico = this.tratarValorNumerico(valorModificador);
                 if (tratarValorNumerico) {
                     quantificador = valoresModificador[index + 1];
                 }
             }
-            if (valorModificador.hasOwnProperty('tipo') && valorModificador.tipo === foles_1.default.METODO) {
+            if (valorModificador.hasOwnProperty("tipo") &&
+                valorModificador.tipo === foles_1.default.METODO) {
                 valoresModificador.splice(index, 1);
             }
         }
@@ -938,23 +1151,36 @@ class AvaliadorSintatico {
             valoresModificador.push(proximoSimbolo);
         }
         this.consumir(foles_1.default.PONTO_E_VIRGULA, `Esperado ';' após declaração de valor de modificador '${modificador.lexema}'.`);
+        if (valoresModificador[0].tipo === foles_1.default.CIFRAO) {
+            const valorVariavel = true;
+            const classeModificadora = new superclasse_1.SeletorModificador(modificador.lexema, valoresModificador[1].lexema, quantificador && quantificador.hasOwnProperty("lexema")
+                ? quantificador.lexema
+                : quantificador, {
+                linha: modificador.linha,
+                colunaInicial: modificador.colunaInicial,
+                colunaFinal: modificador.colunaFinal,
+            }, valorVariavel);
+            return classeModificadora;
+        }
         if (valoresModificador.length <= 2) {
-            const classeModificadora = new superclasse_1.SeletorModificador(modificador.lexema, valoresModificador[0].hasOwnProperty('lexema') ? valoresModificador[0].lexema : valoresModificador[0], quantificador && quantificador.hasOwnProperty('lexema') ?
-                quantificador.lexema :
-                quantificador, {
+            const classeModificadora = new superclasse_1.SeletorModificador(modificador.lexema, valoresModificador[0].hasOwnProperty("lexema")
+                ? valoresModificador[0].lexema
+                : valoresModificador[0], quantificador && quantificador.hasOwnProperty("lexema")
+                ? quantificador.lexema
+                : quantificador, {
                 linha: modificador.linha,
                 colunaInicial: modificador.colunaInicial,
-                colunaFinal: modificador.colunaFinal
+                colunaFinal: modificador.colunaFinal,
             });
             return classeModificadora;
         }
         const atribuicaoAbreviada = this.tratarAtribuicaoAbreviada(valoresModificador);
-        const classeModificadora = new superclasse_1.SeletorModificador(modificador.lexema, atribuicaoAbreviada, quantificador && quantificador.hasOwnProperty('lexema') ?
-            quantificador.lexema :
-            quantificador, {
+        const classeModificadora = new superclasse_1.SeletorModificador(modificador.lexema, atribuicaoAbreviada, quantificador && quantificador.hasOwnProperty("lexema")
+            ? quantificador.lexema
+            : quantificador, {
             linha: modificador.linha,
             colunaInicial: modificador.colunaInicial,
-            colunaFinal: modificador.colunaFinal
+            colunaFinal: modificador.colunaFinal,
         });
         return classeModificadora;
     }
@@ -977,7 +1203,7 @@ class AvaliadorSintatico {
         this.avancarEDevolverAnterior(); // chave direita
         return {
             modificadores,
-            declaracoesAninhadas
+            declaracoesAninhadas,
         };
     }
     declaracao() {
@@ -991,10 +1217,13 @@ class AvaliadorSintatico {
                 this.simbolos.splice(this.atual - 1, 2, ...resultadoImportacao[1].simbolos);
                 this.atual -= 1;
                 return null;
+            case foles_1.default.CIFRAO:
+                const variavel = this.declaracaoVariavel();
+                return new declaracao_variavel_1.DeclaracaoVariavel(variavel.nome, variavel.valor, variavel.quantificador);
             default:
                 const seletores = this.resolverSeletores();
                 const modificadoresEDeclaracoesAninhadas = this.resolverModificadoresEDeclaracoesAninhadas();
-                return new declaracoes_1.Declaracao(seletores, modificadoresEDeclaracoesAninhadas.modificadores, modificadoresEDeclaracoesAninhadas.declaracoesAninhadas);
+                return new declaracoes_1.BlocoDeclaracao(seletores, modificadoresEDeclaracoesAninhadas.modificadores, modificadoresEDeclaracoesAninhadas.declaracoesAninhadas);
         }
     }
     analisar(simbolos) {
@@ -1004,8 +1233,9 @@ class AvaliadorSintatico {
         const declaracoes = [];
         while (!this.estaNoFinal()) {
             declaracoes.push(this.declaracao());
+            this.referenciaDeclaracoes = declaracoes;
         }
-        return declaracoes.filter(d => d);
+        return declaracoes.filter((d) => d);
     }
 }
 exports.AvaliadorSintatico = AvaliadorSintatico;