@designliquido/delegua 0.36.1 → 0.36.2

package/construtos/acesso-indice-variavel.js

@@ -1,21 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AcessoIndiceVariavel = void 0;
-/**
- * Definido como `Subscript` em Égua Clássico, esse construto serve para acessar índices de
- * vetores e dicionários.
- */
-class AcessoIndiceVariavel {
-    constructor(hashArquivo, entidadeChamada, indice, simboloFechamento) {
-        this.linha = entidadeChamada.linha;
-        this.hashArquivo = hashArquivo;
-        this.entidadeChamada = entidadeChamada;
-        this.indice = indice;
-        this.simboloFechamento = simboloFechamento;
-    }
-    async aceitar(visitante) {
-        return await visitante.visitarExpressaoAcessoIndiceVariavel(this);
-    }
-}
-exports.AcessoIndiceVariavel = AcessoIndiceVariavel;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcessoIndiceVariavel = void 0;
+/**
+ * Definido como `Subscript` em Égua Clássico, esse construto serve para acessar índices de
+ * vetores e dicionários.
+ */
+class AcessoIndiceVariavel {
+    constructor(hashArquivo, entidadeChamada, indice, simboloFechamento) {
+        this.linha = entidadeChamada.linha;
+        this.hashArquivo = hashArquivo;
+        this.entidadeChamada = entidadeChamada;
+        this.indice = indice;
+        this.simboloFechamento = simboloFechamento;
+    }
+    async aceitar(visitante) {
+        return await visitante.visitarExpressaoAcessoIndiceVariavel(this);
+    }
+}
+exports.AcessoIndiceVariavel = AcessoIndiceVariavel;
 //# sourceMappingURL=acesso-indice-variavel.js.map

package/construtos/acesso-metodo-ou-propriedade.d.ts

