@designliquido/delegua 0.60.0 → 0.61.0

package/tipos-de-simbolos/delegua.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delegua.d.ts","sourceRoot":"","sources":["../../fontes/tipos-de-simbolos/delegua.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBA8FE"}
+{"version":3,"file":"delegua.d.ts","sourceRoot":"","sources":["../../fontes/tipos-de-simbolos/delegua.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAgGE"}

package/tipos-de-simbolos/delegua.js

@@ -18,6 +18,7 @@ exports.default = {
     COMO: 'COMO',
     CONSTANTE: 'CONSTANTE',
     CONSTRUTOR: 'CONSTRUTOR',
+    CONTEM: 'CONTEM',
     CONTINUA: 'CONTINUA',
     DE: 'DE',
     DECREMENTAR: 'DECREMENTAR',
@@ -64,6 +65,7 @@ exports.default = {
     MODULO_IGUAL: 'MODULO_IGUAL',
     MULTIPLICACAO: 'MULTIPLICACAO',
     MULTIPLICACAO_IGUAL: 'MULTIPLICACAO_IGUAL',
+    NAO: 'NAO',
     NEGACAO: 'NEGACAO',
     NULO: 'NULO',
     NUMERO: 'NUMERO',

package/tipos-de-simbolos/delegua.js.map

@@ -1 +1 @@
-{"version":3,"file":"delegua.js","sourceRoot":"","sources":["../../fontes/tipos-de-simbolos/delegua.ts"],"names":[],"mappings":";;AAAA,kBAAe;IACX,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,aAAa,EAAE,eAAe;IAC9B,cAAc,EAAE,gBAAgB;IAChC,MAAM,EAAE,QAAQ;IAChB,gBAAgB,EAAE,kBAAkB;IACpC,iBAAiB,EAAE,mBAAmB;IACtC,UAAU,EAAE,YAAY;IACxB,IAAI,EAAE,MAAM;IACZ,SAAS,EAAE,WAAW;IACtB,UAAU,EAAE,YAAY;IACxB,QAAQ,EAAE,UAAU;IACpB,EAAE,EAAE,IAAI;IACR,WAAW,EAAE,aAAa;IAC1B,SAAS,EAAE,WAAW;IACtB,OAAO,EAAE,SAAS;IAClB,aAAa,EAAE,eAAe;IAC9B,eAAe,EAAE,iBAAiB;IAClC,qBAAqB,EAAE,uBAAuB;IAC9C,WAAW,EAAE,aAAa;IAC1B,CAAC,EAAE,GAAG;IACN,KAAK,EAAE,OAAO;IACd,EAAE,EAAE,IAAI;IACR,QAAQ,EAAE,UAAU;IACpB,GAAG,EAAE,KAAK;IACV,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,aAAa,EAAE,eAAe;IAC9B,iBAAiB,EAAE,mBAAmB;IACtC,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,UAAU,EAAE,YAAY;IACxB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,aAAa,EAAE,eAAe;IAC9B,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,aAAa;IAC1B,QAAQ,EAAE,UAAU;IACpB,WAAW,EAAE,aAAa;IAC1B,YAAY,EAAE,cAAc;IAC5B,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,gBAAgB,EAAE,kBAAkB;IACpC,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,UAAU,EAAE,YAAY;IACxB,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,MAAM,EAAE,QAAQ;IAChB,YAAY,EAAE,cAAc;IAC5B,aAAa,EAAE,eAAe;IAC9B,mBAAmB,EAAE,qBAAqB;IAC1C,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,EAAE,EAAE,IAAI;IACR,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,iBAAiB,EAAE,mBAAmB;IACtC,kBAAkB,EAAE,oBAAoB;IACxC,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,eAAe,EAAE,iBAAiB;IAClC,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,SAAS,EAAE,WAAW;IACtB,EAAE,EAAE,IAAI;IACR,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,UAAU;IACpB,UAAU,EAAE,YAAY;IACxB,OAAO,EAAE,SAAS;CACrB,CAAC"}
+{"version":3,"file":"delegua.js","sourceRoot":"","sources":["../../fontes/tipos-de-simbolos/delegua.ts"],"names":[],"mappings":"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"}

package/tipos-de-simbolos/microgramaticas/delegua.d.ts

@@ -8,6 +8,7 @@ declare const _default: {
     CHAVE_ESQUERDA: string;
     COLCHETE_DIREITO: string;
     COLCHETE_ESQUERDO: string;
+    CONTEM: string;
     DECREMENTAR: string;
     DIFERENTE: string;
     DIVISAO: string;
@@ -32,6 +33,7 @@ declare const _default: {
     MENOR_MENOR: string;
     MODULO: string;
     MULTIPLICACAO: string;
+    NAO: string;
     NEGACAO: string;
     NULO: string;
     NUMERO: string;

package/tipos-de-simbolos/microgramaticas/delegua.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delegua.d.ts","sourceRoot":"","sources":["../../../fontes/tipos-de-simbolos/microgramaticas/delegua.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBA8CE"}
+{"version":3,"file":"delegua.d.ts","sourceRoot":"","sources":["../../../fontes/tipos-de-simbolos/microgramaticas/delegua.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAgDE"}

package/tipos-de-simbolos/microgramaticas/delegua.js

@@ -10,6 +10,7 @@ exports.default = {
     CHAVE_ESQUERDA: 'CHAVE_ESQUERDA',
     COLCHETE_DIREITO: 'COLCHETE_DIREITO',
     COLCHETE_ESQUERDO: 'COLCHETE_ESQUERDO',
+    CONTEM: 'CONTEM',
     DECREMENTAR: 'DECREMENTAR',
     DIFERENTE: 'DIFERENTE',
     DIVISAO: 'DIVISAO',
@@ -34,6 +35,7 @@ exports.default = {
     MENOR_MENOR: 'MENOR_MENOR',
     MODULO: 'MODULO',
     MULTIPLICACAO: 'MULTIPLICACAO',
+    NAO: 'NAO',
     NEGACAO: 'NEGACAO',
     NULO: 'NULO',
     NUMERO: 'NUMERO',

package/tipos-de-simbolos/microgramaticas/delegua.js.map

@@ -1 +1 @@
-{"version":3,"file":"delegua.js","sourceRoot":"","sources":["../../../fontes/tipos-de-simbolos/microgramaticas/delegua.ts"],"names":[],"mappings":";;AAAA,kBAAe;IACX,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,aAAa,EAAE,eAAe;IAC9B,cAAc,EAAE,gBAAgB;IAChC,gBAAgB,EAAE,kBAAkB;IACpC,iBAAiB,EAAE,mBAAmB;IACtC,WAAW,EAAE,aAAa;IAC1B,SAAS,EAAE,WAAW;IACtB,OAAO,EAAE,SAAS;IAClB,eAAe,EAAE,iBAAiB;IAClC,WAAW,EAAE,aAAa;IAC1B,CAAC,EAAE,GAAG;IACN,KAAK,EAAE,OAAO;IACd,EAAE,EAAE,IAAI;IACR,GAAG,EAAE,KAAK;IACV,aAAa,EAAE,eAAe;IAC9B,KAAK,EAAE,OAAO;IACd,aAAa,EAAE,eAAe;IAC9B,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,YAAY,EAAE,cAAc;IAC5B,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,MAAM,EAAE,QAAQ;IAChB,aAAa,EAAE,eAAe;IAC9B,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,EAAE,EAAE,IAAI;IACR,iBAAiB,EAAE,mBAAmB;IACtC,kBAAkB,EAAE,oBAAoB;IACxC,KAAK,EAAE,OAAO;IACd,SAAS,EAAE,WAAW;IACtB,KAAK,EAAE,OAAO;IACd,QAAQ,EAAE,UAAU;IACpB,UAAU,EAAE,YAAY;IACxB,OAAO,EAAE,SAAS;CACrB,CAAC"}
+{"version":3,"file":"delegua.js","sourceRoot":"","sources":["../../../fontes/tipos-de-simbolos/microgramaticas/delegua.ts"],"names":[],"mappings":";;AAAA,kBAAe;IACX,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,aAAa,EAAE,eAAe;IAC9B,cAAc,EAAE,gBAAgB;IAChC,gBAAgB,EAAE,kBAAkB;IACpC,iBAAiB,EAAE,mBAAmB;IACtC,MAAM,EAAE,QAAQ;IAChB,WAAW,EAAE,aAAa;IAC1B,SAAS,EAAE,WAAW;IACtB,OAAO,EAAE,SAAS;IAClB,eAAe,EAAE,iBAAiB;IAClC,WAAW,EAAE,aAAa;IAC1B,CAAC,EAAE,GAAG;IACN,KAAK,EAAE,OAAO;IACd,EAAE,EAAE,IAAI;IACR,GAAG,EAAE,KAAK;IACV,aAAa,EAAE,eAAe;IAC9B,KAAK,EAAE,OAAO;IACd,aAAa,EAAE,eAAe;IAC9B,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,YAAY,EAAE,cAAc;IAC5B,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,MAAM,EAAE,QAAQ;IAChB,aAAa,EAAE,eAAe;IAC9B,GAAG,EAAE,KAAK;IACV,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,EAAE,EAAE,IAAI;IACR,iBAAiB,EAAE,mBAAmB;IACtC,kBAAkB,EAAE,oBAAoB;IACxC,KAAK,EAAE,OAAO;IACd,SAAS,EAAE,WAAW;IACtB,KAAK,EAAE,OAAO;IACd,QAAQ,EAAE,UAAU;IACpB,UAAU,EAAE,YAAY;IACxB,OAAO,EAAE,SAAS;CACrB,CAAC"}

package/tipos-de-simbolos/pitugues.d.ts

@@ -14,6 +14,7 @@ declare const _default: {
     COMENTARIO: string;
     COMO: string;
     CONSTRUTOR: string;
+    CONTEM: string;
     CONTINUA: string;
     DE: string;
     DIFERENTE: string;
@@ -50,6 +51,7 @@ declare const _default: {
     MENOR_MENOR: string;
     MODULO: string;
     MULTIPLICACAO: string;
+    NAO: string;
     NEGACAO: string;
     NULO: string;
     NUMERO: string;

package/tipos-de-simbolos/pitugues.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pitugues.d.ts","sourceRoot":"","sources":["../../fontes/tipos-de-simbolos/pitugues.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAgFE"}
+{"version":3,"file":"pitugues.d.ts","sourceRoot":"","sources":["../../fontes/tipos-de-simbolos/pitugues.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAkFE"}

package/tipos-de-simbolos/pitugues.js

@@ -16,6 +16,7 @@ exports.default = {
     COMENTARIO: 'COMENTARIO',
     COMO: 'COMO',
     CONSTRUTOR: 'CONSTRUTOR',
+    CONTEM: 'CONTEM',
     CONTINUA: 'CONTINUA',
     DE: 'DE',
     DIFERENTE: 'DIFERENTE',
@@ -52,6 +53,7 @@ exports.default = {
     MENOR_MENOR: 'MENOR_MENOR',
     MODULO: 'MODULO',
     MULTIPLICACAO: 'MULTIPLICACAO',
+    NAO: 'NAO',
     NEGACAO: 'NEGACAO',
     NULO: 'NULO',
     NUMERO: 'NUMERO',

package/tipos-de-simbolos/pitugues.js.map

@@ -1 +1 @@
-{"version":3,"file":"pitugues.js","sourceRoot":"","sources":["../../fontes/tipos-de-simbolos/pitugues.ts"],"names":[],"mappings":";;AAAA,kBAAe;IACX,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,aAAa,EAAE,eAAe;IAC9B,cAAc,EAAE,gBAAgB;IAChC,MAAM,EAAE,QAAQ;IAChB,gBAAgB,EAAE,kBAAkB;IACpC,iBAAiB,EAAE,mBAAmB;IACtC,UAAU,EAAE,YAAY;IACxB,IAAI,EAAE,MAAM;IACZ,UAAU,EAAE,YAAY;IACxB,QAAQ,EAAE,UAAU;IACpB,EAAE,EAAE,IAAI;IACR,SAAS,EAAE,WAAW;IACtB,OAAO,EAAE,SAAS;IAClB,eAAe,EAAE,iBAAiB;IAClC,WAAW,EAAE,aAAa;IAC1B,CAAC,EAAE,GAAG;IACN,EAAE,EAAE,IAAI;IACR,QAAQ,EAAE,UAAU;IACpB,GAAG,EAAE,KAAK;IACV,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,aAAa,EAAE,eAAe;IAC9B,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,aAAa;IAC1B,OAAO,EAAE,SAAS;IAClB,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,UAAU,EAAE,YAAY;IACxB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,aAAa,EAAE,eAAe;IAC9B,QAAQ,EAAE,UAAU;IACpB,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,UAAU,EAAE,YAAY;IACxB,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,MAAM,EAAE,QAAQ;IAChB,aAAa,EAAE,eAAe;IAC9B,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,EAAE,EAAE,IAAI;IACR,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,iBAAiB,EAAE,mBAAmB;IACtC,kBAAkB,EAAE,oBAAoB;IACxC,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,eAAe,EAAE,iBAAiB;IAClC,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,SAAS,EAAE,WAAW;IACtB,EAAE,EAAE,IAAI;IACR,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,iBAAiB,EAAE,mBAAmB;IACtC,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,UAAU;IACpB,UAAU,EAAE,YAAY;IACxB,OAAO,EAAE,SAAS;CACrB,CAAC"}
+{"version":3,"file":"pitugues.js","sourceRoot":"","sources":["../../fontes/tipos-de-simbolos/pitugues.ts"],"names":[],"mappings":";;AAAA,kBAAe;IACX,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,aAAa,EAAE,eAAe;IAC9B,cAAc,EAAE,gBAAgB;IAChC,MAAM,EAAE,QAAQ;IAChB,gBAAgB,EAAE,kBAAkB;IACpC,iBAAiB,EAAE,mBAAmB;IACtC,UAAU,EAAE,YAAY;IACxB,IAAI,EAAE,MAAM;IACZ,UAAU,EAAE,YAAY;IACxB,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,UAAU;IACpB,EAAE,EAAE,IAAI;IACR,SAAS,EAAE,WAAW;IACtB,OAAO,EAAE,SAAS;IAClB,eAAe,EAAE,iBAAiB;IAClC,WAAW,EAAE,aAAa;IAC1B,CAAC,EAAE,GAAG;IACN,EAAE,EAAE,IAAI;IACR,QAAQ,EAAE,UAAU;IACpB,GAAG,EAAE,KAAK;IACV,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,aAAa,EAAE,eAAe;IAC9B,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,aAAa;IAC1B,OAAO,EAAE,SAAS;IAClB,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,UAAU,EAAE,YAAY;IACxB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,aAAa,EAAE,eAAe;IAC9B,QAAQ,EAAE,UAAU;IACpB,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,UAAU,EAAE,YAAY;IACxB,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,MAAM,EAAE,QAAQ;IAChB,aAAa,EAAE,eAAe;IAC9B,GAAG,EAAE,KAAK;IACV,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,EAAE,EAAE,IAAI;IACR,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,iBAAiB,EAAE,mBAAmB;IACtC,kBAAkB,EAAE,oBAAoB;IACxC,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,eAAe,EAAE,iBAAiB;IAClC,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,SAAS,EAAE,WAAW;IACtB,EAAE,EAAE,IAAI;IACR,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,iBAAiB,EAAE,mBAAmB;IACtC,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,UAAU;IACpB,UAAU,EAAE,YAAY;IACxB,OAAO,EAAE,SAAS;CACrB,CAAC"}

package/umd/delegua.js

@@ -426,7 +426,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         throw this.erro(simboloPara, 'Identificador de iteração deve ser ou um par chave-valor, ou um nome de variável.');
     }
     paraTradicionalComoConstruto(simboloPara) {
-        const { inicializador, condicao, incrementar, corpo } = this.logicaComumPara(simboloPara);
+        const { inicializador, condicao, incrementar, corpo } = this.logicaComumPara();
         return new construtos_1.ParaComoConstruto(simboloPara.hashArquivo, simboloPara.linha, inicializador, condicao, incrementar, corpo);
     }
     /**
@@ -711,7 +711,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 return this.resolverCadeiaChamadas(chamada);
             case delegua_2.default.PONTO:
                 this.avancarEDevolverAnterior();
-                const nome = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado nome de método ou propriedade após '.'.");
+                this.verificarSeSimboloAtualEIgualA();
+                const nome = this.avancarEDevolverAnterior();
                 let tipoInferido = expressaoAnterior.tipo;
                 // Se não for um dicionário anônimo (ou seja, ser variável ou constante com nome)
                 if (expressaoAnterior.tipo === 'dicionário' &&
@@ -904,7 +905,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         return construtoChamada;
     }
     unario() {
-        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.NEGACAO, delegua_2.default.SUBTRACAO, delegua_2.default.BIT_NOT, delegua_2.default.INCREMENTAR, delegua_2.default.DECREMENTAR)) {
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.NAO, delegua_2.default.NEGACAO, delegua_2.default.SUBTRACAO, delegua_2.default.BIT_NOT, delegua_2.default.INCREMENTAR, delegua_2.default.DECREMENTAR)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.unario();
             return new construtos_1.Unario(this.hashArquivo, operador, direito, 'ANTES');
@@ -1004,10 +1005,16 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
     }
     em() {
         let expressao = this.comparacaoIgualdade();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.EM)) {
-            const operador = this.simbolos[this.atual - 1];
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.EM, delegua_2.default.CONTEM, delegua_2.default.NAO)) {
+            let operador = this.simbolos[this.atual - 1];
+            let negado = false;
+            if (operador.tipo === delegua_2.default.NAO) {
+                operador = this.consumir(delegua_2.default.CONTEM, `Esperado palavra reservada 'contém' ou 'contem' após palavra reservada ${operador.lexema}.`);
+                negado = true;
+            }
             const direito = this.comparacaoIgualdade();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
+            expressao.negado = negado;
         }
         return expressao;
     }
@@ -1391,7 +1398,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         throw this.erro(simboloPara, 'Identificador de iteração deve ser ou um par chave-valor, ou um nome de variável.');
     }
-    logicaComumPara(simboloPara) {
+    logicaComumPara() {
         const comParenteses = this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO);
         let inicializador;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA)) {
@@ -1430,7 +1437,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         };
     }
     declaracaoParaTradicional(simboloPara) {
-        const { inicializador, condicao, incrementar, corpo } = this.logicaComumPara(simboloPara);
+        const { inicializador, condicao, incrementar, corpo } = this.logicaComumPara();
         return new declaracoes_1.Para(this.hashArquivo, Number(simboloPara.linha), inicializador, condicao, incrementar, corpo);
     }
     declaracaoRetorna() {
@@ -1444,6 +1451,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             delegua_2.default.FUNÇÃO,
             delegua_2.default.IDENTIFICADOR,
             delegua_2.default.ISTO,
+            delegua_2.default.NAO,
             delegua_2.default.NEGACAO,
             delegua_2.default.NUMERO,
             delegua_2.default.NULO,
@@ -3652,10 +3660,16 @@ class AvaliadorSintaticoPitugues {
     }
     em() {
         let expressao = this.comparacaoIgualdade();
-        while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.EM)) {
-            const operador = this.simboloAnterior();
+        while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.EM, pitugues_2.default.CONTEM, pitugues_2.default.NAO)) {
+            let operador = this.simboloAnterior();
+            let negado = false;
+            if (operador.tipo === pitugues_2.default.NAO) {
+                operador = this.consumir(pitugues_2.default.CONTEM, `Esperado palavra reservada 'contém' ou 'contem' após palavra reservada ${operador.lexema}.`);
+                negado = true;
+            }
             const direito = this.comparacaoIgualdade();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
+            expressao.negado = negado;
         }
         return expressao;
     }
@@ -3839,54 +3853,27 @@ class AvaliadorSintaticoPitugues {
             this.blocos -= 1;
         }
     }
-    declaracaoParaCada(simboloPara) {
-        const nomeVariavelIteracao = this.consumir(pitugues_2.default.IDENTIFICADOR, "Esperado identificador de variável de iteração para instrução 'para cada'.");
-        if (!this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DE, pitugues_2.default.EM)) {
-            throw this.erro(this.simbolos[this.atual], "Esperado palavras reservadas 'em' ou 'de' após variável de iteração em instrução 'para cada'.");
-        }
-        const vetor = this.expressao();
-        if (!vetor.hasOwnProperty('tipo')) {
-            throw this.erro(simboloPara, `Variável ou constante em 'para cada' não parece possuir um tipo iterável.`);
-        }
-        const tipoVetor = vetor.tipo;
-        if (!tipoVetor.endsWith('[]') && !['qualquer', 'vetor'].includes(tipoVetor)) {
-            throw this.erro(simboloPara, `Variável ou constante em 'para cada' não é iterável. Tipo resolvido: ${tipoVetor}.`);
-        }
-        this.pilhaEscopos.definirInformacoesVariavel(nomeVariavelIteracao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeVariavelIteracao.lexema, tipoVetor.slice(0, -2)));
-        // TODO: Talvez não seja uma ideia melhor chamar o método de `Bloco` aqui?
-        const corpo = this.resolverDeclaracao();
-        return new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Variavel(this.hashArquivo, nomeVariavelIteracao), vetor, corpo);
-    }
-    declaracaoParaTradicional(simboloPara) {
-        let inicializador;
-        if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.PONTO_E_VIRGULA)) {
-            inicializador = null;
-        }
-        else if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VARIAVEL)) {
-            inicializador = this.declaracaoDeVariaveis();
-        }
-        else {
-            inicializador = this.declaracaoExpressao();
-        }
-        let condicao = null;
-        if (!this.verificarTipoSimboloAtual(pitugues_2.default.PONTO_E_VIRGULA)) {
-            condicao = this.expressao();
-        }
-        let incrementar = null;
-        if (this.simbolos[this.atual].tipo !== pitugues_2.default.DOIS_PONTOS) {
-            incrementar = this.expressao();
-        }
-        const corpo = this.resolverDeclaracao();
-        return new declaracoes_1.Para(this.hashArquivo, Number(simboloPara.linha), inicializador, condicao, incrementar, corpo);
-    }
     declaracaoPara() {
         try {
             const simboloPara = this.simboloAnterior();
             this.blocos += 1;
-            if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.CADA)) {
-                return this.declaracaoParaCada(simboloPara);
+            this.consumir(pitugues_2.default.CADA, `Esperado palavra reservada 'cada' após 'para'. Atual: ${this.simbolos[this.atual].lexema}.`);
+            const nomeVariavelIteracao = this.consumir(pitugues_2.default.IDENTIFICADOR, "Esperado identificador de variável de iteração para instrução 'para cada'.");
+            if (!this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DE, pitugues_2.default.EM)) {
+                throw this.erro(this.simbolos[this.atual], "Esperado palavras reservadas 'em' ou 'de' após variável de iteração em instrução 'para cada'.");
             }
-            return this.declaracaoParaTradicional(simboloPara);
+            const vetor = this.expressao();
+            if (!vetor.hasOwnProperty('tipo')) {
+                throw this.erro(simboloPara, `Variável ou constante em 'para cada' não parece possuir um tipo iterável.`);
+            }
+            const tipoVetor = vetor.tipo;
+            if (!tipoVetor.endsWith('[]') && !['qualquer', 'texto', 'vetor'].includes(tipoVetor)) {
+                throw this.erro(simboloPara, `Variável ou constante em 'para cada' não é iterável. Tipo resolvido: ${tipoVetor}.`);
+            }
+            this.pilhaEscopos.definirInformacoesVariavel(nomeVariavelIteracao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeVariavelIteracao.lexema, tipoVetor.slice(0, -2)));
+            // TODO: Talvez não seja uma ideia melhor chamar o método de `Bloco` aqui?
+            const corpo = this.resolverDeclaracao();
+            return new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Variavel(this.hashArquivo, nomeVariavelIteracao), vetor, corpo);
         }
         catch (erro) {
             throw erro;
@@ -8654,6 +8641,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logico = void 0;
 class Logico {
     constructor(hashArquivo, esquerda, operador, direita) {
+        this.negado = false;
         this.linha = esquerda.linha;
         this.hashArquivo = hashArquivo;
         this.esquerda = esquerda;
@@ -12827,18 +12815,31 @@ class InterpretadorBase {
     async visitarDeclaracaoDeExpressao(declaracao) {
         return await this.avaliar(declaracao.expressao);
     }
+    logicaContemOuEm(esquerda, direita, expressao) {
+        const valorDireitoResolvido = this.resolverValor(direita);
+        if (Array.isArray(valorDireitoResolvido) || typeof valorDireitoResolvido === primitivos_1.default.TEXTO) {
+            const avaliacao = valorDireitoResolvido.includes(esquerda);
+            return expressao.negado ? !avaliacao : avaliacao;
+        }
+        if (valorDireitoResolvido !== null && typeof valorDireitoResolvido === 'object') {
+            const avaliacao = esquerda in valorDireitoResolvido;
+            return expressao.negado ? !avaliacao : avaliacao;
+        }
+        throw new excecoes_1.ErroEmTempoDeExecucao(esquerda, `Tipo de chamada inválida com '${expressao.operador.tipo}'.`, expressao.linha);
+    }
     async visitarExpressaoLogica(expressao) {
         const esquerda = await this.avaliar(expressao.esquerda);
-        if (expressao.operador.tipo === delegua_1.default.EM) {
+        if ([delegua_1.default.EM, delegua_1.default.CONTEM].includes(expressao.operador.tipo)) {
             const direita = await this.avaliar(expressao.direita);
-            if (Array.isArray(direita) || typeof direita === primitivos_1.default.TEXTO) {
-                return direita.includes(esquerda);
-            }
-            else if (direita !== null && typeof direita === 'object') {
-                return (esquerda in direita ||
-                    (direita.valor !== undefined && esquerda in direita.valor));
+            // `3 em lista` é igual a `lista contém 3`.
+            // Portanto, precisamos inverter os operandos de acordo com a 
+            // palavra reservada usada.
+            switch (expressao.operador.tipo) {
+                case delegua_1.default.EM:
+                    return this.logicaContemOuEm(esquerda, direita, expressao);
+                case delegua_1.default.CONTEM:
+                    return this.logicaContemOuEm(direita, esquerda, expressao);
             }
-            throw new excecoes_1.ErroEmTempoDeExecucao(esquerda, "Tipo de chamada inválida com 'em'.", expressao.linha);
         }
         // se um estado for verdadeiro, retorna verdadeiro
         if (expressao.operador.tipo === delegua_1.default.OU) {
@@ -15787,9 +15788,9 @@ class LexadorPitugues {
             this.analisarIndentacao();
         }
     }
-    adicionarSimbolo(tipo, literal = null) {
+    adicionarSimbolo(tipo, literal = null, linha = null) {
         const texto = this.codigo[this.linha].substring(this.inicioSimbolo, this.atual);
-        this.simbolos.push(new simbolo_1.Simbolo(tipo, texto, literal, this.linha + 1, this.hashArquivo));
+        this.simbolos.push(new simbolo_1.Simbolo(tipo, texto, literal, linha || this.linha + 1, this.hashArquivo));
     }
     simboloAtual() {
         if (this.eFinalDaLinha())
@@ -15890,8 +15891,8 @@ class LexadorPitugues {
         else {
             textoPalavraChave = this.codigo[this.linha].substring(this.inicioSimbolo, this.atual);
         }
-        const tipo = textoPalavraChave in pitugues_1.palavrasReservadas
-            ? pitugues_1.palavrasReservadas[textoPalavraChave]
+        const tipo = textoPalavraChave in pitugues_1.palavrasReservadasPitugues
+            ? pitugues_1.palavrasReservadasPitugues[textoPalavraChave]
             : pitugues_2.default.IDENTIFICADOR;
         this.simbolos.push(new simbolo_1.Simbolo(tipo, textoPalavraChave, null, linhaPrimeiroCaracter + 1, this.hashArquivo));
     }
@@ -15914,8 +15915,8 @@ class LexadorPitugues {
             ultimoAtual = this.atual;
             this.avancar();
         }
-        const conteudo = this.codigo[linhaAtual].substring(this.inicioSimbolo + 2, ultimoAtual);
-        this.adicionarSimbolo(pitugues_2.default.COMENTARIO, conteudo.trim());
+        const conteudo = this.codigo[linhaAtual].substring(this.inicioSimbolo + 2, ultimoAtual + 1);
+        this.adicionarSimbolo(pitugues_2.default.COMENTARIO, conteudo.trim(), linhaAtual + 1);
     }
     avancarParaProximaLinha() {
         this.linha++;
@@ -16867,14 +16868,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.palavrasReservadasMicroGramatica = exports.palavrasReservadas = void 0;
+exports.palavrasReservadasMicroGramatica = exports.palavrasReservadasPitugues = void 0;
 const pitugues_1 = __importDefault(require("../../../tipos-de-simbolos/pitugues"));
-exports.palavrasReservadas = {
+exports.palavrasReservadasPitugues = {
     cada: pitugues_1.default.CADA,
     caso: pitugues_1.default.CASO,
     classe: pitugues_1.default.CLASSE,
     como: pitugues_1.default.COMO,
     construtor: pitugues_1.default.CONSTRUTOR,
+    contem: pitugues_1.default.CONTEM,
+    contém: pitugues_1.default.CONTEM,
     continua: pitugues_1.default.CONTINUA,
     de: pitugues_1.default.DE,
     e: pitugues_1.default.E,
@@ -16892,6 +16895,8 @@ exports.palavrasReservadas = {
     imprima: pitugues_1.default.IMPRIMA,
     isto: pitugues_1.default.ISTO,
     leia: pitugues_1.default.LEIA,
+    nao: pitugues_1.default.NAO,
+    não: pitugues_1.default.NAO,
     nulo: pitugues_1.default.NULO,
     ou: pitugues_1.default.OU,
     padrao: pitugues_1.default.PADRAO,
@@ -17409,8 +17414,8 @@ class Lexador {
             this.avancar();
         }
         const codigo = this.codigo[this.linha].substring(this.inicioSimbolo, this.atual);
-        const tipo = codigo in palavras_reservadas_1.palavrasReservadas
-            ? palavras_reservadas_1.palavrasReservadas[codigo]
+        const tipo = codigo in palavras_reservadas_1.palavrasReservadasDelegua
+            ? palavras_reservadas_1.palavrasReservadasDelegua[codigo]
             : delegua_1.default.IDENTIFICADOR;
         this.adicionarSimbolo(tipo);
     }
@@ -17933,17 +17938,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.palavrasReservadasMicroGramatica = exports.palavrasReservadas = void 0;
+exports.palavrasReservadasMicroGramatica = exports.palavrasReservadasDelegua = void 0;
 const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
-exports.palavrasReservadas = {
+exports.palavrasReservadasDelegua = {
     cada: delegua_1.default.CADA,
     caso: delegua_1.default.CASO,
     classe: delegua_1.default.CLASSE,
     como: delegua_1.default.COMO,
     construtor: delegua_1.default.CONSTRUTOR,
-    continua: delegua_1.default.CONTINUA,
     constante: delegua_1.default.CONSTANTE,
     const: delegua_1.default.CONSTANTE,
+    contem: delegua_1.default.CONTEM,
+    contém: delegua_1.default.CONTEM,
+    continua: delegua_1.default.CONTINUA,
     de: delegua_1.default.DE,
     e: delegua_1.default.E,
     em: delegua_1.default.EM,
@@ -17961,6 +17968,8 @@ exports.palavrasReservadas = {
     importar: delegua_1.default.IMPORTAR,
     isto: delegua_1.default.ISTO,
     leia: delegua_1.default.LEIA,
+    nao: delegua_1.default.NAO,
+    não: delegua_1.default.NAO,
     nulo: delegua_1.default.NULO,
     ou: delegua_1.default.OU,
     padrao: delegua_1.default.PADRAO,
@@ -18206,6 +18215,7 @@ exports.default = {
     COMO: 'COMO',
     CONSTANTE: 'CONSTANTE',
     CONSTRUTOR: 'CONSTRUTOR',
+    CONTEM: 'CONTEM',
     CONTINUA: 'CONTINUA',
     DE: 'DE',
     DECREMENTAR: 'DECREMENTAR',
@@ -18252,6 +18262,7 @@ exports.default = {
     MODULO_IGUAL: 'MODULO_IGUAL',
     MULTIPLICACAO: 'MULTIPLICACAO',
     MULTIPLICACAO_IGUAL: 'MULTIPLICACAO_IGUAL',
+    NAO: 'NAO',
     NEGACAO: 'NEGACAO',
     NULO: 'NULO',
     NUMERO: 'NUMERO',
@@ -18392,6 +18403,7 @@ exports.default = {
     CHAVE_ESQUERDA: 'CHAVE_ESQUERDA',
     COLCHETE_DIREITO: 'COLCHETE_DIREITO',
     COLCHETE_ESQUERDO: 'COLCHETE_ESQUERDO',
+    CONTEM: 'CONTEM',
     DECREMENTAR: 'DECREMENTAR',
     DIFERENTE: 'DIFERENTE',
     DIVISAO: 'DIVISAO',
@@ -18416,6 +18428,7 @@ exports.default = {
     MENOR_MENOR: 'MENOR_MENOR',
     MODULO: 'MODULO',
     MULTIPLICACAO: 'MULTIPLICACAO',
+    NAO: 'NAO',
     NEGACAO: 'NEGACAO',
     NULO: 'NULO',
     NUMERO: 'NUMERO',
@@ -18449,6 +18462,7 @@ exports.default = {
     COMENTARIO: 'COMENTARIO',
     COMO: 'COMO',
     CONSTRUTOR: 'CONSTRUTOR',
+    CONTEM: 'CONTEM',
     CONTINUA: 'CONTINUA',
     DE: 'DE',
     DIFERENTE: 'DIFERENTE',
@@ -18485,6 +18499,7 @@ exports.default = {
     MENOR_MENOR: 'MENOR_MENOR',
     MODULO: 'MODULO',
     MULTIPLICACAO: 'MULTIPLICACAO',
+    NAO: 'NAO',
     NEGACAO: 'NEGACAO',
     NULO: 'NULO',
     NUMERO: 'NUMERO',