@openrewrite/rewrite 8.72.2 → 8.72.3

package/dist/javascript/package-json-parser.js

@@ -32,15 +32,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
 var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
@@ -180,56 +171,54 @@ class PackageJsonParser extends parser_1.Parser {
     /**
      * Creates a NodeResolutionResult marker from the package.json content and optional lock file.
      */
-    createMarker(input, dir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const content = (0, parser_1.parserInputRead)(input);
-                const packageJson = JSON.parse(content);
-                // Determine the relative path for the marker
-                const filePath = (0, parser_1.parserInputFile)(input);
-                const relativePath = this.relativeTo
-                    ? path.relative(this.relativeTo, filePath)
-                    : filePath;
-                // Try to read lock file if dependency resolution is not skipped
-                // First try the directory containing the package.json, then walk up toward relativeTo
-                let lockContent = undefined;
-                let packageManager = undefined;
-                if (!this.skipDependencyResolution) {
-                    // Resolve dir relative to relativeTo if dir is relative (e.g., '.' when package.json is at root)
-                    const absoluteDir = this.relativeTo && !path.isAbsolute(dir)
-                        ? path.resolve(this.relativeTo, dir)
-                        : dir;
-                    const lockResult = yield this.tryReadLockFileWithWalkUp(absoluteDir, this.relativeTo);
-                    lockContent = lockResult === null || lockResult === void 0 ? void 0 : lockResult.content;
-                    packageManager = lockResult === null || lockResult === void 0 ? void 0 : lockResult.packageManager;
-                }
-                // Read .npmrc configurations from all scopes
-                const projectDir = this.relativeTo || dir;
-                const npmrcConfigs = yield (0, node_resolution_result_1.readNpmrcConfigs)(projectDir);
-                // Detect workspace member paths if this is a workspace root
-                // Check both package.json workspaces (npm/yarn) and pnpm-workspace.yaml (pnpm)
-                let workspacePackagePaths;
+    async createMarker(input, dir) {
+        try {
+            const content = (0, parser_1.parserInputRead)(input);
+            const packageJson = JSON.parse(content);
+            // Determine the relative path for the marker
+            const filePath = (0, parser_1.parserInputFile)(input);
+            const relativePath = this.relativeTo
+                ? path.relative(this.relativeTo, filePath)
+                : filePath;
+            // Try to read lock file if dependency resolution is not skipped
+            // First try the directory containing the package.json, then walk up toward relativeTo
+            let lockContent = undefined;
+            let packageManager = undefined;
+            if (!this.skipDependencyResolution) {
+                // Resolve dir relative to relativeTo if dir is relative (e.g., '.' when package.json is at root)
                 const absoluteDir = this.relativeTo && !path.isAbsolute(dir)
                     ? path.resolve(this.relativeTo, dir)
                     : dir;
-                if (packageJson.workspaces) {
-                    // npm/yarn style workspaces defined in package.json
-                    workspacePackagePaths = yield this.resolveWorkspacePackagePaths(packageJson.workspaces, absoluteDir, this.relativeTo);
-                }
-                else if (packageManager === node_resolution_result_1.PackageManager.Pnpm) {
-                    // pnpm workspaces defined in pnpm-workspace.yaml
-                    const pnpmWorkspacePatterns = yield this.readPnpmWorkspacePatterns(absoluteDir);
-                    if (pnpmWorkspacePatterns && pnpmWorkspacePatterns.length > 0) {
-                        workspacePackagePaths = yield this.resolveWorkspacePackagePaths(pnpmWorkspacePatterns, absoluteDir, this.relativeTo);
-                    }
-                }
-                return (0, node_resolution_result_1.createNodeResolutionResultMarker)(relativePath, packageJson, lockContent, workspacePackagePaths, packageManager, npmrcConfigs.length > 0 ? npmrcConfigs : undefined);
-            }
-            catch (error) {
-                console.warn(`Failed to create NodeResolutionResult marker: ${error}`);
-                return null;
-            }
-        });
+                const lockResult = await this.tryReadLockFileWithWalkUp(absoluteDir, this.relativeTo);
+                lockContent = lockResult === null || lockResult === void 0 ? void 0 : lockResult.content;
+                packageManager = lockResult === null || lockResult === void 0 ? void 0 : lockResult.packageManager;
+            }
+            // Read .npmrc configurations from all scopes
+            const projectDir = this.relativeTo || dir;
+            const npmrcConfigs = await (0, node_resolution_result_1.readNpmrcConfigs)(projectDir);
+            // Detect workspace member paths if this is a workspace root
+            // Check both package.json workspaces (npm/yarn) and pnpm-workspace.yaml (pnpm)
+            let workspacePackagePaths;
+            const absoluteDir = this.relativeTo && !path.isAbsolute(dir)
+                ? path.resolve(this.relativeTo, dir)
+                : dir;
+            if (packageJson.workspaces) {
+                // npm/yarn style workspaces defined in package.json
+                workspacePackagePaths = await this.resolveWorkspacePackagePaths(packageJson.workspaces, absoluteDir, this.relativeTo);
+            }
+            else if (packageManager === node_resolution_result_1.PackageManager.Pnpm) {
+                // pnpm workspaces defined in pnpm-workspace.yaml
+                const pnpmWorkspacePatterns = await this.readPnpmWorkspacePatterns(absoluteDir);
+                if (pnpmWorkspacePatterns && pnpmWorkspacePatterns.length > 0) {
+                    workspacePackagePaths = await this.resolveWorkspacePackagePaths(pnpmWorkspacePatterns, absoluteDir, this.relativeTo);
+                }
+            }
+            return (0, node_resolution_result_1.createNodeResolutionResultMarker)(relativePath, packageJson, lockContent, workspacePackagePaths, packageManager, npmrcConfigs.length > 0 ? npmrcConfigs : undefined);
+        }
+        catch (error) {
+            console.warn(`Failed to create NodeResolutionResult marker: ${error}`);
+            return null;
+        }
     }
     /**
      * Resolves workspace glob patterns to actual package.json paths.
@@ -244,74 +233,70 @@ class PackageJsonParser extends parser_1.Parser {
      * @param relativeTo Optional base path for creating relative paths
      * @returns Array of relative paths to workspace member package.json files
      */
