@mocoto/mahoraga 0.14.0 → 0.14.1

package/dist/shared/helpers/imports.js

@@ -1,67 +1,95 @@
+// SPDX-License-Identifier: MIT
+// @mahoraga-disable tipo-literal-inline-complexo
+// Justificativa: tipos locais para reescrita de imports
+/**
+ * Helper puro para reescrever imports relativos quando um arquivo é movido.
+ * Não toca disco; apenas retorna o novo conteúdo.
+ */
 import path from 'node:path';
 import { normalizePath } from './index.js';
+/**
+ * Normaliza o caminho de import para uma chave consistente (POSIX).
+ */
 export function normalizarPosix(caminho) {
     return path.posix.normalize(normalizePath(caminho || ''));
 }
+/**
+ * Tenta resolver um caminho de arquivo para um dos arquivos existentes no projeto,
+ * lidando com extensões omitidas e o padrão TS ESM (.js -> .ts).
+ */
 export function resolverArquivoExistente(caminho, arquivosExistentes) {
     const alvo = normalizarPosix(caminho);
-    if (arquivosExistentes.has(alvo))
+    if (arquivosExistentes.has(alvo)) {
         return alvo;
+    }
     const ext = path.posix.extname(alvo);
     const base = ext ? alvo.slice(0, -ext.length) : alvo;
+    // Padrão TS ESM: importar "./x.js" em .ts, mas o arquivo real é "./x.ts"
     if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {
         const candidates = [`${base}.ts`, `${base}.tsx`, `${base}.js`, `${base}.mjs`, `${base}.cjs`];
         for (const elem of candidates) {
             const node = normalizarPosix(elem);
-            if (arquivosExistentes.has(node))
+            if (arquivosExistentes.has(node)) {
                 return node;
+            }
         }
     }
     if (ext === '.jsx') {
         const candidates = [`${base}.tsx`, `${base}.ts`, `${base}.jsx`];
         for (const elem of candidates) {
             const node = normalizarPosix(elem);
-            if (arquivosExistentes.has(node))
+            if (arquivosExistentes.has(node)) {
                 return node;
+            }
         }
     }
+    // Sem extensão: tenta variações comuns e index.*
     if (!ext) {
         const candidates = [`${alvo}.ts`, `${alvo}.tsx`, `${alvo}.js`, `${alvo}.jsx`, `${alvo}.mjs`, `${alvo}.cjs`, `${alvo}.d.ts`, `${alvo}/index.ts`, `${alvo}/index.tsx`, `${alvo}/index.js`, `${alvo}/index.mjs`, `${alvo}/index.cjs`];
         for (const elem of candidates) {
             const node = normalizarPosix(elem);
-            if (arquivosExistentes.has(node))
+            if (arquivosExistentes.has(node)) {
                 return node;
+            }
         }
     }
     return alvo;
 }
