@designliquido/delegua 0.69.0 → 0.70.0

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

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

package/tipos-de-dados/delegua.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     DICIONARIO: 'dicionario',
     DICIONÁRIO: 'dicionário',
+    FUNCAO: 'funcao',
+    FUNÇÃO: 'função',
     INTEIRO: 'inteiro',
     LOGICO: 'logico',
     LÓGICO: 'lógico',

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

@@ -1 +1 @@
-{"version":3,"file":"delegua.js","sourceRoot":"","sources":["../../fontes/tipos-de-dados/delegua.ts"],"names":[],"mappings":";;AAAA,kBAAe;IACX,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE,YAAY;IACxB,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,UAAU;IACpB,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,aAAa,EAAE,WAAW;IAC1B,YAAY,EAAE,UAAU;IACxB,YAAY,EAAE,UAAU;IACxB,YAAY,EAAE,UAAU;IACxB,YAAY,EAAE,UAAU;IACxB,cAAc,EAAE,YAAY;IAC5B,WAAW,EAAE,SAAS;CACzB,CAAC"}
+{"version":3,"file":"delegua.js","sourceRoot":"","sources":["../../fontes/tipos-de-dados/delegua.ts"],"names":[],"mappings":";;AAAA,kBAAe;IACX,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE,YAAY;IACxB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,UAAU;IACpB,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,aAAa,EAAE,WAAW;IAC1B,YAAY,EAAE,UAAU;IACxB,YAAY,EAAE,UAAU;IACxB,YAAY,EAAE,UAAU;IACxB,YAAY,EAAE,UAAU;IACxB,cAAc,EAAE,YAAY;IAC5B,WAAW,EAAE,SAAS;CACzB,CAAC"}

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

