@mocoto/mahoraga 0.14.2 → 0.14.3

package/dist/analysts/corrections/scoring-shared.js

@@ -236,6 +236,24 @@ export function fixSpacingAroundPunct(string) {
         count
     };
 }
+function getCharacterDisplayName(ch) {
+    try {
+        if (typeof Intl !== 'undefined') {
+            const intlApi = Intl;
+            const DisplayNomesCtor = intlApi.DisplayNames;
+            if (DisplayNomesCtor) {
+                const displayNomes = new DisplayNomesCtor(['en'], {
+                    type: 'language'
+                });
+                return typeof displayNomes.of === 'function' ? displayNomes.of(ch) ?? '' : '';
+            }
+        }
+        return '';
+    }
+    catch {
+        return '';
+    }
+}
 /**
  * Detecta caracteres fora do range ASCII comum.
  */
@@ -248,24 +266,7 @@ export function detectUncommonChars(text, limite) {
         }
         const code = ch.codePointAt(0) ?? 0;
         if (code >= LIMITES.ASCII_EXTENDED_MIN && !isCaractereComum(code)) {
-            const name = (() => {
-                try {
-                    if (typeof Intl !== 'undefined') {
-                        const intlApi = Intl;
-                        const DisplayNomesCtor = intlApi.DisplayNames;
-                        if (DisplayNomesCtor) {
-                            const displayNomes = new DisplayNomesCtor(['en'], {
-                                type: 'language'
-                            });
-                            return typeof displayNomes.of === 'function' ? displayNomes.of(ch) ?? '' : '';
-                        }
-                    }
-                    return '';
-                }
-                catch {
-                    return '';
-                }
-            })();
+            const name = getCharacterDisplayName(ch);
             issues.push({
                 tipo: 'caracteres-incomuns',
                 posicao: pos,

package/dist/analysts/corrections/type-safety/context-analyzer.js

@@ -5,6 +5,7 @@
  * Analisador de contexto para Type Safety Auto-Fix
  * Detecta contextos onde any/unknown NÃO devem ser modificados
  */
+const CONFIANCA_PADRAO = 60;
 export { isInComment, isInString, isInStringOrComment } from '../../../shared/helpers/index.js';
 /**
  * Verifica se está em contexto TypeScript específico que deve ser ignorado
@@ -152,6 +153,13 @@ export function extractLineContext(code, position) {
     }
     return '';
 }
+function hasInternalValidation(code, lineContext) {
+    if (!/(analise|result|data|value)\s*:\s*unknown/.test(lineContext)) {
+        return false;
+    }
+    const beforeFunc = code.substring(Math.max(0, lineContext.length - 200), lineContext.length + 100);
+    return /if\s*\(/.test(beforeFunc) || /typeof\s+\w+\s*===/.test(beforeFunc);
+}
 export function categorizarUnknown(code, fileCaminho, lineContext) {
     // Type Guards - 100% legítimo
     if (/:\s*unknown\)\s*:\s*\w+\s+is\s+/.test(lineContext)) {
@@ -393,15 +401,12 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
         };
     }
     // Função de análise com validação interna - 90% legítimo
-    if (/(analise|result|data|value)\s*:\s*unknown/.test(lineContext)) {
-        const beforeFunc = code.substring(Math.max(0, lineContext.length - 200), lineContext.length + 100);
-        if (/if\s*\(/.test(beforeFunc) || /typeof\s+\w+\s*===/.test(beforeFunc)) {
-            return {
-                categoria: 'legitimo',
-                confianca: 90,
-                motivo: 'Parâmetro com validação/narrowing interna - unknown é seguro quando verificado'
-            };
-        }
+    if (hasInternalValidation(code, lineContext)) {
+        return {
+            categoria: 'legitimo',
+            confianca: 90,
+            motivo: 'Parâmetro com validação/narrowing interna - unknown é seguro quando verificado'
+        };
     }
     // Getter de keys com validação - 95% legítimo
     if (/value\s*:\s*unknown/.test(lineContext) && /Object\.keys/.test(contextoAmplo)) {
@@ -422,7 +427,7 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
     // Default: melhorável com análise incerta
     return {
         categoria: 'melhoravel',
-        confianca: 60,
+        confianca: CONFIANCA_PADRAO,
         motivo: 'Tipo unknown genérico - análise contextual limitada',
         sugestao: 'Analisar fluxo de dados para inferir tipo correto',
         variantes: ['Se vem de API externa: definir interface baseada na resposta esperada', 'Se é callback: especificar assinatura da função', 'Se é config/options: criar interface com campos opcionais', 'Se é polimórfico: considerar discriminated union ou generics']

package/dist/analysts/corrections/type-safety/type-validator.js

@@ -4,6 +4,7 @@
  * Verifica compatibilidade e compilação TypeScript
  */
 import { findExistingType, isSameType } from './type-creator.js';
+const CONFIANCA_MINIMA = 60;
 /**
  * Valida substituição de tipo (any/unknown → specific)
  */
@@ -36,7 +37,7 @@ export async function validateTypeReplacement(originalCode, fixedCodigo, typeAna
         }
     }
     // 4. Verificar confiança mínima
-    if (typeAnalise.confidence < 60) {
+    if (typeAnalise.confidence < CONFIANCA_MINIMA) {
         result.warnings.push(`Confiança muito baixa (${typeAnalise.confidence}%). Considere revisão manual.`);
     }
     // 5. Validar sintaxe básica do código modificado

package/dist/analysts/corrections/type-safety/usage-analyzer.js

@@ -128,49 +128,46 @@ function extractObjectProperties(usages) {
     }
     return Array.from(propertiesMap.values());
 }
-/**
- * Detecta type guards no código
- */
+function detectTypeofGuard(usage, context, guards) {
+    const match = context.match(/typeof\s+\w+\s*===\s*['"](\w+)['"]/);
+    if (match) {
+        guards.push({
+            type: 'typeof',
+            expression: usage.context,
+            inferredTipo: match[1],
+            confidence: 95
+        });
+    }
+}
+function detectInstanceofGuard(usage, context, guards) {
+    const match = context.match(/\w+\s+instanceof\s+(\w+)/);
+    if (match) {
+        guards.push({
+            type: 'instanceof',
+            expression: usage.context,
+            inferredTipo: match[1],
+            confidence: 95
+        });
+    }
+}
+function detectInGuard(usage, context, guards) {
+    const match = context.match(/['"](\w+)['"]\s+in\s+\w+/);
+    if (match) {
+        guards.push({
+            type: 'in',
+            expression: usage.context,
+            inferredTipo: `{ ${match[1]}: unknown }`,
+            confidence: 80
+        });
+    }
+}
 function detectTypeGuards(usages) {
     const guards = [];
     for (const usage of usages) {
         const context = usage.context.toLowerCase();
-        // typeof guards
-        if (context.includes('typeof')) {
-            const match = context.match(/typeof\s+\w+\s*===\s*['"](\w+)['"]/);
-            if (match) {
-                guards.push({
-                    type: 'typeof',
-                    expression: usage.context,
-                    inferredTipo: match[1],
-                    confidence: 95
-                });
-            }
-        }
-        // instanceof guards
-        if (context.includes('instanceof')) {
-            const match = context.match(/\w+\s+instanceof\s+(\w+)/);
-            if (match) {
-                guards.push({
-                    type: 'instanceof',
-                    expression: usage.context,
-                    inferredTipo: match[1],
-                    confidence: 95
-                });
-            }
-        }
-        // 'in' operator guards
-        if (context.includes(' in ')) {
-            const match = context.match(/['"](\w+)['"]\s+in\s+\w+/);
-            if (match) {
-                guards.push({
-                    type: 'in',
-                    expression: usage.context,
-                    inferredTipo: `{ ${match[1]}: unknown }`,
-                    confidence: 80
-                });
-            }
-        }
+        detectTypeofGuard(usage, context, guards);
+        detectInstanceofGuard(usage, context, guards);
+        detectInGuard(usage, context, guards);
     }
     return guards;
 }

package/dist/analysts/css/analysts/analyst-css.js

@@ -213,6 +213,18 @@ function detectCssHacks(value) {
     }
     return null;
 }
+function processDuplicateProperty(propChave, propRaw, prev, value, inFontFace, relPath, line, pushOnce) {
+    const ctx = inFontFace ? { currentAtRule: 'font-face' } : undefined;
+    if (isLikelyIntentionalDuplicate(propChave, prev.value, value, ctx)) {
+        return;
+    }
+    if (prev.value === value) {
+        pushOnce(warn(messages.CssMensagens.duplicatePropertySame(propRaw), relPath, line));
+    }
+    else {
+        pushOnce(warn(messages.CssMensagens.duplicatePropertyDifferent(propRaw, prev.value, value), relPath, line));
+    }
+}
 function collectCssIssuesFromPostCssAst(root, relPath) {
     const ocorrencias = [];
     const seen = new Set();
@@ -242,18 +254,7 @@ function collectCssIssuesFromPostCssAst(root, relPath) {
                 const line = getNodeLine(decl);
                 const prev = props[propChave];
                 if (propChave in props) {
-                    const ctx = inFontFace ? {
-                        currentAtRule: 'font-face'
-                    } : undefined;
-                    if (isLikelyIntentionalDuplicate(propChave, prev.value, value, ctx)) {
-                        // duplicata intencional
-                    }
-                    else if (prev.value === value) {
-                        pushOnce(warn(messages.CssMensagens.duplicatePropertySame(propRaw), relPath, line));
-                    }
-                    else {
-                        pushOnce(warn(messages.CssMensagens.duplicatePropertyDifferent(propRaw, prev.value, value), relPath, line));
-                    }
+                    processDuplicateProperty(propChave, propRaw, prev, value, inFontFace, relPath, line, pushOnce);
                 }
                 props[propChave] = {
                     value,
@@ -279,11 +280,11 @@ function collectCssIssuesFromPostCssAst(root, relPath) {
         // 2) Unificação/centralização (apenas em regras com seletores simples)
         if (container.type === 'rule') {
             const rule = container;
-            const selectorText = (rule.selector || '');
+            const selectorText = rule.selector;
             const simpleSelectors = splitSimpleSelectors(selectorText);
             if (simpleSelectors.length) {
                 const decls = [];
-                rule.nodes.forEach(node => {
+                rule.nodes?.forEach(node => {
                     if (node.type !== 'decl') {
                         return;
                     }
@@ -299,7 +300,7 @@ function collectCssIssuesFromPostCssAst(root, relPath) {
                     });
                 });
                 // Detecta regras vazias (ignora @apply do Tailwind CSS)
-                const hasApplyDirective = rule.nodes.some(node => node.type === 'atrule' && (node).name === 'apply');
+                const hasApplyDirective = rule.nodes?.some(node => node.type === 'atrule' && (node).name === 'apply');
                 if (decls.length === 0 && !hasApplyDirective) {
                     pushOnce(warn(messages.CssMensagens.emptyRule, relPath, getNodeLine(rule)));
                 }

package/dist/analysts/css/corrections/correction-css.js

@@ -10,6 +10,22 @@
 import { messages } from '../../../core/messages/index.js';
 import { splitLines } from '../../../shared/helpers/index.js';
 import { criarOcorrencia } from '../../../types/index.js';
+function detectarIdSelector(linha, numeroLinha) {
+    if (!/#[a-zA-Z0-9_-]+\s*\{/.test(linha)) {
+        return null;
+    }
+    const idMatch = linha.match(/#([a-zA-Z0-9_-]+)/);
+    if (!idMatch) {
+        return null;
+    }
+    return {
+        tipo: 'css-id-to-class',
+        original: linha.trim(),
+        sugerido: linha.replace(/#([a-zA-Z0-9_-]+)/, `.${idMatch[1]}`),
+        linha: numeroLinha,
+        confianca: 70
+    };
+}
 export function detectarCorrecoesCss(src, _relPath) {
     const correcoes = [];
     const linhas = splitLines(src);
@@ -24,17 +40,9 @@ export function detectarCorrecoesCss(src, _relPath) {
                 confianca: 80
             });
         }
-        if (/#[a-zA-Z0-9_-]+\s*\{/.test(linha)) {
-            const idMatch = linha.match(/#([a-zA-Z0-9_-]+)/);
-            if (idMatch) {
-                correcoes.push({
-                    tipo: 'css-id-to-class',
-                    original: linha.trim(),
-                    sugerido: linha.replace(/#([a-zA-Z0-9_-]+)/, `.${idMatch[1]}`),
-                    linha: numeroLinha,
-                    confianca: 70
-                });
-            }
+        const idCorrection = detectarIdSelector(linha, numeroLinha);
+        if (idCorrection) {
+            correcoes.push(idCorrection);
         }
     });
     return correcoes;

package/dist/analysts/css/detectors/detector-css-best-practices.js

@@ -63,151 +63,162 @@ export const detectorCssBestPractices = {
         const _idSelectorCount = 0;
         const allSelectors = [];
         const _selectorDepth = 0;
-        linhas.forEach((linha, index) => {
-            const numeroLinha = index + 1;
-            const trimmed = linha.trim();
-            if (trimmed.includes('{')) {
-                depth++;
-                if (depth > maxDepth) {
-                    maxDepth = depth;
+        function processarAberturaBloco(linha, trimmed, numeroLinha) {
+            depth++;
+            if (depth > maxDepth) {
+                maxDepth = depth;
+            }
+            const selectorPart = trimmed.replace(/\s*\{.*$/, '').trim();
+            if (!selectorPart) {
+                return;
+            }
+            allSelectors.push(selectorPart);
+            const simpleCount = selectorPart.split(',').length;
+            if (simpleCount > 5) {
+                ocorrencias.push(criarOcorrencia({
+                    tipo: 'css-too-many-selectors',
+                    nivel: 'info',
+                    mensagem: messages.DetectorCssMensagens.tooManySelectors,
+                    relPath,
+                    linha: numeroLinha,
+                    sugestao: messages.DetectorCssMensagens.tooManySelectorsSugestao
+                }));
+            }
+            const baseSelector = selectorPart.replace(/,.*$/, '').trim();
+            if (baseSelector) {
+                if (seenSelectors.has(baseSelector)) {
+                    seenSelectors.get(baseSelector)?.push(numeroLinha);
                 }
-                const selectorPart = trimmed.replace(/\s*\{.*$/, '').trim();
-                if (selectorPart) {
-                    allSelectors.push(selectorPart);
-                    const simpleCount = selectorPart.split(',').length;
-                    if (simpleCount > 5) {
-                        ocorrencias.push(criarOcorrencia({
-                            tipo: 'css-too-many-selectors',
-                            nivel: 'info',
-                            mensagem: messages.DetectorCssMensagens.tooManySelectors,
-                            relPath,
-                            linha: numeroLinha,
-                            sugestao: messages.DetectorCssMensagens.tooManySelectorsSugestao
-                        }));
-                    }
-                    const baseSelector = selectorPart.replace(/,.*$/, '').trim();
-                    if (baseSelector) {
-                        if (seenSelectors.has(baseSelector)) {
-                            seenSelectors.get(baseSelector)?.push(numeroLinha);
-                        }
-                        else {
-                            seenSelectors.set(baseSelector, [numeroLinha]);
-                        }
-                    }
+                else {
+                    seenSelectors.set(baseSelector, [numeroLinha]);
                 }
             }
-            if (trimmed.includes('}')) {
-                if (propsInBlock.size === 0 && depth > 0) {
-                    ocorrencias.push(criarOcorrencia({
-                        tipo: 'css-empty-rule',
-                        nivel: 'info',
-                        mensagem: messages.DetectorCssMensagens.emptyRule,
-                        relPath,
-                        linha: numeroLinha,
-                        sugestao: messages.DetectorCssMensagens.emptyRuleSugestao
-                    }));
-                }
-                propsInBlock.clear();
-                depth--;
+        }
+        function processarFechamentoBloco(numeroLinha) {
+            if (propsInBlock.size === 0 && depth > 0) {
+                ocorrencias.push(criarOcorrencia({
+                    tipo: 'css-empty-rule',
+                    nivel: 'info',
+                    mensagem: messages.DetectorCssMensagens.emptyRule,
+                    relPath,
+                    linha: numeroLinha,
+                    sugestao: messages.DetectorCssMensagens.emptyRuleSugestao
+                }));
             }
-            if (/!important/.test(trimmed)) {
+            propsInBlock.clear();
+            depth--;
+        }
+        function processarPropriedade(trimmed, numeroLinha) {
+            const propMatch = /^([a-zA-Z-]+)\s*:\s*([^;]+)?/.exec(trimmed);
+            if (!propMatch || depth <= 0) {
+                return;
+            }
+            const prop = propMatch[1].toLowerCase();
+            const value = (propMatch[2] || '').trim();
+            allDeclaredProps.push(prop);
+            if (propsInBlock.has(prop)) {
                 ocorrencias.push(criarOcorrencia({
-                    tipo: 'css-important-usage',
+                    tipo: 'css-duplicate-property',
                     nivel: 'aviso',
-                    mensagem: messages.DetectorCssMensagens.important,
+                    mensagem: messages.DetectorCssMensagens.duplicateProperty(prop),
                     relPath,
                     linha: numeroLinha,
-                    sugestao: messages.DetectorCssMensagens.importantSugestao
+                    sugestao: messages.DetectorCssMensagens.duplicatePropertySugestao
                 }));
             }
-            const propMatch = /^([a-zA-Z-]+)\s*:\s*([^;]+)?/.exec(trimmed);
-            if (propMatch && depth > 0) {
-                const prop = propMatch[1].toLowerCase();
-                const value = (propMatch[2] || '').trim();
-                allDeclaredProps.push(prop);
-                if (propsInBlock.has(prop)) {
-                    ocorrencias.push(criarOcorrencia({
-                        tipo: 'css-duplicate-property',
-                        nivel: 'aviso',
-                        mensagem: messages.DetectorCssMensagens.duplicateProperty(prop),
-                        relPath,
-                        linha: numeroLinha,
-                        sugestao: messages.DetectorCssMensagens.duplicatePropertySugestao
-                    }));
-                }
-                propsInBlock.set(prop, { line: numeroLinha, value });
-                if (value === '0' && !prop.startsWith('--')) {
+            propsInBlock.set(prop, { line: numeroLinha, value });
+            if (value === '0' && !prop.startsWith('--')) {
+                ocorrencias.push(criarOcorrencia({
+                    tipo: 'css-unitless-zero',
+                    nivel: 'info',
+                    mensagem: messages.DetectorCssMensagens.unitlessZero,
+                    relPath,
+                    linha: numeroLinha,
+                    sugestao: messages.DetectorCssMensagens.unitlessZeroSugestao
+                }));
+            }
+            if (prop === 'font-family') {
+                const families = value.split(',').map(f => f.trim().replace(/['"]/g, ''));
+                const hasGeneric = families.some(f => GENERIC_FONTS.has(f.toLowerCase()));
+                if (!hasGeneric) {
                     ocorrencias.push(criarOcorrencia({
-                        tipo: 'css-unitless-zero',
+                        tipo: 'css-font-stack-missing',
                         nivel: 'info',
-                        mensagem: messages.DetectorCssMensagens.unitlessZero,
+                        mensagem: messages.DetectorCssMensagens.fontStackMissing,
                         relPath,
                         linha: numeroLinha,
-                        sugestao: messages.DetectorCssMensagens.unitlessZeroSugestao
+                        sugestao: messages.DetectorCssMensagens.fontStackMissingSugestao
                     }));
                 }
-                if (prop === 'font-family') {
-                    const families = value.split(',').map(f => f.trim().replace(/['"]/g, ''));
-                    const hasGeneric = families.some(f => GENERIC_FONTS.has(f.toLowerCase()));
-                    if (!hasGeneric) {
-                        ocorrencias.push(criarOcorrencia({
-                            tipo: 'css-font-stack-missing',
-                            nivel: 'info',
-                            mensagem: messages.DetectorCssMensagens.fontStackMissing,
-                            relPath,
-                            linha: numeroLinha,
-                            sugestao: messages.DetectorCssMensagens.fontStackMissingSugestao
-                        }));
-                    }
-                }
-                if (prop === 'z-index') {
-                    const zVal = parseInt(value, 10);
-                    if (!isNaN(zVal) && (zVal > 100 || zVal < -1)) {
-                        ocorrencias.push(criarOcorrencia({
-                            tipo: 'css-zindex-unmanaged',
-                            nivel: 'aviso',
-                            mensagem: messages.DetectorCssMensagens.zIndexUnmanaged,
-                            relPath,
-                            linha: numeroLinha,
-                            sugestao: messages.DetectorCssMensagens.zIndexUnmanagedSugestao
-                        }));
-                    }
-                }
-                if (/^(px|pt|pc|mm|cm|in)\b/.test(value) && (prop.startsWith('width') || prop.startsWith('height') || prop === 'font-size')) {
+            }
+            if (prop === 'z-index') {
+                const zVal = parseInt(value, 10);
+                if (!isNaN(zVal) && (zVal > 100 || zVal < -1)) {
                     ocorrencias.push(criarOcorrencia({
-                        tipo: 'css-absolute-units',
-                        nivel: 'info',
-                        mensagem: messages.DetectorCssMensagens.absoluteUnits,
+                        tipo: 'css-zindex-unmanaged',
+                        nivel: 'aviso',
+                        mensagem: messages.DetectorCssMensagens.zIndexUnmanaged,
                         relPath,
                         linha: numeroLinha,
-                        sugestao: messages.DetectorCssMensagens.absoluteUnitsSugestao
+                        sugestao: messages.DetectorCssMensagens.zIndexUnmanagedSugestao
                     }));
                 }
-                const missingPrefix = detectMissingVendorPrefix(prop);
-                if (missingPrefix) {
+            }
+            if (/^(px|pt|pc|mm|cm|in)\b/.test(value) && (prop.startsWith('width') || prop.startsWith('height') || prop === 'font-size')) {
+                ocorrencias.push(criarOcorrencia({
+                    tipo: 'css-absolute-units',
+                    nivel: 'info',
+                    mensagem: messages.DetectorCssMensagens.absoluteUnits,
+                    relPath,
+                    linha: numeroLinha,
+                    sugestao: messages.DetectorCssMensagens.absoluteUnitsSugestao
+                }));
+            }
+            const missingPrefix = detectMissingVendorPrefix(prop);
+            if (missingPrefix) {
+                ocorrencias.push(criarOcorrencia({
+                    tipo: 'css-vendor-prefix-missing',
+                    nivel: 'aviso',
+                    mensagem: messages.DetectorCssMensagens.vendorPrefixMissing,
+                    relPath,
+                    linha: numeroLinha,
+                    sugestao: messages.DetectorCssMensagens.vendorPrefixMissingSugestao
+                }));
+            }
+            if (CSS_SHORTHAND_PROPS.has(prop)) {
+                const related = allDeclaredProps.filter(p => p.startsWith(`${prop}-`));
+                if (related.length >= 2) {
                     ocorrencias.push(criarOcorrencia({
-                        tipo: 'css-vendor-prefix-missing',
-                        nivel: 'aviso',
-                        mensagem: messages.DetectorCssMensagens.vendorPrefixMissing,
+                        tipo: 'css-missing-shorthand',
+                        nivel: 'info',
+                        mensagem: messages.DetectorCssMensagens.missingShorthand,
                         relPath,
                         linha: numeroLinha,
-                        sugestao: messages.DetectorCssMensagens.vendorPrefixMissingSugestao
+                        sugestao: messages.DetectorCssMensagens.missingShorthandSugestao
                     }));
                 }
-                if (CSS_SHORTHAND_PROPS.has(prop)) {
-                    const related = allDeclaredProps.filter(p => p.startsWith(`${prop}-`));
-                    if (related.length >= 2) {
-                        ocorrencias.push(criarOcorrencia({
-                            tipo: 'css-missing-shorthand',
-                            nivel: 'info',
-                            mensagem: messages.DetectorCssMensagens.missingShorthand,
-                            relPath,
-                            linha: numeroLinha,
-                            sugestao: messages.DetectorCssMensagens.missingShorthandSugestao
-                        }));
-                    }
-                }
             }
+        }
+        linhas.forEach((linha, index) => {
+            const numeroLinha = index + 1;
+            const trimmed = linha.trim();
+            if (trimmed.includes('{')) {
+                processarAberturaBloco(linha, trimmed, numeroLinha);
+            }
+            if (trimmed.includes('}')) {
+                processarFechamentoBloco(numeroLinha);
+            }
+            if (/!important/.test(trimmed)) {
+                ocorrencias.push(criarOcorrencia({
+                    tipo: 'css-important-usage',
+                    nivel: 'aviso',
+                    mensagem: messages.DetectorCssMensagens.important,
+                    relPath,
+                    linha: numeroLinha,
+                    sugestao: messages.DetectorCssMensagens.importantSugestao
+                }));
+            }
+            processarPropriedade(trimmed, numeroLinha);
             if (/#[a-zA-Z0-9_-]+\s*\{/.test(trimmed)) {
                 ocorrencias.push(criarOcorrencia({
                     tipo: 'css-id-selector',

package/dist/analysts/css/scorers/scorer-css.js

@@ -1,5 +1,27 @@
 // SPDX-License-Identifier: MIT
 import { splitLines } from '../../../shared/helpers/index.js';
+function contarPropriedadesPorBloco(linhas) {
+    const props = new Map();
+    let inBlock = false;
+    for (const linha of linhas) {
+        if (linha.includes('{')) {
+            inBlock = true;
+            props.clear();
+        }
+        if (linha.includes('}')) {
+            inBlock = false;
+            continue;
+        }
+        if (inBlock) {
+            const match = /^\s*([a-zA-Z-]+)\s*:/.exec(linha);
+            if (match) {
+                const prop = match[1].toLowerCase();
+                props.set(prop, (props.get(prop) ?? 0) + 1);
+            }
+        }
+    }
+    return props;
+}
 export function pontuarCss(src, _relPath) {
     let score = 0;
     const maxScore = 100;
@@ -20,24 +42,7 @@ export function pontuarCss(src, _relPath) {
         score += 3;
         issues.push(`${importantCount} usos de !important - refatore especificidade`);
     }
-    const props = new Map();
-    let inBlock = false;
-    linhas.forEach(linha => {
-        if (linha.includes('{')) {
-            inBlock = true;
-            props.clear();
-        }
-        if (linha.includes('}')) {
-            inBlock = false;
-        }
-        if (inBlock) {
-            const match = /^\s*([a-zA-Z-]+)\s*:/.exec(linha);
-            if (match) {
-                const prop = match[1].toLowerCase();
-                props.set(prop, (props.get(prop) ?? 0) + 1);
-            }
-        }
-    });
+    const props = contarPropriedadesPorBloco(linhas);
     const duplicates = [...props.values()].filter(valor => valor > 1).length;
     if (duplicates === 0) {
         score += 10;