@designliquido/delegua 0.14.6 → 0.15.0

package/fontes/construtos/acesso-indice-variavel.d.ts

@@ -1,15 +1,15 @@
-import { InterpretadorInterface, SimboloInterface } from '../interfaces';
-import { Construto } from './construto';
-/**
- * Definido como `Subscript` em Égua Clássico, esse construto serve para acessar índices de
- * vetores e dicionários.
- */
-export declare class AcessoIndiceVariavel implements Construto {
-    linha: number;
-    hashArquivo?: number;
-    entidadeChamada: Construto;
-    simboloFechamento: SimboloInterface;
-    indice: any;
-    constructor(hashArquivo: number, entidadeChamada: Construto, indice: any, simboloFechamento: SimboloInterface);
-    aceitar(visitante: InterpretadorInterface): Promise<any>;
-}
+import { InterpretadorInterface, SimboloInterface } from '../interfaces';
+import { Construto } from './construto';
+/**
+ * Definido como `Subscript` em Égua Clássico, esse construto serve para acessar índices de
+ * vetores e dicionários.
+ */
+export declare class AcessoIndiceVariavel implements Construto {
+    linha: number;
+    hashArquivo?: number;
+    entidadeChamada: Construto;
+    simboloFechamento: SimboloInterface;
+    indice: any;
+    constructor(hashArquivo: number, entidadeChamada: Construto, indice: any, simboloFechamento: SimboloInterface);
+    aceitar(visitante: InterpretadorInterface): Promise<any>;
+}

package/fontes/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/fontes/construtos/acesso-metodo.d.ts

@@ -1,14 +1,14 @@
-import { InterpretadorInterface, 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 AcessoMetodo implements Construto {
-    linha: number;
-    hashArquivo?: number;
-    objeto: Construto;
-    simbolo: SimboloInterface;
-    constructor(hashArquivo: number, objeto: Construto, simbolo: SimboloInterface);
-    aceitar(visitante: InterpretadorInterface): Promise<any>;
-}
+import { InterpretadorInterface, 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 AcessoMetodo implements Construto {
+    linha: number;
+    hashArquivo?: number;
+    objeto: Construto;
+    simbolo: SimboloInterface;
+    constructor(hashArquivo: number, objeto: Construto, simbolo: SimboloInterface);
+    aceitar(visitante: InterpretadorInterface): Promise<any>;
+}

package/fontes/construtos/acesso-metodo.js

@@ -1,20 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AcessoMetodo = void 0;
-/**
- * Chamado de `Get` em Égua Clássico, é o construto de acesso a métodos ou membros de
- * classe.
- */
-class AcessoMetodo {
-    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.AcessoMetodo = AcessoMetodo;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcessoMetodo = void 0;
+/**
+ * Chamado de `Get` em Égua Clássico, é o construto de acesso a métodos ou membros de
+ * classe.
+ */
+class AcessoMetodo {
+    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.AcessoMetodo = AcessoMetodo;
 //# sourceMappingURL=acesso-metodo.js.map

package/fontes/construtos/agrupamento.d.ts

@@ -1,14 +1,14 @@
-import { InterpretadorInterface } 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: InterpretadorInterface): Promise<any>;
-}
+import { InterpretadorInterface } 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: InterpretadorInterface): Promise<any>;
+}

package/fontes/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/fontes/construtos/atribuicao-sobrescrita.d.ts

@@ -1,11 +1,11 @@
-import { InterpretadorInterface } from '../interfaces';
-import { Construto } from './construto';
-export declare class AtribuicaoSobrescrita 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: InterpretadorInterface): Promise<any>;
-}
+import { InterpretadorInterface } from '../interfaces';
+import { Construto } from './construto';
+export declare class AtribuicaoSobrescrita 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: InterpretadorInterface): Promise<any>;
+}

package/fontes/construtos/atribuicao-sobrescrita.js

@@ -1,17 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AtribuicaoSobrescrita = void 0;
-class AtribuicaoSobrescrita {
-    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.visitarExpressaoAtribuicaoSobrescrita(this);
-    }
-}
-exports.AtribuicaoSobrescrita = AtribuicaoSobrescrita;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtribuicaoSobrescrita = void 0;
+class AtribuicaoSobrescrita {
+    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.visitarExpressaoAtribuicaoSobrescrita(this);
+    }
+}
+exports.AtribuicaoSobrescrita = AtribuicaoSobrescrita;
 //# sourceMappingURL=atribuicao-sobrescrita.js.map

package/fontes/construtos/atribuir.d.ts

