export const ReactMensagens = {
    linkTargetBlank: 'Link with target="_blank" without rel="noreferrer"/"noopener".',
    dangerouslySetInnerHTML: 'Use of dangerouslySetInnerHTML found; validate the need.',
    imgWithoutAlt: 'Image without alt attribute (accessibility).',
    httpFetch: 'HTTP call without TLS detected; prefer HTTPS.',
    hardcodedCredential: 'Possible hardcoded credential; use environment variables.',
    locationHrefRedirect: 'Direct assignment to location.href; validate origin to prevent open redirect.',
    listItemNoKey: 'Item in list (map) without key attribute.',
    indexAsKey: 'Using index as key (may cause reordering issues).',
    inlineHandlerJsx: 'Inline handler detected in JSX; prefer stable functions (useCallback) or extract outside render.',
    deprecatedLifecycleMethod: (name) => `Deprecated lifecycle method: ${name}. Use componentDidMount, componentDidUpdate or hooks.`,
    complexInlineStyles: 'Complex inline styles detected. Consider using CSS modules or styled-components for better performance and organization.'
};
export const ReactHooksMensagens = {
    useEffectNoDeps: 'useEffect without dependency array (evaluate deps to avoid loops).',
    memoCallbackNoDeps: 'Hook without dependency array (useMemo/useCallback).',
    hookInConditional: 'Hook declared inside conditional (breaks Rules of Hooks).'
};
export const TailwindMensagens = {
    conflictingClasses: (key, tokens) => `Possible conflict ${key} (${tokens.slice(0, 4).join(', ')}). Check for duplicates.`,
    repeatedClass: (token) => `Repeated class detected (${token}). Consider removing redundancy.`,
    importantUsage: (token) => `Use of ! (important) detected in (${token}). Prefer utility classes or scope reinforcement instead of important.`,
    variantConflict: (prop, variants) => `Possible variant conflict for ${prop} (variants: ${variants.slice(0, 6).join(', ')}). Check order/scope.`,
    dangerousArbitraryValue: (token) => `Arbitrary value with potentially dangerous url (${token}). Avoid javascript:/data:text/html.`,
    arbitraryValue: (token) => `Class with arbitrary value (${token}). Confirm it aligns with the design.`
};
export const CssMensagens = {
    duplicatePropertySame: (prop) => `Duplicated property with identical value (${prop}): error detected.`,
    duplicatePropertyDifferent: (prop, prev, curr) => `Duplicated property (${prop}) with different values. Possible error: "${prev}" vs "${curr}".`,
    importantUsage: 'Use of !important detected; prefer adequate specificity.',
    httpImport: 'HTTP import detected; prefer HTTPS or local bundling.',
    httpUrl: 'External resource via HTTP in url(); prefer HTTPS.',
    unifySelectors: (selectors, propsCount) => `Identical CSS rules (${propsCount} properties) in selectors (${selectors.slice(0, 6).join(', ')}). Consider unifying/centralizing into a utility class or shared selector.`,
    idSelectorPreferClass: (selector) => `ID selector (${selector}) detected. For reuse and consistency, prefer classes when possible.`,
    invalidProperty: (prop) => `Invalid or unknown CSS property (${prop}). Check spelling or browser support.`,
    malformedSelector: (selector) => `Malformed or invalid CSS selector (${selector}). May cause rendering issues.`,
    emptyRule: 'Empty CSS rule detected. Remove rules without declarations.',
    vendorPrefixDeprecated: (prop) => `Deprecated vendor prefix (${prop}). Use standard properties when supported.`,
    cssHackDetected: (hack) => `CSS hack detected (${hack}). Consider modern approaches or feature queries.`
};
export const HtmlMensagens = {
    doctype: 'Document without <!DOCTYPE html> declared.',
    htmlLang: '<html> element without lang attribute (accessibility).',
    metaCharset: 'Missing <meta charset="utf-8"> in document.',
    viewport: 'Missing viewport meta for responsiveness.',
    title: 'Document without <title> defined.',
    linkTargetBlank: 'Link with target="_blank" without rel="noreferrer"/"noopener".',
    linkNoHref: 'Link without valid href or handler (UX). Use <button> or role="button".',
    imgWithoutAlt: 'Image without alt attribute or accessibility (WCAG 2.1).',
    imgWithoutLoading: 'Image without loading attribute (performance). Consider loading="lazy".',
    imgWithoutDimensions: 'Image without width/height (layout shift). Set dimensions to prevent CLS.',
    formWithoutMethod: 'Form without method specified (GET/POST).',
    formWithoutAction: 'Form without action or data-attribute for processing.',
    inputWithoutLabel: 'Input without name, id or aria-label (accessibility/usability).',
    passwordWithoutAutocomplete: 'Password field without autocomplete specified (security).',
    inputWithoutType: 'Input without type specified (assumes text, but be explicit).',
    inlineHandler: 'Inline handler detected (on*). Prefer external listeners or data-attributes with JS.',
    inlineScript: 'Inline script detected. Prefer external files for better caching and CSP.',
    inlineStyle: 'Inline style detected. Prefer external CSS files for better caching.',
    scriptWithoutDefer: 'Script without defer/async. May block rendering; consider defer.',
    headingSkipped: (current, expected) => `Skipped heading: h${current} without preceding h${expected} (semantic structure).`,
    buttonWithoutText: 'Button without text or aria-label (accessibility).',
    tableWithoutCaption: 'Table without <caption> or aria-label (accessibility).',
    iframeWithoutTitle: 'Iframe without title (accessibility).',
    largeInlineScript: 'Very large inline script. Move to external file.',
    multipleH1: 'Multiple <h1> detected. Use only one per page for SEO/accessibility.'
};
export const XmlMensagens = {
    xmlPrologAusente: 'XML without <?xml ...?> declaration (optional, but improves compatibility).',
    doctypeDetectado: 'XML contains <!DOCTYPE>. Watch out for XXE vectors (external entities).',
    doctypeExternoDetectado: 'XML contains DOCTYPE with external identifier (SYSTEM/PUBLIC). High XXE risk if parser is not secure.',
    entidadeDetectada: 'XML contains <!ENTITY>. Review if there is expansion/XXE risk.',
    entidadeExternaDetectada: 'XML contains external entity (SYSTEM/PUBLIC). High XXE risk if parser is not secure.',
    entidadeParametroDetectada: 'XML contains parameter entity (<!ENTITY % ...>). May be used for XXE/DTD injection; review carefully.',
    xincludeDetectado: 'XML contains XInclude (<xi:include>). May load external resources; validate origin and parser.',
    namespaceUndeclared: (prefix) => `Namespace prefix "${prefix}" used without xmlns:${prefix} declaration.`,
    invalidXmlStructure: 'Invalid XML structure detected (unclosed or poorly nested tags).',
    encodingMismatch: (declared, detected) => `Declared encoding (${declared}) does not match detected (${detected}).`,
    largeEntityExpansion: 'Possible entity with very large expansion. Risk of Billion Laughs attack.',
    cdataInAttribute: 'CDATA detected in attribute value (invalid in XML).'
};
export const FormatadorMensagens = {
    naoFormatado: (parser, detalhes) => {
        const base = `File appears to be unformatted (parser: ${parser}). Consider normalizing with Tutanus formatter.`;
        if (!detalhes)
            return base;
        return `${base} (${detalhes})`;
    },
    parseErro: (parser, err) => `Failed to validate internal formatting (parser: ${parser}): ${err}`
};
export const SvgMensagens = {
    naoPareceSvg: 'File .svg does not contain a valid <svg> tag.',
    semViewBox: 'SVG without viewBox detected (may harm responsiveness).',
    scriptInline: 'SVG contains <script>. Security risk: avoid SVGs with embedded script.',
    eventoInline: 'SVG contains inline handlers (on*). Avoid inline events in assets.',
    javascriptUrl: 'SVG contains javascript: in URL/href. Security risk.',
    podeOtimizar: (originalBytes, optimizedBytes, mudancas) => `SVG can be optimized (${originalBytes}B → ${optimizedBytes}B). Changes: ${mudancas.join(', ')}.`
};
export const CssInJsMensagens = {
    detectedStyledComponents: 'styled-components patterns detected (CSS-in-JS).',
    detectedStyledJsx: 'styled-jsx patterns detected (CSS-in-JS in React).',
    globalStyles: (fonte) => `Global styles detected (${fonte}). Prefer local scope when possible.`,
    importantUsage: 'Use of !important in CSS-in-JS detected; prefer adequate specificity.',
    httpUrl: 'External resource via HTTP in url(); prefer HTTPS.',
    bestPracticesDescricao: 'Detects bad practices in CSS-in-JS',
    detectorGlobalStyles: 'Global styles detected',
    sugestaoEvitarGlobalStyles: 'Avoid global styles - use CSS Modules or scoped styles',
    importantDetected: '!important in CSS-in-JS',
    sugestaoEspecificidade: 'Refactor specificity instead of using !important',
    httpUrlDetected: 'HTTP URL in CSS-in-JS',
    sugestaoHttps: 'Use HTTPS for external resources',
    mixedStyling: 'Mixing className and inline styles',
    sugestaoMixedStyling: 'Choose one approach: CSS-in-JS or inline styles'
};
export const CssInJsPontuacaoMensagens = {
    notDetected: 'CSS-in-JS not detected',
    detected: 'CSS-in-JS detected',
    noGlobalStyles: 'No global styles',
    globalStylesIssue: 'Global styles detected',
    noImportant: 'No !important',
    importantUsageCount: (count) => `${count} !important usage(s)`,
    noHttpUrls: 'No HTTP URLs',
    httpUrlCount: (count) => `${count} HTTP URL(s)`,
    consistentStyling: 'Consistent styling approach',
    mixedStylingIssue: 'Mixing className and inline styles',
    themeUsage: 'Theme system usage',
    noThemeSystem: 'No theme system - consider using ThemeProvider'
};
export const CssInJsCorrecaoMensagens = {
    description: 'Automatic corrections for CSS-in-JS issues',
    correctionSuggested: (tipo) => `Suggested correction: ${tipo}`,
    sugestaoFormat: (original, sugerido, confianca) => `[ERROR] ${original}\n[OK] ${sugerido}\nConfidence: ${confianca}%`,
    extractGlobalCss: '// Consider moving to a separate global CSS file'
};
export const PythonMensagens = {
    missingTypeHints: 'Function without type hints detected; add type hints for better readability.',
    hardcodedString: (string) => `Hardcoded string detected (${string.slice(0, 30)}...); consider using constants.`,
    httpWithoutVerify: 'HTTP request without verify=True detected; validate SSL certificates.',
    sqlInjection: 'Possible SQL injection detected; use prepared statements.',
    broadExcept: 'Generic exception (except:) detected; be specific.',
    bareRaise: 'raise without context detected; always pass the exception to maintain stack trace.',
    passInExcept: 'pass in except block; implement appropriate error handling.',
    printInsteadOfLog: 'print() detected; prefer logging module for production.',
    evalUsage: 'eval() detected; avoid using eval - security vulnerability.',
    execUsage: 'exec() detected; avoid using exec - security vulnerability.',
    subprocessShellTrue: 'subprocess with shell=True detected; risk of command injection. Prefer args list and shell=False.',
    pickleUsage: 'pickle load(s) detected; never deserialize untrusted data (RCE). Prefer safe formats (JSON).',
    yamlUnsafeLoad: 'yaml.load without safe Loader detected; prefer yaml.safe_load (prevents execution).',
    globalKeyword: 'Use of global keyword detected; prefer passing as parameter.',
    mutableDefault: 'Argument with mutable default value (list/dict) detected; use None as default.',
    listComprehensionOpportunity: 'Loop that could be list comprehension detected.',
    loopingOverDict: 'Iteration over dict without .items(); consider using .items().'
};
export const GoMensagens = {
    uncheckedError: 'Unchecked error after function call that may return an error.',
    printWithoutFormat: 'fmt.Print* used without format string; prefer fmt.Printf with format.',
    deferInLoop: 'defer inside a loop may leak resources; move outside the loop.',
    hardcodedSecret: 'Possible hardcoded secret detected; use environment variables.',
    unbufferedChanSend: 'Send on unbuffered channel in same goroutine - deadlock risk.',
    magicNumber: 'Magic number detected; extract to named constant.',
    longFunction: 'Function too long; consider refactoring into smaller functions.',
    missingDeferClose: 'Resource not closed with defer; add defer resource.Close().',
    globalVar: 'Global variable detected; consider dependency injection.',
    ignoredError: 'Error return explicitly ignored with _; consider checking the error.',
    sqlInjection: 'SQL query built via string concatenation; risk of SQL injection. Use parameterized queries.',
    commandInjection: 'Command constructed with variable interpolation; risk of command injection.',
    pathTraversal: 'File operation using user input; risk of path traversal. Validate/sanitize the path.',
    namingConvention: (funcName) => `Function '${funcName}' does not follow Go naming convention (CamelCase).`,
    longVariableName: (varName) => `Variable '${varName}' is long for a short-scope variable; consider a shorter name.`,
    incompleteImportPath: (path) => `Import path '${path}' ends with a dot; possible incomplete path.`,
    goodErrorWrapping: 'Good practice: error wrapping with %w in fmt.Errorf'
};
export const RustMensagens = {
    unwrapUsage: '.unwrap() detected; prefer pattern matching with Result/Option.',
    emptyExpect: '.expect() with empty message; provide a descriptive message.',
    unsafeBlock: 'unsafe block detected; avoid unsafe whenever possible.',
    transmuteUsage: 'transmute usage detected; prefer safe TryFrom/From conversions.',
    noTrimOnInput: 'read_line without trim; value may contain newline.',
    vecWithoutCapacity: 'Vec.push() on Vec created without with_capacity; pre-allocate for performance.',
    mutexAcrossAwait: 'Mutex lock held across .await; deadlock risk.',
    printlnInLib: 'println! in library code; use logging framework.',
    magicNumber: 'Magic number detected; extract to constant.',
    hardcodedSecret: 'Possible hardcoded secret detected; use environment variables.',
    longFunction: 'Function too long; consider refactoring into smaller functions.',
    genericExpect: '.expect() with generic message; provide context about why the value should be Some/Ok.',
    unwrapInResult: '.unwrap() in function returning Result; use ? operator instead.',
    stubMacro: (name) => `${name}() should only be used as a stub; remove in production code.`,
    todoFound: 'todo!() macro found; implement before shipping.',
    rawPointer: 'Raw pointer used inside unsafe block; ensure safety invariants are documented.',
    reprC: '#[repr(C)] detected; ensure it is necessary for FFI compatibility.',
    missingDoc: (fnName) => `Public function '${fnName}' missing documentation comment (///).`,
    namingConvention: (constName) => `Constant '${constName}' should follow SCREAMING_CASE convention.`,
    redundantReturn: 'Redundant return at end of function; Rust uses implicit return (last expression).',
    wildcardImport: (importPath) => `Wildcard import '${importPath}' may pollute namespace; prefer explicit imports.`
};
export const JavaMensagens = {
    sysoutDetected: 'System.out/err.print detected; use logging framework (SLF4J, Logback).',
    printStackTrace: 'e.printStackTrace() detected; use logger to record exceptions.',
    hardcodedSecret: 'Possible hardcoded secret detected; use environment variables.',
    sqlConcatenation: 'SQL concatenation detected; use PreparedStatement.',
    nullAssignment: 'Null assignment detected; consider Optional.',
    emptyCatch: 'Empty catch block detected; at least log the error.',
    genericCatch: 'Generic exception caught (Exception/Throwable); be specific.',
    mutableStatic: 'Mutable static field detected; prefer final or encapsulation.',
    longMethod: 'Method too long; consider extracting smaller methods.',
    lateinitWithoutCheck: 'lateinit var without ::isInitialized check before use.'
};
export const PhpMensagens = {
    sqlInjection: 'Possible SQL injection detected; use prepared statements (PDO).',
    evalUsage: 'eval() detected; security vulnerability - avoid using.',
    assertString: 'assert() with string detected; risk of code injection.',
    unserializeUsage: 'unserialize() detected; RCE risk if data is untrusted.',
    extractUsage: 'extract() detected; risk of variable overwriting.',
    urlFetch: 'file_get_contents with URL detected; validate and restrict URLs.',
    commandExecution: 'Command execution function detected; risk of command injection.',
    requestUsage: '$_REQUEST detected; prefer $_GET, $_POST or $_SERVER for clarity.',
    hardcodedSecret: 'Possible hardcoded secret detected; use environment variables.',
    deprecatedMysql: 'Deprecated mysql_* function detected; migrate to PDO or MySQLi.',
    shortOpenTag: 'Short open tag (<?) detected; prefer <?php for compatibility.',
    errorSuppression: 'Error suppression operator (@) detected; handle errors properly.',
    longFunction: 'Function too long; consider refactoring.',
    debugOutput: 'var_dump/print_r/die detected in production code; remove or use logger.',
    camelCaseFunction: 'CamelCase function name; consider snake_case for PHP convention.'
};
export const SeverityNiveis = {
    error: 'error',
    warning: 'warning',
    info: 'info',
    suggestion: 'suggestion'
};
export const AnalystTipos = {
    react: 'react/rule',
    reactHooks: 'react-hooks/rule',
    tailwind: 'tailwindcss/rule',
    css: 'css/rule',
    html: 'html/rule',
    python: 'python/rule',
    xml: 'xml/rule',
    formatador: 'formatter/rule',
    svg: 'svg/rule',
    cssInJs: 'css-in-js/rule',
    go: 'go/rule',
    rust: 'rust/rule',
    php: 'php/rule'
};
export const AnalystOrigens = {
    react: 'analyst-react',
    reactHooks: 'analyst-react-hooks',
    tailwind: 'analyst-tailwind',
    css: 'analyst-css',
    html: 'analyst-html',
    python: 'analyst-python',
    xml: 'analyst-xml',
    formatador: 'analyst-formatter',
    svg: 'analyst-svg',
    cssInJs: 'analyst-css-in-js',
    go: 'analyst-go',
    rust: 'analyst-rust',
    php: 'analyst-php'
};
//# sourceMappingURL=plugin-messages.js.map