-    resolveWorkspacePackagePaths(workspaces, projectDir, relativeTo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Normalize workspaces to array format
-            const patterns = Array.isArray(workspaces)
-                ? workspaces
-                : workspaces.packages;
-            if (!patterns || patterns.length === 0) {
-                return undefined;
-            }
-            // Separate include and exclude patterns
-            const includePatterns = patterns.filter(p => !p.startsWith('!'));
-            const excludePatterns = patterns.filter(p => p.startsWith('!')).map(p => p.slice(1));
-            // Create picomatch matchers
-            const isIncluded = includePatterns.length > 0
-                ? (0, picomatch_1.default)(includePatterns, { dot: false })
-                : () => false;
-            const isExcluded = excludePatterns.length > 0
-                ? (0, picomatch_1.default)(excludePatterns, { dot: false })
-                : () => false;
-            // Collect all candidate directories by walking the project
-            const candidateDirs = yield this.collectCandidateWorkspaceDirs(projectDir, includePatterns);
-            const memberPaths = [];
-            const basePath = relativeTo || projectDir;
-            for (const candidateDir of candidateDirs) {
-                // Get relative path from project root for pattern matching
-                const relativeDir = path.relative(projectDir, candidateDir);
-                // Check if directory matches include patterns and not exclude patterns
-                if (isIncluded(relativeDir) && !isExcluded(relativeDir)) {
-                    const packageJsonPath = path.join(candidateDir, 'package.json');
-                    if (fs.existsSync(packageJsonPath)) {
-                        const relativePath = path.relative(basePath, packageJsonPath);
-                        memberPaths.push(relativePath);
-                    }
+    async resolveWorkspacePackagePaths(workspaces, projectDir, relativeTo) {
+        // Normalize workspaces to array format
+        const patterns = Array.isArray(workspaces)
+            ? workspaces
+            : workspaces.packages;
+        if (!patterns || patterns.length === 0) {
+            return undefined;
+        }
+        // Separate include and exclude patterns
+        const includePatterns = patterns.filter(p => !p.startsWith('!'));
+        const excludePatterns = patterns.filter(p => p.startsWith('!')).map(p => p.slice(1));
+        // Create picomatch matchers
+        const isIncluded = includePatterns.length > 0
+            ? (0, picomatch_1.default)(includePatterns, { dot: false })
+            : () => false;
+        const isExcluded = excludePatterns.length > 0
+            ? (0, picomatch_1.default)(excludePatterns, { dot: false })
+            : () => false;
+        // Collect all candidate directories by walking the project
+        const candidateDirs = await this.collectCandidateWorkspaceDirs(projectDir, includePatterns);
+        const memberPaths = [];
+        const basePath = relativeTo || projectDir;
+        for (const candidateDir of candidateDirs) {
+            // Get relative path from project root for pattern matching
+            const relativeDir = path.relative(projectDir, candidateDir);
+            // Check if directory matches include patterns and not exclude patterns
+            if (isIncluded(relativeDir) && !isExcluded(relativeDir)) {
+                const packageJsonPath = path.join(candidateDir, 'package.json');
+                if (fs.existsSync(packageJsonPath)) {
+                    const relativePath = path.relative(basePath, packageJsonPath);
+                    memberPaths.push(relativePath);
                 }
             }
-            return memberPaths.length > 0 ? memberPaths : undefined;
-        });
+        }
+        return memberPaths.length > 0 ? memberPaths : undefined;
     }
     /**
      * Collects candidate directories that might match workspace patterns.
      * Uses the patterns to determine how deep to scan.
      */
-    collectCandidateWorkspaceDirs(projectDir, patterns) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const candidates = [];
-            // Determine the maximum depth we need to scan based on patterns
-            // "packages/*" -> depth 1 under packages/
-            // "packages/**" -> unlimited depth under packages/
-            // "{apps,libs}/*" -> depth 1 under apps/ and libs/
-            for (const pattern of patterns) {
-                // Extract base directories from pattern (before any wildcards)
-                const baseDirs = this.extractBaseDirs(pattern);
-                const hasRecursive = pattern.includes('**');
-                for (const baseDir of baseDirs) {
-                    const absoluteBaseDir = path.join(projectDir, baseDir);
-                    if (!fs.existsSync(absoluteBaseDir)) {
-                        continue;
-                    }
-                    // Use walkDirs with appropriate depth limit
-                    const dirs = yield (0, path_utils_1.walkDirs)(absoluteBaseDir, {
-                        maxDepth: hasRecursive ? undefined : 0,
-                        excludeDirs: path_utils_1.DEFAULT_DIR_EXCLUSIONS
-                    });
-                    candidates.push(...dirs);
+    async collectCandidateWorkspaceDirs(projectDir, patterns) {
+        const candidates = [];
+        // Determine the maximum depth we need to scan based on patterns
+        // "packages/*" -> depth 1 under packages/
+        // "packages/**" -> unlimited depth under packages/
+        // "{apps,libs}/*" -> depth 1 under apps/ and libs/
+        for (const pattern of patterns) {
+            // Extract base directories from pattern (before any wildcards)
+            const baseDirs = this.extractBaseDirs(pattern);
+            const hasRecursive = pattern.includes('**');
+            for (const baseDir of baseDirs) {
+                const absoluteBaseDir = path.join(projectDir, baseDir);
+                if (!fs.existsSync(absoluteBaseDir)) {
+                    continue;
                 }
+                // Use walkDirs with appropriate depth limit
+                const dirs = await (0, path_utils_1.walkDirs)(absoluteBaseDir, {
+                    maxDepth: hasRecursive ? undefined : 0,
+                    excludeDirs: path_utils_1.DEFAULT_DIR_EXCLUSIONS
+                });
+                candidates.push(...dirs);
             }
-            return candidates;
-        });
+        }
+        return candidates;
     }
     /**
      * Extracts base directory paths from a glob pattern.
@@ -346,22 +331,20 @@ class PackageJsonParser extends parser_1.Parser {
      * @param projectDir The absolute path to the project directory
      * @returns Array of workspace patterns, or undefined if file doesn't exist
      */
-    readPnpmWorkspacePatterns(projectDir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pnpmWorkspacePath = path.join(projectDir, 'pnpm-workspace.yaml');
-            try {
-                const content = yield fsp.readFile(pnpmWorkspacePath, 'utf-8');
-                const parsed = YAML.parse(content);
-                if (parsed && Array.isArray(parsed.packages)) {
-                    return parsed.packages;
-                }
-                return undefined;
-            }
-            catch (_a) {
-                // File doesn't exist or couldn't be parsed
-                return undefined;
+    async readPnpmWorkspacePatterns(projectDir) {
+        const pnpmWorkspacePath = path.join(projectDir, 'pnpm-workspace.yaml');
+        try {
+            const content = await fsp.readFile(pnpmWorkspacePath, 'utf-8');
+            const parsed = YAML.parse(content);
+            if (parsed && Array.isArray(parsed.packages)) {
+                return parsed.packages;
             }
-        });
+            return undefined;
+        }
+        catch (_a) {
+            // File doesn't exist or couldn't be parsed
+            return undefined;
+        }
     }
     /**
      * Attempts to find and read a lock file by walking up the directory tree.
@@ -375,30 +358,28 @@ class PackageJsonParser extends parser_1.Parser {
      * @param rootDir Optional root directory to stop walking at (e.g., relativeTo/git root)
      * @returns Object with parsed lock file content and detected package manager, or undefined if none found
      */
-    tryReadLockFileWithWalkUp(startDir, rootDir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Normalize paths for comparison
-            const normalizedRoot = rootDir ? path.resolve(rootDir) : undefined;
-            let currentDir = path.resolve(startDir);
-            // Walk up the directory tree looking for a lock file
-            while (true) {
-                const result = yield this.tryReadLockFile(currentDir);
-                if (result) {
-                    return result;
-                }
-                // If we've reached rootDir, stop walking (don't go above it)
-                if (normalizedRoot && currentDir === normalizedRoot) {
-                    break;
-                }
-                // Check if we've reached the filesystem root
-                const parentDir = path.dirname(currentDir);
-                if (parentDir === currentDir) {
-                    break;
-                }
-                currentDir = parentDir;
-            }
-            return undefined;
-        });
+    async tryReadLockFileWithWalkUp(startDir, rootDir) {
+        // Normalize paths for comparison
+        const normalizedRoot = rootDir ? path.resolve(rootDir) : undefined;
+        let currentDir = path.resolve(startDir);
+        // Walk up the directory tree looking for a lock file
+        while (true) {
+            const result = await this.tryReadLockFile(currentDir);
+            if (result) {
+                return result;
+            }
+            // If we've reached rootDir, stop walking (don't go above it)
+            if (normalizedRoot && currentDir === normalizedRoot) {
+                break;
+            }
+            // Check if we've reached the filesystem root
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) {
+                break;
+            }
+            currentDir = parentDir;
+        }
+        return undefined;
     }
     /**
      * Attempts to read and parse a lock file from the given directory.
@@ -406,76 +387,72 @@ class PackageJsonParser extends parser_1.Parser {
      *
      * @returns Object with parsed lock file content and detected package manager, or undefined if no lock file found
      */
