knip 6.34.0 → 6.35.0

package/dist/CatalogCounselor.d.ts

@@ -6,12 +6,14 @@ export type CatalogContainer = {
     filePath: string;
     catalog?: Catalog;
     catalogs?: Catalogs;
+    overrides?: Catalog;
 };
 export declare class CatalogCounselor {
     private filePath;
     private entries;
     private referencedEntries;
     private referenceIssues;
+    private overrideReferences;
     private fileContent?;
     constructor(options: MainOptions);
     private addReferencedCatalogEntry;

package/dist/CatalogCounselor.js

@@ -2,7 +2,7 @@ import { readFile } from 'node:fs/promises';
 import { ROOT_WORKSPACE_NAME } from './constants.js';
 import { JsonCatalogPeeker } from './JsonCatalogPeeker.js';
 import { PackagePeeker } from './PackagePeeker.js';
-import { extractCatalogReferences, parseCatalog } from './util/catalog.js';
+import { extractCatalogReferences, getOverrideCatalogReferences, parseCatalog, } from './util/catalog.js';
 import { extname } from './util/path.js';
 import { YamlCatalogPeeker } from './YamlCatalogPeeker.js';
 export class CatalogCounselor {
@@ -10,10 +10,14 @@ export class CatalogCounselor {
     entries = new Set();
     referencedEntries = new Set();
     referenceIssues = [];
+    overrideReferences = [];
     fileContent;
     constructor(options) {
         this.filePath = options.catalog.filePath;
         this.entries = parseCatalog(options.catalog);
+        this.overrideReferences = getOverrideCatalogReferences(options.catalog.overrides);
+        for (const reference of this.overrideReferences)
+            this.addReference(reference);
     }
     addReferencedCatalogEntry(entryName) {
         this.referencedEntries.add(entryName);
@@ -23,14 +27,18 @@ export class CatalogCounselor {
     }
     addWorkspace({ name: workspace, manifest, manifestPath: filePath, manifestStr, }) {
         const catalogReferences = extractCatalogReferences(manifest);
+        if (workspace === ROOT_WORKSPACE_NAME) {
+            for (const reference of getOverrideCatalogReferences(manifest.pnpm?.overrides))
+                catalogReferences.push(reference);
+        }
         if (catalogReferences.length === 0)
             return;
         const peeker = new PackagePeeker(manifestStr);
-        for (const { catalogName, packageName } of catalogReferences) {
+        for (const { catalogName, packageName, selector } of catalogReferences) {
             const catalogEntryName = `${catalogName}:${packageName}`;
             this.addReferencedCatalogEntry(catalogEntryName);
             if (!this.entries.has(catalogEntryName)) {
-                const pos = peeker.getCatalogReferenceLocation(packageName, catalogName);
+                const pos = peeker.getCatalogReferenceLocation(selector ?? packageName, catalogName);
                 this.referenceIssues.push({
                     type: 'catalogReferences',
                     filePath,
@@ -47,11 +55,12 @@ export class CatalogCounselor {
         const filePath = this.filePath;
         const workspace = ROOT_WORKSPACE_NAME;
         const catalogIssues = [];
-        if (this.entries.size > 0) {
+        const overrideReferenceIssues = [];
+        if (this.entries.size > 0 || this.overrideReferences.length > 0) {
             this.fileContent = await readFile(filePath, 'utf-8');
             const isYaml = ['.yml', '.yaml'].includes(extname(filePath));
-            const Peeker = isYaml ? YamlCatalogPeeker : JsonCatalogPeeker;
-            const peeker = new Peeker(this.fileContent);
+            const yamlPeeker = isYaml ? new YamlCatalogPeeker(this.fileContent) : undefined;
+            const peeker = yamlPeeker ?? new JsonCatalogPeeker(this.fileContent);
             for (const entry of this.entries.keys()) {
                 if (!this.referencedEntries.has(entry)) {
                     const [parentSymbol, symbol] = entry.split(':');
@@ -62,7 +71,21 @@ export class CatalogCounselor {
                     catalogIssues.push({ type: 'catalog', filePath, workspace, symbol, parentSymbol, fixes, ...pos });
                 }
             }
+            for (const { catalogName, packageName, selector } of this.overrideReferences) {
+                if (this.entries.has(`${catalogName}:${packageName}`))
+                    continue;
+                const pos = yamlPeeker?.getOverrideCatalogReferenceLocation(selector);
+                overrideReferenceIssues.push({
+                    type: 'catalogReferences',
+                    filePath,
+                    workspace,
+                    symbol: packageName,
+                    parentSymbol: catalogName,
+                    fixes: [],
+                    ...pos,
+                });
+            }
         }
-        return [...catalogIssues, ...this.referenceIssues];
+        return [...catalogIssues, ...this.referenceIssues, ...overrideReferenceIssues];
     }
 }

package/dist/ConfigurationChief.d.ts

@@ -377,6 +377,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        mise?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         mocha?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1058,6 +1063,7 @@ export declare class ConfigurationChief {
         mdx?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         mdxlint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         metro?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        mise?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         mocha?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         moonrepo?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         msw?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/ConfigurationChief.js

@@ -1,4 +1,5 @@
 import picomatch from 'picomatch';
+import { normalizeCompilers } from './compilers/index.js';
 import { DEFAULT_EXTENSIONS, ROOT_WORKSPACE_NAME } from './constants.js';
 import { pluginNames } from './types/PluginNames.js';
 import { arrayify, compact, partition } from './util/array.js';
@@ -41,8 +42,7 @@ const defaultConfig = {
     ignoreWorkspaces: [],
     ignoreExportsUsedInFile: false,
     isIncludeEntryExports: false,
-    syncCompilers: new Map(),
-    asyncCompilers: new Map(),
+    compilers: new Map(),
     rootPluginConfigs: {},
 };
 export class ConfigurationChief {
@@ -108,7 +108,6 @@ export class ConfigurationChief {
         const ignoreIssues = rawConfig.ignoreIssues ?? {};
         const ignoreWorkspaces = rawConfig.ignoreWorkspaces ?? defaultConfig.ignoreWorkspaces;
         const isIncludeEntryExports = rawConfig.includeEntryExports ?? this.isIncludeEntryExports;
-        const { syncCompilers, asyncCompilers } = rawConfig;
         const rootPluginConfigs = {};
         for (const [pluginName, pluginConfig] of Object.entries(rawConfig)) {
             if (isPluginName(pluginName)) {
@@ -127,8 +126,7 @@ export class ConfigurationChief {
             ignoreIssues,
             ignoreWorkspaces,
             isIncludeEntryExports,
-            syncCompilers: new Map(Object.entries(syncCompilers ?? {})),
-            asyncCompilers: new Map(Object.entries(asyncCompilers ?? {})),
+            compilers: normalizeCompilers(rawConfig),
             rootPluginConfigs,
         };
     }

package/dist/ProjectPrincipal.d.ts

@@ -1,6 +1,6 @@
 import type { ParseResult } from 'oxc-parser';
 import { CacheConsultant } from './CacheConsultant.ts';
-import type { AsyncCompilers, Compilers, SyncCompilers } from './compilers/types.ts';
+import type { Compilers } from './compilers/types.ts';
 import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile, PluginVisitorContext, PluginVisitorObject } from './types/config.ts';
 import type { FileNode, ModuleGraph } from './types/module-graph.ts';
 import type { Paths } from './types/project.ts';
@@ -13,14 +13,13 @@ export declare class ProjectPrincipal {
     projectPaths: Set<string>;
     programPaths: Set<string>;
     skipExportsAnalysis: Set<string>;
+    private includeExportsAnalysis;
     pluginCtx: PluginVisitorContext;
     pluginVisitorObjects: PluginVisitorObject[];
     private _visitor;
     private _localRefsVisitor;
-    syncCompilers: SyncCompilers;
-    asyncCompilers: AsyncCompilers;
-    private scopedSyncCompilers;
-    private scopedAsyncCompilers;
+    compilers: Compilers;
+    private scopedCompilers;
     private paths;
     private rootDirs;
     private tsConfigFile;
@@ -29,6 +28,7 @@ export declare class ProjectPrincipal {
     toSourceFilePath: ToSourceFilePath;
     private findWorkspacePackageTarget;
     private findWorkspaceNameByFilePath;
+    private isReportExports;
     fileManager: SourceFileManager;
     private resolveModule;
     resolveGlobPattern: ResolveGlobPattern;
@@ -40,7 +40,6 @@ export declare class ProjectPrincipal {
     addPaths(paths: Paths, basePath: string, scope: string): void;
     addRootDirs(rootDirs: string[] | undefined, scope: string): void;
     init(): void;
-    readFile(filePath: string): string;
     private hasAcceptedExtension;
     addEntryPath(filePath: string, options?: {
         skipExportsAnalysis: boolean;
@@ -51,12 +50,12 @@ export declare class ProjectPrincipal {
     addProgramPath(filePath: string): void;
     addProjectPath(filePath: string): void;
     removeProjectPath(filePath: string): void;
-    runAsyncCompilers(): Promise<void>;
-    walkAndAnalyze(analyzeFile: (filePath: string, parseResult: ParseResult | undefined, sourceText: string, cachedFile?: FileNode) => Iterable<string> | undefined): void;
-    getUsedResolvedFiles(): string[];
+    walkAndAnalyze(analyzeFile: (filePath: string, parseResult: ParseResult | undefined, sourceText: string, cachedFile?: FileNode) => Iterable<string> | undefined): Promise<void>;
+    getUsedResolvedFiles(): Promise<Set<string>>;
     private resolveSpecifier;
     getUnreferencedFiles(): string[];
-    analyzeSourceFile(filePath: string, options: GetImportsAndExportsOptions, ignoreExportsUsedInFile: IgnoreExportsUsedInFile, parseResult?: ParseResult, sourceText?: string, cachedFile?: FileNode): FileNode;
+    private getCachedFile;
+    analyzeSourceFile(filePath: string, sourceText: string, options: GetImportsAndExportsOptions, ignoreExportsUsedInFile: IgnoreExportsUsedInFile, parseResult?: ParseResult, cachedFile?: FileNode): FileNode;
     invalidateFile(filePath: string): void;
     reconcileCache(graph: ModuleGraph): void;
 }

package/dist/ProjectPrincipal.js

@@ -1,7 +1,6 @@
 import { extractSpecifiers } from './typescript/follow-imports.js';
 import { _parseFile } from './typescript/ast-nodes.js';
 import { CacheConsultant } from './CacheConsultant.js';
-import { getCompilerExtensions } from './compilers/index.js';
 import { DEFAULT_EXTENSIONS } from './constants.js';
 import { _getImportsAndExports } from './typescript/get-imports-and-exports.js';
 import { createBunShellVisitor } from './typescript/visitors/script-visitors.js';
@@ -16,6 +15,7 @@ export class ProjectPrincipal {
     projectPaths = new Set();
     programPaths = new Set();
     skipExportsAnalysis = new Set();
+    includeExportsAnalysis = new Set();
     pluginCtx = {
         filePath: '',
         sourceText: '',
@@ -28,10 +28,8 @@ export class ProjectPrincipal {
     pluginVisitorObjects = [];
     _visitor;
     _localRefsVisitor;
-    syncCompilers = new Map();
-    asyncCompilers = new Map();
-    scopedSyncCompilers = new Map();
-    scopedAsyncCompilers = new Map();
+    compilers = new Map();
+    scopedCompilers = new Map();
     paths = new Map();
     rootDirs = new Map();
     tsConfigFile;
@@ -40,6 +38,7 @@ export class ProjectPrincipal {
     toSourceFilePath;
     findWorkspacePackageTarget;
     findWorkspaceNameByFilePath;
+    isReportExports;
     fileManager;
     resolveModule = () => undefined;
     resolveGlobPattern = pattern => [pattern];
@@ -51,38 +50,25 @@ export class ProjectPrincipal {
         this.toSourceFilePath = toSourceFilePath;
         this.findWorkspacePackageTarget = findWorkspacePackageTarget;
         this.findWorkspaceNameByFilePath = findWorkspaceNameByFilePath;
+        this.isReportExports = options.isReportExports;
         this.tsConfigFile = options.tsConfigFile ? toAbsolute(options.tsConfigFile, options.cwd) : undefined;
         this.pluginVisitorObjects.push(createBunShellVisitor(this.pluginCtx));
         this.fileManager = new SourceFileManager({
-            compilers: [this.syncCompilers, this.asyncCompilers],
+            compilers: this.compilers,
+            isSession: options.isSession || options.isWatch,
         });
         this.walkAndAnalyze = timerify(this.walkAndAnalyze.bind(this), 'walkAndAnalyze');
     }
     addCompilers(workspaceName, compilers) {
-        for (const [ext, compiler] of compilers[0]) {
-            const workspaceCompilers = this.scopedSyncCompilers.get(ext);
+        for (const [ext, compiler] of compilers) {
+            const workspaceCompilers = this.scopedCompilers.get(ext);
             if (workspaceCompilers) {
                 workspaceCompilers.set(workspaceName, compiler);
             }
             else {
                 const workspaceCompilers = new Map([[workspaceName, compiler]]);
-                this.scopedSyncCompilers.set(ext, workspaceCompilers);
-                this.syncCompilers.set(ext, (source, filePath) => {
-                    const owner = this.findWorkspaceNameByFilePath(filePath);
-                    return ((owner ? workspaceCompilers.get(owner) : undefined) ?? compiler)(source, filePath);
-                });
-                this.extensions.add(ext);
-            }
-        }
-        for (const [ext, compiler] of compilers[1]) {
-            const workspaceCompilers = this.scopedAsyncCompilers.get(ext);
-            if (workspaceCompilers) {
-                workspaceCompilers.set(workspaceName, compiler);
-            }
-            else {
-                const workspaceCompilers = new Map([[workspaceName, compiler]]);
-                this.scopedAsyncCompilers.set(ext, workspaceCompilers);
-                this.asyncCompilers.set(ext, (source, filePath) => {
+                this.scopedCompilers.set(ext, workspaceCompilers);
+                this.compilers.set(ext, (source, filePath) => {
                     const owner = this.findWorkspaceNameByFilePath(filePath);
                     return ((owner ? workspaceCompilers.get(owner) : undefined) ?? compiler)(source, filePath);
                 });
@@ -107,19 +93,11 @@ export class ProjectPrincipal {
         this.rootDirs.set(scope, compact([...scoped, ...rootDirs]));
     }
     init() {
-        this.extensions = new Set([
-            ...DEFAULT_EXTENSIONS,
-            ...getCompilerExtensions([this.syncCompilers, this.asyncCompilers]),
-        ]);
-        const customCompilerExtensions = getCompilerExtensions([this.syncCompilers, this.asyncCompilers]);
         const scopedPaths = this.paths.size > 0 ? Array.from(this.paths, ([scope, paths]) => ({ scope, paths })) : undefined;
         const scopedRootDirs = this.rootDirs.size > 0 ? Array.from(this.rootDirs, ([scope, rootDirs]) => ({ scope, rootDirs })) : undefined;
-        this.resolveModule = createCustomModuleResolver({ scopedPaths, scopedRootDirs }, customCompilerExtensions, this.toSourceFilePath, this.findWorkspacePackageTarget, this.tsConfigFile);
+        this.resolveModule = createCustomModuleResolver({ scopedPaths, scopedRootDirs }, [...this.compilers.keys()], this.toSourceFilePath, this.findWorkspacePackageTarget, this.tsConfigFile);
         this.resolveGlobPattern = createGlobAliasResolver(scopedPaths);
     }
-    readFile(filePath) {
-        return this.fileManager.readFile(filePath);
-    }
     hasAcceptedExtension(filePath) {
         return this.extensions.has(extname(filePath));
     }
@@ -127,8 +105,16 @@ export class ProjectPrincipal {
         if (!isInNodeModules(filePath) && this.hasAcceptedExtension(filePath)) {
             this.entryPaths.add(filePath);
             this.projectPaths.add(filePath);
-            if (options?.skipExportsAnalysis)
-                this.skipExportsAnalysis.add(filePath);
+            if (options) {
+                if (options.skipExportsAnalysis) {
+                    if (!this.includeExportsAnalysis.has(filePath))
+                        this.skipExportsAnalysis.add(filePath);
+                }
+                else {
+                    this.includeExportsAnalysis.add(filePath);
+                    this.skipExportsAnalysis.delete(filePath);
+                }
+            }
             this.onPathAdded?.(filePath);
         }
     }
@@ -151,23 +137,19 @@ export class ProjectPrincipal {
     removeProjectPath(filePath) {
         this.entryPaths.delete(filePath);
         this.projectPaths.delete(filePath);
+        this.skipExportsAnalysis.delete(filePath);
+        this.includeExportsAnalysis.delete(filePath);
         this.invalidateFile(filePath);
         this.deletedFiles.add(filePath);
     }
-    async runAsyncCompilers() {
-        const add = timerify(this.fileManager.compileAndAddSourceFile.bind(this.fileManager));
-        for (const filePath of this.projectPaths)
-            if (this.asyncCompilers.has(extname(filePath)))
-                await add(filePath);
-    }
-    walkAndAnalyze(analyzeFile) {
+    async walkAndAnalyze(analyzeFile) {
         this.resolvedFiles.clear();
         const visited = new Set([...this.entryPaths, ...this.programPaths]);
         this.onPathAdded = p => visited.add(p);
         try {
             for (const filePath of visited) {
                 const isProjectPath = this.projectPaths.has(filePath);
-                const cachedFile = isProjectPath ? this.cache.getCachedFile(filePath) : undefined;
+                const cachedFile = isProjectPath ? this.getCachedFile(filePath) : undefined;
                 if (cachedFile) {
                     const internalPaths = analyzeFile(filePath, undefined, '', cachedFile);
                     if (internalPaths)
@@ -175,7 +157,8 @@ export class ProjectPrincipal {
                             visited.add(p);
                     continue;
                 }
-                const sourceText = this.fileManager.readFile(filePath);
+                const loaded = this.fileManager.loadSourceText(filePath);
+                const sourceText = typeof loaded === 'string' ? loaded : await loaded;
                 if (!sourceText) {
                     if (isProjectPath)
                         analyzeFile(filePath, undefined, '');
@@ -207,11 +190,12 @@ export class ProjectPrincipal {
         }
         this.resolvedFiles = visited;
     }
-    getUsedResolvedFiles() {
+    async getUsedResolvedFiles() {
         this.resolvedFiles.clear();
         const visited = new Set([...this.entryPaths, ...this.programPaths]);
         for (const filePath of visited) {
-            const sourceText = this.fileManager.readFile(filePath);
+            const loaded = this.fileManager.loadSourceText(filePath);
+            const sourceText = typeof loaded === 'string' ? loaded : await loaded;
             if (!sourceText)
                 continue;
             try {
@@ -226,7 +210,11 @@ export class ProjectPrincipal {
             }
         }
         this.resolvedFiles = visited;
-        return Array.from(this.projectPaths).filter(filePath => visited.has(filePath));
+        const usedFiles = new Set();
+        for (const filePath of this.projectPaths)
+            if (visited.has(filePath))
+                usedFiles.add(filePath);
+        return usedFiles;
     }
     resolveSpecifier(specifier, containingFile) {
         return this.resolveModule(specifier, containingFile)?.resolvedFileName;
@@ -234,17 +222,21 @@ export class ProjectPrincipal {
     getUnreferencedFiles() {
         return Array.from(this.projectPaths).filter(filePath => !this.resolvedFiles.has(filePath));
     }
-    analyzeSourceFile(filePath, options, ignoreExportsUsedInFile, parseResult, sourceText, cachedFile) {
+    getCachedFile(filePath) {
+        const cachedFile = this.cache.getCachedFile(filePath);
+        const skipExports = this.skipExportsAnalysis.has(filePath) || !this.isReportExports;
+        return cachedFile?.skipExports === skipExports ? cachedFile : undefined;
+    }
+    analyzeSourceFile(filePath, sourceText, options, ignoreExportsUsedInFile, parseResult, cachedFile) {
         if (cachedFile)
             return cachedFile;
-        const cached = this.cache.getCachedFile(filePath);
+        const cached = this.getCachedFile(filePath);
         if (cached)
             return cached;
-        sourceText ??= this.fileManager.readFile(filePath);
         const skipExports = this.skipExportsAnalysis.has(filePath);
         if (options.isFixExports || options.isFixTypes) {
             const ext = extname(filePath);
-            if (!DEFAULT_EXTENSIONS.has(ext) && (this.syncCompilers.has(ext) || this.asyncCompilers.has(ext))) {
+            if (!DEFAULT_EXTENSIONS.has(ext) && this.compilers.has(ext)) {
                 options = { ...options, isFixExports: false, isFixTypes: false };
             }
         }
@@ -255,6 +247,7 @@ export class ProjectPrincipal {
     }
     invalidateFile(filePath) {
         this.fileManager.invalidate(filePath);
+        this.cache.removeEntry(filePath);
     }
     reconcileCache(graph) {
         for (const [filePath, file] of graph) {

package/dist/WorkspaceWorker.d.ts

@@ -18,7 +18,7 @@ type WorkspaceManagerOptions = {
     handleInput: HandleInput;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
     getManifest: (dir: string) => Manifest | undefined;
-    readFile: (filePath: string) => string;
+    readRawFile: (filePath: string) => string;
     negatedWorkspacePatterns: string[];
     ignoredWorkspacePatterns: string[];
     enabledPluginsInAncestors: string[];
@@ -40,7 +40,7 @@ export declare class WorkspaceWorker {
     handleInput: HandleInput;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
     getManifest: (dir: string) => Manifest | undefined;
-    readFile: (filePath: string) => string;
+    readRawFile: (filePath: string) => string;
     negatedWorkspacePatterns: string[];
     ignoredWorkspacePatterns: string[];
     options: MainOptions;
@@ -49,7 +49,7 @@ export declare class WorkspaceWorker {
     enabledPluginsInAncestors: string[];
     cache: CacheConsultant<CacheItem>;
     configFilesMap: Map<string, Map<PluginName, Set<string>>>;
-    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getManifest, readFile, configFilesMap, options, }: WorkspaceManagerOptions);
+    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getManifest, readRawFile, configFilesMap, options, }: WorkspaceManagerOptions);
     init(): Promise<void>;
     private determineEnabledPlugins;
     private getConfigForPlugin;

package/dist/WorkspaceWorker.js

@@ -31,7 +31,7 @@ export class WorkspaceWorker {
     handleInput;
     findWorkspaceByFilePath;
     getManifest;
-    readFile;
+    readRawFile;
     negatedWorkspacePatterns = [];
     ignoredWorkspacePatterns = [];
     options;
@@ -40,7 +40,7 @@ export class WorkspaceWorker {
     enabledPluginsInAncestors;
     cache;
     configFilesMap;
-    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getManifest, readFile, configFilesMap, options, }) {
+    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getManifest, readRawFile, configFilesMap, options, }) {
         this.name = name;
         this.dir = dir;
         this.config = config;
@@ -54,7 +54,7 @@ export class WorkspaceWorker {
         this.handleInput = handleInput;
         this.findWorkspaceByFilePath = findWorkspaceByFilePath;
         this.getManifest = getManifest;
-        this.readFile = readFile;
+        this.readRawFile = readRawFile;
         this.options = options;
         this.cache = new CacheConsultant(`plugins-${name}`, options);
         this.getConfigurationHints = timerify(this.getConfigurationHints.bind(this), 'getConfigurationHints');
@@ -341,7 +341,7 @@ export class WorkspaceWorker {
                         parsed = parsedConfigCache.get(configFilePath);
                     }
                     else {
-                        const sourceText = this.readFile(configFilePath);
+                        const sourceText = this.readRawFile(configFilePath);
                         parsed = sourceText ? _parseFile(configFilePath, sourceText) : undefined;
                         parsedConfigCache.set(configFilePath, parsed);
                     }
@@ -387,7 +387,7 @@ export class WorkspaceWorker {
                     }
                 }
                 if (plugin.resolveFromAST && parsed) {
-                    const resolveASTOpts = { ...resolveOpts, readFile: this.readFile };
+                    const resolveASTOpts = { ...resolveOpts, readFile: this.readRawFile };
                     const inputs = plugin.resolveFromAST(parsed.program, resolveASTOpts);
                     for (const input of inputs)
                         addInput(input, configFilePath);
@@ -461,7 +461,7 @@ export class WorkspaceWorker {
             if (visited.has(filePath))
                 return;
             visited.add(filePath);
-            const sourceText = this.readFile(filePath);
+            const sourceText = this.readRawFile(filePath);
             if (!sourceText)
                 return;
             for (const literal of collectStringLiterals(sourceText, filePath)) {

package/dist/YamlCatalogPeeker.d.ts

@@ -9,4 +9,8 @@ export declare class YamlCatalogPeeker {
         line: number;
         col: number;
     } | undefined;
+    getOverrideCatalogReferenceLocation(selector: string): {
+        line: number;
+        col: number;
+    } | undefined;
 }

package/dist/YamlCatalogPeeker.js

@@ -22,6 +22,9 @@ export class YamlCatalogPeeker {
             else if (line.startsWith('catalogs:')) {
                 this.sections.catalogs = i;
             }
+            else if (line.startsWith('overrides:')) {
+                this.sections.overrides = i;
+            }
         }
         this.ready = true;
     }
@@ -63,4 +66,18 @@ export class YamlCatalogPeeker {
             }
         }
     }
+    getOverrideCatalogReferenceLocation(selector) {
+        if (!this.ready)
+            this.init();
+        const startLine = this.sections.overrides;
+        if (typeof startLine === 'undefined')
+            return;
+        for (let i = startLine + 1; i < this.lines.length; i++) {
+            const line = this.lines[i];
+            if (!line.startsWith('  '))
+                break;
+            if (matchesKey(line, '  ', selector))
+                return { line: i + 1, col: line.indexOf(selector) + 1 };
+        }
+    }
 }

package/dist/binaries/bash-parser.d.ts

@@ -1,3 +1,3 @@
 import type { GetInputsFromScriptsOptions } from '../types/config.ts';
-import { type Input } from '../util/input.ts';
+import type { Input } from '../util/input.ts';
 export declare const getDependenciesFromScript: (script: string, options: GetInputsFromScriptsOptions) => Input[];

package/dist/binaries/bash-parser.js

@@ -1,16 +1,11 @@
 import { parse } from 'unbash';
-import { Plugins, pluginArgsMap } from '../plugins.js';
 import { debugLogObject } from '../util/debug.js';
-import { toBinary, toDeferResolve } from '../util/input.js';
 import { extractBinary, isValidBinary } from '../util/modules.js';
 import { relative } from '../util/path.js';
 import { substringBefore, truncate } from '../util/string.js';
 import { walkCommands } from '../util/scripts.js';
-import { resolve as fallbackResolve } from './fallback.js';
-import KnownResolvers from './resolvers/index.js';
-import { resolve as resolverFromPlugins } from './plugins.js';
-import { parseNodeArgs } from './util.js';
-const spawningBinaries = ['cross-env', 'retry-cli'];
+import { getDependenciesFromCommand } from './command.js';
+import { toScript } from './util.js';
 const collectExpansionScripts = (word, out) => {
     if (!word.parts)
         return;
@@ -35,21 +30,19 @@ export const getDependenciesFromScript = (script, options) => {
         const first = typeof args[0] === 'string' ? args[0] : args[0].value;
         if (!isValidBinary(substringBefore(first, ' ')))
             return [];
-        const parts = [];
-        for (const arg of args) {
-            if (typeof arg === 'string') {
-                if (arg !== '--')
-                    parts.push(arg);
-            }
-            else if (arg.value !== '--')
-                parts.push(arg.text);
-        }
-        return getDependenciesFromScript(parts.join(' '), {
+        return getDependenciesFromScript(toScript(args), {
             ...options,
             knownBinsOnly: false,
             ...opts,
         });
     };
+    const fromWords = (words, opts) => {
+        const script = words
+            .filter(word => word.text !== '--')
+            .map(word => word.text)
+            .join(' ');
+        return getDependenciesFromScript(script, opts);
+    };
     const definedFunctions = new Set();
     const collectFunctionNames = (statements) => {
         for (const stmt of statements)
@@ -68,8 +61,6 @@ export const getDependenciesFromScript = (script, options) => {
         return [...mainDeps, ...expansionDeps];
     };
     const processCommand = (node, pending) => {
-        const text = node.name?.value;
-        const binary = text ? extractBinary(text) : text;
         if (node.name)
             collectExpansionScripts(node.name, pending);
         for (const prefix of node.prefix)
@@ -77,46 +68,9 @@ export const getDependenciesFromScript = (script, options) => {
                 collectExpansionScripts(prefix.value, pending);
         for (const suffix of node.suffix)
             collectExpansionScripts(suffix, pending);
-        if (!binary || binary === '.' || binary === 'source' || binary === '[')
-            return [];
-        if (binary.startsWith('-') || binary.startsWith('..'))
-            return [];
-        if (definedFunctions.has(binary))
-            return [];
-        const words = node.suffix;
-        if (binary === '!' || binary === 'test')
-            return fromArgs(words);
-        const fromNodeOptions = node.prefix
-            .filter(a => a.name === 'NODE_OPTIONS' && a.value)
-            .map(a => a.value.value)
-            .map(arg => parseNodeArgs(arg.split(' ')))
-            .filter(args => args.require)
-            .flatMap(arg => arg.require)
-            .map(id => toDeferResolve(id));
-        if (binary in KnownResolvers) {
-            const resolver = KnownResolvers[binary];
-            return resolver(binary, words, { ...options, fromArgs });
-        }
-        if (pluginArgsMap.has(binary)) {
-            return [...resolverFromPlugins(binary, words, { ...options, fromArgs }), ...fromNodeOptions];
-        }
-        if (spawningBinaries.includes(binary)) {
-            const rest = node.suffix
-                .filter(w => w.text !== '--')
-                .map(w => w.text)
-                .join(' ');
-            return [toBinary(binary), ...getDependenciesFromScript(rest, options)];
-        }
-        if (binary in Plugins) {
-            const inputs = fallbackResolve(binary, words, { ...options, fromArgs });
-            if (options.knownBinsOnly)
-                for (const input of inputs)
-                    input.optional = true;
-            return [...inputs, ...fromNodeOptions];
-        }
-        if (options.knownBinsOnly && !text?.startsWith('.'))
+        if (definedFunctions.size && node.name && definedFunctions.has(extractBinary(node.name.value)))
             return [];
-        return [...fallbackResolve(binary, words, { ...options, fromArgs }), ...fromNodeOptions];
+        return getDependenciesFromCommand(node, { ...options, fromArgs }, fromWords);
     };
     try {
         const parsed = parse(script);