@@ -75,7 +75,6 @@ declare const _default: {
     PARA: string;
     PARENTESE_DIREITO: string;
     PARENTESE_ESQUERDO: string;
-    PAUSA: string;
     PEGUE: string;
     PONTO: string;
     PONTO_E_VIRGULA: string;

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,wBAiGE"}
+{"version":3,"file":"delegua.d.ts","sourceRoot":"","sources":["../../fontes/tipos-de-simbolos/delegua.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAgGE"}

package/tipos-de-simbolos/delegua.js

@@ -77,7 +77,6 @@ exports.default = {
     PARA: 'PARA',
     PARENTESE_DIREITO: 'PARENTESE_DIREITO',
     PARENTESE_ESQUERDO: 'PARENTESE_ESQUERDO',
-    PAUSA: 'PAUSA',
     PEGUE: 'PEGUE',
     PONTO: 'PONTO',
     PONTO_E_VIRGULA: 'PONTO_E_VIRGULA',

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

@@ -1 +1 @@
-{"version":3,"file":"delegua.js","sourceRoot":"","sources":["../../fontes/tipos-de-simbolos/delegua.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"delegua.js","sourceRoot":"","sources":["../../fontes/tipos-de-simbolos/delegua.ts"],"names":[],"mappings":";;AAAA,kBAAe;IACX,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,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,MAAM,EAAE,QAAQ;IAChB,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,GAAG,EAAE,KAAK;IACV,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,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"}

package/tradutores/mermaid/index.d.ts

@@ -1,5 +1,6 @@
 export * from './aresta-fluxograma';
 export * from './diagrama-classe';
 export * from './subgrafo-classe';
+export * from './subgrafo-funcao';
 export * from './vertice-fluxograma';
 //# sourceMappingURL=index.d.ts.map

package/tradutores/mermaid/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../fontes/tradutores/mermaid/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../fontes/tradutores/mermaid/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC"}

package/tradutores/mermaid/index.js

@@ -17,5 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./aresta-fluxograma"), exports);
 __exportStar(require("./diagrama-classe"), exports);
 __exportStar(require("./subgrafo-classe"), exports);
+__exportStar(require("./subgrafo-funcao"), exports);
 __exportStar(require("./vertice-fluxograma"), exports);
 //# sourceMappingURL=index.js.map

package/tradutores/mermaid/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../fontes/tradutores/mermaid/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sDAAoC;AACpC,oDAAkC;AAClC,oDAAkC;AAClC,uDAAqC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../fontes/tradutores/mermaid/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sDAAoC;AACpC,oDAAkC;AAClC,oDAAkC;AAClC,oDAAkC;AAClC,uDAAqC"}

package/tradutores/mermaid/subgrafo-funcao.d.ts

@@ -0,0 +1,11 @@
+import { ArestaFluxograma } from "./aresta-fluxograma";
+import { VerticeFluxograma } from "./vertice-fluxograma";
+export declare class SubgrafoFuncao {
+    nomeClasse: string;
+    linhaDeclaracao: number;
+    vertices: VerticeFluxograma[];
+    arestaInicial: ArestaFluxograma;
+    arestaFinal: ArestaFluxograma;
+    constructor(nomeClasse: string, linhaDeclaracao: number, arestaInicial: ArestaFluxograma, arestaFinal: ArestaFluxograma);
+}
+//# sourceMappingURL=subgrafo-funcao.d.ts.map

package/tradutores/mermaid/subgrafo-funcao.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subgrafo-funcao.d.ts","sourceRoot":"","sources":["../../../fontes/tradutores/mermaid/subgrafo-funcao.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEzD,qBAAa,cAAc;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAC9B,aAAa,EAAE,gBAAgB,CAAC;IAChC,WAAW,EAAE,gBAAgB,CAAC;gBAElB,UAAU,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,aAAa,EAAE,gBAAgB,EAAE,WAAW,EAAE,gBAAgB;CAO1H"}

package/tradutores/mermaid/subgrafo-funcao.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubgrafoFuncao = void 0;
+class SubgrafoFuncao {
+    constructor(nomeClasse, linhaDeclaracao, arestaInicial, arestaFinal) {
+        this.nomeClasse = nomeClasse;
+        this.linhaDeclaracao = linhaDeclaracao;
+        this.vertices = [];
+        this.arestaInicial = arestaInicial;
+        this.arestaFinal = arestaFinal;
+    }
+}
+exports.SubgrafoFuncao = SubgrafoFuncao;
+//# sourceMappingURL=subgrafo-funcao.js.map

package/tradutores/mermaid/subgrafo-funcao.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subgrafo-funcao.js","sourceRoot":"","sources":["../../../fontes/tradutores/mermaid/subgrafo-funcao.ts"],"names":[],"mappings":";;;AAGA,MAAa,cAAc;IAOvB,YAAY,UAAkB,EAAE,eAAuB,EAAE,aAA+B,EAAE,WAA6B;QACnH,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;IACnC,CAAC;CACJ;AAdD,wCAcC"}

package/tradutores/tradutor-assembly-x64.js

@@ -54,13 +54,13 @@ class TradutorAssemblyX64 {
             Escreva: this.traduzirDeclaracaoEscreva.bind(this),
         };
         this.indentacao = 0;
-        this.text = `
-section .text
-    ${this.alvo === 'linux' ? 'global _start' : 'global main'}
+        this.text = `
+section .text
+    ${this.alvo === 'linux' ? 'global _start' : 'global main'}
 ${this.alvo === 'linux' ? '_start:' : 'main:'}`;
         if (this.alvo === 'windows') {
-            this.text = `
-extern printf
+            this.text = `
+extern printf
 ` + this.text;
         }
     }
@@ -122,8 +122,8 @@ extern printf
         }
         const indice = this.dicionarioConstrutos[construto.indice.constructor.name](construto.indice);
         const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
-        this.text += `
-    mov rax, ${valor}
+        this.text += `
+    mov rax, ${valor}
     mov [${nomeVar} + ${indice} * 8], rax`;
     }
     traduzirConstrutoAtribuir(construto) {
@@ -142,8 +142,8 @@ extern printf
             this.bss += `    ${varLabel} resq 1\n`;
             this.variaveis.set(nomeVar, varLabel);
         }
-        this.text += `
-    mov rax, ${valor}
+        this.text += `
+    mov rax, ${valor}
     mov [${this.variaveis.get(nomeVar)}], rax`;
     }
     traduzirConstrutoBinario(construto) {
@@ -151,35 +151,35 @@ extern printf
         const direita = this.dicionarioConstrutos[construto.direita.constructor.name](construto.direita);
         const operador = construto.operador.lexema;
         const reg = this.obterRegistrador();
-        this.text += `
-    mov rax, ${esquerda}
+        this.text += `
+    mov rax, ${esquerda}
     mov ${reg}, ${direita}`;
         switch (operador) {
             case '+':
-                this.text += `
+                this.text += `
     add rax, ${reg}`;
                 break;
             case '-':
-                this.text += `
+                this.text += `
     sub rax, ${reg}`;
                 break;
             case '*':
-                this.text += `
+                this.text += `
     imul rax, ${reg}`;
                 break;
             case '/':
-                this.text += `
-    xor rdx, rdx
+                this.text += `
+    xor rdx, rdx
     idiv ${reg}`;
                 break;
             case '%':
-                this.text += `
-    xor rdx, rdx
-    idiv ${reg}
+                this.text += `
+    xor rdx, rdx
+    idiv ${reg}
     mov rax, rdx`;
                 break;
             default:
-                this.text += `
+                this.text += `
     ; Operador ${operador} não implementado`;
         }
         this.liberarRegistrador(reg);
@@ -198,28 +198,28 @@ extern printf
         construto.argumentos.forEach((arg, index) => {
             if (index < registrosArgs.length) {
                 const valorArg = this.dicionarioConstrutos[arg.constructor.name](arg);
-                this.text += `
+                this.text += `
     mov ${registrosArgs[index]}, ${valorArg}`;
             }
             else {
                 // TODO: push extra args on stack according to target ABI
             }
         });