-    tryReadLockFile(dir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            // Use shared lock file detection config (first match wins based on priority)
-            for (const config of (0, package_manager_1.getLockFileDetectionConfig)()) {
-                const lockPath = path.join(dir, config.filename);
-                if (!fs.existsSync(lockPath)) {
-                    continue;
-                }
-                // Lock file exists - determine package manager
-                // Once we find a lock file, we commit to this package manager even if parsing fails
-                try {
-                    const fileContent = yield fsp.readFile(lockPath, 'utf-8');
-                    const packageManager = typeof config.packageManager === 'function'
-                        ? config.packageManager(fileContent)
-                        : config.packageManager;
-                    // For package managers where lock file omits details, prefer node_modules
-                    if (config.preferNodeModules) {
-                        const parsed = yield this.walkNodeModules(dir);
-                        if (parsed) {
-                            return { content: parsed, packageManager };
-                        }
-                    }
-                    // Parse lock file based on package manager
-                    const content = yield this.parseLockFileContent(config.filename, fileContent, dir);
-                    if (content) {
-                        return { content, packageManager };
+    async tryReadLockFile(dir) {
+        var _a;
+        // Use shared lock file detection config (first match wins based on priority)
+        for (const config of (0, package_manager_1.getLockFileDetectionConfig)()) {
+            const lockPath = path.join(dir, config.filename);
+            if (!fs.existsSync(lockPath)) {
+                continue;
+            }
+            // Lock file exists - determine package manager
+            // Once we find a lock file, we commit to this package manager even if parsing fails
+            try {
+                const fileContent = await fsp.readFile(lockPath, 'utf-8');
+                const packageManager = typeof config.packageManager === 'function'
+                    ? config.packageManager(fileContent)
+                    : config.packageManager;
+                // For package managers where lock file omits details, prefer node_modules
+                if (config.preferNodeModules) {
+                    const parsed = await this.walkNodeModules(dir);
+                    if (parsed) {
+                        return { content: parsed, packageManager };
                     }
-                    // Lock file exists but couldn't be parsed - still return the package manager
-                    // This ensures we use the correct package manager even without resolved dependencies
-                    return { content: { lockfileVersion: 0, packages: {} }, packageManager };
                 }
-                catch (error) {
-                    (_a = console.debug) === null || _a === void 0 ? void 0 : _a.call(console, `Failed to parse ${config.filename}: ${error}`);
-                    // Even on error, we found this lock file - return the package manager with empty content
-                    const packageManager = typeof config.packageManager === 'function'
-                        ? node_resolution_result_1.PackageManager.YarnClassic // Default for yarn.lock if we can't read content
-                        : config.packageManager;
-                    return { content: { lockfileVersion: 0, packages: {} }, packageManager };
+                // Parse lock file based on package manager
+                const content = await this.parseLockFileContent(config.filename, fileContent, dir);
+                if (content) {
+                    return { content, packageManager };
                 }
+                // Lock file exists but couldn't be parsed - still return the package manager
+                // This ensures we use the correct package manager even without resolved dependencies
+                return { content: { lockfileVersion: 0, packages: {} }, packageManager };
             }
-            // Fallback: if node_modules exists but no lock file was found (e.g., symlinked from another workspace),
-            // walk node_modules to get resolved dependency information
-            const parsed = yield this.walkNodeModules(dir);
-            if (parsed) {
-                // Assume npm as the default package manager when only node_modules exists
-                return { content: parsed, packageManager: node_resolution_result_1.PackageManager.Npm };
+            catch (error) {
+                (_a = console.debug) === null || _a === void 0 ? void 0 : _a.call(console, `Failed to parse ${config.filename}: ${error}`);
+                // Even on error, we found this lock file - return the package manager with empty content
+                const packageManager = typeof config.packageManager === 'function'
+                    ? node_resolution_result_1.PackageManager.YarnClassic // Default for yarn.lock if we can't read content
+                    : config.packageManager;
+                return { content: { lockfileVersion: 0, packages: {} }, packageManager };
             }
-            return undefined;
-        });
+        }
+        // Fallback: if node_modules exists but no lock file was found (e.g., symlinked from another workspace),
+        // walk node_modules to get resolved dependency information
+        const parsed = await this.walkNodeModules(dir);
+        if (parsed) {
+            // Assume npm as the default package manager when only node_modules exists
+            return { content: parsed, packageManager: node_resolution_result_1.PackageManager.Npm };
+        }
+        return undefined;
     }
     /**
      * Parses lock file content based on the lock file type.
      */
-    parseLockFileContent(filename, content, dir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (filename) {
-                case 'package-lock.json':
-                    return JSON.parse(content);
-                case 'bun.lock':
-                    return this.convertBunLockToNpmFormat(this.parseJsonc(content));
-                case 'pnpm-lock.yaml':
-                    // Fall back to pnpm CLI when node_modules unavailable
-                    return this.getPnpmDependencies(dir);
-                case 'yarn.lock':
-                    return this.parseYarnLock(content);
-                default:
-                    return undefined;
-            }
-        });
+    async parseLockFileContent(filename, content, dir) {
+        switch (filename) {
+            case 'package-lock.json':
+                return JSON.parse(content);
+            case 'bun.lock':
+                return this.convertBunLockToNpmFormat(this.parseJsonc(content));
+            case 'pnpm-lock.yaml':
+                // Fall back to pnpm CLI when node_modules unavailable
+                return this.getPnpmDependencies(dir);
+            case 'yarn.lock':
+                return this.parseYarnLock(content);
+            default:
+                return undefined;
+        }
     }
     /**
      * Parses JSONC (JSON with Comments and trailing commas) content.
@@ -492,82 +469,78 @@ class PackageJsonParser extends parser_1.Parser {
      * @param dir The project directory containing node_modules
      * @returns npm package-lock.json format with packages map, or undefined if node_modules doesn't exist
      */
-    walkNodeModules(dir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const nodeModulesPath = path.join(dir, 'node_modules');
-            if (!fs.existsSync(nodeModulesPath)) {
-                return undefined;
-            }
-            const packages = {
-                "": {} // Root package placeholder
-            };
-            // Check if this is a pnpm project (has .pnpm directory)
-            const pnpmPath = path.join(nodeModulesPath, '.pnpm');
-            if (fs.existsSync(pnpmPath)) {
-                yield this.walkPnpmNodeModules(pnpmPath, packages);
-            }
-            else {
-                yield this.walkNodeModulesRecursive(nodeModulesPath, 'node_modules', packages);
-            }
-            return Object.keys(packages).length > 1 ? {
-                lockfileVersion: 3,
-                packages
-            } : undefined;
-        });
+    async walkNodeModules(dir) {
+        const nodeModulesPath = path.join(dir, 'node_modules');
+        if (!fs.existsSync(nodeModulesPath)) {
+            return undefined;
+        }
+        const packages = {
+            "": {} // Root package placeholder
+        };
+        // Check if this is a pnpm project (has .pnpm directory)
+        const pnpmPath = path.join(nodeModulesPath, '.pnpm');
+        if (fs.existsSync(pnpmPath)) {
+            await this.walkPnpmNodeModules(pnpmPath, packages);
+        }
+        else {
+            await this.walkNodeModulesRecursive(nodeModulesPath, 'node_modules', packages);
+        }
+        return Object.keys(packages).length > 1 ? {
+            lockfileVersion: 3,
+            packages
+        } : undefined;
     }
     /**
      * Walks pnpm's .pnpm directory structure to build packages map.
      * pnpm stores packages in .pnpm/<name>@<version>/node_modules/<name>/
      */
-    walkPnpmNodeModules(pnpmPath, packages) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let entries;
+    async walkPnpmNodeModules(pnpmPath, packages) {
+        let entries;
+        try {
+            entries = await fsp.readdir(pnpmPath, { withFileTypes: true });
+        }
+        catch (_a) {
+            return;
+        }
+        // Process entries in parallel for better performance
+        await Promise.all(entries.map(async (entry) => {
+            // Skip non-directories and special files
+            if (!entry.isDirectory() || entry.name === 'node_modules') {
+                return;
+            }
+            // Parse name@version from directory name
+            // pnpm directory format: <name>@<version> or <name>@<version>_<peer-deps-context>
+            // Handle scoped packages: @scope+name@version
+            // Example: @babel+helper-module-transforms@7.28.3_@babel+core@7.28.5
+            //   -> name: @babel/helper-module-transforms, version: 7.28.3
+            // First, strip peer dependency context (everything after first _)
+            const underscoreIndex = entry.name.indexOf('_');
+            const mainPart = underscoreIndex > 0 ? entry.name.substring(0, underscoreIndex) : entry.name;
+            // Now parse name@version from the main part
+            const atIndex = mainPart.lastIndexOf('@');
+            if (atIndex <= 0)
+                return;
+            let name = mainPart.substring(0, atIndex);
+            const version = mainPart.substring(atIndex + 1);
+            // pnpm encodes @ as + in scoped packages: @scope+name -> @scope/name
+            if (name.startsWith('@') && name.includes('+')) {
+                name = name.replace('+', '/');
+            }
+            // The actual package is at .pnpm/<name>@<version>/node_modules/<name>/
+            const pkgDir = path.join(pnpmPath, entry.name, 'node_modules', name.replace('/', path.sep));
+            const packageJsonPath = path.join(pkgDir, 'package.json');
+            let pkgJson;
             try {
-                entries = yield fsp.readdir(pnpmPath, { withFileTypes: true });
+                const content = await fsp.readFile(packageJsonPath, 'utf-8');
+                pkgJson = JSON.parse(content);
             }
             catch (_a) {
                 return;
             }
-            // Process entries in parallel for better performance
-            yield Promise.all(entries.map((entry) => __awaiter(this, void 0, void 0, function* () {
-                // Skip non-directories and special files
-                if (!entry.isDirectory() || entry.name === 'node_modules') {
-                    return;
-                }
-                // Parse name@version from directory name
-                // pnpm directory format: <name>@<version> or <name>@<version>_<peer-deps-context>
-                // Handle scoped packages: @scope+name@version
-                // Example: @babel+helper-module-transforms@7.28.3_@babel+core@7.28.5
-                //   -> name: @babel/helper-module-transforms, version: 7.28.3
-                // First, strip peer dependency context (everything after first _)
-                const underscoreIndex = entry.name.indexOf('_');
-                const mainPart = underscoreIndex > 0 ? entry.name.substring(0, underscoreIndex) : entry.name;
-                // Now parse name@version from the main part
-                const atIndex = mainPart.lastIndexOf('@');
-                if (atIndex <= 0)
-                    return;
-                let name = mainPart.substring(0, atIndex);
-                const version = mainPart.substring(atIndex + 1);
-                // pnpm encodes @ as + in scoped packages: @scope+name -> @scope/name
-                if (name.startsWith('@') && name.includes('+')) {
-                    name = name.replace('+', '/');
-                }
-                // The actual package is at .pnpm/<name>@<version>/node_modules/<name>/
-                const pkgDir = path.join(pnpmPath, entry.name, 'node_modules', name.replace('/', path.sep));
-                const packageJsonPath = path.join(pkgDir, 'package.json');
-                let pkgJson;
-                try {
-                    const content = yield fsp.readFile(packageJsonPath, 'utf-8');
-                    pkgJson = JSON.parse(content);
-                }
-                catch (_a) {
-                    return;
-                }
-                // Use name@version as the key for pnpm (flat structure with version)
-                const pkgKey = `node_modules/${name}@${version}`;
-                packages[pkgKey] = PackageJsonParser.extractPackageMetadata(pkgJson, version);
-            })));
-        });
+            // Use name@version as the key for pnpm (flat structure with version)
+            const pkgKey = `node_modules/${name}@${version}`;
+            packages[pkgKey] = PackageJsonParser.extractPackageMetadata(pkgJson, version);
+        }));
     }
     /**
      * Recursively walks a node_modules directory, reading package.json files
@@ -577,79 +550,75 @@ class PackageJsonParser extends parser_1.Parser {
      * @param relativePath Relative path from project root (e.g., "node_modules" or "node_modules/foo/node_modules")
      * @param packages The packages map to populate
      */
