@designliquido/delegua 0.36.1 → 0.36.2

package/construtos/comentario.js

@@ -1,21 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Comentario = void 0;
-/**
- * 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.
- */
-class Comentario {
-    constructor(hashArquivo, linha, conteudo, multilinha) {
-        this.hashArquivo = hashArquivo;
-        this.linha = linha;
-        this.conteudo = conteudo;
-        this.multilinha = multilinha;
-    }
-    async aceitar(visitante) {
-        return await visitante.visitarDeclaracaoComentario(this);
-    }
-}
-exports.Comentario = Comentario;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Comentario = void 0;
+/**
+ * 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.
+ */
+class Comentario {
+    constructor(hashArquivo, linha, conteudo, multilinha) {
+        this.hashArquivo = hashArquivo;
+        this.linha = linha;
+        this.conteudo = conteudo;
+        this.multilinha = multilinha;
+    }
+    async aceitar(visitante) {
+        return await visitante.visitarDeclaracaoComentario(this);
+    }
+}
+exports.Comentario = Comentario;
 //# sourceMappingURL=comentario.js.map

package/construtos/constante.d.ts

@@ -1,13 +1,13 @@
-import { VisitanteComumInterface, SimboloInterface, VariavelInterface } from '../interfaces';
-import { Construto } from './construto';
-/**
- * O construto de constante.
- */
-export declare class Constante<TTipoSimbolo extends string = string> implements Construto {
-    linha: number;
-    hashArquivo: number;
-    simbolo: SimboloInterface<TTipoSimbolo>;
-    constructor(hashArquivo: number, simbolo: SimboloInterface<TTipoSimbolo>);
-    aceitar(visitante: VisitanteComumInterface): Promise<VariavelInterface>;
-}
+import { VisitanteComumInterface, SimboloInterface, VariavelInterface } from '../interfaces';
+import { Construto } from './construto';
+/**
+ * O construto de constante.
+ */
+export declare class Constante<TTipoSimbolo extends string = string> implements Construto {
+    linha: number;
+    hashArquivo: number;
+    simbolo: SimboloInterface<TTipoSimbolo>;
+    constructor(hashArquivo: number, simbolo: SimboloInterface<TTipoSimbolo>);
+    aceitar(visitante: VisitanteComumInterface): Promise<VariavelInterface>;
+}
 //# sourceMappingURL=constante.d.ts.map

package/construtos/constante.js

@@ -1,18 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Constante = void 0;
-/**
- * O construto de constante.
- */
-class Constante {
-    constructor(hashArquivo, simbolo) {
-        this.linha = Number(simbolo.linha);
-        this.hashArquivo = hashArquivo;
-        this.simbolo = simbolo;
-    }
-    async aceitar(visitante) {
-        return Promise.resolve(visitante.visitarExpressaoDeVariavel(this));
-    }
-}
-exports.Constante = Constante;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Constante = void 0;
+/**
+ * O construto de constante.
+ */
+class Constante {
+    constructor(hashArquivo, simbolo) {
+        this.linha = Number(simbolo.linha);
+        this.hashArquivo = hashArquivo;
+        this.simbolo = simbolo;
+    }
+    async aceitar(visitante) {
+        return Promise.resolve(visitante.visitarExpressaoDeVariavel(this));
+    }
+}
+exports.Constante = Constante;
 //# sourceMappingURL=constante.js.map

package/construtos/construto.d.ts