-        this.text += `
+        this.text += `
     call ${nomeFuncao}`;
     }
     traduzirConstrutoDefinirValor(construto) {
         const objeto = this.dicionarioConstrutos[construto.objeto.constructor.name](construto.objeto);
         const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
-        this.text += `
-    mov rax, ${valor}
+        this.text += `
+    mov rax, ${valor}
     mov [${objeto}], rax`;
     }
     traduzirFuncaoConstruto(construto) {
         const labelFuncao = `func_${this.gerarDigitoAleatorio()}`;
-        this.text += `
-${labelFuncao}:
-    push rbp
+        this.text += `
+${labelFuncao}:
+    push rbp
     mov rbp, rsp`;
         // Traduzir corpo da função
         if (construto.corpo && Array.isArray(construto.corpo)) {
@@ -229,8 +229,8 @@ ${labelFuncao}:
                 }
             });
         }
-        this.text += `
-    pop rbp
+        this.text += `
+    pop rbp
     ret`;
     }
     traduzirConstrutoLiteral(construto) {
@@ -245,29 +245,29 @@ ${labelFuncao}:
         const operador = construto.operador.lexema;
         const labelVerdadeiro = this.gerarLabel();
         const labelFim = this.gerarLabel();
-        this.text += `
-    mov rax, ${esquerda}
+        this.text += `
+    mov rax, ${esquerda}
     cmp rax, 0`;
         if (operador === 'e' || operador === '&&') {
-            this.text += `
-    je ${labelFim}
-    mov rax, ${direita}
-    cmp rax, 0
-    je ${labelFim}
-${labelVerdadeiro}:
-    mov rax, 1
+            this.text += `
+    je ${labelFim}
+    mov rax, ${direita}
+    cmp rax, 0
+    je ${labelFim}
+${labelVerdadeiro}:
+    mov rax, 1
 ${labelFim}:`;
         }
         else if (operador === 'ou' || operador === '||') {
-            this.text += `
-    jne ${labelVerdadeiro}
-    mov rax, ${direita}
-    cmp rax, 0
-    jne ${labelVerdadeiro}
-    mov rax, 0
-    jmp ${labelFim}
-${labelVerdadeiro}:
-    mov rax, 1
+            this.text += `
+    jne ${labelVerdadeiro}
+    mov rax, ${direita}
+    cmp rax, 0
+    jne ${labelVerdadeiro}
+    mov rax, 0
+    jmp ${labelFim}
+${labelVerdadeiro}:
+    mov rax, 1
 ${labelFim}:`;
         }
         return 'rax';
@@ -280,16 +280,16 @@ ${labelFim}:`;
     traduzirConstrutoUnario(construto) {
         const operando = this.dicionarioConstrutos[construto.operando.constructor.name](construto.operando);
         const operador = construto.operador.lexema;
-        this.text += `
+        this.text += `
     mov rax, ${operando}`;
         if (operador === '-') {
-            this.text += `
+            this.text += `
     neg rax`;
         }
         else if (operador === '!' || operador === 'nao') {
-            this.text += `
-    cmp rax, 0
-    sete al
+            this.text += `
+    cmp rax, 0
+    sete al
     movzx rax, al`;
         }
         return 'rax';
@@ -311,8 +311,8 @@ ${labelFim}:`;
             construto.valores.forEach((valor, index) => {
                 if (this.dicionarioConstrutos[valor.constructor.name]) {
                     const valorTraduzido = this.dicionarioConstrutos[valor.constructor.name](valor);
-                    this.text += `
-    mov rax, ${valorTraduzido}
+                    this.text += `
+    mov rax, ${valorTraduzido}
     mov [${labelVetor} + ${index * 8}], rax`;
                 }
             });
@@ -332,17 +332,17 @@ ${labelFim}:`;
     traduzirDeclaracaoEnquanto(declaracao) {
         const labelInicio = this.gerarLabel();
         const labelFim = this.gerarLabel();
-        this.text += `
+        this.text += `
 ${labelInicio}:`;
         const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
-        this.text += `
-    cmp ${condicao}, 0
+        this.text += `
+    cmp ${condicao}, 0
     je ${labelFim}`;
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
         }
-        this.text += `
-    jmp ${labelInicio}
+        this.text += `
+    jmp ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoEscolha(declaracao) {
@@ -353,9 +353,9 @@ ${labelFim}:`;
                 const labelProximo = this.gerarLabel();
                 if (caminho.condicoes && caminho.condicoes[0]) {
                     const valorCaso = this.dicionarioConstrutos[caminho.condicoes[0].constructor.name](caminho.condicoes[0]);
-                    this.text += `
-    mov rax, ${valorEscolha}
-    cmp rax, ${valorCaso}
+                    this.text += `
+    mov rax, ${valorEscolha}
+    cmp rax, ${valorCaso}
     jne ${labelProximo}`;
                     if (caminho.declaracoes && Array.isArray(caminho.declaracoes)) {
                         caminho.declaracoes.forEach((decl) => {
@@ -364,13 +364,13 @@ ${labelFim}:`;
                             }
                         });
                     }
-                    this.text += `
-    jmp ${labelFim}
+                    this.text += `
+    jmp ${labelFim}
 ${labelProximo}:`;
                 }
             });
         }
-        this.text += `
+        this.text += `
 ${labelFim}:`;
     }
     traduzirDeclaracaoExpressao(declaracao) {
@@ -380,7 +380,7 @@ ${labelFim}:`;
     }
     traduzirDeclaracaoFazer(declaracao) {
         const labelInicio = this.gerarLabel();
-        this.text += `
+        this.text += `
 ${labelInicio}:`;
         // Em Delégua, fazer-enquanto tem caminhoFazer que é um Bloco
         if (declaracao.caminhoFazer && declaracao.caminhoFazer.declaracoes) {
@@ -392,8 +392,8 @@ ${labelInicio}:`;
         }
         if (declaracao.condicaoEnquanto) {
             const condicao = this.dicionarioConstrutos[declaracao.condicaoEnquanto.constructor.name](declaracao.condicaoEnquanto);
-            this.text += `
-    cmp ${condicao}, 0
+            this.text += `
+    cmp ${condicao}, 0
     jne ${labelInicio}`;
         }
     }
@@ -406,25 +406,25 @@ ${labelInicio}:`;
             }
         }
         if (this.alvo === 'linux') {
-            this.text += `
-        ; Falhar com mensagem: ${mensagem}
-        mov eax, 1
-        mov ebx, 1
+            this.text += `
+        ; Falhar com mensagem: ${mensagem}
+        mov eax, 1
+        mov ebx, 1
         int 0x80`;
         }
         else {
-            this.text += `
-        ; Falhar com mensagem: ${mensagem}
-        mov eax, 1
+            this.text += `
+        ; Falhar com mensagem: ${mensagem}
+        mov eax, 1
         ret`;
         }
     }
     traduzirDeclaracaoFuncao(declaracao) {
         var _a;
         const nomeFuncao = ((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'funcao';
-        this.text += `
-${nomeFuncao}:
-    push rbp
+        this.text += `
+${nomeFuncao}:
+    push rbp
     mov rbp, rsp`;
         if (declaracao.funcao && declaracao.funcao.corpo && Array.isArray(declaracao.funcao.corpo)) {
             declaracao.funcao.corpo.forEach((decl) => {
@@ -433,13 +433,13 @@ ${nomeFuncao}:
                 }
             });
         }
-        this.text += `
-    pop rbp
+        this.text += `
+    pop rbp
     ret`;
     }
     traduzirDeclaracaoImportar(declaracao) {
         // Importação é tratada em tempo de linkagem
-        this.text += `
+        this.text += `
     ; Importar: ${declaracao.caminho || 'unknown'}`;
     }
     traduzirDeclaracaoLeia(declaracao) {
@@ -455,11 +455,11 @@ ${nomeFuncao}:
             this.bss += `    ${varLabel} resb 256\n`;
             this.variaveis.set(nomeVar, varLabel);
         }
-        this.text += `
-    mov eax, 3
-    mov ebx, 0
-    mov ecx, ${this.variaveis.get(nomeVar)}
-    mov edx, 256
+        this.text += `
+    mov eax, 3
+    mov ebx, 0
+    mov ecx, ${this.variaveis.get(nomeVar)}
+    mov edx, 256
     int 0x80`;
     }
     traduzirDeclaracaoPara(declaracao) {
@@ -475,12 +475,12 @@ ${nomeFuncao}:
                 this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
             }
         }
-        this.text += `
+        this.text += `
 ${labelInicio}:`;
         if (declaracao.condicao) {
             const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
-            this.text += `
-    cmp ${condicao}, 0
+            this.text += `
+    cmp ${condicao}, 0
     je ${labelFim}`;
         }
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
@@ -491,8 +491,8 @@ ${labelInicio}:`;
                 this.dicionarioConstrutos[declaracao.incrementar.constructor.name](declaracao.incrementar);
             }
         }
-        this.text += `
-    jmp ${labelInicio}
+        this.text += `
+    jmp ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoParaCada(declaracao) {
@@ -508,57 +508,57 @@ ${labelFim}:`;
         if (vetor instanceof construtos_1.Vetor) {
             tamanhoVetor = vetor.tamanho || 0;
         }
-        this.text += `
-    xor rcx, rcx
-${labelInicio}:
-    cmp rcx, ${tamanhoVetor}
+        this.text += `
+    xor rcx, rcx
+${labelInicio}:
+    cmp rcx, ${tamanhoVetor}
     jge ${labelFim}`;
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
         }
-        this.text += `
-    inc rcx
-    jmp ${labelInicio}
+        this.text += `
+    inc rcx
+    jmp ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoRetorna(declaracao) {
         if (declaracao.valor) {
             const valor = this.dicionarioConstrutos[declaracao.valor.constructor.name](declaracao.valor);
-            this.text += `
+            this.text += `
     mov rax, ${valor}`;
         }
-        this.text += `
-    pop rbp
+        this.text += `
+    pop rbp
     ret`;
     }
     traduzirDeclaracaoSe(declaracao) {
         const labelSenao = this.gerarLabel();
         const labelFim = this.gerarLabel();
         const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
-        this.text += `
-    cmp ${condicao}, 0
+        this.text += `
+    cmp ${condicao}, 0
     je ${labelSenao}`;
         if (this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name](declaracao.caminhoEntao);
         }