@@ -1,15 +1,15 @@
-import { VisitanteComumInterface, SimboloInterface } from '../interfaces';
-import { Construto } from './construto';
-/**
- * Chamado de `Get` em Égua Clássico, é o construto de acesso a métodos ou membros de
- * classe.
- */
-export declare class AcessoMetodoOuPropriedade<TTipoSimbolo extends string = string> implements Construto {
-    linha: number;
-    hashArquivo: number;
-    objeto: Construto;
-    simbolo: SimboloInterface<TTipoSimbolo>;
-    constructor(hashArquivo: number, objeto: Construto, simbolo: SimboloInterface<TTipoSimbolo>);
-    aceitar(visitante: VisitanteComumInterface): Promise<any>;
-}
+import { VisitanteComumInterface, SimboloInterface } from '../interfaces';
+import { Construto } from './construto';
+/**
+ * Chamado de `Get` em Égua Clássico, é o construto de acesso a métodos ou membros de
+ * classe.
+ */
+export declare class AcessoMetodoOuPropriedade<TTipoSimbolo extends string = string> implements Construto {
+    linha: number;
+    hashArquivo: number;
+    objeto: Construto;
+    simbolo: SimboloInterface<TTipoSimbolo>;
+    constructor(hashArquivo: number, objeto: Construto, simbolo: SimboloInterface<TTipoSimbolo>);
+    aceitar(visitante: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=acesso-metodo-ou-propriedade.d.ts.map

package/construtos/acesso-metodo-ou-propriedade.js

@@ -1,20 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AcessoMetodoOuPropriedade = void 0;
-/**
- * Chamado de `Get` em Égua Clássico, é o construto de acesso a métodos ou membros de
- * classe.
- */
-class AcessoMetodoOuPropriedade {
-    constructor(hashArquivo, objeto, simbolo) {
-        this.linha = objeto.linha;
-        this.hashArquivo = hashArquivo;
-        this.objeto = objeto;
-        this.simbolo = simbolo;
-    }
-    async aceitar(visitante) {
-        return await visitante.visitarExpressaoAcessoMetodo(this);
-    }
-}
-exports.AcessoMetodoOuPropriedade = AcessoMetodoOuPropriedade;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcessoMetodoOuPropriedade = void 0;
+/**
+ * Chamado de `Get` em Égua Clássico, é o construto de acesso a métodos ou membros de
+ * classe.
+ */
+class AcessoMetodoOuPropriedade {
+    constructor(hashArquivo, objeto, simbolo) {
+        this.linha = objeto.linha;
+        this.hashArquivo = hashArquivo;
+        this.objeto = objeto;
+        this.simbolo = simbolo;
+    }
+    async aceitar(visitante) {
+        return await visitante.visitarExpressaoAcessoMetodo(this);
+    }
+}
+exports.AcessoMetodoOuPropriedade = AcessoMetodoOuPropriedade;
 //# sourceMappingURL=acesso-metodo-ou-propriedade.js.map

package/construtos/agrupamento.d.ts

@@ -1,15 +1,15 @@
-import { VisitanteComumInterface } from '../interfaces';
-import { Construto } from './construto';
-/**
- * Um agrupamento é essencialmente uma expressão qualquer dentro de parênteses.
- * Usado para resolver precedência de operadores. Por exemplo:
- * `(2 + 2) * 5`, `(2 + 2)` é um agrupamento cuja expressão é `2 + 2`.
- */
-export declare class Agrupamento implements Construto {
-    linha: number;
-    hashArquivo: number;
-    expressao: Construto;
-    constructor(hashArquivo: number, linha: number, expressao: Construto);
-    aceitar(visitante: VisitanteComumInterface): Promise<any>;
-}
+import { VisitanteComumInterface } from '../interfaces';
+import { Construto } from './construto';
+/**
+ * Um agrupamento é essencialmente uma expressão qualquer dentro de parênteses.
+ * Usado para resolver precedência de operadores. Por exemplo:
+ * `(2 + 2) * 5`, `(2 + 2)` é um agrupamento cuja expressão é `2 + 2`.
+ */
+export declare class Agrupamento implements Construto {
+    linha: number;
+    hashArquivo: number;
+    expressao: Construto;
+    constructor(hashArquivo: number, linha: number, expressao: Construto);
+    aceitar(visitante: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=agrupamento.d.ts.map

package/construtos/agrupamento.js

@@ -1,20 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Agrupamento = void 0;
-/**
- * Um agrupamento é essencialmente uma expressão qualquer dentro de parênteses.
- * Usado para resolver precedência de operadores. Por exemplo:
- * `(2 + 2) * 5`, `(2 + 2)` é um agrupamento cuja expressão é `2 + 2`.
- */
-class Agrupamento {
-    constructor(hashArquivo, linha, expressao) {
-        this.linha = linha;
-        this.hashArquivo = hashArquivo;
-        this.expressao = expressao;
-    }
-    async aceitar(visitante) {
-        return await visitante.visitarExpressaoAgrupamento(this);
-    }
-}
-exports.Agrupamento = Agrupamento;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agrupamento = void 0;
+/**
+ * Um agrupamento é essencialmente uma expressão qualquer dentro de parênteses.
+ * Usado para resolver precedência de operadores. Por exemplo:
+ * `(2 + 2) * 5`, `(2 + 2)` é um agrupamento cuja expressão é `2 + 2`.
+ */
+class Agrupamento {
+    constructor(hashArquivo, linha, expressao) {
+        this.linha = linha;
+        this.hashArquivo = hashArquivo;
+        this.expressao = expressao;
+    }
+    async aceitar(visitante) {
+        return await visitante.visitarExpressaoAgrupamento(this);
+    }
+}
+exports.Agrupamento = Agrupamento;
 //# sourceMappingURL=agrupamento.js.map

package/construtos/atribuicao-por-indice.d.ts

@@ -1,12 +1,12 @@
-import { VisitanteComumInterface } from '../interfaces';
-import { Construto } from './construto';
-export declare class AtribuicaoPorIndice implements Construto {
-    linha: number;
-    hashArquivo: number;
-    objeto: any;
-    valor: any;
-    indice: any;
-    constructor(hashArquivo: number, linha: number, objeto: any, indice: any, valor: any);
-    aceitar(visitante: VisitanteComumInterface): Promise<any>;
-}
+import { VisitanteComumInterface } from '../interfaces';
+import { Construto } from './construto';
+export declare class AtribuicaoPorIndice implements Construto {
+    linha: number;
+    hashArquivo: number;
+    objeto: any;
+    valor: any;
+    indice: any;
+    constructor(hashArquivo: number, linha: number, objeto: any, indice: any, valor: any);
+    aceitar(visitante: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=atribuicao-por-indice.d.ts.map

package/construtos/atribuicao-por-indice.js

@@ -1,17 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AtribuicaoPorIndice = void 0;
-class AtribuicaoPorIndice {
-    constructor(hashArquivo, linha, objeto, indice, valor) {
-        this.linha = linha;
-        this.hashArquivo = hashArquivo;
-        this.objeto = objeto;
-        this.indice = indice;
-        this.valor = valor;
-    }
-    async aceitar(visitante) {
-        return await visitante.visitarExpressaoAtribuicaoPorIndice(this);
-    }
-}
-exports.AtribuicaoPorIndice = AtribuicaoPorIndice;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtribuicaoPorIndice = void 0;
+class AtribuicaoPorIndice {
+    constructor(hashArquivo, linha, objeto, indice, valor) {
+        this.linha = linha;
+        this.hashArquivo = hashArquivo;
+        this.objeto = objeto;
+        this.indice = indice;
+        this.valor = valor;
+    }
+    async aceitar(visitante) {
+        return await visitante.visitarExpressaoAtribuicaoPorIndice(this);
+    }
+}
+exports.AtribuicaoPorIndice = AtribuicaoPorIndice;
 //# sourceMappingURL=atribuicao-por-indice.js.map

package/construtos/atribuicao-por-indices-matriz.d.ts

@@ -1,13 +1,13 @@
-import { VisitanteComumInterface } from '../interfaces';
-import { Construto } from './construto';
-export declare class AtribuicaoPorIndicesMatriz implements Construto {
-    linha: number;
-    hashArquivo: number;
-    objeto: any;
-    valor: any;
-    indicePrimario: any;
-    indiceSecundario: any;
-    constructor(hashArquivo: number, linha: number, objeto: any, indicePrimario: any, indiceSecundario: any, valor: any);
-    aceitar(visitante: VisitanteComumInterface): Promise<any>;
-}
+import { VisitanteComumInterface } from '../interfaces';
+import { Construto } from './construto';
+export declare class AtribuicaoPorIndicesMatriz implements Construto {
+    linha: number;
+    hashArquivo: number;
+    objeto: any;
+    valor: any;
+    indicePrimario: any;
+    indiceSecundario: any;
+    constructor(hashArquivo: number, linha: number, objeto: any, indicePrimario: any, indiceSecundario: any, valor: any);
+    aceitar(visitante: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=atribuicao-por-indices-matriz.d.ts.map

package/construtos/atribuicao-por-indices-matriz.js

@@ -1,18 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AtribuicaoPorIndicesMatriz = void 0;
-class AtribuicaoPorIndicesMatriz {
-    constructor(hashArquivo, linha, objeto, indicePrimario, indiceSecundario, valor) {
-        this.linha = linha;
-        this.hashArquivo = hashArquivo;
-        this.objeto = objeto;
-        this.indicePrimario = indicePrimario;
-        this.indiceSecundario = indiceSecundario;
-        this.valor = valor;
-    }
-    async aceitar(visitante) {
-        return await visitante.visitarExpressaoAtribuicaoPorIndicesMatriz(this);
-    }
-}
-exports.AtribuicaoPorIndicesMatriz = AtribuicaoPorIndicesMatriz;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtribuicaoPorIndicesMatriz = void 0;
+class AtribuicaoPorIndicesMatriz {
+    constructor(hashArquivo, linha, objeto, indicePrimario, indiceSecundario, valor) {
+        this.linha = linha;
+        this.hashArquivo = hashArquivo;
+        this.objeto = objeto;
+        this.indicePrimario = indicePrimario;
+        this.indiceSecundario = indiceSecundario;
+        this.valor = valor;
+    }
+    async aceitar(visitante) {
+        return await visitante.visitarExpressaoAtribuicaoPorIndicesMatriz(this);
+    }
+}
+exports.AtribuicaoPorIndicesMatriz = AtribuicaoPorIndicesMatriz;
 //# sourceMappingURL=atribuicao-por-indices-matriz.js.map

package/construtos/atribuir.d.ts

@@ -1,16 +1,16 @@
-import { VisitanteComumInterface, SimboloInterface } from '../interfaces';
-import { Construto } from './construto';
-import { Literal } from './literal';
-/**
- * Construto de atribuição de um valor a um símbolo.
- */
-export declare class Atribuir<TTipoSimbolo extends string = string> implements Construto {
-    linha: number;
-    hashArquivo: number;
-    indice?: Literal;
-    simbolo: SimboloInterface<TTipoSimbolo>;
-    valor: any;
-    constructor(hashArquivo: number, simbolo: SimboloInterface<TTipoSimbolo>, valor: any, indice?: Literal);
-    aceitar(visitante: VisitanteComumInterface): Promise<any>;
-}
+import { VisitanteComumInterface, SimboloInterface } from '../interfaces';
+import { Construto } from './construto';
+import { Literal } from './literal';
+/**
+ * Construto de atribuição de um valor a um símbolo.
+ */
+export declare class Atribuir<TTipoSimbolo extends string = string> implements Construto {
+    linha: number;
+    hashArquivo: number;
+    indice?: Literal;
+    simbolo: SimboloInterface<TTipoSimbolo>;
+    valor: any;
+    constructor(hashArquivo: number, simbolo: SimboloInterface<TTipoSimbolo>, valor: any, indice?: Literal);
+    aceitar(visitante: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=atribuir.d.ts.map

package/construtos/atribuir.js

@@ -1,25 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Atribuir = void 0;
-/**
- * Construto de atribuição de um valor a um símbolo.
- */
-class Atribuir {
-    constructor(hashArquivo, simbolo, valor, 
-    // indice so é usado para variaveis de vetores
-    // TODO: criar alguma validaçao para garantir que indice so seja passado para variaveis de vetores
-    indice) {
-        this.linha = Number(simbolo.linha);
-        this.hashArquivo = hashArquivo;
-        this.simbolo = simbolo;
-        this.valor = valor;
-        if (indice !== undefined) {
-            this.indice = indice;
-        }
-    }
-    async aceitar(visitante) {
-        return await visitante.visitarExpressaoDeAtribuicao(this);
-    }
-}
-exports.Atribuir = Atribuir;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Atribuir = void 0;
+/**
+ * Construto de atribuição de um valor a um símbolo.
+ */
+class Atribuir {
+    constructor(hashArquivo, simbolo, valor, 
+    // indice so é usado para variaveis de vetores
+    // TODO: criar alguma validaçao para garantir que indice so seja passado para variaveis de vetores
+    indice) {
+        this.linha = Number(simbolo.linha);
+        this.hashArquivo = hashArquivo;
+        this.simbolo = simbolo;
+        this.valor = valor;
+        if (indice !== undefined) {
+            this.indice = indice;
+        }
+    }
+    async aceitar(visitante) {
+        return await visitante.visitarExpressaoDeAtribuicao(this);
+    }
+}
+exports.Atribuir = Atribuir;
 //# sourceMappingURL=atribuir.js.map

package/construtos/atribuir.js.map

@@ -1 +1 @@
-{"version":3,"file":"atribuir.js","sourceRoot":"","sources":["../../fontes/construtos/atribuir.ts"],"names":[],"mappings":";;;AAIA;;GAEG;AACH,MAAa,QAAQ;IASjB,YACI,WAAmB,EACnB,OAAuC,EACvC,KAAU;IACV,8CAA8C;IAC9C,kGAAkG;IAClG,MAAgB;QAEhB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACnC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAE/B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,IAAI,MAAM,KAAK,SAAS,EAAE;YACtB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;SACxB;IACL,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,SAAkC;QAC5C,OAAO,MAAM,SAAS,CAAC,4BAA4B,CAAC,IAAI,CAAC,CAAC;IAC9D,CAAC;CACJ;AA/BD,4BA+BC"}
+{"version":3,"file":"atribuir.js","sourceRoot":"","sources":["../../fontes/construtos/atribuir.ts"],"names":[],"mappings":";;;AAIA;;GAEG;AACH,MAAa,QAAQ;IASjB,YACI,WAAmB,EACnB,OAAuC,EACvC,KAAU;IACV,8CAA8C;IAC9C,kGAAkG;IAClG,MAAgB;QAEhB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACnC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAE/B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACvB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACzB,CAAC;IACL,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,SAAkC;QAC5C,OAAO,MAAM,SAAS,CAAC,4BAA4B,CAAC,IAAI,CAAC,CAAC;IAC9D,CAAC;CACJ;AA/BD,4BA+BC"}

package/construtos/binario.d.ts

@@ -1,34 +1,34 @@
-import { VisitanteComumInterface, SimboloInterface } from '../interfaces';
-import { Construto } from './construto';
-/**
- * Binário é uma estrutura com um operador e dois operandos: esquerda e direita.
- * Implementa as seguintes operações para Delégua e todos os dialetos:
- *
- * - `+` (Adição);
- * - `-` (Subtração);
- * - `*` (Multiplicação);
- * - `/` (Divisão);
- * - `%` (Módulo);
- *
- * Algumas outras operações podem ser suportadas de dialeto para dialeto,
- * como por exemplo:
- *
- * - `+=` (Adição com Atribuição);
- * - `-=` (Subtração com Atribuição);
- * - `*=` (Multiplicação com Atribuição);
- * - `/=` (Divisão com Atribuição);
- * - `%=` (Módulo com Atribuição);
- * - `**` (Exponenciação);
- * - `::` (Concatenação);
- * - `\` (Divisão inteira).
- */
-export declare class Binario<TTipoSimbolo extends string = string> implements Construto {
-    linha: number;
-    hashArquivo: number;
-    esquerda: Construto;
-    operador: SimboloInterface<TTipoSimbolo>;
-    direita: Construto;
-    constructor(hashArquivo: number, esquerda: any, operador: SimboloInterface<TTipoSimbolo>, direita: any);
-    aceitar(visitante: VisitanteComumInterface): Promise<any>;
-}
+import { VisitanteComumInterface, SimboloInterface } from '../interfaces';
+import { Construto } from './construto';
+/**
+ * Binário é uma estrutura com um operador e dois operandos: esquerda e direita.
+ * Implementa as seguintes operações para Delégua e todos os dialetos:
+ *
+ * - `+` (Adição);
+ * - `-` (Subtração);
+ * - `*` (Multiplicação);
+ * - `/` (Divisão);
+ * - `%` (Módulo);
+ *
+ * Algumas outras operações podem ser suportadas de dialeto para dialeto,
+ * como por exemplo:
+ *
+ * - `+=` (Adição com Atribuição);
+ * - `-=` (Subtração com Atribuição);
+ * - `*=` (Multiplicação com Atribuição);
+ * - `/=` (Divisão com Atribuição);
+ * - `%=` (Módulo com Atribuição);
+ * - `**` (Exponenciação);
+ * - `::` (Concatenação);
+ * - `\` (Divisão inteira).
+ */
+export declare class Binario<TTipoSimbolo extends string = string> implements Construto {
+    linha: number;
+    hashArquivo: number;
+    esquerda: Construto;
+    operador: SimboloInterface<TTipoSimbolo>;
+    direita: Construto;
+    constructor(hashArquivo: number, esquerda: any, operador: SimboloInterface<TTipoSimbolo>, direita: any);
+    aceitar(visitante: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=binario.d.ts.map

package/construtos/binario.js

@@ -1,39 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Binario = void 0;
-/**
- * Binário é uma estrutura com um operador e dois operandos: esquerda e direita.
- * Implementa as seguintes operações para Delégua e todos os dialetos:
- *
- * - `+` (Adição);
- * - `-` (Subtração);
- * - `*` (Multiplicação);
- * - `/` (Divisão);
- * - `%` (Módulo);
- *
- * Algumas outras operações podem ser suportadas de dialeto para dialeto,
- * como por exemplo:
- *
- * - `+=` (Adição com Atribuição);
- * - `-=` (Subtração com Atribuição);
- * - `*=` (Multiplicação com Atribuição);
- * - `/=` (Divisão com Atribuição);
- * - `%=` (Módulo com Atribuição);
- * - `**` (Exponenciação);
- * - `::` (Concatenação);
- * - `\` (Divisão inteira).
- */
-class Binario {
-    constructor(hashArquivo, esquerda, operador, direita) {
-        this.linha = esquerda.linha;
-        this.hashArquivo = hashArquivo;
-        this.esquerda = esquerda;
-        this.operador = operador;
-        this.direita = direita;
-    }
-    async aceitar(visitante) {
-        return await visitante.visitarExpressaoBinaria(this);
-    }
-}
-exports.Binario = Binario;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Binario = void 0;
+/**
+ * Binário é uma estrutura com um operador e dois operandos: esquerda e direita.
+ * Implementa as seguintes operações para Delégua e todos os dialetos:
+ *
+ * - `+` (Adição);
+ * - `-` (Subtração);
+ * - `*` (Multiplicação);
+ * - `/` (Divisão);
+ * - `%` (Módulo);
+ *
+ * Algumas outras operações podem ser suportadas de dialeto para dialeto,
+ * como por exemplo:
+ *
+ * - `+=` (Adição com Atribuição);
+ * - `-=` (Subtração com Atribuição);
+ * - `*=` (Multiplicação com Atribuição);
+ * - `/=` (Divisão com Atribuição);
+ * - `%=` (Módulo com Atribuição);
+ * - `**` (Exponenciação);
+ * - `::` (Concatenação);
+ * - `\` (Divisão inteira).
+ */
+class Binario {
+    constructor(hashArquivo, esquerda, operador, direita) {
+        this.linha = esquerda.linha;
+        this.hashArquivo = hashArquivo;
+        this.esquerda = esquerda;
+        this.operador = operador;
+        this.direita = direita;
+    }
+    async aceitar(visitante) {
+        return await visitante.visitarExpressaoBinaria(this);
+    }
+}
+exports.Binario = Binario;
 //# sourceMappingURL=binario.js.map

package/construtos/chamada.d.ts

@@ -1,16 +1,16 @@
-import { VisitanteComumInterface } from '../interfaces';
-import { Construto } from './construto';
-/**
- * Chamada de funções, métodos, etc.
- */
-export declare class Chamada implements Construto {
-    id: string;
-    linha: number;
-    hashArquivo: number;
-    entidadeChamada: Construto;
-    argumentos: any[];
-    parentese: any;
-    constructor(hashArquivo: number, entidadeChamada: Construto, parentese: any, argumentos: any[]);
-    aceitar(visitante: VisitanteComumInterface): Promise<any>;
-}
+import { VisitanteComumInterface } from '../interfaces';
+import { Construto } from './construto';
+/**
+ * Chamada de funções, métodos, etc.
+ */
+export declare class Chamada implements Construto {
+    id: string;
+    linha: number;
+    hashArquivo: number;
+    entidadeChamada: Construto;
+    argumentos: any[];
+    parentese: any;
+    constructor(hashArquivo: number, entidadeChamada: Construto, parentese: any, argumentos: any[]);
+    aceitar(visitante: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=chamada.d.ts.map

package/construtos/chamada.js

@@ -1,22 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Chamada = void 0;
-const geracao_identificadores_1 = require("../geracao-identificadores");
-/**
- * Chamada de funções, métodos, etc.
- */
-class Chamada {
-    constructor(hashArquivo, entidadeChamada, parentese, argumentos) {
-        this.id = (0, geracao_identificadores_1.uuidv4)();
-        this.linha = entidadeChamada.linha;
-        this.hashArquivo = hashArquivo;
-        this.entidadeChamada = entidadeChamada;
-        this.parentese = parentese;
-        this.argumentos = argumentos;
-    }
-    async aceitar(visitante) {
-        return await visitante.visitarExpressaoDeChamada(this);
-    }
-}
-exports.Chamada = Chamada;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chamada = void 0;
+const geracao_identificadores_1 = require("../geracao-identificadores");
+/**
+ * Chamada de funções, métodos, etc.
+ */
+class Chamada {
+    constructor(hashArquivo, entidadeChamada, parentese, argumentos) {
+        this.id = (0, geracao_identificadores_1.uuidv4)();
+        this.linha = entidadeChamada.linha;
+        this.hashArquivo = hashArquivo;
+        this.entidadeChamada = entidadeChamada;
+        this.parentese = parentese;
+        this.argumentos = argumentos;
+    }
+    async aceitar(visitante) {
+        return await visitante.visitarExpressaoDeChamada(this);
+    }
+}
+exports.Chamada = Chamada;
 //# sourceMappingURL=chamada.js.map

package/construtos/comentario.d.ts

@@ -1,16 +1,16 @@
-import { VisitanteComumInterface } from "../interfaces";
-import { Construto } from "./construto";
-/**
- * Como construto, um comentário é normalmente útil para formatadores de código.
- * Pode ser que em alguns casos ter um conteúdo dentro de um comentário possa ser
- * importante. Por exemplo, uma ferramenta de testes ou de auto-documentação.
- */
-export declare class Comentario implements Construto {
-    linha: number;
-    hashArquivo: number;
-    conteudo: string | string[];
-    multilinha: boolean;
-    constructor(hashArquivo: number, linha: number, conteudo: string | string[], multilinha: boolean);
-    aceitar(visitante: VisitanteComumInterface): Promise<any>;
-}
+import { VisitanteComumInterface } from "../interfaces";
+import { Construto } from "./construto";
+/**
+ * Como construto, um comentário é normalmente útil para formatadores de código.
+ * Pode ser que em alguns casos ter um conteúdo dentro de um comentário possa ser
+ * importante. Por exemplo, uma ferramenta de testes ou de auto-documentação.
+ */
+export declare class Comentario implements Construto {
+    linha: number;
+    hashArquivo: number;
+    conteudo: string | string[];
+    multilinha: boolean;
+    constructor(hashArquivo: number, linha: number, conteudo: string | string[], multilinha: boolean);
+    aceitar(visitante: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=comentario.d.ts.map