+/**
+ * Resolve um módulo (externo, absoluto ou relativo) para uma chave consistente.
+ */
 export function resolverModulo(mod, relPath, arquivosExistentes) {
+    // Externo (node_modules / builtin): mantém como está
     if (!mod.startsWith('.') && !mod.startsWith('/')) {
         return {
             key: mod,
             existe: true
         };
     }
+    // Import absoluto: trata como caminho normalizado
     if (mod.startsWith('/')) {
         const absNorm = normalizarPosix(mod);
-        if (!arquivosExistentes)
+        if (!arquivosExistentes) {
             return {
                 key: absNorm,
                 existe: true
             };
+        }
         const resolved = resolverArquivoExistente(absNorm, arquivosExistentes);
         return {
             key: resolved,
             existe: arquivosExistentes.has(resolved)
         };
     }
+    // Relativo
     const fromDir = normalizarPosix(path.posix.dirname(normalizarPosix(relPath)));
     const joined = normalizarPosix(path.posix.join(fromDir, mod));
-    if (!arquivosExistentes)
+    if (!arquivosExistentes) {
         return {
             key: joined,
             existe: true
         };
+    }
     const resolved = resolverArquivoExistente(joined, arquivosExistentes);
     return {
         key: resolved,
@@ -69,48 +97,71 @@ export function resolverModulo(mod, relPath, arquivosExistentes) {
     };
 }
 export function reescreverImports(conteudo, arquivoDe, arquivoPara) {
+    // Suporta import/export from e require simples
     const padrao = /(import\s+[^'";]+from\s*['"]([^'"\n]+)['"]\s*;?|export\s+\*?\s*from\s*['"]([^'"\n]+)['"];?|require\(\s*['"]([^'"\n]+)['"]\s*\))/g;
     const norm = (caminho) => path.posix.normalize(normalizePath(caminho));
     const baseDe = path.posix.dirname(norm(arquivoDe));
     const basePara = path.posix.dirname(norm(arquivoPara));
+    // raízes calculadas anteriormente não são usadas; mantemos somente baseDe/basePara
     const reescritos = [];
     const novoConteudo = conteudo.replace(padrao, (full, _i1, gFrom, gExport, gReq) => {
-        const spec = gFrom || gExport || gReq;
-        if (!spec)
+        const spec = (gFrom ?? gExport ?? gReq) ?? '';
+        if (!spec) {
             return full;
+        }
+        // Só reescreve relativos ou aliases conhecidos do projeto que mapeiam para src/*
         const isRelative = spec.startsWith('./') || spec.startsWith('../');
         const isAliasRaiz = spec.startsWith('@/');
+        // Aliases internos do projeto que queremos normalizar para src/<alias>/...
+        // Mantém @nucleo/* intacto (tratado como pacote/externo nos testes)
         const isProjectAlias = /^@(?:analistas|arquitetos|cli|relatorios|tipos|zeladores)\//.test(spec);
-        if (!isAliasRaiz && !isProjectAlias && !spec.includes('/src/') && !isRelative)
+        if (!isAliasRaiz && !isProjectAlias && !spec.includes('/src/') && !isRelative) {
             return full;
+        }
         let alvoAntigo;
         if (isAliasRaiz || isProjectAlias || spec.includes('/src/')) {
+            // Normaliza alias para caminho sob 'src/...'
             let specNormalized = spec;
-            if (isAliasRaiz)
+            if (isAliasRaiz) {
                 specNormalized = specNormalized.replace(/^@\//, 'src/');
-            else if (isProjectAlias)
+            }
+            else if (isProjectAlias) {
                 specNormalized = specNormalized.replace(/^@([^/]+)\//, 'src/$1/');
+            }
+            // extrai sempre o segmento após a primeira ocorrência de 'src/'
+            // lida com spec que comece com 'src/...', '/src/...', '@/...' (convertido para 'src/...')
             let afterSrc = specNormalized.replace(/^.*src\//, '');
+            // remove extensão .js caso presente para evitar preservá-la nos relativos
             afterSrc = afterSrc.replace(/\.js$/, '');
-            alvoAntigo = norm(path.posix.join('src', afterSrc || ''));
+            alvoAntigo = norm(path.posix.join('src', afterSrc));
+            // Corrige casos onde testes referenciam caminhos improváveis como src/cli/utils/*
+            // Padroniza para src/utils/*, evitando inflar profundidade relativa
             alvoAntigo = alvoAntigo.replace(/^src\/cli\/utils\//, 'src/utils/').replace(/^src\/cli\//, 'src/')
+                // Colapsa o primeiro segmento após src quando for util|utils
                 .replace(/^src\/[^/]+\/(?:util|utils)\//, 'src/utils/');
+            // Evita duplicação utils/utils
             alvoAntigo = alvoAntigo.replace(/\/utils\/utils\//g, '/utils/');
         }
         else {
             alvoAntigo = norm(path.posix.join(baseDe, spec));
         }
         let novoRel = path.posix.relative(basePara, alvoAntigo);
+        // Normaliza separadores e remove duplicações
         novoRel = path.posix.normalize(novoRel);
-        if (!novoRel.startsWith('.'))
+        // Garante relativo com ./ ou ../
+        if (!novoRel.startsWith('.')) {
             novoRel = `./${novoRel}`;
+        }
+        // NodeNext: detecta imports pra diretórios (sem extensão) → precisa de /index
         const originalExt = path.posix.extname(spec);
         if (!originalExt && !path.posix.extname(novoRel) && !novoRel.endsWith('/index')) {
             novoRel += '/index';
         }
+        // NodeNext requer extensão .js em imports relativos
         if (originalExt === '.js' || originalExt === '.mjs' || originalExt === '.cjs') {
-            if (!novoRel.endsWith(originalExt))
+            if (!novoRel.endsWith(originalExt)) {
                 novoRel += originalExt;
+            }
         }
         else if (!path.posix.extname(novoRel)) {
             novoRel += '.js';
@@ -126,4 +177,3 @@ export function reescreverImports(conteudo, arquivoDe, arquivoPara) {
         reescritos
     };
 }
-//# sourceMappingURL=imports.js.map

package/dist/shared/helpers/index.js

@@ -21,4 +21,3 @@ export * from './rule-config.js';
 export * from './structural-hash.js';
 export * from './structure.js';
 export * from './suppressao.js';
-//# sourceMappingURL=index.js.map

package/dist/shared/helpers/json-mode.js

@@ -1,14 +1,34 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Controle global do modo JSON para suprimir logs visuais.
+ *
+ * Quando --json está ativo, devemos produzir APENAS JSON puro no stdout,
+ * sem logs INFO, SUCESSO, spinners, cores, ou qualquer outra saída visual.
+ *
+ * Isso é crítico para integração com CI/CD e ferramentas que parsam o JSON.
+ */
 let _jsonModeAtivo = false;
+/**
+ * Ativa o modo JSON (suprime todos os logs visuais)
+ */
 export function ativarModoJson() {
     _jsonModeAtivo = true;
 }
+/**
+ * Desativa o modo JSON (restaura logs visuais)
+ */
 export function desativarModoJson() {
     _jsonModeAtivo = false;
 }
+/**
+ * Verifica se o modo JSON está ativo
+ */
 export function isJsonMode() {
     return _jsonModeAtivo;
 }
+/**
+ * Reseta o estado (útil para testes)
+ */
 export function resetJsonMode() {
     _jsonModeAtivo = false;
 }
-//# sourceMappingURL=json-mode.js.map

package/dist/shared/helpers/json.js

@@ -1,3 +1,13 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Utilidades de JSON: escape Unicode e stringificação segura para consumidores legados.
+ *
+ * Regras:
+ * - Converte qualquer caractere fora do ASCII básico em sequências \uXXXX.
+ * - Para caracteres fora do BMP, emite pares substitutos (dois \uXXXX).
+ * - Mantém caracteres ASCII intactos.
+ */
+// Constantes Unicode e BMP
 const ASCII_MAX = 0x7f;
 const BMP_MAX = 0xffff;
 const SUPPLEMENTARY_PLANO_DESLOCAMENTO = 0x10000;
@@ -7,6 +17,9 @@ const SURROGATE_DESLOCAMENTO = 10;
 const SURROGATE_MASCARA = 0x3ff;
 const HEX_PAD_LENGTH = 4;
 const JSON_INDENTACAO_PADRAO = 2;
+/**
+ * Escapa caracteres não-ASCII para sequências \uXXXX, incluindo pares substitutos.
+ */
 export function escapeNonAscii(string) {
     let out = '';
     for (const ch of string) {
@@ -18,6 +31,7 @@ export function escapeNonAscii(string) {
             out += `\\u${cp.toString(16).padStart(HEX_PAD_LENGTH, '0')}`;
         }
         else {
+            // caracteres fora do BMP -> pares substitutos
             const codePointOffset = cp - SUPPLEMENTARY_PLANO_DESLOCAMENTO;
             const highSurrogate = HIGH_SURROGATE_BASE + (codePointOffset >> SURROGATE_DESLOCAMENTO);
             const lowSurrogate = LOW_SURROGATE_BASE + (codePointOffset & SURROGATE_MASCARA);
@@ -27,9 +41,14 @@ export function escapeNonAscii(string) {
     }
     return out;
 }
+/**
+ * Stringifica um objeto em JSON aplicando escapeNonAscii em todos os strings do objeto.
+ * Normaliza possíveis double-escapes ("\\uXXXX" -> "\uXXXX").
+ */
 export function stringifyJsonEscaped(value, space = JSON_INDENTACAO_PADRAO) {
     const replacer = (_key, valor) => typeof valor === 'string' ? escapeNonAscii(valor) : valor;
     const raw = JSON.stringify(value, replacer, space);
+    // JSON.stringify pode escapar as barras invertidas inseridas pelo replacer
+    // (\\u -> \u). Normalizamos para os consumidores que esperam \uXXXX.
     return raw.replace(/\\\\u/g, '\\u');
 }
-//# sourceMappingURL=json.js.map

package/dist/shared/helpers/line-lookup.js

@@ -1,21 +1,31 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Cria uma função de consulta de linha (1-based) para um índice de string (0-based).
+ * Otimiza casos com muitos `matchAll`/índices evitando `slice(0, i).split('\n')`.
+ */
 export function createLineLookup(src) {
     const newlineIndexes = [];
     for (let indice = 0; indice < src.length; indice++) {
-        if (src.charCodeAt(indice) === 10)
+        if (src.charCodeAt(indice) === 10) {
             newlineIndexes.push(indice);
+        }
     }
     const lineAt = (index) => {
-        if (!index || index <= 0)
+        if (!index || index <= 0) {
             return 1;
+        }
         const clampedIndex = Math.min(src.length, Math.max(0, index));
+        // upper_bound: quantidade de '\n' com pos < i
         let lo = 0;
         let hi = newlineIndexes.length;
         while (lo < hi) {
             const mid = lo + hi >>> 1;
-            if (newlineIndexes[mid] < clampedIndex)
+            if (newlineIndexes[mid] < clampedIndex) {
                 lo = mid + 1;
-            else
+            }
+            else {
                 hi = mid;
+            }
         }
         return lo + 1;
     };
@@ -23,4 +33,3 @@ export function createLineLookup(src) {
         lineAt
     };
 }
-//# sourceMappingURL=line-lookup.js.map

package/dist/shared/helpers/lines.js

@@ -1,4 +1,7 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Divide o conteúdo de um arquivo em linhas de forma compatível com diferentes sistemas operacionais.
+ */
 export function splitLines(src) {
     return src.split(/\r?\n/);
 }
-//# sourceMappingURL=lines.js.map

package/dist/shared/helpers/magic-constants-whitelist.js

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Discord.js API limits (oficialmente documentados)
+ * @see https://discord.com/developers/docs/resources/channel#embed-limits
+ * @see https://discord.com/developers/docs/interactions/message-components#select-menus
+ */
 export const DISCORD_LIMITES = [{
         value: 10,
         description: 'Máximo de fields em embed'
@@ -26,6 +32,9 @@ export const DISCORD_LIMITES = [{
         value: 6000,
         description: 'Máximo total de caracteres em embed'
     }];
+/**
+ * HTTP Status Codes comuns
+ */
 export const HTTP_STATUS_CODIGOS = [{
         value: 200,
         description: 'HTTP OK'
@@ -57,6 +66,9 @@ export const HTTP_STATUS_CODIGOS = [{
         value: 503,
         description: 'HTTP Service Unavailable'
     }];
+/**
+ * Limites comuns de paginação e performance
+ */
 export const COMUM_LIMITES = [{
         value: 20,
         description: 'Paginação padrão (20 items)'
@@ -70,6 +82,9 @@ export const COMUM_LIMITES = [{
         value: 10000,
         description: 'Limite de query results'
     }];
+/**
+ * Valores matemáticos comuns (já cobertos no detector, mas listados para completude)
+ */
 export const MATH_CONSTANTES = [{
         value: -1,
         description: 'Index not found'
@@ -92,6 +107,9 @@ export const MATH_CONSTANTES = [{
         value: 1000,
         description: 'Milhar/conversão ms→s'
     }];
+/**
+ * Mapa de frameworks para suas whitelists
+ */
 export const FRAMEWORK_WHITELISTS = {
     'Discord.js': DISCORD_LIMITES,
     Express: HTTP_STATUS_CODIGOS,
@@ -103,30 +121,41 @@ export const FRAMEWORK_WHITELISTS = {
     Stripe: [],
     'AWS SDK': []
 };
+/**
+ * Verifica se um valor numérico está na whitelist para os frameworks detectados
+ */
 export function isWhitelistedConstant(value, frameworks, userWhitelist) {
-    if (userWhitelist && userWhitelist.includes(value)) {
+    // Verificar whitelist do usuário primeiro
+    if (userWhitelist?.includes(value)) {
         return true;
     }
+    // Verificar valores matemáticos comuns (sempre válidos)
     if (MATH_CONSTANTES.some(rule => rule.value === value)) {
         return true;
     }
+    // Verificar limites comuns
     if (COMUM_LIMITES.some(rule => rule.value === value)) {
         return true;
     }
+    // Verificar HTTP status codes (sempre válidos em projetos web)
     if (HTTP_STATUS_CODIGOS.some(rule => rule.value === value)) {
         return true;
     }
+    // Verificar whitelists específicas de frameworks
     for (const framework of frameworks) {
         const whitelist = FRAMEWORK_WHITELISTS[framework];
-        if (whitelist && whitelist.some(rule => rule.value === value)) {
+        if (whitelist.some(rule => rule.value === value)) {
             return true;
         }
     }
     return false;
 }
+/**
+ * Obtém a descrição de um magic constant, se estiver na whitelist
+ */
 export function getConstantDescription(value, frameworks) {
+    // Verificar todas as whitelists
     const allRules = [...MATH_CONSTANTES, ...COMUM_LIMITES, ...HTTP_STATUS_CODIGOS, ...frameworks.flatMap(arquivo => FRAMEWORK_WHITELISTS[arquivo] || [])];
-    const rule = allRules?.find(raiz => raiz.value === value);
+    const rule = allRules.find(raiz => raiz.value === value);
     return rule?.description;
 }
-//# sourceMappingURL=magic-constants-whitelist.js.map

package/dist/shared/helpers/masking.js

@@ -1,137 +1,219 @@
+// SPDX-License-Identifier: MIT
+// Utilitários de mascaramento que preservam quebras de linha para manter o cálculo de linhas estável.
+/**
+ * Mascara uma região de texto substituindo caracteres por espaços,
+ * preservando quebras de linha para manter a contagem de linhas estável.
+ * @param src - Texto fonte
+ * @param start - Índice de início da região a mascarar
+ * @param end - Índice de fim da região a mascarar
+ * @returns Texto com a região mascarada
+ */
 export function maskKeepingNewlines(src, start, end) {
     const before = src.slice(0, start);
     const mid = src.slice(start, end).replace(/[^\n]/g, ' ');
     const after = src.slice(end);
     return before + mid + after;
 }
+/**
+ * Mascara comentários JavaScript/TypeScript (bloco e linha),
+ * preservando quebras de linha.
+ * @param src - Código fonte JS/TS
+ * @returns Código com comentários mascarados
+ */
 export function maskJsComments(src) {
     let out = src;
     for (const metrica of out.matchAll(/\/\*[\s\S]*?\*\//g)) {
         const start = metrica.index ?? -1;
-        if (start < 0)
+        if (start < 0) {
             continue;
+        }
         out = maskKeepingNewlines(out, start, start + metrica[0].length);
     }
+    // Usa negative lookbehind para evitar match em URLs (://)
     for (const metrica of out.matchAll(/(?<![\\:])\/\/.*$/gm)) {
         const start = metrica.index ?? -1;
-        if (start < 0)
+        if (start < 0) {
             continue;
-        out = maskKeepingNewlines(out, start, start + (metrica[0]?.length ?? 0));
+        }
+        out = maskKeepingNewlines(out, start, start + (metrica[0].length ?? 0));
     }
     return out;
 }
+/**
+ * Mascara comentários HTML (`<!-- -->`), preservando quebras de linha.
+ * @param src - Código fonte HTML
+ * @returns Código com comentários HTML mascarados
+ */
 export function maskHtmlComments(src) {
     let out = src;
     for (const metrica of out.matchAll(/<!--([\s\S]*?)-->/g)) {
         const start = metrica.index ?? -1;
-        if (start < 0)
+        if (start < 0) {
             continue;
+        }
         out = maskKeepingNewlines(out, start, start + metrica[0].length);
     }
     return out;
 }
+/**
+ * Mascara blocos de tags HTML (script ou style) inteiros,
+ * preservando quebras de linha.
+ * @param src - Código fonte HTML
+ * @param tag - Tag a mascarar ('script' ou 'style')
+ * @returns Código com os blocos da tag mascarados
+ */
 export function maskTagBlocks(src, tag) {
     let out = src;
     const re = new RegExp(`<${tag}\\b[^>]*>[\\s\\S]*?<\\/${tag}>`, 'gi');
     for (const metrica of out.matchAll(re)) {
         const start = metrica.index ?? -1;
-        if (start < 0)
+        if (start < 0) {
             continue;
+        }
         out = maskKeepingNewlines(out, start, start + metrica[0].length);
     }
     return out;
 }
+/**
+ * Mascara conteúdo não-código em XML (comentários e seções CDATA),
+ * preservando quebras de linha.
+ * @param src - Código fonte XML
+ * @returns Código com conteúdo não-código mascarado
+ */
 export function maskXmlNonCode(src) {
     let out = src;
     for (const metrica of out.matchAll(/<!--[\s\S]*?-->/g)) {
         const start = metrica.index ?? -1;
-        if (start < 0)
+        if (start < 0) {
             continue;
+        }
         out = maskKeepingNewlines(out, start, start + metrica[0].length);
     }
     for (const metrica of out.matchAll(/<!\[CDATA\[[\s\S]*?\]\]>/g)) {
         const start = metrica.index ?? -1;
-        if (start < 0)
+        if (start < 0) {
             continue;
+        }
         out = maskKeepingNewlines(out, start, start + metrica[0].length);
     }
     return out;
 }
+/**
+ * Mascara strings e comentários Python, preservando quebras de linha.
+ * Trata strings triplas, strings simples e comentários com `#`.
+ * @param src - Código fonte Python
+ * @returns Código com strings e comentários mascarados
+ */
 export function maskPythonStringsAndComments(src) {
     let out = maskPythonComments(src);
     for (const metrica of out.matchAll(/([ruRUfFbB]{0,3})("""|''')[\s\S]*?\2/g)) {
         const start = metrica.index ?? -1;
-        if (start < 0)
+        if (start < 0) {
             continue;
+        }
         out = maskKeepingNewlines(out, start, start + metrica[0].length);
     }
     for (const metrica of out.matchAll(/([ruRUfFbB]{0,3})("([^"\\\n]|\\.)*"|'([^'\\\n]|\\.)*')/g)) {
         const start = metrica.index ?? -1;
-        if (start < 0)
+        if (start < 0) {
             continue;
+        }
         out = maskKeepingNewlines(out, start, start + metrica[0].length);
     }
     return out;
 }
+/**
+ * Mascara comentários Python (linhas com `#`), preservando quebras de linha.
+ * @param src - Código fonte Python
+ * @returns Código com comentários mascarados
+ */
 export function maskPythonComments(src) {
     let out = src;
     for (const metrica of out.matchAll(/(^|[^\\])#.*$/gm)) {
         const start = (metrica.index ?? -1) + (metrica[1] ? metrica[1].length : 0);
-        if (start < 0)
+        if (start < 0) {
             continue;
-        out = maskKeepingNewlines(out, start, start + (metrica[0]?.length ?? 0) - (metrica[1] ? metrica[1].length : 0));
+        }
+        out = maskKeepingNewlines(out, start, start + (metrica[0].length ?? 0) - (metrica[1] ? metrica[1].length : 0));
     }
     return out;
 }
+/**
+ * Mascara comentários Go (linha e bloco), preservando quebras de linha.
+ * @param src - Código fonte Go
+ * @returns Código com comentários mascarados
+ */
 export function maskGoComments(src) {
     let out = src;
     for (const metrica of out.matchAll(/\/\*[\s\S]*?\*\//g)) {
         const start = metrica.index ?? -1;
-        if (start < 0)
+        if (start < 0) {
             continue;
+        }
         out = maskKeepingNewlines(out, start, start + metrica[0].length);
     }
     for (const metrica of out.matchAll(/\/\/.*$/gm)) {
         const start = metrica.index ?? -1;
-        if (start < 0)
+        if (start < 0) {
             continue;
+        }
         out = maskKeepingNewlines(out, start, start + metrica[0].length);
     }
     return out;
 }
+/**
+ * Mascara comentários Rust (linha e bloco), preservando quebras de linha.
+ * @param src - Código fonte Rust
+ * @returns Código com comentários mascarados
+ */
 export function maskRustComments(src) {
     return maskGoComments(src);
 }
+/**
+ * Mascara comentários (linha, bloco),
+ * preservando quebras de linha.
+ * @param src - Código fonte
+ * @returns Código com comentários mascarados
+ */
 export function maskJavaComments(src) {
     let out = src;
     for (const metrica of out.matchAll(/\/\*[\s\S]*?\*\//g)) {
         const start = metrica.index ?? -1;
-        if (start < 0)
+        if (start < 0) {
             continue;
+        }
         out = maskKeepingNewlines(out, start, start + metrica[0].length);
     }
     for (const metrica of out.matchAll(/\/\/.*$/gm)) {
         const start = metrica.index ?? -1;
-        if (start < 0)
+        if (start < 0) {
             continue;
+        }
         out = maskKeepingNewlines(out, start, start + metrica[0].length);
     }
     return out;
 }
+/**
+ * Mascara strings e comentários PHP, preservando quebras de linha.
+ * Trata strings com aspas simples/duplas e comentarios de linha.
+ * @param src - Código fonte PHP
+ * @returns Código com strings e comentários mascarados
+ */
 export function maskPhpComments(src) {
     let out = src;
     for (const metrica of out.matchAll(/\/\*[\s\S]*?\*\//g)) {
         const start = metrica.index ?? -1;
-        if (start < 0)
+        if (start < 0) {
             continue;
+        }
         out = maskKeepingNewlines(out, start, start + metrica[0].length);
     }
     for (const metrica of out.matchAll(/(\/\/|#).*$/gm)) {
         const start = metrica.index ?? -1;
-        if (start < 0)
+        if (start < 0) {
             continue;
+        }
         out = maskKeepingNewlines(out, start, start + metrica[0].length);
     }
     return out;
 }
-//# sourceMappingURL=masking.js.map

package/dist/shared/helpers/occurrences.js

@@ -1,5 +1,10 @@
+// SPDX-License-Identifier: MIT
 import { SharedCommonMensagens } from '../../core/messages/index.js';
 import { criarOcorrencia } from '../../types/index.js';
+/**
+ * Cria uma ocorrência de erro de análise padronizada.
+ * Útil para capturar try/catch em detectores e analistas.
+ */
 export function criarErroAnalise(relPath, erro) {
     return criarOcorrencia({
         tipo: 'ERRO_ANALISE',
@@ -9,4 +14,3 @@ export function criarErroAnalise(relPath, erro) {
         linha: 1,
     });
 }
-//# sourceMappingURL=occurrences.js.map