-        this.text += `
-    jmp ${labelFim}
+        this.text += `
+    jmp ${labelFim}
 ${labelSenao}:`;
         if (declaracao.caminhoSenao && this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name](declaracao.caminhoSenao);
         }
-        this.text += `
+        this.text += `
 ${labelFim}:`;
     }
     traduzirDeclaracaoClasse(declaracao) {
         var _a;
         // Classes em assembly são complexas - implementação básica
-        this.text += `
+        this.text += `
     ; Classe: ${((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'unknown'}`;
     }
     traduzirDeclaracaoTente(declaracao) {
         // Try-catch em assembly requer handler complexo
-        this.text += `
+        this.text += `
     ; Tente-pegue`;
         if (declaracao.caminhoTente && Array.isArray(declaracao.caminhoTente)) {
             declaracao.caminhoTente.forEach((decl) => {
@@ -597,8 +597,8 @@ ${labelFim}:`;
             }
             else if (this.dicionarioConstrutos[tipoInicializador]) {
                 const valor = this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
-                this.text += `
-    mov rax, ${valor}
+                this.text += `
+    mov rax, ${valor}
     mov [${varLabel}], rax`;
             }
         }
@@ -621,32 +621,32 @@ ${labelFim}:`;
             tam_string_literal = this.criaTamanhoNaMemoriaReferenteAVar(nome_string_literal);
         }
         if (this.alvo === 'linux') {
-            this.text += `
-    mov edx, ${tam_string_literal}
-    mov ecx, ${nome_string_literal}
-    mov ebx, 1        ; fd stdout
-    mov eax, 4        ; sys_write
+            this.text += `
+    mov edx, ${tam_string_literal}
+    mov ecx, ${nome_string_literal}
+    mov ebx, 1        ; fd stdout
+    mov eax, 4        ; sys_write
     int 0x80`;
         }
         else {
             // Windows: prototype `extern printf` and follow Win64 calling convention
             // RCX = format pointer; here we use the literal directly as a C string
-            this.text += `
-    lea rcx, [rel ${nome_string_literal}]
+            this.text += `
+    lea rcx, [rel ${nome_string_literal}]
     call printf`;
         }
     }
     saidaSistema() {
         if (this.alvo === 'linux') {
-            this.text += `
-        mov eax, 1        ; sys_exit
-        xor ebx, ebx      ; status 0
+            this.text += `
+        mov eax, 1        ; sys_exit
+        xor ebx, ebx      ; status 0
         int 0x80`;
         }
         else {
             // Windows: return from main with 0 in EAX
-            this.text += `
-        xor eax, eax
+            this.text += `
+        xor eax, eax
         ret`;
         }
     }

package/tradutores/tradutor-mermaidjs.d.ts

@@ -1,7 +1,7 @@
 import { AcessoIndiceVariavel, AcessoMetodo, AcessoMetodoOuPropriedade, AcessoPropriedade, Agrupamento, Atribuir, Binario, Chamada, DefinirValor, Dicionario, FuncaoConstruto, Leia, Literal, Separador, Unario, Variavel, Vetor } from '../construtos';
 import { Bloco, Classe, Const, Declaracao, Enquanto, Escolha, Escreva, Expressao, Fazer, FuncaoDeclaracao, Para, ParaCada, Se, Var } from '../declaracoes';
 import { CaminhoEscolha, TradutorInterface } from '../interfaces';
-import { ArestaFluxograma, DiagramaClasse, VerticeFluxograma } from './mermaid';
+import { ArestaFluxograma, DiagramaClasse, SubgrafoFuncao, VerticeFluxograma } from './mermaid';
 /**
  * [MermaidJs](https://mermaid.js.org/) é uma especificação que nos permite
  * criar fluxogramas através de uma notação por texto.
@@ -18,8 +18,11 @@ export declare class TradutorMermaidJs implements TradutorInterface<Declaracao>
     anteriores: ArestaFluxograma[];
     vertices: VerticeFluxograma[];
     ultimaDicaVertice: string | undefined;
-    diagramasClasses: DiagramaClasse[];
-    subgrafosFuncoes: string[];
+    classes: DiagramaClasse[];
+    subgrafosFuncoes: {
+        [nome: string]: SubgrafoFuncao;
+    };
+    indentacaoAtual: number;
     traduzirConstrutoAcessoIndiceVariavel(acessoIndiceVariavel: AcessoIndiceVariavel): string;
     traduzirConstrutoAcessoMetodo(acessoMetodo: AcessoMetodo): string;
     traduzirConstrutoAcessoMetodoOuPropriedade(acessoMetodoOuPropriedade: AcessoMetodoOuPropriedade): string;
@@ -93,6 +96,12 @@ export declare class TradutorMermaidJs implements TradutorInterface<Declaracao>
         Se: any;
         Var: any;
     };
+    /**
+     * Ponto de entrada para a tradução de declarações em um fluxograma
+     * no formato MermaidJs.
+     * @param {Declaracao[]} declaracoes As declarações a serem traduzidas.
+     * @returns {string} Texto no formato MermaidJs representando o fluxograma.
+     */
     traduzir(declaracoes: Declaracao[]): string;
 }
 //# sourceMappingURL=tradutor-mermaidjs.d.ts.map