@mocoto/mahoraga 0.14.0 → 0.14.2

package/dist/shared/formatters/formatters/markdown.js

@@ -1,11 +1,13 @@
+// SPDX-License-Identifier: MIT
 import { corrigirPontuacaoECodigo, normalizarFimDeLinha, normalizarNewlinesFinais, removerEspacosFinaisPorLinha } from './commons.js';
 export function matchMarkdownFence(line) {
     const trimmedLeft = line.replace(/^\s+/, '');
     const metrica = trimmedLeft.match(/^([`~])\1{2,}/);
-    if (!metrica)
+    if (!metrica) {
         return null;
-    const ch = (metrica[1] ?? '`') === '~' ? '~' : '`';
-    const len = (metrica[0] ?? '').length;
+    }
+    const ch = (metrica[1]) === '~' ? '~' : '`';
+    const len = metrica[0].length;
     const rest = trimmedLeft.slice(len);
     return {
         ch,
@@ -24,36 +26,42 @@ function normalizarCercasMarkdown(code, protectedLines) {
     let changed = false;
     const out = lines.map((line, idx) => {
         const lineNo = idx + 1;
-        if (protectedLines && protectedLines.has(lineNo))
+        if (protectedLines?.has(lineNo)) {
             return line;
+        }
         const typo = line.match(/^(\s*)``è(.*)$/);
         if (typo) {
-            const prefix = typo[1] ?? '';
-            const after = typo[2] ?? '';
+            const prefix = typo[1];
+            const after = typo[2];
             const normalized = `${prefix}\`\`\`${after}`;
-            if (normalized !== line)
+            if (normalized !== line) {
                 changed = true;
+            }
             return normalized;
         }
         const metrica = line.match(/^(\s*)(`{3,}|~{3,})(.*)$/);
-        if (!metrica)
+        if (!metrica) {
             return line;
-        const prefix = metrica[1] ?? '';
-        const fence = metrica[2] ?? '';
-        const afterFence = metrica[3] ?? '';
+        }
+        const prefix = metrica[1];
+        const fence = metrica[2];
+        const afterFence = metrica[3];
         const info = afterFence.match(/^(\s*)(\S+)(.*)$/);
-        if (!info)
+        if (!info) {
             return line;
-        const lead = info[1] ?? '';
-        const token = info[2] ?? '';
-        const tail = info[3] ?? '';
+        }
+        const lead = info[1];
+        const token = info[2];
+        const tail = info[3];
         const shouldNormalizeToken = /[^\x00-\x7F]/.test(token);
-        if (!shouldNormalizeToken)
+        if (!shouldNormalizeToken) {
             return line;
+        }
         const normalizedToken = stripDiacritics(token);
         const normalized = `${prefix}${fence}${lead}${normalizedToken}${tail}`;
-        if (normalized !== line)
+        if (normalized !== line) {
             changed = true;
+        }
         return normalized;
     });
     return {
@@ -61,17 +69,19 @@ function normalizarCercasMarkdown(code, protectedLines) {
         changed
     };
 }
-function corrigirHtmlInlineEmMarkdown(text, protectedLines) {
+function corrigirHtmlInlineEmMarkdown(text, _protectedLines) {
     let changed = false;
     const fixed = text.replace(/<[^>\n]+>/g, tag => {
-        if (tag.startsWith('<!--') || tag.startsWith('<!'))
+        if (tag.startsWith('<!--') || tag.startsWith('<!')) {
             return tag;
+        }
         let textoTitulo = tag;
         textoTitulo = textoTitulo.replace(/^<\s+/, '<').replace(/^<\/\s+/, '</');
         textoTitulo = textoTitulo.replace(/\s+\/>$/, '/>').replace(/\s+>$/, '>');
         textoTitulo = textoTitulo.replace(/^<\/\s+/, '</');
-        if (textoTitulo !== tag)
+        if (textoTitulo !== tag) {
             changed = true;
+        }
         return textoTitulo;
     });
     return {
@@ -82,24 +92,33 @@ function corrigirHtmlInlineEmMarkdown(text, protectedLines) {
 function corrigirEnfaseMarkdown(text) {
     let changed = false;
     let out = text;
-    if (/^\s*[-*+]\s/.test(out))
+    let current = text;
+    // Não corrigir ênfase em itens de lista markdown (podem ter sintaxe ambígua intencional)
+    if (/^\s*[-*+]\s/.test(out)) {
         return {
             text: out,
             changed: false
         };
+    }
+    // Normalizar padrões mistos óbvios
     out = out.replace(/\*\*\*([^\s*][^*\n]*?)\*\*\*(?!\*)/g, '**$1**');
     out = out.replace(/(^|[^*])\*([^\s*][^*\n]*?)\*\*(?!\*)/g, '$1*$2*');
     out = out.replace(/(^|[^*])\*([^\s*][^*\n]*?)\*\*\*(?!\*)/g, '$1*$2*');
-    if (out !== text)
+    if (out !== current) {
         changed = true;
-    text = out;
+    }
+    current = out;
     const encontrarFimEnfase = (texto) => {
+        // Heurísticas para encontrar onde a ênfase deve terminar:
+        // 1. Se há vírgula seguida de espaço, pode indicar fim da ênfase
         const virgula = texto.match(/,\s/);
-        if (virgula && virgula.index !== undefined) {
+        if (virgula?.index !== undefined) {
             return virgula.index;
         }
+        // 2. Pontuação forte (.!?) no final da string = fim da ênfase antes da pontuação
         const pontuacaoForte = texto.match(/[.!?]+$/);
-        if (pontuacaoForte && pontuacaoForte.index !== undefined) {
+        if (pontuacaoForte?.index !== undefined) {
+            // Verificar se não é abreviação comum
             const antes = texto.slice(0, pontuacaoForte.index);
             const ultimaPalavra = antes.match(/(\S+)$/);
             if (ultimaPalavra) {
@@ -112,15 +131,18 @@ function corrigirEnfaseMarkdown(text) {
                 }
             }
         }
+        // 3. Se texto tem várias palavras e termina com pontuação, ênfase vai até antes da pontuação
         const temEspacos = texto.includes(' ');
         const terminaPontuacao = /[.!?]$/.test(texto.trimEnd());
         if (temEspacos && terminaPontuacao) {
             return texto.trimEnd().length;
         }
+        // 4. Palavra única seguida de espaço e mais texto
         const palavraUnica = texto.match(/^(\S+)\s+\S/);
-        if (palavraUnica && palavraUnica[1]) {
+        if (palavraUnica?.[1]) {
             return palavraUnica[1].length;
         }
+        // 5. Caso padrão: ênfase vai até o fim do conteúdo
         return texto.trimEnd().length;
     };
     const fixarEnfasePorMarcador = (str, marcador) => {
@@ -138,13 +160,14 @@ function corrigirEnfaseMarkdown(text) {
             posicoes.push(idx);
             idx += len;
         }
-        if (posicoes.length === 0 || posicoes.length % 2 === 0)
+        if (posicoes.length === 0 || posicoes.length % 2 === 0) {
             return str;
+        }
         const ultimoIdx = posicoes[posicoes.length - 1];
-        if (ultimoIdx === undefined)
-            return str;
-        if (ultimoIdx === 0 || ultimoIdx + len >= str.trimEnd().length)
+        // Não corrigir se o marcador órfão está no início ou fim da linha (pode ser intencional)
+        if (ultimoIdx === 0 || ultimoIdx + len >= str.trimEnd().length) {
             return str;
+        }
         const antesTexto = ultimoIdx > 0 ? str[ultimoIdx - 1] : '';
         const depoisTexto = ultimoIdx + len < str.length ? str[ultimoIdx + len] : '';
         const espacoRegex = /\s/;
@@ -183,13 +206,14 @@ function corrigirEnfaseMarkdown(text) {
                 idx++;
             }
         }
-        if (posicoes.length === 0 || posicoes.length % 2 === 0)
+        if (posicoes.length === 0 || posicoes.length % 2 === 0) {
             return str;
+        }
         const ultimoIdx = posicoes[posicoes.length - 1];
-        if (ultimoIdx === undefined)
-            return str;
-        if (ultimoIdx === 0 || ultimoIdx + len >= str.trimEnd().length)
+        // Não corrigir se o marcador órfão está no início ou fim da linha (pode ser intencional)
+        if (ultimoIdx === 0 || ultimoIdx + len >= str.trimEnd().length) {
             return str;
+        }
         const antesTexto = ultimoIdx > 0 ? str[ultimoIdx - 1] : '';
         const depoisTexto = ultimoIdx + len < str.length ? str[ultimoIdx + len] : '';
         const espacoRegex = /\s/;
@@ -210,6 +234,7 @@ function corrigirEnfaseMarkdown(text) {
         }
         return str;
     };
+    // Processar cada linha separadamente
     const linhas = out.split('\n');
     const corrigidas = linhas.map(linha => {
         let raiz = linha;
@@ -220,8 +245,9 @@ function corrigirEnfaseMarkdown(text) {
         return raiz;
     });
     out = corrigidas.join('\n');
-    if (out !== text)
+    if (out !== current) {
         changed = true;
+    }
     return {
         text: out,
         changed
@@ -246,8 +272,9 @@ function corrigirMarkdownInlineForaDeCodigo(code) {
                 next = erro.text;
                 const hash = corrigirHtmlInlineEmMarkdown(next);
                 next = hash.text;
-                if (next !== chunk)
+                if (next !== chunk) {
                     changed = true;
+                }
                 acc += next;
                 break;
             }
@@ -257,12 +284,14 @@ function corrigirMarkdownInlineForaDeCodigo(code) {
             next = erro.text;
             const hash = corrigirHtmlInlineEmMarkdown(next);
             next = hash.text;
-            if (next !== chunk)
+            if (next !== chunk) {
                 changed = true;
+            }
             acc += next;
             let runFim = tickInicio;
-            while (runFim < text.length && text[runFim] === '`')
+            while (runFim < text.length && text[runFim] === '`') {
                 runFim++;
+            }
             const run = text.slice(tickInicio, runFim);
             const closeIndex = text.indexOf(run, runFim);
             if (closeIndex === -1) {
@@ -332,8 +361,8 @@ function assegurarLinhaVaziaAposTitulosMarkdown(code) {
         out.push(line);
         const ehHeading = /^#{1,6}\s+\S/.test(line.trim());
         const proxima = lines[indice + 1];
-        const proximaTambemHeading = proxima !== undefined && /^#{1,6}\s+\S/.test(proxima.trim());
-        const precisaEspaco = ehHeading && proxima !== undefined && proxima.trim() !== '' && !proximaTambemHeading;
+        const proximaTambemHeading = typeof proxima === 'string' && /^#{1,6}\s+\S/.test(proxima.trim());
+        const precisaEspaco = ehHeading && typeof proxima === 'string' && proxima.trim() !== '' && !proximaTambemHeading;
         if (precisaEspaco) {
             out.push('');
             changed = true;
@@ -374,8 +403,8 @@ function formatarListasMarkdown(code) {
         }
         const listMatch = line.match(/^(\s*)([*+\-])\s+(.*)$/);
         if (listMatch) {
-            const indent = listMatch[1] ?? '';
-            const content = listMatch[3] ?? '';
+            const indent = listMatch[1];
+            const content = listMatch[3];
             const normalized = `${indent}- ${content}`;
             if (normalized !== line) {
                 changed = true;
@@ -400,14 +429,18 @@ function formatarTabelasMarkdown(code) {
     let inTable = false;
     let tableRows = [];
     const processTable = () => {
-        if (tableRows.length === 0)
+        if (tableRows.length === 0) {
             return;
+        }
+        // Verificar se a tabela já está bem formada
+        // Só reformatar se houver problemas estruturais
         const hasSeparatorRow = tableRows.length >= 2 && /^\s*[-:|]+\s*$/.test(tableRows[1] ?? '');
         const colCounts = tableRows.map(row => {
             const cells = row.split('|').filter((_, posAtual, arr) => posAtual > 0 && posAtual < arr.length - 1);
             return cells.length;
         });
         const consistentCols = colCounts.every(elem => elem === colCounts[0]);
+        // Se a tabela tem separador e colunas consistentes, preservar como está
         if (hasSeparatorRow && consistentCols) {
             for (const row of tableRows) {
                 out.push(row);
@@ -416,6 +449,7 @@ function formatarTabelasMarkdown(code) {
             inTable = false;
             return;
         }
+        // Tabela com problemas: reformatar
         const parsedRows = tableRows.map(row => {
             const content = row.replace(/^\s*\|/, '').replace(/\|\s*$/, '');
             return content.split('|').map(cell => cell.trim());
@@ -543,6 +577,9 @@ function limitarLinhasEmBrancoMarkdown(code, maxConsecutivas = 2) {
         changed
     };
 }
+/**
+ * Minimal Markdown formatter.
+ */
 export function formatarMarkdownMinimo(code, protectedLines) {
     const normalized = normalizarFimDeLinha(code);
     const trimmed = removerEspacosFinaisPorLinha(normalized);
@@ -551,6 +588,7 @@ export function formatarMarkdownMinimo(code, protectedLines) {
     const { code: comEspacoTitulos, changed: changedHeadings } = assegurarLinhaVaziaAposTitulosMarkdown(markdownCorrigido);
     const { code: comListasFormatadas, changed: changedListas } = formatarListasMarkdown(comEspacoTitulos);
     const { code: comTabelasFormatadas, changed: changedTabelas } = formatarTabelasMarkdown(comListasFormatadas);
+    // Aplicar correção de pontuação APENAS fora de code fences
     const { code: comPontuacaoCorrigida, changed: changedPunctuation, stats } = corrigirPontuacaoECodigoPreservandoCodeFences(comTabelasFormatadas, protectedLines);
     const { code: semBlanks, changed: changedBlanks } = limitarLinhasEmBrancoMarkdown(comPontuacaoCorrigida, 2);
     const formatted = normalizarNewlinesFinais(semBlanks);
@@ -563,6 +601,9 @@ export function formatarMarkdownMinimo(code, protectedLines) {
         reason: anyChanged ? `estilo-mahoraga-markdown(punct:${stats.pontuacaoRepetida},space:${stats.espacamentoIncorreto},ops:${stats.operadoresRelacionais})` : 'normalizacao-basica'
     };
 }
+/**
+ * Corrige pontuação preservando code fences (blocos de código)
+ */
 function corrigirPontuacaoECodigoPreservandoCodeFences(code, protectedLines) {
     const lines = normalizarFimDeLinha(code).split('\n');
     const out = [];
@@ -578,6 +619,7 @@ function corrigirPontuacaoECodigoPreservandoCodeFences(code, protectedLines) {
         const line = lines[indice] ?? '';
         const lineNo = indice + 1;
         const fence = matchMarkdownFence(line);
+        // Detectar abertura de code fence
         if (!inFence && fence) {
             inFence = true;
             fenceChar = fence.ch;
@@ -585,6 +627,7 @@ function corrigirPontuacaoECodigoPreservandoCodeFences(code, protectedLines) {
             out.push(line);
             continue;
         }
+        // Detectar fechamento de code fence
         if (inFence && fence && isMarkdownFenceCloser(fence, fenceChar, fenceLen)) {
             inFence = false;
             fenceChar = null;
@@ -592,14 +635,17 @@ function corrigirPontuacaoECodigoPreservandoCodeFences(code, protectedLines) {
             out.push(line);
             continue;
         }
+        // Se estiver dentro de code fence, preservar linha
         if (inFence) {
             out.push(line);
             continue;
         }
-        if (protectedLines && protectedLines.has(lineNo)) {
+        // Se linha está protegida por supressão, preservar
+        if (protectedLines?.has(lineNo)) {
             out.push(line);
             continue;
         }
+        // Fora de code fence, aplicar correção de pontuação
         const { text: corrigida, stats } = corrigirPontuacaoECodigo(line);
         totalStats.pontuacaoRepetida += stats.pontuacaoRepetida;
         totalStats.espacamentoIncorreto += stats.espacamentoIncorreto;
@@ -613,4 +659,3 @@ function corrigirPontuacaoECodigoPreservandoCodeFences(code, protectedLines) {
         stats: totalStats
     };
 }
-//# sourceMappingURL=markdown.js.map

package/dist/shared/formatters/formatters/properties.js

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 import { corrigirPontuacaoECodigo, limitarLinhasEmBranco, normalizarFimDeLinha, normalizarNewlinesFinais, removerBom } from './commons.js';
 function parsePropertiesLines(code) {
     const lines = normalizarFimDeLinha(code).split('\n');
@@ -6,6 +7,7 @@ function parsePropertiesLines(code) {
     for (const raw of lines) {
         const trimmed = raw.trim();
         if (inContinuation) {
+            // Continuação de linha (termina com \)
             const isLast = !trimmed.endsWith('\\');
             if (isLast) {
                 inContinuation = false;
@@ -36,10 +38,11 @@ function parsePropertiesLines(code) {
             });
             continue;
         }
+        // Key-value com separador := ou =
         const sepMatch = trimmed.match(/^([^:=]+?)\s*[:=]\s*(.*)$/);
         if (sepMatch) {
-            const key = (sepMatch[1] ?? '').trim();
-            const val = (sepMatch[2] ?? '').trim();
+            const key = sepMatch[1].trim();
+            const val = sepMatch[2].trim();
             const isContinuation = val.endsWith('\\');
             if (isContinuation) {
                 inContinuation = true;
@@ -68,6 +71,7 @@ function corrigirEspacamentoProperties(entries) {
             out.push(entry);
             continue;
         }
+        // Garantir formato: key = value (espaços em torno de =)
         const fixed = `${entry.key} = ${entry.value}`;
         if (fixed !== entry.raw) {
             out.push({
@@ -88,6 +92,8 @@ function corrigirUnicodeEscapes(entries) {
             out.push(entry);
             continue;
         }
+        // Decodificar unicode escapes no valor se necessário
+        // \uXXXX → caractere Unicode
         const decoded = entry.value.replace(/\\u([0-9a-fA-F]{4})/g, (_match, hex) => {
             return String.fromCharCode(parseInt(hex, 16));
         });
@@ -104,13 +110,23 @@ function corrigirUnicodeEscapes(entries) {
     }
     return out;
 }
+/* ────────────────────────── Public API ────────────────────────── */
+/**
+ * Properties formatter com detecção de contexto para line continuation e unicode escapes.
+ */
 export function formatarPropertiesMinimo(code) {
     const normalized = normalizarFimDeLinha(removerBom(code));
+    // Parse com contexto
     const entries = parsePropertiesLines(normalized);
+    // Correção de espaçamento
     const comEspacamento = corrigirEspacamentoProperties(entries);
+    // Decodificar unicode escapes
     const comUnicode = corrigirUnicodeEscapes(comEspacamento);
+    // Reconstruir
     const rebuilt = comUnicode.map(erro => erro.raw).join('\n');
+    // Limitar linhas em branco
     const { code: limitado } = limitarLinhasEmBranco(rebuilt, 2);
+    // Correção de pontuação
     const { text: comPontuacao, stats } = corrigirPontuacaoECodigo(limitado);
     const formatted = normalizarNewlinesFinais(comPontuacao);
     const baseline = normalizarNewlinesFinais(normalized);
@@ -123,6 +139,10 @@ export function formatarPropertiesMinimo(code) {
         reason: anyChanged ? `estilo-mahoraga-properties(punct:${stats.pontuacaoRepetida},space:${stats.espacamentoIncorreto},ops:${stats.operadoresRelacionais})` : 'normalizacao-basica'
     };
 }
+/* ────────────────────────── Gradle ────────────────────────── */
+/**
+ * Gradle formatter com detecção de contexto.
+ */
 export function formatarGradleMinimo(code) {
     const normalized = normalizarFimDeLinha(removerBom(code));
     const lines = normalized.split('\n');
@@ -131,6 +151,7 @@ export function formatarGradleMinimo(code) {
     let prevWasBlock = false;
     for (const raw of lines) {
         const trimmed = raw.trim();
+        // Multiline comments
         if (inMultilineComment) {
             out.push(raw);
             if (trimmed.includes('*/')) {
@@ -143,16 +164,19 @@ export function formatarGradleMinimo(code) {
             out.push(raw);
             continue;
         }
+        // Single line comments
         if (trimmed.startsWith('//')) {
             out.push(raw);
             continue;
         }
+        // Empty lines
         if (!trimmed) {
             out.push(raw);
             continue;
         }
+        // Linha em branco antes de blocos (dependencies, plugins, etc.)
         if (/^(dependencies|plugins|repositories|buildscript|subprojects|allprojects|configurations)\s*[\{]/.test(trimmed)) {
-            if (prevWasBlock === false && out.length > 0 && out[out.length - 1] !== '') {
+            if (!prevWasBlock && out.length > 0 && out[out.length - 1] !== '') {
                 out.push('');
             }
             prevWasBlock = true;
@@ -160,6 +184,7 @@ export function formatarGradleMinimo(code) {
         else {
             prevWasBlock = false;
         }
+        // Trailing whitespace
         out.push(raw.replace(/[ \t]+$/, ''));
     }
     const { code: limitado } = limitarLinhasEmBranco(out.join('\n'), 2);
@@ -175,4 +200,3 @@ export function formatarGradleMinimo(code) {
         reason: anyChanged ? `estilo-mahoraga-gradle(punct:${stats.pontuacaoRepetida},space:${stats.espacamentoIncorreto},ops:${stats.operadoresRelacionais})` : 'normalizacao-basica'
     };
 }
-//# sourceMappingURL=properties.js.map

package/dist/shared/formatters/formatters/shell.js

@@ -1,6 +1,8 @@
+// SPDX-License-Identifier: MIT
 import { corrigirPontuacaoECodigo, limitarLinhasEmBranco, normalizarFimDeLinha, normalizarNewlinesFinais, removerBom } from './commons.js';
 function parseShellLine(raw, ctx) {
     const trimmed = raw.trimEnd();
+    // Here-doc: preservar exatamente
     if (ctx.inHereDoc) {
         const isEnd = ctx.hereDocStripTabs ? trimmed.trim() === ctx.hereDocDelimiter : trimmed === ctx.hereDocDelimiter;
         if (isEnd) {
@@ -19,32 +21,34 @@ function parseShellLine(raw, ctx) {
             ctx
         };
     }
+    // Linha vazia
     if (!trimmed.trim()) {
         return {
             output: trimmed,
             ctx
         };
     }
+    // Comentário
     if (/^\s*#/.test(trimmed)) {
         return {
             output: trimmed,
             ctx
         };
     }
+    // Analisar quoting e here-doc
     let inSingleQuote = ctx.inSingleQuote;
     let inDoubleQuote = ctx.inDoubleQuote;
     let escaped = false;
     let indice = 0;
     while (indice < trimmed.length) {
         const ch = trimmed[indice];
-        if (ch === undefined)
-            break;
         if (escaped) {
             escaped = false;
             indice++;
             continue;
         }
         if (ch === '\\') {
+            // Verificar se é continuação de linha
             if (indice === trimmed.length - 1 && !inSingleQuote) {
                 return {
                     output: trimmed,
@@ -82,11 +86,12 @@ function parseShellLine(raw, ctx) {
             indice++;
             continue;
         }
+        // Here-doc (fora de quotes)
         if (ch === '<') {
             const rest = trimmed.slice(indice);
             const hereDocMatch = rest.match(/<<-?\s*['"]?(\w+)['"]?/);
             if (hereDocMatch) {
-                const delimiter = hereDocMatch[1] ?? '';
+                const delimiter = hereDocMatch[1];
                 const stripTabs = rest.includes('<<-');
                 return {
                     output: trimmed,
@@ -102,6 +107,7 @@ function parseShellLine(raw, ctx) {
         }
         indice++;
     }
+    // Verificar continuação
     const endsWithBackslash = trimmed.endsWith('\\') && !escaped;
     if (endsWithBackslash && !inSingleQuote && !inDoubleQuote) {
         return {
@@ -145,18 +151,23 @@ function corrigirEspacamentoShell(lines) {
             out.push(output);
             continue;
         }
+        // Comentários: garantir espaço após #
         if (/^\s*#\S/.test(output)) {
             out.push(output.replace(/^(\s*)#(\S)/, '$1# $2'));
             continue;
         }
+        // Espaçamento em atribuições: VAR=value (sem espaços em torno de =)
+        // Mas não em comparações [ $a = $b ]
         if (/^\s*[a-zA-Z_][\w]*\s+=\s/.test(output) && !output.includes('[')) {
             out.push(output.replace(/^(\s*[a-zA-Z_][\w]*)\s+=\s/, '$1='));
             continue;
         }
+        // Espaçamento em pipes: | → | (espaços em torno)
         if (/\S\|\S/.test(output)) {
             out.push(output.replace(/(\S)\|(\S)/g, '$1 | $2'));
             continue;
         }
+        // Espaçamento em redirecionamentos: >file → > file
         if (/\S[><]\S/.test(output)) {
             out.push(output.replace(/(\S)([><])(\S)/g, '$1 $2 $3'));
             continue;
@@ -165,11 +176,18 @@ function corrigirEspacamentoShell(lines) {
     }
     return out;
 }
+/* ────────────────────────── Public API ────────────────────────── */
+/**
+ * Shell formatter com detecção de contexto para here-docs, quoting e continuação.
+ */
 export function formatarShellMinimo(code) {
     const normalized = normalizarFimDeLinha(removerBom(code));
     const lines = normalized.split('\n');
+    // Correção de espaçamento context-aware
     const comEspacamento = corrigirEspacamentoShell(lines);
+    // Limitar linhas em branco
     const { code: limitedBlanks } = limitarLinhasEmBranco(comEspacamento.join('\n'), 2);
+    // Correção de pontuação (preserva here-docs e comentários)
     const { text: comPontuacao, stats } = corrigirPontuacaoECodigo(limitedBlanks);
     const formatted = normalizarNewlinesFinais(comPontuacao);
     const baseline = normalizarNewlinesFinais(normalized);
@@ -182,4 +200,3 @@ export function formatarShellMinimo(code) {
         reason: anyChanged ? `estilo-mahoraga-shell(punct:${stats.pontuacaoRepetida},space:${stats.espacamentoIncorreto},ops:${stats.operadoresRelacionais})` : 'normalizacao-basica'
     };
 }
-//# sourceMappingURL=shell.js.map