@mocoto/mahoraga 0.14.0 → 0.14.2

package/dist/shared/formatters/code-min-formatter.js

@@ -1,12 +1,17 @@
 import { normalizarFimDeLinha, normalizarNewlinesFinais, removerEspacosFinaisPorLinha } from './formatters/commons.js';
+/**
+ * Formata código minimamente, normalizando terminações de linha, newlines finais e espaços
+ * @param code - Código fonte a ser formatado
+ * @param opts - Opções de formatação (separadores, relPath, parser)
+ * @returns Resultado da formatação
+ */
 export function formatarCodeMinimo(code, opts) {
     const normalized = normalizarFimDeLinha(code);
     const formatted = normalizarNewlinesFinais(removerEspacosFinaisPorLinha(normalized));
     return {
         ok: true,
-        parser: opts?.parser ?? 'code',
+        parser: opts?.parser,
         formatted,
         changed: formatted !== normalizarNewlinesFinais(normalized),
     };
 }
-//# sourceMappingURL=code-min-formatter.js.map

package/dist/shared/formatters/core/formatter-registry.js

@@ -1,13 +1,24 @@
+// SPDX-License-Identifier: MIT
 const registry = new Map();
+/**
+ * Registra um formatador para uma extensão de arquivo específica.
+ * @param ext Extensão do arquivo (ex: '.ts', '.md').
+ * @param fn Função de formatação a ser associada à extensão.
+ */
 export function registerFormatter(ext, fn) {
     registry.set(ext.toLowerCase(), fn);
 }
+/**
+ * Obtém o formatador registrado para um determinado caminho de arquivo.
+ * @param relPath Caminho relativo do arquivo.
+ * @returns A função de formatação ou null se nenhum formatador estiver registrado.
+ */
 export function getFormatterForPath(relPath) {
     const normalizedPath = (relPath || '').toLowerCase();
     for (const [ext, fn] of registry.entries()) {
-        if (normalizedPath.endsWith(ext))
+        if (normalizedPath.endsWith(ext)) {
             return fn;
+        }
     }
     return null;
 }
-//# sourceMappingURL=formatter-registry.js.map

package/dist/shared/formatters/core/index.js

@@ -1,3 +1,2 @@
 export * from './formatter-registry.js';
 export * from './syntax-map.js';
-//# sourceMappingURL=index.js.map

package/dist/shared/formatters/core/syntax-map.js