-    walkNodeModulesRecursive(nodeModulesPath, relativePath, packages) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let entries;
-            try {
-                entries = yield fsp.readdir(nodeModulesPath, { withFileTypes: true });
+    async walkNodeModulesRecursive(nodeModulesPath, relativePath, packages) {
+        let entries;
+        try {
+            entries = await fsp.readdir(nodeModulesPath, { withFileTypes: true });
+        }
+        catch (_a) {
+            return; // Directory not readable
+        }
+        // Process entries in parallel for better performance
+        await Promise.all(entries.map(async (entry) => {
+            // Skip hidden files
+            if (entry.name.startsWith('.')) {
+                return;
             }
-            catch (_a) {
-                return; // Directory not readable
+            // Accept directories and symlinks (pnpm uses symlinks)
+            const isDirectoryOrSymlink = entry.isDirectory() || entry.isSymbolicLink();
+            if (!isDirectoryOrSymlink) {
+                return;
             }
-            // Process entries in parallel for better performance
-            yield Promise.all(entries.map((entry) => __awaiter(this, void 0, void 0, function* () {
-                // Skip hidden files
-                if (entry.name.startsWith('.')) {
-                    return;
+            // Handle scoped packages (@scope/name)
+            if (entry.name.startsWith('@')) {
+                const scopePath = path.join(nodeModulesPath, entry.name);
+                let scopeEntries;
+                try {
+                    scopeEntries = await fsp.readdir(scopePath, { withFileTypes: true });
                 }
-                // Accept directories and symlinks (pnpm uses symlinks)
-                const isDirectoryOrSymlink = entry.isDirectory() || entry.isSymbolicLink();
-                if (!isDirectoryOrSymlink) {
+                catch (_a) {
                     return;
                 }
-                // Handle scoped packages (@scope/name)
-                if (entry.name.startsWith('@')) {
-                    const scopePath = path.join(nodeModulesPath, entry.name);
-                    let scopeEntries;
-                    try {
-                        scopeEntries = yield fsp.readdir(scopePath, { withFileTypes: true });
-                    }
-                    catch (_a) {
+                await Promise.all(scopeEntries.map(async (scopeEntry) => {
+                    // Accept directories and symlinks for scoped packages too
+                    if (!scopeEntry.isDirectory() && !scopeEntry.isSymbolicLink())
                         return;
-                    }
-                    yield Promise.all(scopeEntries.map((scopeEntry) => __awaiter(this, void 0, void 0, function* () {
-                        // Accept directories and symlinks for scoped packages too
-                        if (!scopeEntry.isDirectory() && !scopeEntry.isSymbolicLink())
-                            return;
-                        const scopedName = `${entry.name}/${scopeEntry.name}`;
-                        const pkgPath = path.join(scopePath, scopeEntry.name);
-                        yield this.processPackage(pkgPath, `${relativePath}/${scopedName}`, packages);
-                    })));
-                }
-                else {
-                    const pkgPath = path.join(nodeModulesPath, entry.name);
-                    yield this.processPackage(pkgPath, `${relativePath}/${entry.name}`, packages);
-                }
-            })));
-        });
+                    const scopedName = `${entry.name}/${scopeEntry.name}`;
+                    const pkgPath = path.join(scopePath, scopeEntry.name);
+                    await this.processPackage(pkgPath, `${relativePath}/${scopedName}`, packages);
+                }));
+            }
+            else {
+                const pkgPath = path.join(nodeModulesPath, entry.name);
+                await this.processPackage(pkgPath, `${relativePath}/${entry.name}`, packages);
+            }
+        }));
     }
     /**
      * Processes a single package directory, reading its package.json and
      * recursively processing nested node_modules.
      */
-    processPackage(pkgPath, relativePath, packages) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const packageJsonPath = path.join(pkgPath, 'package.json');
-            // Read and parse the package's package.json
-            let pkgJson;
-            try {
-                const content = yield fsp.readFile(packageJsonPath, 'utf-8');
-                pkgJson = JSON.parse(content);
-            }
-            catch (_a) {
-                return; // Not a valid package
-            }
-            packages[relativePath] = PackageJsonParser.extractPackageMetadata(pkgJson);
-            // Recursively process nested node_modules
-            const nestedNodeModules = path.join(pkgPath, 'node_modules');
-            try {
-                yield fsp.access(nestedNodeModules);
-                yield this.walkNodeModulesRecursive(nestedNodeModules, `${relativePath}/node_modules`, packages);
-            }
-            catch (_b) {
-                // No nested node_modules, that's fine
-            }
-        });
+    async processPackage(pkgPath, relativePath, packages) {
+        const packageJsonPath = path.join(pkgPath, 'package.json');
+        // Read and parse the package's package.json
+        let pkgJson;
+        try {
+            const content = await fsp.readFile(packageJsonPath, 'utf-8');
+            pkgJson = JSON.parse(content);
+        }
+        catch (_a) {
+            return; // Not a valid package
+        }
+        packages[relativePath] = PackageJsonParser.extractPackageMetadata(pkgJson);
+        // Recursively process nested node_modules
+        const nestedNodeModules = path.join(pkgPath, 'node_modules');
+        try {
+            await fsp.access(nestedNodeModules);
+            await this.walkNodeModulesRecursive(nestedNodeModules, `${relativePath}/node_modules`, packages);
+        }
+        catch (_b) {
+            // No nested node_modules, that's fine
+        }
     }
     /**
      * Converts bun.lock format to npm package-lock.json format for unified processing.