@@ -1,10 +1,10 @@
-import { InterpretadorInterface, SimboloInterface } from '../interfaces';
-import { Construto } from './construto';
-export declare class Atribuir implements Construto {
-    linha: number;
-    hashArquivo?: number;
-    simbolo: SimboloInterface;
-    valor: any;
-    constructor(hashArquivo: number, simbolo: SimboloInterface, valor: any);
-    aceitar(visitante: InterpretadorInterface): Promise<any>;
-}
+import { InterpretadorInterface, SimboloInterface } from '../interfaces';
+import { Construto } from './construto';
+export declare class Atribuir implements Construto {
+    linha: number;
+    hashArquivo?: number;
+    simbolo: SimboloInterface;
+    valor: any;
+    constructor(hashArquivo: number, simbolo: SimboloInterface, valor: any);
+    aceitar(visitante: InterpretadorInterface): Promise<any>;
+}

package/fontes/construtos/atribuir.js

@@ -1,16 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Atribuir = void 0;
-class Atribuir {
-    constructor(hashArquivo, simbolo, valor) {
-        this.linha = Number(simbolo.linha);
-        this.hashArquivo = hashArquivo;
-        this.simbolo = simbolo;
-        this.valor = valor;
-    }
-    async aceitar(visitante) {
-        return await visitante.visitarDeclaracaoDeAtribuicao(this);
-    }
-}
-exports.Atribuir = Atribuir;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Atribuir = void 0;
+class Atribuir {
+    constructor(hashArquivo, simbolo, valor) {
+        this.linha = Number(simbolo.linha);
+        this.hashArquivo = hashArquivo;
+        this.simbolo = simbolo;
+        this.valor = valor;
+    }
+    async aceitar(visitante) {
+        return await visitante.visitarDeclaracaoDeAtribuicao(this);
+    }
+}
+exports.Atribuir = Atribuir;
 //# sourceMappingURL=atribuir.js.map

package/fontes/construtos/binario.d.ts

@@ -1,22 +1,22 @@
-import { InterpretadorInterface, 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:
- *
- * - `+` (Adição) e `+=` (Adição com Atribuição)
- * - `-` (Subtração) e `-=` (Subtração com Atribuição)
- * - `*` (Multiplicação) e `*=` (Multiplicação com Atribuição)
- * - `/` (Divisão) e `/=` (Divisão com Atribuição)
- * - `%` (Módulo) e `%=` (Módulo com Atribuição)
- * - `**` (Exponenciação)
- */
-export declare class Binario implements Construto {
-    linha: number;
-    hashArquivo?: number;
-    esquerda: any;
-    operador: SimboloInterface;
-    direita: any;
-    constructor(hashArquivo: number, esquerda: any, operador: SimboloInterface, direita: any);
-    aceitar(visitante: InterpretadorInterface): Promise<any>;
-}
+import { InterpretadorInterface, 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:
+ *
+ * - `+` (Adição) e `+=` (Adição com Atribuição)
+ * - `-` (Subtração) e `-=` (Subtração com Atribuição)
+ * - `*` (Multiplicação) e `*=` (Multiplicação com Atribuição)
+ * - `/` (Divisão) e `/=` (Divisão com Atribuição)
+ * - `%` (Módulo) e `%=` (Módulo com Atribuição)
+ * - `**` (Exponenciação)
+ */
+export declare class Binario implements Construto {
+    linha: number;
+    hashArquivo?: number;
+    esquerda: any;
+    operador: SimboloInterface;
+    direita: any;
+    constructor(hashArquivo: number, esquerda: any, operador: SimboloInterface, direita: any);
+    aceitar(visitante: InterpretadorInterface): Promise<any>;
+}

package/fontes/construtos/binario.js

@@ -1,28 +1,28 @@
-"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:
- *
- * - `+` (Adição) e `+=` (Adição com Atribuição)
- * - `-` (Subtração) e `-=` (Subtração com Atribuição)
- * - `*` (Multiplicação) e `*=` (Multiplicação com Atribuição)
- * - `/` (Divisão) e `/=` (Divisão com Atribuição)
- * - `%` (Módulo) e `%=` (Módulo com Atribuição)
- * - `**` (Exponenciação)
- */
-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:
+ *
+ * - `+` (Adição) e `+=` (Adição com Atribuição)
+ * - `-` (Subtração) e `-=` (Subtração com Atribuição)
+ * - `*` (Multiplicação) e `*=` (Multiplicação com Atribuição)
+ * - `/` (Divisão) e `/=` (Divisão com Atribuição)
+ * - `%` (Módulo) e `%=` (Módulo com Atribuição)
+ * - `**` (Exponenciação)
+ */
+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/fontes/construtos/chamada.d.ts

@@ -1,13 +1,13 @@
-import { InterpretadorInterface } from '../interfaces';
-import { Construto } from './construto';
-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[]);
-    private uuidv4;
-    aceitar(visitante: InterpretadorInterface): Promise<any>;
-}
+import { InterpretadorInterface } from '../interfaces';
+import { Construto } from './construto';
+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[]);
+    private uuidv4;
+    aceitar(visitante: InterpretadorInterface): Promise<any>;
+}

package/fontes/construtos/chamada.js