@@ -1,3 +1,8 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Mapa de extensões de arquivo para informações de sintaxe.
+ * Cada entrada mapeia uma extensão para o parser correspondente e se é formatável.
+ */
 export const syntaxMap = {
     '.ts': { parser: 'typescript', formatavel: true },
     '.tsx': { parser: 'typescript', formatavel: true },
@@ -21,8 +26,10 @@ export const syntaxMap = {
     '.htm': { parser: 'html', formatavel: true },
     '.php': { parser: 'php', formatavel: true },
     '.xml': { parser: 'xml', formatavel: true },
+    // Linguagens de programação
     '.py': { parser: 'python', formatavel: true },
     '.go': { parser: 'go', formatavel: true },
+    // Arquivos de configuração e sistema
     '.gitignore': { parser: 'gitignore', formatavel: true },
     '.editorconfig': { parser: 'editorconfig', formatavel: true },
     '.npmrc': { parser: 'npmrc', formatavel: true },
@@ -37,16 +44,22 @@ export const syntaxMap = {
     '.dockerfile': { parser: 'dockerfile', formatavel: true },
     '.sh': { parser: 'shell', formatavel: true },
     '.bash': { parser: 'shell', formatavel: true },
+    // Arquivos de texto e logs
     '.txt': { parser: 'code', formatavel: true },
     '.log': { parser: 'code', formatavel: true },
     '.env': { parser: 'code', formatavel: true },
 };
+/**
+ * Obtém informações de sintaxe para um caminho de arquivo baseado na extensão.
+ * @param relPath Caminho relativo do arquivo.
+ * @returns Informações de sintaxe ou null se a extensão não for reconhecida.
+ */
 export function getSyntaxInfoForPath(relPath) {
     const normalizedPath = (relPath || '').toLowerCase();
     for (const ext of Object.keys(syntaxMap)) {
-        if (normalizedPath.endsWith(ext))
+        if (normalizedPath.endsWith(ext)) {
             return syntaxMap[ext];
+        }
     }
     return null;
 }
-//# sourceMappingURL=syntax-map.js.map

package/dist/shared/formatters/engines/index.js

@@ -1,4 +1,3 @@
 export * from './prettier.js';
 export * from './stylelint.js';
 export * from './svgs.js';
-//# sourceMappingURL=index.js.map

package/dist/shared/formatters/engines/prettier.js

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 import fs from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
@@ -10,13 +11,14 @@ const prettierCache = new Map();
 async function carregarPrettierDoProjeto(baseDir) {
     const base = baseDir || process.cwd();
     const cached = prettierCache.get(base);
-    if (cached)
+    if (cached) {
         return cached;
+    }
     const loader = (async () => {
         const tryImportPrettier = async (resolved) => {
             try {
                 const mod = await import(resolved);
-                const candidate = mod && typeof mod === 'object' && 'default' in mod ? mod.default : mod;
+                const candidate = typeof mod === 'object' && 'default' in mod ? mod.default : mod;
                 if (!candidate || !isPrettierApi(candidate)) {
                     return null;
                 }
@@ -36,17 +38,20 @@ async function carregarPrettierDoProjeto(baseDir) {
             }
         };
         const fromProjectPkg = await tryResolveFromProjectPkg(base, tryResolveFrom);
-        if (fromProjectPkg)
+        if (fromProjectPkg) {
             return fromProjectPkg;
+        }
         {
             const api = await tryResolveFrom(createRequire(import.meta.url));
-            if (api)
+            if (api) {
                 return api;
+            }
         }
-        const feedbackDir = process.env.MAHORAGA_PRETTIER_FEEDBACK_DIR || path.join(base, 'feedback', 'prettier');
+        const feedbackDir = process.env.SUKUNA_PRETTIER_FEEDBACK_DIR ?? path.join(base, 'feedback', 'prettier');
         const fromFeedback = await tryResolveFromFeedbackDir(feedbackDir, tryImportPrettier);
-        if (fromFeedback)
+        if (fromFeedback) {
             return fromFeedback;
+        }
         return null;
     })();
     prettierCache.set(base, loader);
@@ -75,20 +80,24 @@ async function tryResolveFromFeedbackDir(feedbackDir, tryImportPrettier) {
                 continue;
             }
             const api = await tryImportPrettier(caminho);
-            if (api)
+            if (api) {
                 return api;
+            }
         }
     }
     catch {
+        // feedback package not found, continue
     }
     return null;
 }
 function inferPrettierParser(relPath, code) {
     const info = getSyntaxInfoForPath(relPath ?? '');
-    if (!info)
+    if (!info) {
         return null;
-    if (!info.formatavel)
+    }
+    if (!info.formatavel) {
         return null;
+    }
     const rp = (relPath ?? '').toLowerCase();
     if (rp.endsWith('.json')) {
         const src = code ?? '';
@@ -99,7 +108,7 @@ function inferPrettierParser(relPath, code) {
     return info.parser ?? null;
 }
 export async function formatarComPrettierProjeto(params) {
-    const baseDir = params.baseDir || process.cwd();
+    const baseDir = params.baseDir ?? process.cwd();
     const relPath = params.relPath;
     const absCaminho = path.resolve(baseDir, relPath);
     const prettier = await carregarPrettierDoProjeto(baseDir);
@@ -128,8 +137,8 @@ export async function formatarComPrettierProjeto(params) {
         });
         const inferSingleQuote = (src) => {
             try {
-                const singles = (src.match(/'/g) || []).length;
-                const doubles = (src.match(/"/g) || []).length;
+                const singles = (src.match(/'/g) ?? []).length;
+                const doubles = (src.match(/"/g) ?? []).length;
                 return singles > doubles;
             }
             catch {
@@ -137,7 +146,7 @@ export async function formatarComPrettierProjeto(params) {
             }
         };
         const options = {
-            ...(resolvedConfig || {}),
+            ...(resolvedConfig ?? {}),
             filepath: absCaminho,
             parser
         };
@@ -147,7 +156,7 @@ export async function formatarComPrettierProjeto(params) {
             }
         }
         const out = await prettier.format(params.code, options);
-        const formatted = String(out);
+        const formatted = out;
         return {
             ok: true,
             parser: 'code',
@@ -165,4 +174,3 @@ export async function formatarComPrettierProjeto(params) {
         };
     }
 }
-//# sourceMappingURL=prettier.js.map

package/dist/shared/formatters/engines/stylelint.js

@@ -1,3 +1,10 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Lint de CSS interno do Mahoraga (inspirado em linters de CSS do ecossistema).
+ *
+ * Importante: este arquivo NÃO usa nem depende dos artefatos em /implis.
+ * A pasta implis serve apenas como referência/"inspiração" de regras.
+ */
 import * as csstree from 'css-tree';
 function normalizeWhitespace(input) {
     return input.replace(/\s+/g, ' ').trim();
@@ -15,10 +22,12 @@ function checkNoInvalidDoubleSlashComments(code) {
         const lineNo = indice + 1;
         const line = lines[indice] ?? '';
         const idx = line.indexOf('//');
-        if (idx === -1)
+        if (idx === -1) {
             continue;
-        if (isLikelyHttpUrlLine(line))
+        }
+        if (isLikelyHttpUrlLine(line)) {
             continue;
+        }
         out.push({
             rule: 'no-invalid-double-slash-comments',
             severity: 'warning',
@@ -40,32 +49,40 @@ function hasImageSet(value) {
 }
 export function isLikelyIntentionalDuplicate(prop, prevValue, newValue, ctx) {
     const normalizedProp = prop.toLowerCase();
+    // Fallbacks de viewport (100vh / 100dvh)
     if (/(100)?(vh|dvh|vw|dvw)/i.test(prevValue) || /(100)?(vh|dvh|vw|dvw)/i.test(newValue)) {
         return true;
     }
+    // Fallback com var(); comum quando há valor default + CSS custom properties
     if (hasCssVar(prevValue) || hasCssVar(newValue)) {
         return true;
     }
+    // Fallbacks de cor (rgb/rgba/hex)
     if (/(^#|rgb|hsl|color)/i.test(prevValue) && /(^#|rgb|hsl|color)/i.test(newValue) && prevValue !== newValue) {
         return true;
     }
     const gradientPrev = hasGradient(prevValue);
     const gradientNew = hasGradient(newValue);
+    // Fallbacks de gradient (ou cor -> gradient) são intencionais para browsers antigos
     const isBackgroundProp = normalizedProp === 'background' || normalizedProp === 'background-image';
     if (gradientPrev && gradientNew && prevValue !== newValue || isBackgroundProp && (gradientPrev || gradientNew)) {
         return true;
     }
+    // image-set() vs url() costuma ser fallback/resolução
     if (isBackgroundProp && (hasImageSet(prevValue) || hasImageSet(newValue))) {
         return true;
     }
-    const inFontFace = (ctx?.currentAtRule || '').toLowerCase() === 'font-face';
+    // Fallback de fontes em @font-face: múltiplos src são esperados
+    const inFontFace = (ctx?.currentAtRule ?? '').toLowerCase() === 'font-face';
     if (inFontFace && normalizedProp === 'src') {
         return true;
     }
+    // Propriedades com prefixos vendor (transform, animation, transition, etc)
     const vendorProp = normalizedProp.replace(/^(-webkit|-moz|-ms|-o)-/, '');
     if (vendorProp !== normalizedProp) {
         return true;
     }
+    // Fallback de display entre flex e grid é suspeito mas não impossível
     if (normalizedProp === 'display' && (prevValue === 'flex' || prevValue === 'grid') && (newValue === 'flex' || newValue === 'grid')) {
         return false;
     }
@@ -106,8 +123,9 @@ export function lintCssLikeStylelint(opts) {
     const keyframesSeen = new Set();
     const atruleStack = [];
     function currentScopeKey() {
-        if (!atruleStack.length)
+        if (!atruleStack.length) {
             return '';
+        }
         return atruleStack.map(arquivo => {
             const caminho = arquivo.prelude ? ` ${arquivo.prelude}` : '';
             return `@${arquivo.name}${caminho}`;
@@ -117,11 +135,13 @@ export function lintCssLikeStylelint(opts) {
         return node.prelude ? normalizeWhitespace(csstree.generate(node.prelude)) : '';
     }
     function checkAtImport(node) {
-        if (node?.type !== 'Atrule' || String(node.name || '').toLowerCase() !== 'import')
+        if (node.type !== 'Atrule' || typeof node.name !== 'string' || node.name.toLowerCase() !== 'import') {
             return;
+        }
         const prelude = generateNodeText(node);
-        if (!prelude)
+        if (!prelude) {
             return;
+        }
         if (hasHttpUrl(prelude)) {
             warnings.push({
                 rule: 'no-http-at-import-rules',
@@ -145,12 +165,14 @@ export function lintCssLikeStylelint(opts) {
         }
     }
     function checkKeyframes(node) {
-        if (node?.type !== 'Atrule')
+        if (node.type !== 'Atrule') {
             return;
-        const name = String(node.name || '').toLowerCase();
+        }
+        const name = typeof node.name === 'string' ? node.name.toLowerCase() : '';
         const isKeyframes = name === 'keyframes' || name === '-webkit-keyframes' || name === '-moz-keyframes';
-        if (!isKeyframes)
+        if (!isKeyframes) {
             return;
+        }
         const prelude = generateNodeText(node);
         const key = `${name}:${prelude}`;
         if (keyframesSeen.has(key)) {
@@ -167,18 +189,21 @@ export function lintCssLikeStylelint(opts) {
         }
     }
     function pushAtRuleScope(node) {
-        if (node?.type !== 'Atrule' || !node.block)
+        if (node.type !== 'Atrule' || !node.block) {
             return;
-        const name = String(node.name || '').toLowerCase();
+        }
+        const name = typeof node.name === 'string' ? node.name.toLowerCase() : '';
         const prelude = generateNodeText(node);
         atruleStack.push({ name, prelude });
     }
     function checkDuplicateSelector(node) {
-        if (node?.type !== 'Rule' || !node?.prelude)
+        if (node.type !== 'Rule' || !node.prelude) {
             return;
+        }
         const selector = normalizeWhitespace(csstree.generate(node.prelude));
-        if (!selector)
+        if (!selector) {
             return;
+        }
         const key = `${currentScopeKey()}||${selector}`;
         if (selectorSeenByScope.has(key)) {
             warnings.push({
@@ -194,26 +219,32 @@ export function lintCssLikeStylelint(opts) {
         }
     }
     function checkEmptyBlock(node) {
-        if (node?.type !== 'Rule' && node?.type !== 'Atrule')
+        if (node.type !== 'Rule' && node.type !== 'Atrule') {
             return;
-        if (!node?.block?.children)
+        }
+        if (!node.block?.children) {
             return;
+        }
         const children = node.block.children;
         const isEmpty = typeof children.getSize === 'function' ? children.getSize() === 0 : false;
-        if (!isEmpty)
+        if (!isEmpty) {
             return;
+        }
         const loc = node.loc?.start;
-        if (!loc?.line)
+        if (!loc?.line) {
             return;
+        }
         const lines = code.split('\n');
         let ruleText = '';
         for (let posAtual = Math.max(0, loc.line - 1); posAtual < Math.min(lines.length, loc.line + 5); posAtual++) {
             ruleText += `${lines[posAtual]}\n`;
-            if (lines[posAtual]?.includes('}'))
+            if (lines[posAtual]?.includes('}')) {
                 break;
+            }
         }
-        if (/@apply/.test(ruleText))
+        if (/@apply/.test(ruleText)) {
             return;
+        }
         warnings.push({
             rule: 'block-no-empty',
             severity: 'warning',
@@ -231,11 +262,12 @@ export function lintCssLikeStylelint(opts) {
             checkEmptyBlock(node);
         },
         leave: (node) => {
-            if (node?.type === 'Atrule' && node.block) {
+            if (node.type === 'Atrule' && node.block) {
                 atruleStack.pop();
             }
         }
     });
+    // Duplicatas por bloco (declarações)
     const conflictProps = new Set(['display', 'position', 'float', 'clear']);
     const atruleStackForDecl = [];
     const declStack = [];
@@ -243,18 +275,21 @@ export function lintCssLikeStylelint(opts) {
         return prelude ? normalizeWhitespace(csstree.generate(prelude)) : '';
     }
     function pushAtRuleDeclStack(node) {
-        if (node?.type !== 'Atrule' || !node.block)
+        if (node.type !== 'Atrule' || !node.block) {
             return;
-        const name = String(node.name || '').toLowerCase();
+        }
+        const name = typeof node.name === 'string' ? node.name.toLowerCase() : '';
         const prelude = generateNodeTextSimple(node.prelude);
         atruleStackForDecl.push({ name, prelude });
     }
     function pushRuleDeclStack(node) {
-        if (node?.type !== 'Rule' && node?.type !== 'Atrule')
+        if (node.type !== 'Rule' && node.type !== 'Atrule') {
             return;
-        if (!node.block?.children)
+        }
+        if (!node.block?.children) {
             return;
-        const name = node.type === 'Atrule' ? String(node.name || '').toLowerCase() : '';
+        }
+        const name = node.type === 'Atrule' && typeof node.name === 'string' ? node.name.toLowerCase() : '';
         const prelude = node.type === 'Atrule' ? generateNodeTextSimple(node.prelude) : '';
         declStack.push({
             nodeType: node.type,
@@ -264,8 +299,9 @@ export function lintCssLikeStylelint(opts) {
         });
     }
     function checkImportant(node, loc) {
-        if (node.important !== true)
+        if (node.important !== true) {
             return;
+        }
         warnings.push({
             rule: 'declaration-no-important',
             severity: 'warning',
@@ -275,8 +311,9 @@ export function lintCssLikeStylelint(opts) {
         });
     }
     function checkHttpUrl(value, loc) {
-        if (!/\burl\(\s*['"]?http:\/\//i.test(value))
+        if (!/\burl\(\s*['"]?http:\/\//i.test(value)) {
             return;
+        }
         warnings.push({
             rule: 'no-http-url',
             severity: 'warning',
@@ -286,16 +323,15 @@ export function lintCssLikeStylelint(opts) {
         });
     }
     function processDeclaration(node) {
-        if (node?.type !== 'Declaration')
+        if (node.type !== 'Declaration') {
             return;
+        }
         const current = declStack[declStack.length - 1];
-        const prop = String(node.property || '').toLowerCase();
+        const prop = node.property.toLowerCase();
         const value = node.value ? normalizeWhitespace(csstree.generate(node.value)) : '';
         const loc = node.loc?.start;
         checkImportant(node, loc);
         checkHttpUrl(value, loc);
-        if (!current)
-            return;
         const prev = current.seen.get(prop);
         if (!prev) {
             current.seen.set(prop, { value, line: loc?.line, column: loc?.column });
@@ -306,8 +342,9 @@ export function lintCssLikeStylelint(opts) {
             currentAtRule: current.name,
             currentAtRulePrelude: current.prelude
         };
-        if (isLikelyIntentionalDuplicate(prop, prev.value, value, duplicateCtx))
+        if (isLikelyIntentionalDuplicate(prop, prev.value, value, duplicateCtx)) {
             return;
+        }
         const same = prev.value === value;
         const isStructuralConflict = conflictProps.has(prop) && !same;
         warnings.push({
@@ -325,14 +362,13 @@ export function lintCssLikeStylelint(opts) {
             processDeclaration(node);
         },
         leave: (node) => {
-            if ((node?.type === 'Rule' || node?.type === 'Atrule') && node.block?.children) {
+            if ((node.type === 'Rule' || node.type === 'Atrule') && node.block?.children) {
                 declStack.pop();
             }
-            if (node?.type === 'Atrule' && node.block) {
+            if (node.type === 'Atrule' && node.block) {
                 atruleStackForDecl.pop();
             }
         }
     });
     return warnings;
 }
-//# sourceMappingURL=stylelint.js.map

package/dist/shared/formatters/engines/svgs.js

@@ -1,10 +1,17 @@
+// Limiar padrão para evitar ruído em galerias de ícones:
+// só sugerimos otimização quando a economia é relevante.
 export const SVG_OPT_MIN_BYTES_SALVO = 40;
 export const SVG_OPT_MIN_PORCENTAGEM_SALVO = 5;
+/**
+ * Checks if SVG optimization should be suggested based on byte savings.
+ */
 export function shouldSugerirOtimizacaoSvg(originalBytes, optimizedBytes) {
-    if (!Number.isFinite(originalBytes) || originalBytes <= 0)
+    if (!Number.isFinite(originalBytes) || originalBytes <= 0) {
         return false;
-    if (!Number.isFinite(optimizedBytes) || optimizedBytes >= originalBytes)
+    }
+    if (!Number.isFinite(optimizedBytes) || optimizedBytes >= originalBytes) {
         return false;
+    }
     const saved = originalBytes - optimizedBytes;
     const pct = saved / originalBytes * 100;
     return saved >= SVG_OPT_MIN_BYTES_SALVO || pct >= SVG_OPT_MIN_PORCENTAGEM_SALVO;
@@ -67,19 +74,25 @@ function removerDefsVazio(code) {
 function removerAtributosRaiz(code) {
     let out = code;
     const mudancas = [];
+    // remove version="1.1" etc (geralmente redundante)
     const beforeVersion = out;
     out = out.replace(/(<svg\b[^>]*?)\s+version=("[^"]*"|'[^']*')/i, '$1');
-    if (out !== beforeVersion)
+    if (out !== beforeVersion) {
         mudancas.push('remover-version');
+    }
+    // remove enable-background="new ..." (deprecated)
     const beforeEnable = out;
     out = out.replace(/(<svg\b[^>]*?)\s+enable-background=("[^"]*"|'[^']*')/i, '$1');
-    if (out !== beforeEnable)
+    if (out !== beforeEnable) {
         mudancas.push('remover-enable-background');
+    }
+    // remove xmlns:xlink se xlink: não aparece no arquivo
     if (!/\bxlink:/i.test(out)) {
         const beforeXlink = out;
         out = out.replace(/(<svg\b[^>]*?)\s+xmlns:xlink=("[^"]*"|'[^']*')/i, '$1');
-        if (out !== beforeXlink)
+        if (out !== beforeXlink) {
             mudancas.push('remover-xmlns-xlink');
+        }
     }
     return {
         out,
@@ -89,21 +102,26 @@ function removerAtributosRaiz(code) {
 }
 function colapsarEspacosEntreTags(code, params) {
     if (params?.pretty) {
+        // Adiciona quebra de linha entre TODAS as tags, mesmo quando estão coladas
         const out = code.replace(/></g, '>\\n<');
+        // Indentação básica para pretty mode
         const lines = out.split('\n');
         let indent = 0;
         const formatted = lines.map(line => {
             const trimmed = line.trim();
-            if (!trimmed)
+            if (!trimmed) {
                 return '';
+            }
             const isClosing = trimmed.startsWith('</');
             const isSelfClosing = trimmed.endsWith('/>');
             const isSingleTag = trimmed.startsWith('<') && trimmed.includes('>');
-            if (isClosing)
+            if (isClosing) {
                 indent = Math.max(0, indent - 1);
+            }
             const res = '  '.repeat(indent) + trimmed;
-            if (isSingleTag && !isClosing && !isSelfClosing)
+            if (isSingleTag && !isClosing && !isSelfClosing) {
                 indent++;
+            }
             return res;
         }).filter(linha => linha.trim()).join('\n');
         return {
@@ -111,24 +129,33 @@ function colapsarEspacosEntreTags(code, params) {
             changed: formatted !== code
         };
     }
+    // Sem pretty: colapsa tudo em uma linha
     const out = code.replace(/>\\s+</g, '><');
     return {
         out,
         changed: out !== code
     };
 }
+/**
+ * Optimizes SVG content using SVGO-like transformations.
+ */
 export function otimizarSvgLikeSvgo(params) {
     const warnings = [];
     const original = params.svg;
     const originalBytes = Buffer.byteLength(original, 'utf8');
     let out = original;
     const mudancas = [];
-    if (/<script\b/i.test(out))
+    // Flags de segurança: não altera, só sinaliza
+    if (/<script\b/i.test(out)) {
         warnings.push('script-inline');
-    if (/\son\w+\s*=\s*['"]/i.test(out))
+    }
+    if (/\son\w+\s*=\s*['"]/i.test(out)) {
         warnings.push('evento-inline');
-    if (/javascript:\s*/i.test(out))
+    }
+    if (/javascript:\s*/i.test(out)) {
         warnings.push('javascript-url');
+    }
+    // Default para pretty: true (manter legibilidade com quebras de linha)
     const opts = {
         ...params,
         pretty: params.pretty ?? true
@@ -194,4 +221,3 @@ export function otimizarSvgLikeSvgo(params) {
         warnings
     };
 }
-//# sourceMappingURL=svgs.js.map