@@ -1,8 +1,8 @@
-import { VisitanteComumInterface } from '../interfaces';
-export interface Construto {
-    linha: number;
-    hashArquivo: number;
-    valor?: any;
-    aceitar(visitante: VisitanteComumInterface): Promise<any>;
-}
+import { VisitanteComumInterface } from '../interfaces';
+export interface Construto {
+    linha: number;
+    hashArquivo: number;
+    valor?: any;
+    aceitar(visitante: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=construto.d.ts.map

package/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/construtos/decorador.d.ts

@@ -1,15 +1,15 @@
-import { VisitanteComumInterface } from '../interfaces';
-import { Construto } from './construto';
-/**
- * Um decorador é um construto especial que, em código, existe antes de uma declaração, e
- * na avaliação sintática, é colocado juntamente com a próxima declaração.
- */
-export declare class Decorador implements Construto {
-    linha: number;
-    hashArquivo: number;
-    nome: string;
-    parametros?: any[];
-    constructor(hashArquivo: number, linha: number, nome: string, parametros?: any[]);
-    aceitar(visitante: VisitanteComumInterface): Promise<any>;
-}
+import { VisitanteComumInterface } from '../interfaces';
+import { Construto } from './construto';
+/**
+ * Um decorador é um construto especial que, em código, existe antes de uma declaração, e
+ * na avaliação sintática, é colocado juntamente com a próxima declaração.
+ */
+export declare class Decorador implements Construto {
+    linha: number;
+    hashArquivo: number;
+    nome: string;
+    parametros?: any[];
+    constructor(hashArquivo: number, linha: number, nome: string, parametros?: any[]);
+    aceitar(visitante: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=decorador.d.ts.map

package/construtos/decorador.js

@@ -1,20 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Decorador = void 0;
-/**
- * Um decorador é um construto especial que, em código, existe antes de uma declaração, e
- * na avaliação sintática, é colocado juntamente com a próxima declaração.
- */
-class Decorador {
-    constructor(hashArquivo, linha, nome, parametros) {
-        this.linha = linha;
-        this.hashArquivo = hashArquivo;
-        this.nome = nome;
-        this.parametros = parametros;
-    }
-    async aceitar(visitante) {
-        return Promise.reject(new Error('Este método não deveria ser chamado.'));
-    }
-}
-exports.Decorador = Decorador;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decorador = void 0;
+/**
+ * Um decorador é um construto especial que, em código, existe antes de uma declaração, e
+ * na avaliação sintática, é colocado juntamente com a próxima declaração.
+ */
+class Decorador {
+    constructor(hashArquivo, linha, nome, parametros) {
+        this.linha = linha;
+        this.hashArquivo = hashArquivo;
+        this.nome = nome;
+        this.parametros = parametros;
+    }
+    async aceitar(visitante) {
+        return Promise.reject(new Error('Este método não deveria ser chamado.'));
+    }
+}
+exports.Decorador = Decorador;
 //# sourceMappingURL=decorador.js.map

package/construtos/definir-valor.d.ts

@@ -1,12 +1,12 @@
-import { SimboloInterface, VisitanteComumInterface } from '../interfaces';
-import { Construto } from './construto';
-export declare class DefinirValor<TTipoSimbolo extends string = string> implements Construto {
-    linha: number;
-    hashArquivo: number;
-    objeto: Construto;
-    nome: SimboloInterface<TTipoSimbolo>;
-    valor: any;
-    constructor(hashArquivo: number, linha: number, objeto: Construto, nome: SimboloInterface<TTipoSimbolo>, valor: any);
-    aceitar(visitante: VisitanteComumInterface): Promise<any>;
-}
+import { SimboloInterface, VisitanteComumInterface } from '../interfaces';
+import { Construto } from './construto';
+export declare class DefinirValor<TTipoSimbolo extends string = string> implements Construto {
+    linha: number;
+    hashArquivo: number;
+    objeto: Construto;
+    nome: SimboloInterface<TTipoSimbolo>;
+    valor: any;
+    constructor(hashArquivo: number, linha: number, objeto: Construto, nome: SimboloInterface<TTipoSimbolo>, valor: any);
+    aceitar(visitante: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=definir-valor.d.ts.map

package/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/construtos/dicionario.d.ts

@@ -1,11 +1,11 @@
-import { VisitanteComumInterface } 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: VisitanteComumInterface): Promise<any>;
-}
+import { VisitanteComumInterface } 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: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=dicionario.d.ts.map

package/construtos/dicionario.js

@@ -1,16 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dicionario = void 0;
-class Dicionario {
-    constructor(hashArquivo, linha, chaves, valores) {
-        this.linha = linha;
-        this.hashArquivo = hashArquivo;
-        this.chaves = chaves;
-        this.valores = valores;
-    }
-    async aceitar(visitante) {
-        return await visitante.visitarExpressaoDicionario(this);
-    }
-}
-exports.Dicionario = Dicionario;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dicionario = void 0;
+class Dicionario {
+    constructor(hashArquivo, linha, chaves, valores) {
+        this.linha = linha;
+        this.hashArquivo = hashArquivo;
+        this.chaves = chaves;
+        this.valores = valores;
+    }
+    async aceitar(visitante) {
+        return await visitante.visitarExpressaoDicionario(this);
+    }
+}
+exports.Dicionario = Dicionario;
 //# sourceMappingURL=dicionario.js.map

package/construtos/expressao-regular.d.ts

@@ -1,11 +1,11 @@
-import { VisitanteComumInterface, SimboloInterface } from '../interfaces';
-import { Construto } from './construto';
-export declare class ExpressaoRegular<TTipoSimbolo extends string = string> implements Construto {
-    linha: number;
-    hashArquivo: number;
-    valor: any;
-    simbolo: SimboloInterface<TTipoSimbolo>;
-    constructor(hashArquivo: number, simbolo: SimboloInterface<TTipoSimbolo>, valor: any);
-    aceitar(visitante: VisitanteComumInterface): Promise<any>;
-}
+import { VisitanteComumInterface, SimboloInterface } from '../interfaces';
+import { Construto } from './construto';
+export declare class ExpressaoRegular<TTipoSimbolo extends string = string> implements Construto {
+    linha: number;
+    hashArquivo: number;
+    valor: any;
+    simbolo: SimboloInterface<TTipoSimbolo>;
+    constructor(hashArquivo: number, simbolo: SimboloInterface<TTipoSimbolo>, valor: any);
+    aceitar(visitante: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=expressao-regular.d.ts.map

package/construtos/expressao-regular.js

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

package/construtos/fim-para.d.ts

@@ -1,23 +1,23 @@
-import { Declaracao } from '../declaracoes';
-import { VisitanteComumInterface } from '../interfaces';
-import { Binario } from './binario';
-import { Construto } from './construto';
-/**
- * Construto especial para algumas linguagens como VisuAlg, que combina a
- * avaliação da condição de continuação com o incremento.
- *
- * No caso específico do VisuAlg, ao final da última execução do bloco `para`,
- * o incremento não deve acontecer.
- *
- * Considerando como o depurador executa, o efeito visualnusando apenas as
- * declarações já existentes causava umansérie de comportamentos estranhos.
- */
-export declare class FimPara implements Construto {
-    linha: number;
-    hashArquivo: number;
-    condicaoPara: Binario;
-    incremento?: Declaracao;
-    constructor(hashArquivo: number, linha: number, condicaoPara: Binario, blocoIncremento?: Declaracao);
-    aceitar(visitante: VisitanteComumInterface): Promise<any>;
-}
+import { Declaracao } from '../declaracoes';
+import { VisitanteComumInterface } from '../interfaces';
+import { Binario } from './binario';
+import { Construto } from './construto';
+/**
+ * Construto especial para algumas linguagens como VisuAlg, que combina a
+ * avaliação da condição de continuação com o incremento.
+ *
+ * No caso específico do VisuAlg, ao final da última execução do bloco `para`,
+ * o incremento não deve acontecer.
+ *
+ * Considerando como o depurador executa, o efeito visualnusando apenas as
+ * declarações já existentes causava umansérie de comportamentos estranhos.
+ */
+export declare class FimPara implements Construto {
+    linha: number;
+    hashArquivo: number;
+    condicaoPara: Binario;
+    incremento?: Declaracao;
+    constructor(hashArquivo: number, linha: number, condicaoPara: Binario, blocoIncremento?: Declaracao);
+    aceitar(visitante: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=fim-para.d.ts.map

package/construtos/fim-para.js

@@ -1,26 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FimPara = void 0;
-/**
- * Construto especial para algumas linguagens como VisuAlg, que combina a
- * avaliação da condição de continuação com o incremento.
- *
- * No caso específico do VisuAlg, ao final da última execução do bloco `para`,
- * o incremento não deve acontecer.
- *
- * Considerando como o depurador executa, o efeito visualnusando apenas as
- * declarações já existentes causava umansérie de comportamentos estranhos.
- */
-class FimPara {
-    constructor(hashArquivo, linha, condicaoPara, blocoIncremento) {
-        this.hashArquivo = hashArquivo;
-        this.linha = linha;
-        this.condicaoPara = condicaoPara;
-        this.incremento = blocoIncremento;
-    }
-    async aceitar(visitante) {
-        return await visitante.visitarExpressaoFimPara(this);
-    }
-}
-exports.FimPara = FimPara;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FimPara = void 0;
+/**
+ * Construto especial para algumas linguagens como VisuAlg, que combina a
+ * avaliação da condição de continuação com o incremento.
+ *
+ * No caso específico do VisuAlg, ao final da última execução do bloco `para`,
+ * o incremento não deve acontecer.
+ *
+ * Considerando como o depurador executa, o efeito visualnusando apenas as
+ * declarações já existentes causava umansérie de comportamentos estranhos.
+ */
+class FimPara {
+    constructor(hashArquivo, linha, condicaoPara, blocoIncremento) {
+        this.hashArquivo = hashArquivo;
+        this.linha = linha;
+        this.condicaoPara = condicaoPara;
+        this.incremento = blocoIncremento;
+    }
+    async aceitar(visitante) {
+        return await visitante.visitarExpressaoFimPara(this);
+    }
+}
+exports.FimPara = FimPara;
 //# sourceMappingURL=fim-para.js.map

package/construtos/formatacao-escrita.d.ts

@@ -1,17 +1,17 @@
-import { VisitanteComumInterface } from '../interfaces';
-import { Construto } from './construto';
-/**
- * Um construto de formatação de escrita é utilizado por instruções `escreva`
- * e derivadas para adição de espaços e casas decimais, este último para quando
- * o conteúdo da escrita é um número.
- */
-export declare class FormatacaoEscrita implements Construto {
-    linha: number;
-    hashArquivo: number;
-    expressao: Construto;
-    espacos: number;
-    casasDecimais: number;
-    constructor(hashArquivo: number, linha: number, expressao: Construto, espacos?: number, casasDecimais?: number);
-    aceitar(visitante: VisitanteComumInterface): Promise<any>;
-}
+import { VisitanteComumInterface } from '../interfaces';
+import { Construto } from './construto';
+/**
+ * Um construto de formatação de escrita é utilizado por instruções `escreva`
+ * e derivadas para adição de espaços e casas decimais, este último para quando
+ * o conteúdo da escrita é um número.
+ */
+export declare class FormatacaoEscrita implements Construto {
+    linha: number;
+    hashArquivo: number;
+    expressao: Construto;
+    espacos: number;
+    casasDecimais: number;
+    constructor(hashArquivo: number, linha: number, expressao: Construto, espacos?: number, casasDecimais?: number);
+    aceitar(visitante: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=formatacao-escrita.d.ts.map

package/construtos/formatacao-escrita.js

@@ -1,22 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FormatacaoEscrita = void 0;
-/**
- * Um construto de formatação de escrita é utilizado por instruções `escreva`
- * e derivadas para adição de espaços e casas decimais, este último para quando
- * o conteúdo da escrita é um número.
- */
-class FormatacaoEscrita {
-    constructor(hashArquivo, linha, expressao, espacos, casasDecimais) {
-        this.linha = linha;
-        this.hashArquivo = hashArquivo;
-        this.expressao = expressao;
-        this.espacos = espacos || -1;
-        this.casasDecimais = casasDecimais || -1;
-    }
-    async aceitar(visitante) {
-        return await visitante.visitarExpressaoFormatacaoEscrita(this);
-    }
-}
-exports.FormatacaoEscrita = FormatacaoEscrita;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatacaoEscrita = void 0;
+/**
+ * Um construto de formatação de escrita é utilizado por instruções `escreva`
+ * e derivadas para adição de espaços e casas decimais, este último para quando
+ * o conteúdo da escrita é um número.
+ */
+class FormatacaoEscrita {
+    constructor(hashArquivo, linha, expressao, espacos, casasDecimais) {
+        this.linha = linha;
+        this.hashArquivo = hashArquivo;
+        this.expressao = expressao;
+        this.espacos = espacos || -1;
+        this.casasDecimais = casasDecimais || -1;
+    }
+    async aceitar(visitante) {
+        return await visitante.visitarExpressaoFormatacaoEscrita(this);
+    }
+}
+exports.FormatacaoEscrita = FormatacaoEscrita;
 //# sourceMappingURL=formatacao-escrita.js.map

package/construtos/funcao.d.ts

@@ -1,13 +1,13 @@
-import { Declaracao } from '../declaracoes';
-import { VisitanteComumInterface, ParametroInterface } from '../interfaces';
-import { Construto } from './construto';
-export declare class FuncaoConstruto implements Construto {
-    linha: number;
-    hashArquivo: number;
-    parametros: ParametroInterface[];
-    tipoRetorno?: string;
-    corpo: Declaracao[];
-    constructor(hashArquivo: number, linha: number, parametros: ParametroInterface[], corpo: Declaracao[], tipoRetorno?: string);
-    aceitar(visitante: VisitanteComumInterface): Promise<any>;
-}
+import { Declaracao } from '../declaracoes';
+import { VisitanteComumInterface, ParametroInterface } from '../interfaces';
+import { Construto } from './construto';
+export declare class FuncaoConstruto implements Construto {
+    linha: number;
+    hashArquivo: number;
+    parametros: ParametroInterface[];
+    tipoRetorno?: string;
+    corpo: Declaracao[];
+    constructor(hashArquivo: number, linha: number, parametros: ParametroInterface[], corpo: Declaracao[], tipoRetorno?: string);
+    aceitar(visitante: VisitanteComumInterface): Promise<any>;
+}
 //# sourceMappingURL=funcao.d.ts.map

package/construtos/funcao.js

@@ -1,17 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FuncaoConstruto = void 0;
-class FuncaoConstruto {
-    constructor(hashArquivo, linha, parametros, corpo, tipoRetorno) {
-        this.linha = linha;
-        this.hashArquivo = hashArquivo;
-        this.parametros = parametros;
-        this.tipoRetorno = tipoRetorno;
-        this.corpo = corpo;
-    }
-    async aceitar(visitante) {
-        return Promise.resolve(visitante.visitarExpressaoDeleguaFuncao(this));
-    }
-}
-exports.FuncaoConstruto = FuncaoConstruto;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FuncaoConstruto = void 0;
+class FuncaoConstruto {
+    constructor(hashArquivo, linha, parametros, corpo, tipoRetorno) {
+        this.linha = linha;
+        this.hashArquivo = hashArquivo;
+        this.parametros = parametros;
+        this.tipoRetorno = tipoRetorno;
+        this.corpo = corpo;
+    }
+    async aceitar(visitante) {
+        return Promise.resolve(visitante.visitarExpressaoDeleguaFuncao(this));
+    }
+}
+exports.FuncaoConstruto = FuncaoConstruto;
 //# sourceMappingURL=funcao.js.map