@vibecheckai/cli 3.5.0 → 3.5.2

package/bin/runners/lib/bundle/bundle-intelligence.js

@@ -1,846 +0,0 @@
-/**
- * Bundle Intelligence Engine
- * 
- * ═══════════════════════════════════════════════════════════════════════════════
- * COMPETITIVE MOAT FEATURE - Smart Bundle Analysis & Optimization
- * ═══════════════════════════════════════════════════════════════════════════════
- * 
- * This engine analyzes JavaScript bundles to find optimization opportunities
- * that most developers miss. It goes beyond basic bundle analysis.
- * 
- * Features:
- * - Dead import detection (imported but not used)
- * - Tree-shaking opportunities
- * - Duplicate dependency detection
- * - Bundle size impact analysis
- * - Code splitting recommendations
- * - Dynamic import suggestions
- * - Side-effect analysis
- * - Module graph visualization
- */
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// LARGE PACKAGE DATABASE (common packages and their tree-shakeable alternatives)
-// ═══════════════════════════════════════════════════════════════════════════════
-
-const LARGE_PACKAGES = {
-  lodash: {
-    size: "~70KB",
-    alternative: "lodash-es or individual imports",
-    treeShakeable: false,
-    imports: {
-      debounce: { alternative: "lodash/debounce", size: "~1KB" },
-      throttle: { alternative: "lodash/throttle", size: "~1KB" },
-      cloneDeep: { alternative: "lodash/cloneDeep", size: "~5KB" },
-      merge: { alternative: "lodash/merge", size: "~3KB" },
-      get: { alternative: "lodash/get", size: "~1KB" },
-      set: { alternative: "lodash/set", size: "~2KB" },
-      isEqual: { alternative: "lodash/isEqual", size: "~4KB" }
-    }
-  },
-  moment: {
-    size: "~300KB with locales",
-    alternative: "date-fns or dayjs",
-    treeShakeable: false,
-    modernAlternatives: ["date-fns", "dayjs", "luxon"]
-  },
-  "date-fns": {
-    size: "~80KB full",
-    treeShakeable: true,
-    note: "Import individual functions for best results"
-  },
-  rxjs: {
-    size: "~140KB",
-    treeShakeable: true,
-    note: "Use deep imports: rxjs/operators"
-  },
-  ramda: {
-    size: "~45KB",
-    treeShakeable: false,
-    alternative: "Individual imports or ramda-es"
-  },
-  "core-js": {
-    size: "~150KB full",
-    note: "Use @babel/preset-env with useBuiltIns for selective polyfills"
-  },
-  antd: {
-    size: "~1MB+ full",
-    treeShakeable: true,
-    note: "Import specific components: import { Button } from 'antd'"
-  },
-  "@mui/material": {
-    size: "~800KB+ full",
-    treeShakeable: true,
-    note: "Import specific components"
-  },
-  "react-icons": {
-    size: "~10MB full",
-    treeShakeable: true,
-    note: "Import from specific icon pack: react-icons/fa"
-  }
-};
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// IMPORT ANALYZER
-// ═══════════════════════════════════════════════════════════════════════════════
-
-class ImportAnalyzer {
-  constructor(content, filePath) {
-    this.content = content;
-    this.filePath = filePath;
-    this.imports = [];
-    this.exports = [];
-    this.usages = new Map();
-  }
-
-  /**
-   * Analyze all imports in the file
-   */
-  analyze() {
-    this.extractImports();
-    this.extractExports();
-    this.findUsages();
-    return this.getAnalysis();
-  }
-
-  /**
-   * Extract import statements
-   */
-  extractImports() {
-    // ES6 named imports: import { a, b } from 'module'
-    const namedImportRegex = /import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g;
-    let match;
-    
-    while ((match = namedImportRegex.exec(this.content)) !== null) {
-      const names = match[1].split(",").map(n => {
-        const parts = n.trim().split(/\s+as\s+/);
-        return {
-          imported: parts[0].trim(),
-          local: (parts[1] || parts[0]).trim()
-        };
-      });
-      
-      for (const name of names) {
-        this.imports.push({
-          type: "named",
-          module: match[2],
-          imported: name.imported,
-          local: name.local,
-          line: this.getLineNumber(match.index)
-        });
-      }
-    }
-
-    // ES6 default imports: import X from 'module'
-    const defaultImportRegex = /import\s+(\w+)\s+from\s*['"]([^'"]+)['"]/g;
-    
-    while ((match = defaultImportRegex.exec(this.content)) !== null) {
-      // Skip if it's actually a named import we already caught
-      if (this.content.substring(match.index, match.index + 20).includes("{")) {
-        continue;
-      }
-      
-      this.imports.push({
-        type: "default",
-        module: match[2],
-        local: match[1],
-        line: this.getLineNumber(match.index)
-      });
-    }
-
-    // ES6 namespace imports: import * as X from 'module'
-    const namespaceImportRegex = /import\s*\*\s*as\s+(\w+)\s+from\s*['"]([^'"]+)['"]/g;
-    
-    while ((match = namespaceImportRegex.exec(this.content)) !== null) {
-      this.imports.push({
-        type: "namespace",
-        module: match[2],
-        local: match[1],
-        line: this.getLineNumber(match.index)
-      });
-    }
-
-    // Side-effect imports: import 'module'
-    const sideEffectRegex = /import\s*['"]([^'"]+)['"]\s*;/g;
-    
-    while ((match = sideEffectRegex.exec(this.content)) !== null) {
-      this.imports.push({
-        type: "sideEffect",
-        module: match[1],
-        line: this.getLineNumber(match.index)
-      });
-    }
-
-    // Dynamic imports: import('module')
-    const dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-    
-    while ((match = dynamicImportRegex.exec(this.content)) !== null) {
-      this.imports.push({
-        type: "dynamic",
-        module: match[1],
-        line: this.getLineNumber(match.index)
-      });
-    }
-
-    // CommonJS require: const x = require('module')
-    const requireRegex = /(?:const|let|var)\s+(?:\{([^}]+)\}|(\w+))\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-    
-    while ((match = requireRegex.exec(this.content)) !== null) {
-      if (match[1]) {
-        // Destructured require
-        const names = match[1].split(",").map(n => n.trim().split(":")[0].trim());
-        for (const name of names) {
-          this.imports.push({
-            type: "commonjs",
-            module: match[3],
-            local: name,
-            line: this.getLineNumber(match.index)
-          });
-        }
-      } else {
-        // Default require
-        this.imports.push({
-          type: "commonjs",
-          module: match[3],
-          local: match[2],
-          line: this.getLineNumber(match.index)
-        });
-      }
-    }
-  }
-
-  /**
-   * Extract export statements
-   */
-  extractExports() {
-    // Named exports: export { a, b }
-    const namedExportRegex = /export\s*\{([^}]+)\}/g;
-    let match;
-    
-    while ((match = namedExportRegex.exec(this.content)) !== null) {
-      const names = match[1].split(",").map(n => n.trim().split(/\s+as\s+/)[0].trim());
-      for (const name of names) {
-        this.exports.push({ type: "named", name });
-      }
-    }
-
-    // Export declarations: export const/function/class
-    const exportDeclRegex = /export\s+(?:const|let|var|function|class|async\s+function)\s+(\w+)/g;
-    
-    while ((match = exportDeclRegex.exec(this.content)) !== null) {
-      this.exports.push({ type: "declaration", name: match[1] });
-    }
-
-    // Default export
-    if (/export\s+default\s/.test(this.content)) {
-      this.exports.push({ type: "default" });
-    }
-  }
-
-  /**
-   * Find usages of imported identifiers
-   */
-  findUsages() {
-    // Remove import/export lines and comments for cleaner usage detection
-    const codeOnly = this.content
-      .replace(/import\s+.*?from\s*['"][^'"]+['"]\s*;?/g, "")
-      .replace(/export\s+.*?;/g, "")
-      .replace(/\/\/.*$/gm, "")
-      .replace(/\/\*[\s\S]*?\*\//g, "");
-
-    for (const imp of this.imports) {
-      if (imp.local) {
-        // Count usages of the local name
-        const usageRegex = new RegExp(`\\b${imp.local}\\b`, "g");
-        const matches = codeOnly.match(usageRegex) || [];
-        this.usages.set(imp.local, matches.length);
-      }
-    }
-  }
-
-  /**
-   * Get analysis results
-   */
-  getAnalysis() {
-    const deadImports = [];
-    const namespaceIssues = [];
-    const largePackageIssues = [];
-
-    for (const imp of this.imports) {
-      // Check for dead imports
-      if (imp.local && imp.type !== "sideEffect") {
-        const usage = this.usages.get(imp.local) || 0;
-        if (usage === 0) {
-          deadImports.push({
-            ...imp,
-            issue: "unused",
-            message: `'${imp.local}' is imported but never used`
-          });
-        }
-      }
-
-      // Check for namespace imports that could be specific
-      if (imp.type === "namespace") {
-        const usageCount = this.usages.get(imp.local) || 0;
-        if (usageCount < 5) {
-          namespaceIssues.push({
-            ...imp,
-            issue: "namespace",
-            message: `Namespace import of '${imp.module}' - consider named imports for better tree-shaking`,
-            usageCount
-          });
-        }
-      }
-
-      // Check for large packages
-      const packageName = this.getPackageName(imp.module);
-      if (LARGE_PACKAGES[packageName]) {
-        const pkgInfo = LARGE_PACKAGES[packageName];
-        if (!pkgInfo.treeShakeable) {
-          largePackageIssues.push({
-            ...imp,
-            issue: "largePackage",
-            package: packageName,
-            size: pkgInfo.size,
-            alternative: pkgInfo.alternative,
-            message: `'${packageName}' (${pkgInfo.size}) is not tree-shakeable`
-          });
-        }
-      }
-    }
-
-    return {
-      file: this.filePath,
-      imports: this.imports,
-      exports: this.exports,
-      issues: {
-        deadImports,
-        namespaceIssues,
-        largePackageIssues,
-        total: deadImports.length + namespaceIssues.length + largePackageIssues.length
-      },
-      usages: Object.fromEntries(this.usages)
-    };
-  }
-
-  /**
-   * Get line number from index
-   */
-  getLineNumber(index) {
-    return this.content.substring(0, index).split("\n").length;
-  }
-
-  /**
-   * Extract package name from import path
-   */
-  getPackageName(importPath) {
-    // Handle scoped packages (@org/package)
-    if (importPath.startsWith("@")) {
-      const parts = importPath.split("/");
-      return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : importPath;
-    }
-    // Regular packages
-    return importPath.split("/")[0];
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// BUNDLE INTELLIGENCE ENGINE
-// ═══════════════════════════════════════════════════════════════════════════════
-
-class BundleIntelligenceEngine {
-  constructor(options = {}) {
-    this.projectRoot = options.projectRoot || process.cwd();
-    this.results = [];
-    this.moduleGraph = new Map();
-    this.packageSizes = new Map();
-  }
-
-  /**
-   * Analyze a single file
-   */
-  analyzeFile(filePath, content = null) {
-    const fullPath = path.isAbsolute(filePath) 
-      ? filePath 
-      : path.join(this.projectRoot, filePath);
-    
-    if (content === null) {
-      if (!fs.existsSync(fullPath)) {
-        return { file: filePath, error: "File not found" };
-      }
-      content = fs.readFileSync(fullPath, "utf8");
-    }
-
-    const analyzer = new ImportAnalyzer(content, filePath);
-    return analyzer.analyze();
-  }
-
-  /**
-   * Analyze entire project
-   */
-  analyzeProject() {
-    const files = this.collectFiles();
-    this.results = [];
-
-    for (const file of files) {
-      const result = this.analyzeFile(file);
-      this.results.push(result);
-      
-      // Build module graph
-      this.moduleGraph.set(file, result.imports.map(i => i.module));
-    }
-
-    return this.generateReport();
-  }
-
-  /**
-   * Collect JavaScript/TypeScript files
-   */
-  collectFiles(dir = this.projectRoot, collected = []) {
-    const extensions = [".js", ".jsx", ".ts", ".tsx", ".mjs"];
-    const ignoreDirs = ["node_modules", "dist", "build", ".next", "coverage", ".git"];
-    
-    try {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-      
-      for (const entry of entries) {
-        if (ignoreDirs.includes(entry.name)) continue;
-        
-        const fullPath = path.join(dir, entry.name);
-        const relativePath = path.relative(this.projectRoot, fullPath);
-        
-        if (entry.isDirectory()) {
-          this.collectFiles(fullPath, collected);
-        } else if (extensions.some(ext => entry.name.endsWith(ext))) {
-          collected.push(relativePath);
-        }
-      }
-    } catch {
-      // Skip unreadable directories
-    }
-    
-    return collected;
-  }
-
-  /**
-   * Generate comprehensive report
-   */
-  generateReport() {
-    const allIssues = this.results.flatMap(r => [
-      ...r.issues.deadImports,
-      ...r.issues.namespaceIssues,
-      ...r.issues.largePackageIssues
-    ]);
-
-    // Group by issue type
-    const byType = {
-      unused: allIssues.filter(i => i.issue === "unused"),
-      namespace: allIssues.filter(i => i.issue === "namespace"),
-      largePackage: allIssues.filter(i => i.issue === "largePackage")
-    };
-
-    // Find duplicate dependencies
-    const duplicates = this.findDuplicateDependencies();
-
-    // Calculate potential savings
-    const savings = this.calculatePotentialSavings(byType, duplicates);
-
-    // Generate code splitting recommendations
-    const codeSplitting = this.analyzeCodeSplitting();
-
-    // Analyze circular dependencies
-    const circular = this.findCircularDependencies();
-
-    return {
-      timestamp: new Date().toISOString(),
-      summary: {
-        filesAnalyzed: this.results.length,
-        totalIssues: allIssues.length,
-        deadImports: byType.unused.length,
-        namespaceIssues: byType.namespace.length,
-        largePackages: byType.largePackage.length,
-        duplicateDependencies: duplicates.length,
-        circularDependencies: circular.length,
-        potentialSavings: savings
-      },
-      issues: {
-        deadImports: byType.unused.map(i => ({
-          file: i.file,
-          line: i.line,
-          import: i.local,
-          from: i.module,
-          action: "Remove unused import"
-        })),
-        namespaceImports: byType.namespace.map(i => ({
-          file: i.file,
-          line: i.line,
-          import: `* as ${i.local}`,
-          from: i.module,
-          usages: i.usageCount,
-          action: "Convert to named imports for tree-shaking"
-        })),
-        largePackages: this.aggregateLargePackages(byType.largePackage),
-        duplicates,
-        circular
-      },
-      recommendations: this.generateRecommendations(byType, duplicates, codeSplitting),
-      codeSplitting
-    };
-  }
-
-  /**
-   * Find duplicate dependencies across files
-   */
-  findDuplicateDependencies() {
-    const packageVersions = new Map();
-    
-    // Read package.json and package-lock.json
-    try {
-      const lockPath = path.join(this.projectRoot, "package-lock.json");
-      if (fs.existsSync(lockPath)) {
-        const lock = JSON.parse(fs.readFileSync(lockPath, "utf8"));
-        
-        // Analyze dependencies for duplicates
-        const packages = lock.packages || lock.dependencies || {};
-        
-        for (const [pkgPath, info] of Object.entries(packages)) {
-          if (!pkgPath) continue;
-          
-          const name = pkgPath.replace(/^node_modules\//, "").split("/node_modules/").pop();
-          if (!name) continue;
-          
-          if (!packageVersions.has(name)) {
-            packageVersions.set(name, []);
-          }
-          
-          packageVersions.get(name).push({
-            version: info.version,
-            path: pkgPath
-          });
-        }
-      }
-    } catch {
-      // Skip if no lock file
-    }
-
-    const duplicates = [];
-    for (const [name, versions] of packageVersions) {
-      const uniqueVersions = [...new Set(versions.map(v => v.version))];
-      if (uniqueVersions.length > 1) {
-        duplicates.push({
-          package: name,
-          versions: uniqueVersions,
-          instances: versions.length,
-          action: "Dedupe to single version"
-        });
-      }
-    }
-
-    return duplicates;
-  }
-
-  /**
-   * Calculate potential bundle size savings
-   */
-  calculatePotentialSavings(byType, duplicates) {
-    let savings = {
-      fromDeadImports: "~0KB",
-      fromTreeShaking: "Unknown",
-      fromDedupe: "Unknown",
-      total: "Unknown"
-    };
-
-    // Estimate savings from large packages
-    const largePackageSavings = byType.largePackage.reduce((total, issue) => {
-      const size = issue.size?.match(/~?(\d+)/)?.[1];
-      return total + (parseInt(size) || 0);
-    }, 0);
-
-    if (largePackageSavings > 0) {
-      savings.fromTreeShaking = `~${largePackageSavings}KB (potential)`;
-    }
-
-    // Estimate dead import savings (rough)
-    if (byType.unused.length > 0) {
-      savings.fromDeadImports = `~${byType.unused.length * 0.5}KB (estimated)`;
-    }
-
-    return savings;
-  }
-
-  /**
-   * Analyze code splitting opportunities
-   */
-  analyzeCodeSplitting() {
-    const opportunities = [];
-    
-    // Find route-based splitting opportunities
-    const routeFiles = this.results.filter(r => 
-      r.file.includes("/pages/") || 
-      r.file.includes("/routes/") ||
-      r.file.includes("/app/")
-    );
-
-    // Find heavy components
-    for (const result of this.results) {
-      const heavyImports = result.imports.filter(i => {
-        const pkg = i.module.split("/")[0];
-        return LARGE_PACKAGES[pkg];
-      });
-
-      if (heavyImports.length > 0 && !result.file.includes("layout")) {
-        opportunities.push({
-          file: result.file,
-          type: "heavy_component",
-          heavyImports: heavyImports.map(i => i.module),
-          recommendation: "Consider lazy loading with React.lazy() or dynamic import"
-        });
-      }
-    }
-
-    // Find common chunks
-    const importCounts = new Map();
-    for (const result of this.results) {
-      for (const imp of result.imports) {
-        const key = imp.module;
-        importCounts.set(key, (importCounts.get(key) || 0) + 1);
-      }
-    }
-
-    const commonModules = [...importCounts.entries()]
-      .filter(([mod, count]) => count > 5 && !mod.startsWith("."))
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 10);
-
-    if (commonModules.length > 0) {
-      opportunities.push({
-        type: "common_chunk",
-        modules: commonModules.map(([mod, count]) => ({ module: mod, usedIn: count })),
-        recommendation: "These modules are widely used - good candidates for commons chunk"
-      });
-    }
-
-    return opportunities;
-  }
-
-  /**
-   * Find circular dependencies
-   */
-  findCircularDependencies() {
-    const circular = [];
-    const visited = new Set();
-    const stack = new Set();
-
-    const dfs = (file, path = []) => {
-      if (stack.has(file)) {
-        // Found circular dependency
-        const cycleStart = path.indexOf(file);
-        const cycle = [...path.slice(cycleStart), file];
-        circular.push(cycle);
-        return;
-      }
-      
-      if (visited.has(file)) return;
-      
-      visited.add(file);
-      stack.add(file);
-      
-      const deps = this.moduleGraph.get(file) || [];
-      for (const dep of deps) {
-        // Only check relative imports
-        if (dep.startsWith(".")) {
-          const resolved = this.resolveImport(file, dep);
-          if (resolved) {
-            dfs(resolved, [...path, file]);
-          }
-        }
-      }
-      
-      stack.delete(file);
-    };
-
-    for (const file of this.moduleGraph.keys()) {
-      dfs(file);
-    }
-
-    // Deduplicate cycles
-    const uniqueCycles = [];
-    const seen = new Set();
-    
-    for (const cycle of circular) {
-      const key = [...cycle].sort().join("->");
-      if (!seen.has(key)) {
-        seen.add(key);
-        uniqueCycles.push({
-          files: cycle,
-          length: cycle.length
-        });
-      }
-    }
-
-    return uniqueCycles;
-  }
-
-  /**
-   * Resolve relative import to file path
-   */
-  resolveImport(fromFile, importPath) {
-    const extensions = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
-    const dir = path.dirname(fromFile);
-    const basePath = path.join(dir, importPath);
-    
-    for (const ext of extensions) {
-      const resolved = basePath + ext;
-      if (this.moduleGraph.has(resolved)) {
-        return resolved;
-      }
-    }
-    
-    return null;
-  }
-
-  /**
-   * Aggregate large package issues
-   */
-  aggregateLargePackages(issues) {
-    const byPackage = new Map();
-    
-    for (const issue of issues) {
-      if (!byPackage.has(issue.package)) {
-        byPackage.set(issue.package, {
-          package: issue.package,
-          size: issue.size,
-          alternative: issue.alternative,
-          usedIn: []
-        });
-      }
-      byPackage.get(issue.package).usedIn.push(issue.file);
-    }
-    
-    return [...byPackage.values()];
-  }
-
-  /**
-   * Generate actionable recommendations
-   */
-  generateRecommendations(byType, duplicates, codeSplitting) {
-    const recommendations = [];
-
-    // Dead import recommendation
-    if (byType.unused.length > 0) {
-      recommendations.push({
-        priority: "high",
-        type: "cleanup",
-        title: "Remove Dead Imports",
-        description: `${byType.unused.length} unused imports found`,
-        impact: "Reduces bundle size and improves code clarity",
-        action: "Run ESLint with no-unused-vars or use IDE quick-fix"
-      });
-    }
-
-    // Tree-shaking recommendation
-    if (byType.namespace.length > 0) {
-      recommendations.push({
-        priority: "high",
-        type: "optimization",
-        title: "Enable Better Tree-Shaking",
-        description: `${byType.namespace.length} namespace imports could be converted`,
-        impact: "Enables bundler to remove unused code",
-        action: "Convert 'import * as X' to 'import { specific } from'"
-      });
-    }
-
-    // Large package recommendations
-    if (byType.largePackage.length > 0) {
-      const packages = [...new Set(byType.largePackage.map(i => i.package))];
-      recommendations.push({
-        priority: "high",
-        type: "replacement",
-        title: "Replace Large Dependencies",
-        description: `${packages.length} large packages found: ${packages.join(", ")}`,
-        impact: "Could reduce bundle by 100KB+",
-        action: "Consider lighter alternatives or selective imports"
-      });
-    }
-
-    // Duplicate dependencies
-    if (duplicates.length > 0) {
-      recommendations.push({
-        priority: "medium",
-        type: "dedupe",
-        title: "Deduplicate Dependencies",
-        description: `${duplicates.length} packages have multiple versions`,
-        impact: "Reduces node_modules size and potential bundle bloat",
-        action: "Run 'npm dedupe' or update version ranges"
-      });
-    }
-
-    // Code splitting
-    const heavyComponents = codeSplitting.filter(c => c.type === "heavy_component");
-    if (heavyComponents.length > 0) {
-      recommendations.push({
-        priority: "medium",
-        type: "splitting",
-        title: "Implement Code Splitting",
-        description: `${heavyComponents.length} components could be lazy loaded`,
-        impact: "Faster initial page load",
-        action: "Use React.lazy() or dynamic import() for heavy components"
-      });
-    }
-
-    return recommendations.sort((a, b) => {
-      const priority = { high: 0, medium: 1, low: 2 };
-      return priority[a.priority] - priority[b.priority];
-    });
-  }
-
-  /**
-   * Get quick fixes for common issues
-   */
-  getQuickFixes() {
-    const fixes = [];
-
-    for (const result of this.results) {
-      // Dead import fixes
-      for (const issue of result.issues.deadImports) {
-        fixes.push({
-          file: issue.file,
-          line: issue.line,
-          type: "remove",
-          description: `Remove unused import '${issue.local}'`,
-          originalImport: issue.imported,
-          module: issue.module
-        });
-      }
-
-      // Namespace import fixes
-      for (const issue of result.issues.namespaceIssues) {
-        fixes.push({
-          file: issue.file,
-          line: issue.line,
-          type: "refactor",
-          description: `Convert namespace import to named imports`,
-          original: `import * as ${issue.local} from '${issue.module}'`,
-          suggestion: `Identify used exports and import them specifically`
-        });
-      }
-    }
-
-    return fixes;
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// EXPORTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-module.exports = {
-  BundleIntelligenceEngine,
-  ImportAnalyzer,
-  LARGE_PACKAGES
-};