react-code-smell-detector 1.1.1 → 1.3.1

package/dist/detectors/memoryLeak.js

@@ -0,0 +1,111 @@
+import * as t from '@babel/types';
+/**
+ * Detect potential memory leaks in React components
+ */
+export function detectMemoryLeaks(component, filePath, sourceCode, config) {
+    if (!config.checkMemoryLeaks)
+        return [];
+    const smells = [];
+    // Check for setInterval without cleanup
+    component.path.traverse({
+        CallExpression(path) {
+            const node = path.node;
+            const { callee } = node;
+            if (t.isIdentifier(callee) && callee.name === 'setInterval') {
+                // Check if result is stored
+                const parent = path.parentPath;
+                if (!parent || !t.isVariableDeclarator(parent.node)) {
+                    const loc = node.loc;
+                    smells.push({
+                        type: 'memory-leak-timer',
+                        severity: 'error',
+                        message: `setInterval without storing ID for cleanup in "${component.name}"`,
+                        file: filePath,
+                        line: loc?.start.line || 0,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Store the interval ID and call clearInterval in cleanup.',
+                    });
+                }
+            }
+        },
+    });
+    // Check useEffect hooks for cleanup issues
+    for (const effect of component.hooks.useEffect) {
+        const hasCleanup = checkEffectHasCleanup(effect);
+        const hasSubscription = checkEffectHasSubscription(effect, component);
+        const hasEventListener = checkEffectHasEventListener(effect, component);
+        if (hasEventListener && !hasCleanup) {
+            const loc = effect.loc;
+            smells.push({
+                type: 'memory-leak-event-listener',
+                severity: 'error',
+                message: `useEffect adds event listener without cleanup in "${component.name}"`,
+                file: filePath,
+                line: loc?.start.line || 0,
+                column: 0,
+                suggestion: 'Return a cleanup function that calls removeEventListener.',
+            });
+        }
+        if (hasSubscription && !hasCleanup) {
+            const loc = effect.loc;
+            smells.push({
+                type: 'memory-leak-subscription',
+                severity: 'error',
+                message: `useEffect creates subscription without cleanup in "${component.name}"`,
+                file: filePath,
+                line: loc?.start.line || 0,
+                column: 0,
+                suggestion: 'Return a cleanup function that unsubscribes.',
+            });
+        }
+    }
+    return smells;
+}
+function checkEffectHasCleanup(effect) {
+    const args = effect.arguments;
+    if (args.length === 0)
+        return false;
+    const callback = args[0];
+    if (!t.isArrowFunctionExpression(callback) && !t.isFunctionExpression(callback)) {
+        return false;
+    }
+    // Check if callback body has a return statement
+    if (t.isBlockStatement(callback.body)) {
+        for (const stmt of callback.body.body) {
+            if (t.isReturnStatement(stmt) && stmt.argument) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function checkEffectHasEventListener(effect, component) {
+    let hasListener = false;
+    const args = effect.arguments;
+    if (args.length === 0)
+        return false;
+    const callback = args[0];
+    if (!t.isArrowFunctionExpression(callback) && !t.isFunctionExpression(callback)) {
+        return false;
+    }
+    if (t.isBlockStatement(callback.body)) {
+        const sourceCode = JSON.stringify(callback.body);
+        hasListener = sourceCode.includes('addEventListener');
+    }
+    return hasListener;
+}
+function checkEffectHasSubscription(effect, component) {
+    let hasSubscription = false;
+    const args = effect.arguments;
+    if (args.length === 0)
+        return false;
+    const callback = args[0];
+    if (!t.isArrowFunctionExpression(callback) && !t.isFunctionExpression(callback)) {
+        return false;
+    }
+    if (t.isBlockStatement(callback.body)) {
+        const sourceCode = JSON.stringify(callback.body);
+        hasSubscription = sourceCode.includes('subscribe') || sourceCode.includes('addListener');
+    }
+    return hasSubscription;
+}

package/dist/detectors/security.d.ts

@@ -0,0 +1,12 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detects security vulnerabilities:
+ * - dangerouslySetInnerHTML usage
+ * - eval() and Function() constructor
+ * - innerHTML assignments
+ * - Unsafe URLs (javascript:, data:)
+ * - Exposed secrets/API keys
+ */
+export declare function detectSecurityIssues(component: ParsedComponent, filePath: string, sourceCode: string, config?: DetectorConfig): CodeSmell[];
+//# sourceMappingURL=security.d.ts.map

package/dist/detectors/security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../src/detectors/security.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAkB,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAkB,MAAM,mBAAmB,CAAC;AAE9E;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,cAA+B,GACtC,SAAS,EAAE,CAiKb"}

package/dist/detectors/security.js

@@ -0,0 +1,161 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects security vulnerabilities:
+ * - dangerouslySetInnerHTML usage
+ * - eval() and Function() constructor
+ * - innerHTML assignments
+ * - Unsafe URLs (javascript:, data:)
+ * - Exposed secrets/API keys
+ */
+export function detectSecurityIssues(component, filePath, sourceCode, config = DEFAULT_CONFIG) {
+    if (!config.checkSecurity)
+        return [];
+    const smells = [];
+    // Detect dangerouslySetInnerHTML
+    component.path.traverse({
+        JSXAttribute(path) {
+            if (t.isJSXIdentifier(path.node.name) &&
+                path.node.name.name === 'dangerouslySetInnerHTML') {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'security-xss',
+                    severity: 'error',
+                    message: `dangerouslySetInnerHTML is a security risk in "${component.name}"`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Sanitize HTML with DOMPurify or use a safe alternative like converting to React elements',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+    });
+    // Detect eval() and Function() constructor
+    component.path.traverse({
+        CallExpression(path) {
+            const { callee } = path.node;
+            // eval()
+            if (t.isIdentifier(callee) && callee.name === 'eval') {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'security-eval',
+                    severity: 'error',
+                    message: `eval() is a critical security risk in "${component.name}"`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Never use eval(). Parse JSON with JSON.parse() or restructure logic to avoid dynamic code execution.',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+        // new Function()
+        NewExpression(path) {
+            const { callee } = path.node;
+            if (t.isIdentifier(callee) && callee.name === 'Function') {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'security-eval',
+                    severity: 'error',
+                    message: `new Function() is equivalent to eval() and is a security risk`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Avoid creating functions from strings. Restructure to use static function definitions.',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+    });
+    // Detect innerHTML assignments
+    component.path.traverse({
+        AssignmentExpression(path) {
+            const { left } = path.node;
+            if (t.isMemberExpression(left) && t.isIdentifier(left.property)) {
+                if (left.property.name === 'innerHTML' || left.property.name === 'outerHTML') {
+                    const loc = path.node.loc;
+                    smells.push({
+                        type: 'security-xss',
+                        severity: 'warning',
+                        message: `Direct ${left.property.name} assignment can lead to XSS`,
+                        file: filePath,
+                        line: loc?.start.line || 0,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Use textContent for plain text, or sanitize HTML with DOMPurify',
+                        codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                    });
+                }
+            }
+        },
+    });
+    // Detect unsafe URLs (javascript:, data:)
+    component.path.traverse({
+        JSXAttribute(path) {
+            if (!t.isJSXIdentifier(path.node.name))
+                return;
+            const propName = path.node.name.name;
+            if (!['href', 'src', 'action'].includes(propName))
+                return;
+            const value = path.node.value;
+            if (t.isStringLiteral(value)) {
+                const url = value.value.toLowerCase().trim();
+                if (url.startsWith('javascript:')) {
+                    const loc = path.node.loc;
+                    smells.push({
+                        type: 'security-xss',
+                        severity: 'error',
+                        message: `javascript: URLs are a security risk`,
+                        file: filePath,
+                        line: loc?.start.line || 0,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Use onClick handlers instead of javascript: URLs',
+                        codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                    });
+                }
+                if (url.startsWith('data:') && propName === 'href') {
+                    const loc = path.node.loc;
+                    smells.push({
+                        type: 'security-xss',
+                        severity: 'warning',
+                        message: `data: URLs in href can be a security risk`,
+                        file: filePath,
+                        line: loc?.start.line || 0,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Validate and sanitize data URLs, or use blob URLs instead',
+                        codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                    });
+                }
+            }
+        },
+    });
+    // Detect potential exposed secrets
+    const secretPatterns = [
+        { pattern: /['"](?:sk[-_]live|pk[-_]live|api[-_]?key|secret[-_]?key|access[-_]?token|auth[-_]?token)['"]\s*[:=]\s*['"][a-zA-Z0-9-_]{20,}/i, name: 'API key' },
+        { pattern: /['"](?:ghp|gho|ghu|ghs|ghr)_[a-zA-Z0-9]{36,}['"]/i, name: 'GitHub token' },
+        { pattern: /['"]AKIA[A-Z0-9]{16}['"]/i, name: 'AWS access key' },
+        { pattern: /password\s*[:=]\s*['"][^'"]{8,}['"]/i, name: 'Hardcoded password' },
+    ];
+    const lines = sourceCode.split('\n');
+    lines.forEach((line, index) => {
+        const lineNum = index + 1;
+        if (lineNum < component.startLine || lineNum > component.endLine)
+            return;
+        secretPatterns.forEach(({ pattern, name }) => {
+            if (pattern.test(line)) {
+                smells.push({
+                    type: 'security-secrets',
+                    severity: 'error',
+                    message: `Potential ${name} exposed in code`,
+                    file: filePath,
+                    line: lineNum,
+                    column: 0,
+                    suggestion: 'Move secrets to environment variables (.env) and never commit them to version control',
+                    codeSnippet: getCodeSnippet(sourceCode, lineNum),
+                });
+            }
+        });
+    });
+    return smells;
+}

package/dist/fixer.d.ts

@@ -0,0 +1,23 @@
+import { CodeSmell, SmellType } from './types/index.js';
+export interface FixResult {
+    file: string;
+    fixedSmells: CodeSmell[];
+    skippedSmells: CodeSmell[];
+}
+/**
+ * Check if a smell type can be auto-fixed
+ */
+export declare function isFixable(smell: CodeSmell): boolean;
+/**
+ * Apply fixes to a file based on detected smells
+ */
+export declare function fixFile(filePath: string, smells: CodeSmell[]): Promise<FixResult>;
+/**
+ * Get list of fixable smell types
+ */
+export declare function getFixableTypes(): SmellType[];
+/**
+ * Describe what fix will be applied for a smell type
+ */
+export declare function describeFixAction(type: SmellType): string;
+//# sourceMappingURL=fixer.d.ts.map

package/dist/fixer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixer.d.ts","sourceRoot":"","sources":["../src/fixer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,SAAS,EAAE,CAAC;IACzB,aAAa,EAAE,SAAS,EAAE,CAAC;CAC5B;AAUD;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAEnD;AAED;;GAEG;AACH,wBAAsB,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC,SAAS,CAAC,CAuCvF;AAyED;;GAEG;AACH,wBAAgB,eAAe,IAAI,SAAS,EAAE,CAE7C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAazD"}

package/dist/fixer.js

@@ -0,0 +1,133 @@
+import fs from 'fs/promises';
+// Smell types that can be auto-fixed
+const FIXABLE_TYPES = [
+    'debug-statement',
+    'js-var-usage',
+    'js-loose-equality',
+    'a11y-missing-alt',
+];
+/**
+ * Check if a smell type can be auto-fixed
+ */
+export function isFixable(smell) {
+    return FIXABLE_TYPES.includes(smell.type);
+}
+/**
+ * Apply fixes to a file based on detected smells
+ */
+export async function fixFile(filePath, smells) {
+    const fixableSmells = smells.filter(isFixable);
+    const skippedSmells = smells.filter(s => !isFixable(s));
+    if (fixableSmells.length === 0) {
+        return { file: filePath, fixedSmells: [], skippedSmells };
+    }
+    let content = await fs.readFile(filePath, 'utf-8');
+    const lines = content.split('\n');
+    const fixedSmells = [];
+    // Sort by line descending to fix from bottom up (preserves line numbers)
+    const sortedSmells = [...fixableSmells].sort((a, b) => b.line - a.line);
+    for (const smell of sortedSmells) {
+        const lineIndex = smell.line - 1;
+        if (lineIndex < 0 || lineIndex >= lines.length)
+            continue;
+        const originalLine = lines[lineIndex];
+        const fixedLine = applyFix(smell, originalLine);
+        if (fixedLine !== originalLine) {
+            if (fixedLine === null) {
+                // Remove the line entirely
+                lines.splice(lineIndex, 1);
+            }
+            else {
+                lines[lineIndex] = fixedLine;
+            }
+            fixedSmells.push(smell);
+        }
+    }
+    // Write back if any fixes were applied
+    if (fixedSmells.length > 0) {
+        await fs.writeFile(filePath, lines.join('\n'), 'utf-8');
+    }
+    return { file: filePath, fixedSmells, skippedSmells };
+}
+/**
+ * Apply a specific fix to a line of code
+ * Returns the fixed line, or null to remove the line
+ */
+function applyFix(smell, line) {
+    switch (smell.type) {
+        case 'debug-statement':
+            return fixDebugStatement(line);
+        case 'js-var-usage':
+            return fixVarUsage(line);
+        case 'js-loose-equality':
+            return fixLooseEquality(line);
+        case 'a11y-missing-alt':
+            return fixMissingAlt(line);
+        default:
+            return line;
+    }
+}
+/**
+ * Remove console.log, console.debug, debugger statements
+ */
+function fixDebugStatement(line) {
+    const trimmed = line.trim();
+    // If line is just a console statement or debugger, remove it
+    if (/^console\.(log|debug|info|warn|error|trace|dir)\s*\(.*\);?\s*$/.test(trimmed)) {
+        return null;
+    }
+    if (/^debugger;?\s*$/.test(trimmed)) {
+        return null;
+    }
+    // If console is part of a larger expression, comment it out
+    if (/console\.(log|debug|info|warn|error|trace|dir)\s*\(/.test(line)) {
+        return line.replace(/console\.(log|debug|info|warn|error|trace|dir)\s*\([^)]*\);?/g, '/* $& */');
+    }
+    return line;
+}
+/**
+ * Replace var with let or const
+ */
+function fixVarUsage(line) {
+    // Simple heuristic: if reassigned later, use let; otherwise const
+    // For auto-fix, default to let (safer)
+    return line.replace(/\bvar\s+/, 'let ');
+}
+/**
+ * Replace == with === and != with !==
+ */
+function fixLooseEquality(line) {
+    return line
+        .replace(/([^=!])={2}([^=])/g, '$1===$2')
+        .replace(/!={1}([^=])/g, '!==$1');
+}
+/**
+ * Add alt="" to img tags missing alt attribute
+ */
+function fixMissingAlt(line) {
+    // Add alt="" to <img> tags without alt
+    return line.replace(/<img\s+(?![^>]*\balt\b)([^>]*?)(\/?>)/gi, '<img $1alt="" $2');
+}
+/**
+ * Get list of fixable smell types
+ */
+export function getFixableTypes() {
+    return [...FIXABLE_TYPES];
+}
+/**
+ * Describe what fix will be applied for a smell type
+ */
+export function describeFixAction(type) {
+    switch (type) {
+        case 'debug-statement':
+            return 'Remove console.log/debugger statements';
+        case 'js-var-usage':
+            return 'Replace var with let';
+        case 'js-loose-equality':
+            return 'Replace == with === and != with !==';
+        case 'a11y-missing-alt':
+            return 'Add alt="" to images';
+        default:
+            return 'Not auto-fixable';
+    }
+}

package/dist/git.d.ts

@@ -0,0 +1,28 @@
+export interface GitInfo {
+    isGitRepo: boolean;
+    currentBranch?: string;
+    changedFiles: string[];
+    stagedFiles: string[];
+    untrackedFiles: string[];
+}
+/**
+ * Get git information for a directory
+ */
+export declare function getGitInfo(rootDir: string): GitInfo;
+/**
+ * Get files changed since a specific commit or branch
+ */
+export declare function getFilesSince(rootDir: string, ref: string): string[];
+/**
+ * Get files changed in the last N commits
+ */
+export declare function getFilesFromLastCommits(rootDir: string, count?: number): string[];
+/**
+ * Get all modified files (changed + staged + untracked)
+ */
+export declare function getAllModifiedFiles(rootDir: string): string[];
+/**
+ * Filter file list to only include React/JS/TS files
+ */
+export declare function filterReactFiles(files: string[]): string[];
+//# sourceMappingURL=git.d.ts.map

package/dist/git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../src/git.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,OAAO;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CA0DnD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAcpE;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAU,GAAG,MAAM,EAAE,CAcpF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAW7D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAG1D"}

package/dist/git.js

@@ -0,0 +1,117 @@
+import { execSync } from 'child_process';
+import path from 'path';
+/**
+ * Get git information for a directory
+ */
+export function getGitInfo(rootDir) {
+    try {
+        // Check if it's a git repo
+        execSync('git rev-parse --is-inside-work-tree', {
+            cwd: rootDir,
+            stdio: 'pipe',
+        });
+        const currentBranch = execSync('git branch --show-current', {
+            cwd: rootDir,
+            encoding: 'utf-8',
+        }).trim();
+        // Get changed files (modified but not staged)
+        const changedOutput = execSync('git diff --name-only', {
+            cwd: rootDir,
+            encoding: 'utf-8',
+        });
+        const changedFiles = changedOutput
+            .split('\n')
+            .filter(f => f.trim())
+            .map(f => path.resolve(rootDir, f));
+        // Get staged files
+        const stagedOutput = execSync('git diff --cached --name-only', {
+            cwd: rootDir,
+            encoding: 'utf-8',
+        });
+        const stagedFiles = stagedOutput
+            .split('\n')
+            .filter(f => f.trim())
+            .map(f => path.resolve(rootDir, f));
+        // Get untracked files
+        const untrackedOutput = execSync('git ls-files --others --exclude-standard', {
+            cwd: rootDir,
+            encoding: 'utf-8',
+        });
+        const untrackedFiles = untrackedOutput
+            .split('\n')
+            .filter(f => f.trim())
+            .map(f => path.resolve(rootDir, f));
+        return {
+            isGitRepo: true,
+            currentBranch,
+            changedFiles,
+            stagedFiles,
+            untrackedFiles,
+        };
+    }
+    catch {
+        return {
+            isGitRepo: false,
+            changedFiles: [],
+            stagedFiles: [],
+            untrackedFiles: [],
+        };
+    }
+}
+/**
+ * Get files changed since a specific commit or branch
+ */
+export function getFilesSince(rootDir, ref) {
+    try {
+        const output = execSync(`git diff --name-only ${ref}`, {
+            cwd: rootDir,
+            encoding: 'utf-8',
+        });
+        return output
+            .split('\n')
+            .filter(f => f.trim())
+            .map(f => path.resolve(rootDir, f));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get files changed in the last N commits
+ */
+export function getFilesFromLastCommits(rootDir, count = 1) {
+    try {
+        const output = execSync(`git diff --name-only HEAD~${count}`, {
+            cwd: rootDir,
+            encoding: 'utf-8',
+        });
+        return output
+            .split('\n')
+            .filter(f => f.trim())
+            .map(f => path.resolve(rootDir, f));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get all modified files (changed + staged + untracked)
+ */
+export function getAllModifiedFiles(rootDir) {
+    const info = getGitInfo(rootDir);
+    if (!info.isGitRepo)
+        return [];
+    const allFiles = new Set([
+        ...info.changedFiles,
+        ...info.stagedFiles,
+        ...info.untrackedFiles,
+    ]);
+    return Array.from(allFiles);
+}
+/**
+ * Filter file list to only include React/JS/TS files
+ */
+export function filterReactFiles(files) {
+    const extensions = ['.tsx', '.jsx', '.ts', '.js'];
+    return files.filter(f => extensions.some(ext => f.endsWith(ext)));
+}

package/dist/htmlReporter.d.ts

@@ -0,0 +1,6 @@
+import { AnalysisResult } from './types/index.js';
+/**
+ * Generate a beautiful HTML report with charts and styling
+ */
+export declare function generateHTMLReport(result: AnalysisResult, rootDir: string): string;
+//# sourceMappingURL=htmlReporter.d.ts.map

package/dist/htmlReporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlReporter.d.ts","sourceRoot":"","sources":["../src/htmlReporter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAiB,MAAM,kBAAkB,CAAC;AAGjE;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CA8YlF"}