@rigour-labs/core 5.0.0 → 5.1.0

package/dist/gates/side-effect-helpers/resource-tracking.js

@@ -0,0 +1,281 @@
+import { stripStrings } from './types.js';
+import { findBlockEndBrace } from './scope-analysis.js';
+// ═══════════════════════════════════════════════════════════════════
+// VARIABLE BINDING — Track resource creation → cleanup pairs
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * Extract the variable name from an assignment.
+ * "const timer = setInterval(...)"  → "timer"
+ * "let fd = fs.open(...)"           → "fd"
+ * "self.watcher = chokidar.watch()" → "self.watcher"
+ * "timer := time.NewTicker(...)"    → "timer" (Go)
+ *
+ * Returns null if the call result is NOT stored in a variable.
+ */
+export function extractVariableBinding(line, lang) {
+    const stripped = stripStrings(line).trim();
+    if (lang === 'go') {
+        // Go: `ticker := time.NewTicker(...)` or `ticker, _ := ...`
+        const goMatch = stripped.match(/^(\w+)(?:\s*,\s*\w+)*\s*:?=\s*/);
+        if (goMatch)
+            return goMatch[1];
+        return null;
+    }
+    if (lang === 'py') {
+        // Python: `timer = threading.Timer(...)` or `self.timer = ...`
+        const pyMatch = stripped.match(/^((?:self\.)?[\w.]+)\s*=\s*(?!==)/);
+        if (pyMatch)
+            return pyMatch[1];
+        return null;
+    }
+    if (lang === 'rb') {
+        // Ruby: `@watcher = Listen.to(...)` or `watcher = ...`
+        const rbMatch = stripped.match(/^(@?\w+)\s*=\s*/);
+        if (rbMatch)
+            return rbMatch[1];
+        return null;
+    }
+    // JS/TS/Java/C#/Rust: `const x = ...`, `let x = ...`, `var x = ...`, `auto x = ...`
+    const jsMatch = stripped.match(/^(?:const|let|var|final|auto|val)\s+(\w+)\s*=\s*/);
+    if (jsMatch)
+        return jsMatch[1];
+    // Member assignment: `this.timer = ...`, `self.timer = ...`
+    const memberMatch = stripped.match(/^(?:this|self)\.([\w]+)\s*=\s*/);
+    if (memberMatch)
+        return memberMatch[1];
+    // Simple assignment: `timer = ...`
+    const simpleMatch = stripped.match(/^(\w+)\s*=\s*(?!==)/);
+    if (simpleMatch) {
+        // Exclude control flow keywords
+        const name = simpleMatch[1];
+        if (['if', 'for', 'while', 'switch', 'return', 'throw'].includes(name))
+            return null;
+        return name;
+    }
+    return null;
+}
+/**
+ * Check if a specific variable is used in a cleanup call within a scope.
+ *
+ * Unlike the naive "does clearInterval exist in the file?", this checks:
+ * 1. The cleanup function references the specific variable
+ * 2. The cleanup is within the correct scope (same function or cleanup callback)
+ *
+ * Example: for variable "timer" and cleanup patterns [/clearInterval/],
+ * matches: `clearInterval(timer)`, `clearInterval(this.timer)`, `timer.close()`
+ */
+export function hasCleanupForVariable(lines, varName, scopeStart, scopeEnd, cleanupPatterns, lang) {
+    const scope = lines.slice(scopeStart, scopeEnd);
+    for (let i = 0; i < scope.length; i++) {
+        const stripped = stripStrings(scope[i]);
+        // Check cleanup patterns that reference the specific variable
+        for (const pat of cleanupPatterns) {
+            if (!pat.test(stripped))
+                continue;
+            // The cleanup call should reference our variable
+            const escapedVar = varName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const varRef = new RegExp(`\\b${escapedVar}\\b`);
+            if (varRef.test(stripped))
+                return true;
+            // Also check method calls on the variable: timer.close(), timer.stop()
+            // The pattern might match a generic .close() — check if it's on our var
+        }
+        // Direct method cleanup on the variable: varName.close(), varName.Stop()
+        const escapedVar = varName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const methodCleanup = new RegExp(`\\b${escapedVar}\\.(?:close|stop|destroy|kill|terminate|dispose|cancel|shutdown|unsubscribe|disconnect|end|release|Clear|Stop|Dispose|Close|Cancel)\\s*\\(`);
+        if (methodCleanup.test(stripped))
+            return true;
+    }
+    return false;
+}
+/**
+ * Check if a line is inside a cleanup/teardown context.
+ *
+ * Cleanup contexts where resource cleanup is expected:
+ * - JS/TS: useEffect return function, componentWillUnmount, beforeDestroy, ngOnDestroy, dispose()
+ * - Python: __del__, __exit__, close(), cleanup(), teardown
+ * - Go: defer statement
+ * - Java: finally block, close() method, @PreDestroy
+ * - C#: Dispose(), using block, finalizer
+ * - Ruby: ensure block, at_exit
+ */
+export function isInsideCleanupContext(lines, lineIdx, lang) {
+    // Scan backwards up to 30 lines for cleanup context markers
+    for (let j = lineIdx; j >= Math.max(0, lineIdx - 30); j--) {
+        const trimmed = lines[j].trim();
+        switch (lang) {
+            case 'js':
+            case 'ts':
+                // React useEffect cleanup: `return () => { cleanup }`
+                if (/\breturn\s+(?:\(\)\s*=>|function\s*\()/.test(trimmed))
+                    return true;
+                // Lifecycle: componentWillUnmount, ngOnDestroy, beforeDestroy
+                if (/\b(?:componentWillUnmount|ngOnDestroy|beforeDestroy|dispose)\s*\(/.test(trimmed))
+                    return true;
+                // Event: 'beforeunload', 'unload'
+                if (/['"](?:beforeunload|unload)['"]\s*,/.test(trimmed))
+                    return true;
+                break;
+            case 'py':
+                if (/\bdef\s+(?:__del__|__exit__|close|cleanup|teardown|dispose)\s*\(/.test(trimmed))
+                    return true;
+                if (/\bfinally\s*:/.test(trimmed))
+                    return true;
+                break;
+            case 'go':
+                if (/\bdefer\b/.test(trimmed))
+                    return true;
+                break;
+            case 'java':
+                if (/\bfinally\s*\{/.test(trimmed))
+                    return true;
+                if (/\b(?:close|destroy|cleanup|dispose)\s*\(/.test(trimmed))
+                    return true;
+                if (/@PreDestroy/.test(trimmed))
+                    return true;
+                break;
+            case 'cs':
+                if (/\bDispose\s*\(/.test(trimmed))
+                    return true;
+                if (/\busing\s*\(/.test(trimmed))
+                    return true;
+                if (/~\w+\s*\(/.test(trimmed))
+                    return true; // finalizer
+                break;
+            case 'rb':
+                if (/\bensure\b/.test(trimmed))
+                    return true;
+                break;
+            case 'rs':
+                if (/\bimpl\s+Drop\b/.test(trimmed))
+                    return true;
+                break;
+        }
+        // Stop at function boundaries
+        if (isFunctionBoundary(trimmed, lang))
+            break;
+    }
+    return false;
+}
+// ═══════════════════════════════════════════════════════════════════
+// FRAMEWORK-AWARE PATTERNS — Detect safe idioms per ecosystem
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * Check if a timer/resource creation is inside a React useEffect
+ * that returns a cleanup function.
+ *
+ * Pattern:
+ *   useEffect(() => {
+ *     const timer = setInterval(...)  ← creation
+ *     return () => clearInterval(timer)  ← cleanup
+ *   }, [deps])
+ */
+export function isInUseEffectWithCleanup(lines, lineIdx) {
+    // Walk backwards to find useEffect
+    let braceDepth = 0;
+    for (let j = lineIdx; j >= Math.max(0, lineIdx - 30); j--) {
+        const stripped = stripStrings(lines[j]);
+        for (const ch of stripped) {
+            if (ch === '}')
+                braceDepth++;
+            if (ch === '{')
+                braceDepth--;
+        }
+        if (/\buseEffect\s*\(/.test(stripped) && braceDepth <= 0) {
+            // Found enclosing useEffect — now check if it has a return () => ...
+            const effectEnd = findBlockEndBrace(lines, j);
+            const effectBody = lines.slice(j, effectEnd).join('\n');
+            // Look for cleanup return: `return () =>` or `return function`
+            if (/\breturn\s+(?:\(\)\s*=>|function\s*\()/.test(effectBody)) {
+                return true;
+            }
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Check if a Go resource open is immediately followed by defer close.
+ *
+ * Idiomatic Go:
+ *   f, err := os.Open(path)
+ *   if err != nil { return err }
+ *   defer f.Close()
+ */
+export function hasGoDefer(lines, openLine, varName) {
+    // Check lines between open and open+5 for defer using the variable
+    const escaped = varName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const deferPat = new RegExp(`\\bdefer\\s+${escaped}\\.`);
+    for (let j = openLine + 1; j < Math.min(lines.length, openLine + 6); j++) {
+        if (deferPat.test(lines[j]))
+            return true;
+        // Also match: defer func() { varName.Close() }()
+        if (/\bdefer\s+func\s*\(\)/.test(lines[j])) {
+            const endDefer = findBlockEndBrace(lines, j);
+            const body = lines.slice(j, endDefer).join('\n');
+            if (new RegExp(`\\b${escaped}\\.`).test(body))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if a Python open() is inside a `with` statement (context manager).
+ */
+export function isPythonWithStatement(line) {
+    return /\bwith\s+/.test(stripStrings(line));
+}
+/**
+ * Check if a Java resource open is inside try-with-resources.
+ * Pattern: try (var x = new FileStream(...)) { ... }
+ */
+export function isJavaTryWithResources(lines, lineIdx) {
+    for (let j = lineIdx; j >= Math.max(0, lineIdx - 3); j--) {
+        if (/\btry\s*\(/.test(stripStrings(lines[j])))
+            return true;
+    }
+    return false;
+}
+/**
+ * Check if a C# resource is inside a using statement/declaration.
+ * Patterns: `using (var x = ...)` or `using var x = ...` (C# 8+)
+ */
+export function isCSharpUsing(line) {
+    const stripped = stripStrings(line);
+    return /\busing\s*\(/.test(stripped) || /\busing\s+(?:var|await)\b/.test(stripped);
+}
+/**
+ * Check if a Ruby File.open uses block form (auto-closes).
+ * Pattern: File.open(path) do |f| ... end
+ *          File.open(path) { |f| ... }
+ */
+export function isRubyBlockForm(line) {
+    return /\bdo\s*\|/.test(line) || /\{\s*\|/.test(line);
+}
+/**
+ * Check if a Rust resource is automatically dropped (RAII).
+ * In Rust, all resources are dropped when they go out of scope,
+ * so we only flag resources in unsafe blocks or static/global context.
+ */
+export function isRustAutoDropped(lines, lineIdx) {
+    // Check if inside unsafe block (manual memory management)
+    for (let j = lineIdx; j >= Math.max(0, lineIdx - 20); j--) {
+        if (/\bunsafe\s*\{/.test(lines[j]))
+            return false; // Not auto-dropped in unsafe
+    }
+    return true; // Normal Rust = RAII applies
+}
+function isFunctionBoundary(trimmed, lang) {
+    switch (lang) {
+        case 'py':
+            return /^(?:def|class|async\s+def)\s/.test(trimmed);
+        case 'go':
+            return /^func\s/.test(trimmed);
+        case 'rb':
+            return /^(?:def|class|module)\s/.test(trimmed);
+        case 'rs':
+            return /^(?:fn|impl|pub\s+fn|pub\s+async\s+fn)\s/.test(trimmed);
+        default:
+            return /^(?:export\s+)?(?:async\s+)?(?:function|class)\s/.test(trimmed);
+    }
+}

package/dist/gates/side-effect-helpers/scope-analysis.d.ts

@@ -0,0 +1,21 @@
+import { SideEffectLang } from './types.js';
+/**
+ * Find the enclosing function scope for a given line.
+ * Returns { start, end } of the function body.
+ * For module-level code, returns { start: 0, end: lines.length }.
+ *
+ * Follows promise-safety's approach of backward scanning with brace tracking.
+ */
+export declare function findEnclosingFunction(lines: string[], lineIdx: number, lang: SideEffectLang): {
+    start: number;
+    end: number;
+};
+/**
+ * Find the end of a brace-delimited block starting at `start`.
+ */
+export declare function findBlockEndBrace(lines: string[], start: number): number;
+/**
+ * Find the end of an indentation-delimited block (Python).
+ */
+export declare function findBlockEndIndent(lines: string[], start: number): number;
+export declare function getFunctionPatterns(lang: SideEffectLang): RegExp[];

package/dist/gates/side-effect-helpers/scope-analysis.js

@@ -0,0 +1,146 @@
+import { stripStrings } from './types.js';
+// ═══════════════════════════════════════════════════════════════════
+// SCOPE ANALYSIS — Find function/block boundaries
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * Find the enclosing function scope for a given line.
+ * Returns { start, end } of the function body.
+ * For module-level code, returns { start: 0, end: lines.length }.
+ *
+ * Follows promise-safety's approach of backward scanning with brace tracking.
+ */
+export function findEnclosingFunction(lines, lineIdx, lang) {
+    if (lang === 'py')
+        return findEnclosingFunctionPython(lines, lineIdx);
+    if (lang === 'rb')
+        return findEnclosingFunctionRuby(lines, lineIdx);
+    return findEnclosingFunctionBrace(lines, lineIdx, lang);
+}
+function findEnclosingFunctionBrace(lines, lineIdx, lang) {
+    // Walk backwards tracking brace depth to find function definition
+    let braceDepth = 0;
+    const funcPatterns = getFunctionPatterns(lang);
+    for (let j = lineIdx; j >= Math.max(0, lineIdx - 200); j--) {
+        const stripped = stripStrings(lines[j]);
+        // Count braces (reverse direction: } increases, { decreases)
+        for (const ch of stripped) {
+            if (ch === '}')
+                braceDepth++;
+            if (ch === '{')
+                braceDepth--;
+        }
+        // If braceDepth < 0, we've exited the enclosing block going backwards
+        if (braceDepth < 0) {
+            // Check if this line is a function definition
+            for (const pat of funcPatterns) {
+                if (pat.test(stripped)) {
+                    const end = findBlockEndBrace(lines, j);
+                    return { start: j, end };
+                }
+            }
+            // It's some other block (if/for/etc), keep looking
+            braceDepth = 0;
+        }
+    }
+    // Module level
+    return { start: 0, end: lines.length };
+}
+function findEnclosingFunctionPython(lines, lineIdx) {
+    const lineIndent = lines[lineIdx].length - lines[lineIdx].trimStart().length;
+    for (let j = lineIdx - 1; j >= 0; j--) {
+        const trimmed = lines[j].trim();
+        if (trimmed === '' || trimmed.startsWith('#'))
+            continue;
+        const indent = lines[j].length - lines[j].trimStart().length;
+        if (indent < lineIndent && /^\s*(?:async\s+)?def\s+\w+/.test(lines[j])) {
+            const end = findBlockEndIndent(lines, j);
+            return { start: j, end };
+        }
+        if (indent === 0 && /^\s*(?:class|def|async\s+def)\s/.test(lines[j])) {
+            const end = findBlockEndIndent(lines, j);
+            return { start: j, end };
+        }
+    }
+    return { start: 0, end: lines.length };
+}
+function findEnclosingFunctionRuby(lines, lineIdx) {
+    for (let j = lineIdx - 1; j >= Math.max(0, lineIdx - 100); j--) {
+        const trimmed = lines[j].trim();
+        if (/^def\s+\w+/.test(trimmed)) {
+            const end = findBlockEndRuby(lines, j);
+            return { start: j, end };
+        }
+    }
+    return { start: 0, end: lines.length };
+}
+/**
+ * Find the end of a brace-delimited block starting at `start`.
+ */
+export function findBlockEndBrace(lines, start) {
+    let braces = 0;
+    let started = false;
+    const maxScan = Math.min(lines.length, start + 300);
+    for (let j = start; j < maxScan; j++) {
+        const stripped = stripStrings(lines[j]);
+        for (const ch of stripped) {
+            if (ch === '{') {
+                braces++;
+                started = true;
+            }
+            if (ch === '}')
+                braces--;
+        }
+        if (started && braces <= 0)
+            return j + 1;
+    }
+    return maxScan;
+}
+/**
+ * Find the end of an indentation-delimited block (Python).
+ */
+export function findBlockEndIndent(lines, start) {
+    const baseIndent = lines[start].length - lines[start].trimStart().length;
+    const maxScan = Math.min(lines.length, start + 300);
+    for (let j = start + 1; j < maxScan; j++) {
+        const trimmed = lines[j].trim();
+        if (trimmed === '' || trimmed.startsWith('#'))
+            continue;
+        const indent = lines[j].length - lines[j].trimStart().length;
+        if (indent <= baseIndent)
+            return j;
+    }
+    return maxScan;
+}
+function findBlockEndRuby(lines, start) {
+    let depth = 0;
+    const maxScan = Math.min(lines.length, start + 300);
+    const openers = /\b(?:def|do|class|module|if|unless|while|until|for|begin|case)\b/;
+    for (let j = start; j < maxScan; j++) {
+        const trimmed = lines[j].trim();
+        if (openers.test(trimmed))
+            depth++;
+        if (/^\s*end\b/.test(trimmed)) {
+            depth--;
+            if (depth <= 0)
+                return j + 1;
+        }
+    }
+    return maxScan;
+}
+export function getFunctionPatterns(lang) {
+    switch (lang) {
+        case 'go':
+            return [/\bfunc\s+/];
+        case 'rs':
+            return [/\bfn\s+\w+/];
+        case 'java':
+        case 'cs':
+            return [/(?:public|private|protected|static|async|void|int|string|Task|var)\s+\w+\s*\(/];
+        default: // js, ts
+            return [
+                /(?:export\s+)?(?:async\s+)?function\s+\w+/,
+                /(?:const|let|var)\s+\w+\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
+                /\w+\s*\([^)]*\)\s*\{/, // method shorthand
+            ];
+    }
+}

package/dist/gates/side-effect-helpers/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Side-Effect Analysis Helpers
+ *
+ * Context-aware utilities for smart side-effect detection.
+ * Follows the same architectural patterns as promise-safety-helpers.ts:
+ *   - Scope-aware analysis (brace/indent tracking)
+ *   - Variable binding tracking (pair resource creation with cleanup)
+ *   - Framework detection (React useEffect, Go defer, Python with, etc.)
+ *   - Path overlap analysis (circular file watcher detection)
+ *
+ * These helpers make side-effect detection SMART — instead of asking
+ * "does clearInterval exist anywhere in the file?", we ask
+ * "is the specific timer variable cleaned up in the right scope?"
+ */
+export type SideEffectLang = 'js' | 'ts' | 'py' | 'go' | 'rs' | 'cs' | 'java' | 'rb';
+export interface SideEffectViolation {
+    rule: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    file: string;
+    line: number;
+    match: string;
+    description: string;
+    hint: string;
+}
+/**
+ * Tracks a resource creation and its expected cleanup.
+ * E.g.: { varName: 'timer', createLine: 5, createCall: 'setInterval' }
+ */
+export interface ResourceBinding {
+    varName: string | null;
+    createLine: number;
+    createCall: string;
+    scopeStart: number;
+    scopeEnd: number;
+}
+export declare const LANG_MAP: Record<string, SideEffectLang>;
+export declare const FILE_GLOBS: string[];
+export declare function stripStrings(line: string): string;

package/dist/gates/side-effect-helpers/types.js

@@ -0,0 +1,41 @@
+/**
+ * Side-Effect Analysis Helpers
+ *
+ * Context-aware utilities for smart side-effect detection.
+ * Follows the same architectural patterns as promise-safety-helpers.ts:
+ *   - Scope-aware analysis (brace/indent tracking)
+ *   - Variable binding tracking (pair resource creation with cleanup)
+ *   - Framework detection (React useEffect, Go defer, Python with, etc.)
+ *   - Path overlap analysis (circular file watcher detection)
+ *
+ * These helpers make side-effect detection SMART — instead of asking
+ * "does clearInterval exist anywhere in the file?", we ask
+ * "is the specific timer variable cleaned up in the right scope?"
+ */
+// ── Language detection ──
+export const LANG_MAP = {
+    '.ts': 'ts', '.tsx': 'ts', '.mts': 'ts',
+    '.js': 'js', '.jsx': 'js', '.mjs': 'js', '.cjs': 'js',
+    '.py': 'py',
+    '.go': 'go',
+    '.rs': 'rs',
+    '.cs': 'cs',
+    '.java': 'java',
+    '.rb': 'rb',
+};
+export const FILE_GLOBS = [
+    '**/*.{ts,tsx,mts,js,jsx,mjs,cjs}',
+    '**/*.py',
+    '**/*.go',
+    '**/*.rs',
+    '**/*.cs',
+    '**/*.java',
+    '**/*.rb',
+];
+// ── Strip string contents to avoid false positives in regex matching ──
+export function stripStrings(line) {
+    return line
+        .replace(/`[^`]*`/g, '""')
+        .replace(/"(?:[^"\\]|\\.)*"/g, '""')
+        .replace(/'(?:[^'\\]|\\.)*'/g, '""');
+}

package/dist/gates/side-effect-rules.d.ts

@@ -10,7 +10,6 @@
  * - a check function that verifies context (surrounding lines)
  * - severity and description
  *
- * @since v4.3.0
  */
 export type SideEffectLang = 'js' | 'ts' | 'py' | 'go' | 'rs' | 'cs' | 'java' | 'rb';
 export interface SideEffectViolation {

package/dist/gates/side-effect-rules.js

@@ -10,7 +10,6 @@
  * - a check function that verifies context (surrounding lines)
  * - severity and description
  *
- * @since v4.3.0
  */
 // ── Language detection ──
 export const LANG_MAP = {

package/dist/gates/style-drift-rules.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Style Drift Detection Gate — Naming Convention Rules and Regexes
+ *
+ * Contains per-language naming convention rules and naming pattern regexes.
+ */
+/**
+ * Casing classification rules
+ */
+export declare function classifyCasing(name: string): 'camelCase' | 'snake_case' | 'PascalCase' | 'SCREAMING_SNAKE' | null;
+/**
+ * Function name pattern for JavaScript
+ */
+export declare const JS_FUNCTION_PATTERN: RegExp;
+/**
+ * Method definition pattern for all languages
+ */
+export declare const METHOD_PATTERN: RegExp;
+/**
+ * Arrow function assignment pattern
+ */
+export declare const ARROW_FUNCTION_PATTERN: RegExp;
+/**
+ * Variable declaration pattern (non-function)
+ */
+export declare const VAR_DECLARATION_PATTERN: RegExp;
+/**
+ * Python function pattern
+ */
+export declare const PYTHON_FUNCTION_PATTERN: RegExp;
+/**
+ * Python variable pattern
+ */
+export declare const PYTHON_VAR_PATTERN: RegExp;
+/**
+ * Go function pattern
+ */
+export declare const GO_FUNCTION_PATTERN: RegExp;
+/**
+ * Go variable pattern
+ */
+export declare const GO_VAR_PATTERN: RegExp;
+/**
+ * Rust function pattern
+ */
+export declare const RUST_FUNCTION_PATTERN: RegExp;
+/**
+ * Rust variable pattern
+ */
+export declare const RUST_VAR_PATTERN: RegExp;
+/**
+ * Ruby method pattern
+ */
+export declare const RUBY_METHOD_PATTERN: RegExp;
+/**
+ * Ruby variable pattern
+ */
+export declare const RUBY_VAR_PATTERN: RegExp;
+/**
+ * Java/Kotlin/C# method pattern
+ */
+export declare const JAVA_METHOD_PATTERN: RegExp;
+/**
+ * Java/Kotlin/C# variable pattern
+ */
+export declare const JAVA_VAR_PATTERN: RegExp;
+/**
+ * Error handling patterns
+ */
+export declare const TRY_CATCH_PATTERN: RegExp;
+export declare const CATCH_PATTERN: RegExp;
+export declare const RESULT_TYPE_PATTERN: RegExp;
+/**
+ * Import style patterns
+ */
+export declare const NAMED_IMPORT_PATTERN: RegExp;
+export declare const WILDCARD_IMPORT_PATTERN: RegExp;
+export declare const SIDE_EFFECT_IMPORT_PATTERN: RegExp;
+export declare const DEFAULT_IMPORT_PATTERN: RegExp;
+/**
+ * Quote style detection
+ */
+export declare function countQuotes(line: string): {
+    single: number;
+    double: number;
+    backtick: number;
+};