@@ -1,37 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Chamada = void 0;
-class Chamada {
-    constructor(hashArquivo, entidadeChamada, parentese, argumentos) {
-        this.id = this.uuidv4();
-        this.linha = entidadeChamada.linha;
-        this.hashArquivo = hashArquivo;
-        this.entidadeChamada = entidadeChamada;
-        this.parentese = parentese;
-        this.argumentos = argumentos;
-    }
-    uuidv4() {
-        // Public Domain/MIT
-        let d = new Date().getTime(); // Timestamp
-        let d2 = (typeof performance !== 'undefined' && performance.now && performance.now() * 1000) || 0; // Time in microseconds since page-load or 0 if unsupported
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-            let r = Math.random() * 16; // random number between 0 and 16
-            if (d > 0) {
-                // Use timestamp until depleted
-                r = (d + r) % 16 | 0;
-                d = Math.floor(d / 16);
-            }
-            else {
-                // Use microseconds since page-load if supported
-                r = (d2 + r) % 16 | 0;
-                d2 = Math.floor(d2 / 16);
-            }
-            return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
-        });
-    }
-    async aceitar(visitante) {
-        return await visitante.visitarExpressaoDeChamada(this);
-    }
-}
-exports.Chamada = Chamada;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chamada = void 0;
+class Chamada {
+    constructor(hashArquivo, entidadeChamada, parentese, argumentos) {
+        this.id = this.uuidv4();
+        this.linha = entidadeChamada.linha;
+        this.hashArquivo = hashArquivo;
+        this.entidadeChamada = entidadeChamada;
+        this.parentese = parentese;
+        this.argumentos = argumentos;
+    }
+    uuidv4() {
+        // Public Domain/MIT
+        let d = new Date().getTime(); // Timestamp
+        let d2 = (typeof performance !== 'undefined' && performance.now && performance.now() * 1000) || 0; // Time in microseconds since page-load or 0 if unsupported
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            let r = Math.random() * 16; // random number between 0 and 16
+            if (d > 0) {
+                // Use timestamp until depleted
+                r = (d + r) % 16 | 0;
+                d = Math.floor(d / 16);
+            }
+            else {
+                // Use microseconds since page-load if supported
+                r = (d2 + r) % 16 | 0;
+                d2 = Math.floor(d2 / 16);
+            }
+            return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
+        });
+    }
+    async aceitar(visitante) {
+        return await visitante.visitarExpressaoDeChamada(this);
+    }
+}
+exports.Chamada = Chamada;
 //# sourceMappingURL=chamada.js.map

package/fontes/construtos/construto.d.ts

@@ -1,7 +1,7 @@
-import { InterpretadorInterface } from '../interfaces';
-export interface Construto {
-    linha: number;
-    hashArquivo?: number;
-    valor?: any;
-    aceitar(visitante: InterpretadorInterface): Promise<any>;
-}
+import { InterpretadorInterface } from '../interfaces';
+export interface Construto {
+    linha: number;
+    hashArquivo?: number;
+    valor?: any;
+    aceitar(visitante: InterpretadorInterface): Promise<any>;
+}

package/fontes/construtos/construto.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=construto.js.map

package/fontes/construtos/definir-valor.d.ts

@@ -1,11 +1,11 @@
-import { InterpretadorInterface } from '../interfaces';
-import { Construto } from './construto';
-export declare class DefinirValor implements Construto {
-    linha: number;
-    hashArquivo?: number;
-    objeto: any;
-    nome: any;
-    valor: any;
-    constructor(hashArquivo: number, linha: number, objeto: any, nome: any, valor: any);
-    aceitar(visitante: InterpretadorInterface): Promise<any>;
-}
+import { InterpretadorInterface } from '../interfaces';
+import { Construto } from './construto';
+export declare class DefinirValor implements Construto {
+    linha: number;
+    hashArquivo?: number;
+    objeto: any;
+    nome: any;
+    valor: any;
+    constructor(hashArquivo: number, linha: number, objeto: any, nome: any, valor: any);
+    aceitar(visitante: InterpretadorInterface): Promise<any>;
+}

package/fontes/construtos/definir-valor.js

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

package/fontes/construtos/dicionario.d.ts

@@ -1,10 +1,10 @@
-import { InterpretadorInterface } from '../interfaces';
-import { Construto } from './construto';
-export declare class Dicionario implements Construto {
-    linha: number;
-    hashArquivo?: number;
-    chaves: any;
-    valores: any;
-    constructor(hashArquivo: number, linha: number, chaves: any, valores: any);
-    aceitar(visitante: InterpretadorInterface): Promise<any>;
-}
+import { InterpretadorInterface } from '../interfaces';
+import { Construto } from './construto';
+export declare class Dicionario implements Construto {
+    linha: number;
+    hashArquivo?: number;
+    chaves: any;
+    valores: any;
+    constructor(hashArquivo: number, linha: number, chaves: any, valores: any);
+    aceitar(visitante: InterpretadorInterface): Promise<any>;
+}