knip 1.10.0 → 1.11.0

package/README.md

@@ -229,6 +229,10 @@ be part of the analysis. Here's an example:
 {
   "ignoreWorkspaces": ["packages/ignore-me"],
   "workspaces": {
+    ".": {
+      "entry": "src/index.ts",
+      "project": "src/**/*.ts"
+    },
     "packages/*": {
       "entry": "{index,cli}.ts",
       "project": "**/*.ts"
@@ -240,6 +244,8 @@ be part of the analysis. Here's an example:
 }
 ```
 
+Note that if you have a root workspace, it must be under `workspaces` and have the `"."` key like in the example.
+
 Knip supports workspaces as defined in three possible locations:
 
 - In the `workspaces` array in `package.json`.

package/dist/constants.js

@@ -8,6 +8,7 @@ export const DEFAULT_WORKSPACE_CONFIG = {
 };
 export const TEST_FILE_PATTERNS = ['**/*.{test,spec}.{js,jsx,ts,tsx}', '**/__tests__/**/*.{js,jsx,ts,tsx}'];
 export const IGNORED_GLOBAL_BINARIES = [
+    'bun',
     'deno',
     'git',
     'node',
@@ -22,6 +23,7 @@ export const IGNORED_GLOBAL_BINARIES = [
     'mkdir',
     'mv',
     'rm',
+    'sh',
     'sudo',
 ];
 export const IGNORE_DEFINITELY_TYPED = ['node'];

package/dist/dependency-deputy.d.ts

@@ -10,7 +10,6 @@ type Options = {
 export default class DependencyDeputy {
     isStrict: boolean;
     _manifests: WorkspaceManifests;
-    manifests: Map<string, PackageJson>;
     ignoreDependencies: string[];
     referencedDependencies: Map<string, Set<string>>;
     peerDependencies: Map<string, PeerDependencies>;
@@ -23,7 +22,6 @@ export default class DependencyDeputy {
         manifestPath: string;
         manifest: PackageJson;
     }): void;
-    getManifest(workspaceName: string): PackageJson | undefined;
     getWorkspaceManifest(workspaceName: string): {
         workspaceDir: string;
         manifestPath: string;

package/dist/dependency-deputy.js

@@ -5,7 +5,6 @@ import { getPackageNameFromModuleSpecifier, isDefinitelyTyped, getDefinitelyType
 export default class DependencyDeputy {
     isStrict;
     _manifests = new Map();
-    manifests = new Map();
     ignoreDependencies;
     referencedDependencies;
     peerDependencies;
@@ -25,7 +24,6 @@ export default class DependencyDeputy {
         const optionalDependencies = Object.keys(manifest.optionalDependencies ?? {});
         const devDependencies = Object.keys(manifest.devDependencies ?? {});
         const allDependencies = [...dependencies, ...devDependencies, ...peerDependencies, ...optionalDependencies];
-        this.manifests.set(name, manifest);
         this._manifests.set(name, {
             workspaceDir: dir,
             manifestPath,
@@ -37,9 +35,6 @@ export default class DependencyDeputy {
             allDependencies,
         });
     }
-    getManifest(workspaceName) {
-        return this.manifests.get(workspaceName);
-    }
     getWorkspaceManifest(workspaceName) {
         return this._manifests.get(workspaceName);
     }

package/dist/index.js

@@ -31,6 +31,7 @@ export const main = async (unresolvedConfiguration) => {
         .reverse();
     const lab = new SourceLab({ report, workspaceDirs, isIncludeEntryExports });
     const principal = new ProjectPrincipal();
+    const enabledPluginsStore = new Map();
     for (const { name, dir, config, ancestors } of workspaces) {
         const isRoot = name === ROOT_WORKSPACE_NAME;
         const suffix = isRoot ? '' : ` (${name})`;
@@ -63,15 +64,14 @@ export const main = async (unresolvedConfiguration) => {
             config,
             rootWorkspaceConfig: chief.getConfigForWorkspace(ROOT_WORKSPACE_NAME),
             manifest,
-            ancestorManifests: ancestors.map(name => deputy.getManifest(name)),
             rootConfig: chief.config,
             negatedWorkspacePatterns,
             rootWorkspaceDir: cwd,
             isProduction,
         });
-        await worker.init();
-        deputy.addPeerDependencies(name, worker.peerDependencies);
-        deputy.setInstalledBinaries(name, worker.installedBinaries);
+        const enabledPluginsInAncestors = ancestors.flatMap(ancestor => enabledPluginsStore.get(ancestor) ?? []);
+        await worker.setEnabledPlugins(enabledPluginsInAncestors);
+        await worker.initReferencedDependencies();
         if (config?.entry && config?.project) {
             if (isProduction) {
                 {
@@ -183,13 +183,18 @@ export const main = async (unresolvedConfiguration) => {
                 }
             }
             if (report.dependencies || report.unlisted || report.files) {
-                const { referencedDependencyIssues } = await worker.findDependenciesByPlugins();
+                await worker.findDependenciesByPlugins();
+                const { referencedDependencyIssues, peerDependencies, installedBinaries, entryFiles, enabledPlugins } = worker.getFinalDependencies();
                 referencedDependencyIssues.forEach(issue => {
                     const workspace = { name, dir, config, ancestors };
                     const unlistedDependency = deputy.maybeAddListedReferencedDependency(workspace, issue.symbol);
                     if (unlistedDependency)
                         collector.addIssue(issue);
                 });
+                deputy.addPeerDependencies(name, peerDependencies);
+                deputy.setInstalledBinaries(name, installedBinaries);
+                principal.addEntryPaths(entryFiles);
+                enabledPluginsStore.set(name, enabledPlugins);
             }
         }
     }

package/dist/manifest/index.d.ts

@@ -13,5 +13,6 @@ export declare const findDependencies: ({ rootConfig, manifest, isRoot, isProduc
     dependencies: string[];
     peerDependencies: PeerDependencies;
     installedBinaries: InstalledBinaries;
+    entryFiles: string[];
 }>;
 export {};

package/dist/manifest/index.js

@@ -1,4 +1,4 @@
-import { getBinariesFromScripts } from '../util/binaries/index.js';
+import { _getReferencesFromScripts } from '../util/binaries/index.js';
 import { timerify } from '../util/performance.js';
 import { getPackageManifest } from './helpers.js';
 const findManifestDependencies = async ({ rootConfig, manifest, isRoot, isProduction, dir, cwd }) => {
@@ -12,7 +12,11 @@ const findManifestDependencies = async ({ rootConfig, manifest, isRoot, isProduc
         }
         return scripts;
     }, []);
-    const referencedBinaries = getBinariesFromScripts(scripts, { manifest, ignore: rootConfig.ignoreBinaries });
+    const { entryFiles, binaries: referencedBinaries } = _getReferencesFromScripts(scripts, {
+        cwd: dir,
+        manifest,
+        ignore: rootConfig.ignoreBinaries,
+    });
     const installedBinaries = new Map();
     const packageNames = [...Object.keys(manifest.dependencies ?? {}), ...Object.keys(manifest.devDependencies ?? {})];
     for (const packageName of packageNames) {
@@ -56,6 +60,7 @@ const findManifestDependencies = async ({ rootConfig, manifest, isRoot, isProduc
         dependencies: Array.from(referencedDependencies),
         peerDependencies,
         installedBinaries,
+        entryFiles,
     };
 };
 export const findDependencies = timerify(findManifestDependencies);

package/dist/plugins/github-actions/index.js

@@ -1,4 +1,4 @@
-import { getBinariesFromScripts } from '../../util/binaries/index.js';
+import { _getReferencesFromScripts } from '../../util/binaries/index.js';
 import { _firstGlob } from '../../util/glob.js';
 import { _load } from '../../util/loader.js';
 import { getValuesByKeyDeep } from '../../util/object.js';
@@ -7,19 +7,17 @@ export const NAME = 'GitHub Actions';
 export const ENABLERS = 'This plugin is enabled when a `.yml` file is found in the `.github/workflows` folder.';
 export const isEnabled = async ({ cwd }) => Boolean(await _firstGlob({ cwd, patterns: ['.github/workflows/*.yml'] }));
 export const CONFIG_FILE_PATTERNS = ['.github/workflows/*.yml', '.github/**/action.{yml,yaml}'];
-const findGithubActionsDependencies = async (configFilePath, { manifest, rootConfig }) => {
+const findGithubActionsDependencies = async (configFilePath, { cwd, manifest, rootConfig }) => {
     const config = await _load(configFilePath);
     if (!config)
         return [];
-    const scripts = getValuesByKeyDeep(config, 'run')
-        .filter((value) => typeof value === 'string')
-        .flatMap(script => script.split('\n'))
-        .map(script => script.trim());
-    const binaries = getBinariesFromScripts(scripts, {
+    const scripts = getValuesByKeyDeep(config, 'run').filter((value) => typeof value === 'string');
+    const { binaries, entryFiles } = _getReferencesFromScripts(scripts, {
+        cwd,
         manifest,
         ignore: rootConfig.ignoreBinaries,
         knownGlobalsOnly: true,
     });
-    return binaries;
+    return { dependencies: binaries, entryFiles };
 };
 export const findDependencies = timerify(findGithubActionsDependencies);

package/dist/plugins/husky/index.js

@@ -1,5 +1,5 @@
 import { readFileSync } from 'fs';
-import { getBinariesFromScripts } from '../../util/binaries/index.js';
+import { _getReferencesFromScripts } from '../../util/binaries/index.js';
 import { timerify } from '../../util/performance.js';
 import { hasDependency } from '../../util/plugin.js';
 export const NAME = 'husky';
@@ -10,16 +10,14 @@ export const CONFIG_FILE_PATTERNS = [
     '.husky/pre-{applypatch,commit,merge-commit,push,rebase,receive}',
     '.husky/post-{checkout,commit,merge,rewrite}',
 ];
-const findHuskyDependencies = async (configFilePath, { manifest, rootConfig }) => {
+const findHuskyDependencies = async (configFilePath, { cwd, manifest, rootConfig }) => {
     const script = readFileSync(configFilePath);
-    const scripts = String(script)
-        .split('\n')
-        .map(script => script.trim());
-    const binaries = getBinariesFromScripts(scripts, {
+    const { binaries, entryFiles } = _getReferencesFromScripts(String(script), {
+        cwd,
         manifest,
         ignore: rootConfig.ignoreBinaries,
         knownGlobalsOnly: true,
     });
-    return binaries;
+    return { dependencies: binaries, entryFiles };
 };
 export const findDependencies = timerify(findHuskyDependencies);

package/dist/plugins/lint-staged/index.js

@@ -1,4 +1,4 @@
-import { getBinariesFromScripts } from '../../util/binaries/index.js';
+import { _getReferencesFromScripts } from '../../util/binaries/index.js';
 import { _load } from '../../util/loader.js';
 import { timerify } from '../../util/performance.js';
 import { hasDependency } from '../../util/plugin.js';
@@ -13,7 +13,7 @@ export const CONFIG_FILE_PATTERNS = [
     'lint-staged.config.{js,mjs,cjs}',
     'package.json',
 ];
-const findLintStagedDependencies = async (configFilePath, { manifest, rootConfig }) => {
+const findLintStagedDependencies = async (configFilePath, { cwd, manifest, rootConfig }) => {
     let config = configFilePath.endsWith('package.json')
         ? manifest['lint-staged']
         : await _load(configFilePath);
@@ -25,7 +25,8 @@ const findLintStagedDependencies = async (configFilePath, { manifest, rootConfig
     const binaries = new Set();
     for (const entry of Object.values(config).flat()) {
         const scripts = [typeof entry === 'function' ? await entry([]) : entry].flat();
-        getBinariesFromScripts(scripts, { manifest, ignore: rootConfig.ignoreBinaries }).forEach(bin => binaries.add(bin));
+        const options = { cwd, manifest, ignore: rootConfig.ignoreBinaries };
+        _getReferencesFromScripts(scripts, options).binaries.forEach(bin => binaries.add(bin));
     }
     return Array.from(binaries);
 };

package/dist/plugins/nx/index.js

@@ -1,5 +1,5 @@
 import { compact } from '../../util/array.js';
-import { getBinariesFromScripts } from '../../util/binaries/index.js';
+import { _getReferencesFromScripts } from '../../util/binaries/index.js';
 import { _load } from '../../util/loader.js';
 import { timerify } from '../../util/performance.js';
 import { hasDependency } from '../../util/plugin.js';
@@ -7,7 +7,7 @@ export const NAME = 'Nx';
 export const ENABLERS = [/^@nrwl\//];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['{apps,libs}/**/project.json'];
-const findNxDependencies = async (configFilePath, { manifest }) => {
+const findNxDependencies = async (configFilePath, { cwd, manifest }) => {
     const config = await _load(configFilePath);
     if (!config)
         return [];
@@ -19,7 +19,7 @@ const findNxDependencies = async (configFilePath, { manifest }) => {
     const scripts = compact(targets
         .filter(target => target.executor === 'nx:run-commands')
         .flatMap(target => (target.options?.commands ?? target.options?.command ? [target.options.command] : [])));
-    const binaries = getBinariesFromScripts(scripts, { manifest, knownGlobalsOnly: true });
-    return [...executors, ...binaries];
+    const { binaries, entryFiles } = _getReferencesFromScripts(scripts, { cwd, manifest, knownGlobalsOnly: true });
+    return { dependencies: [...executors, ...binaries], entryFiles };
 };
 export const findDependencies = timerify(findNxDependencies);

package/dist/plugins/release-it/index.js

@@ -1,3 +1,4 @@
+import { _getReferencesFromScripts } from '../../util/binaries/index.js';
 import { _load } from '../../util/loader.js';
 import { timerify } from '../../util/performance.js';
 import { hasDependency } from '../../util/plugin.js';
@@ -10,10 +11,15 @@ export const CONFIG_FILE_PATTERNS = [
     '.release-it.{yml,yaml}',
     'package.json',
 ];
-const findReleaseItDependencies = async (configFilePath, { manifest }) => {
+const findReleaseItDependencies = async (configFilePath, { cwd, manifest }) => {
     const config = configFilePath.endsWith('package.json')
         ? manifest['release-it']
         : await _load(configFilePath);
-    return config?.plugins ? Object.keys(config.plugins) : [];
+    if (!config)
+        return [];
+    const plugins = config.plugins ? Object.keys(config.plugins) : [];
+    const scripts = config.hooks ? Object.values(config.hooks).flat() : [];
+    const { binaries } = _getReferencesFromScripts(scripts, { cwd, manifest });
+    return [...plugins, ...binaries];
 };
 export const findDependencies = timerify(findReleaseItDependencies);

package/dist/plugins/release-it/types.d.ts

@@ -1,3 +1,4 @@
 export type ReleaseItConfig = {
     plugins?: Record<string, unknown>;
+    hooks?: Record<string, string | string[]>;
 };

package/dist/project-principal.d.ts

@@ -10,6 +10,7 @@ export default class ProjectPrincipal {
     projectWorkspace?: Project;
     entryFiles?: SourceFile[];
     addEntryPath(filePath: string): void;
+    addEntryPaths(filePaths: Set<string>): void;
     addSourceFile(filePath: string): void;
     addProjectPath(filePath: string): void;
     removeProjectPath(filePath: string): void;

package/dist/project-principal.js

@@ -26,6 +26,9 @@ export default class ProjectPrincipal {
     addEntryPath(filePath) {
         this.entryPaths.add(filePath);
     }
+    addEntryPaths(filePaths) {
+        filePaths.forEach(filePath => this.entryPaths.add(filePath));
+    }
     addSourceFile(filePath) {
         this.entryWorkspace?.addSourceFileAtPath(filePath);
     }

package/dist/types/plugins.d.ts

@@ -14,5 +14,8 @@ type GenericPluginCallbackOptions = {
     rootConfig: Configuration;
     isProduction: boolean;
 };
-export type GenericPluginCallback = (configFilePath: string, { cwd, manifest, config, workspaceConfig, isProduction }: GenericPluginCallbackOptions) => Promise<string[]> | string[];
+export type GenericPluginCallback = (configFilePath: string, { cwd, manifest, config, workspaceConfig, isProduction }: GenericPluginCallbackOptions) => Promise<string[] | {
+    dependencies: string[];
+    entryFiles?: string[];
+}> | string[];
 export {};

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

@@ -0,0 +1,6 @@
+import type { PackageJson } from 'type-fest';
+export declare const getBinariesFromScript: (script: string, { cwd, manifest, knownGlobalsOnly }: {
+    cwd: string;
+    manifest: PackageJson;
+    knownGlobalsOnly?: boolean | undefined;
+}) => string[];

package/dist/util/binaries/bash-parser.js

@@ -0,0 +1,54 @@
+import parse from 'bash-parser';
+import parseArgs from 'minimist';
+import * as FallbackResolver from './resolvers/fallback.js';
+import * as KnownResolvers from './resolvers/index.js';
+const spawningBinaries = ['cross-env', 'dotenv'];
+export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly = false }) => {
+    const findByArgs = (args) => (args.length > 0 ? findBinaries(parse(args.join(' ')).commands) : []);
+    const findBinaries = (items) => items.flatMap(item => {
+        switch (item.type) {
+            case 'Command': {
+                const binary = item.name?.text;
+                if (!binary || binary === '.' || binary === 'source')
+                    return [];
+                if (binary.startsWith('-') || binary.startsWith('"') || binary.startsWith('..'))
+                    return [];
+                if (['bun', 'deno'].includes(binary))
+                    return [];
+                const args = item.suffix?.map(arg => arg.text) ?? [];
+                if (['!', 'test'].includes(binary))
+                    return findByArgs(args);
+                if (binary in KnownResolvers) {
+                    return KnownResolvers[binary].resolve(binary, args, cwd, manifest, (args) => {
+                        const [binary, ...rest] = args;
+                        return FallbackResolver.resolve(binary, rest, cwd);
+                    });
+                }
+                if (knownGlobalsOnly)
+                    return [];
+                if (spawningBinaries.includes(binary)) {
+                    const parsedArgs = parseArgs(args);
+                    const [spawnedBinary] = parsedArgs._;
+                    if (spawnedBinary) {
+                        const restArgs = args.slice(args.indexOf(spawnedBinary));
+                        return [binary, ...findByArgs(restArgs)];
+                    }
+                    else {
+                        return [];
+                    }
+                }
+                return FallbackResolver.resolve(binary, args, cwd);
+            }
+            case 'LogicalExpression':
+                return findBinaries([item.left, item.right]);
+            case 'If':
+                return findBinaries([...item.clause.commands, ...item.then.commands]);
+            case 'For':
+                return findBinaries(item.do.commands);
+            default:
+                return [];
+        }
+    });
+    const parsed = parse(script);
+    return parsed?.commands ? findBinaries(parsed.commands) : [];
+};

package/dist/util/binaries/index.d.ts

@@ -1,8 +1,13 @@
 import type { PackageJson } from 'type-fest';
-export declare const getFirstPositionalArg: (args: string[]) => string | undefined;
-export declare const getDependenciesFromLoaderArguments: (args: string[]) => string[];
-export declare const getBinariesFromScripts: (npmScripts: string[], { manifest, ignore, knownGlobalsOnly, }: {
-    manifest: PackageJson;
-    ignore?: string[] | undefined;
-    knownGlobalsOnly?: boolean | undefined;
-}) => string[];
+type Options = {
+    cwd?: string;
+    manifest?: PackageJson;
+    ignore?: string[];
+    knownGlobalsOnly?: boolean;
+};
+type GetBinariesFromScripts = (npmScripts: string | string[], options?: Options) => {
+    entryFiles: string[];
+    binaries: string[];
+};
+export declare const _getReferencesFromScripts: GetBinariesFromScripts;
+export {};

package/dist/util/binaries/index.js

@@ -1,47 +1,25 @@
 import { IGNORED_GLOBAL_BINARIES } from '../../constants.js';
-import { getArgumentValues } from '../plugin.js';
-import { toCamelCase } from '../plugin.js';
-import * as BinaryResolvers from './binaries/index.js';
-import * as GlobalBinaryResolvers from './globals/index.js';
-const normalizeBinaries = (command) => command
-    .replace(/(\.\/)?node_modules\/\.bin\/(\w+)/, '$2')
-    .replace(/\$\(npm bin\)\/(\w+)/, '$1')
-    .replace(/(\S+)@.*/, '$1');
-const stripEnvironmentVariables = (value) => value.replace(/([A-Z][^ ]*)=([^ ])+ /g, '');
-const getLoaderArgumentValues = (value) => getArgumentValues(value, / (--(experimental-)?loader|--require|-r)[ =]([^ ]+)/g);
-export const getFirstPositionalArg = (args) => args.find(arg => /^[a-zA-Z@]/.test(arg));
-export const getDependenciesFromLoaderArguments = (args) => getLoaderArgumentValues(' ' + args.join(' '))
-    .filter(scripts => !scripts.startsWith('.'))
-    .map(script => {
-    if (script.startsWith('@')) {
-        const [scope, packageName] = script.split('/');
-        return [scope, packageName].join('/');
-    }
-    return script.split('/')[0];
-});
-export const getBinariesFromScripts = (npmScripts, { manifest, ignore = [], knownGlobalsOnly = false, }) => Array.from(npmScripts.reduce((binaries, script) => {
-    script
-        .split(' && ')
-        .flatMap(command => command.split(' -- '))
-        .map(normalizeBinaries)
-        .filter(command => /^\w/.test(command))
-        .map(stripEnvironmentVariables)
-        .flatMap(command => {
-        const [binary, ...args] = command.trim().split(' ');
-        const camelCased = toCamelCase(binary);
-        if (['bun', 'deno'].includes(binary))
-            return [];
-        if (camelCased in GlobalBinaryResolvers) {
-            return GlobalBinaryResolvers[camelCased].resolve(binary, args, manifest);
-        }
-        if (knownGlobalsOnly)
-            return [];
-        if (camelCased in BinaryResolvers) {
-            return BinaryResolvers[camelCased].resolve(binary, args);
-        }
-        const dependenciesFromArguments = getDependenciesFromLoaderArguments(args);
-        return [binary, ...dependenciesFromArguments];
-    })
-        .forEach(binary => binary && binaries.add(binary));
-    return binaries;
-}, new Set())).filter(binaryName => !IGNORED_GLOBAL_BINARIES.includes(binaryName) && !ignore.includes(binaryName));
+import { compact } from '../array.js';
+import { getPackageNameFromModuleSpecifier, stripBinary } from '../modules.js';
+import { timerify } from '../performance.js';
+import { getBinariesFromScript } from './bash-parser.js';
+const partition = (values) => values.reduce((acc, value) => {
+    acc[/^(\/|[A-Z]:)/.test(value) ? 1 : 0].push(value);
+    return acc;
+}, [[], []]);
+const getReferencesFromScripts = (npmScripts, options = {}) => {
+    const { cwd = process.cwd(), manifest = {}, ignore = [], knownGlobalsOnly = false } = options;
+    const results = [npmScripts]
+        .flat()
+        .flatMap(script => getBinariesFromScript(script, { cwd, manifest, knownGlobalsOnly }));
+    const [binaries, entryFiles] = partition(compact(results));
+    return {
+        entryFiles,
+        binaries: binaries
+            .map(stripBinary)
+            .filter(binary => !binary.startsWith('.'))
+            .map(getPackageNameFromModuleSpecifier)
+            .filter(binaryName => !IGNORED_GLOBAL_BINARIES.includes(binaryName) && !ignore.includes(binaryName)),
+    };
+};
+export const _getReferencesFromScripts = timerify(getReferencesFromScripts);

package/dist/util/binaries/resolvers/fallback.d.ts

@@ -0,0 +1 @@
+export declare const resolve: (binary: string, args: string[], cwd: string) => string[];

package/dist/util/binaries/resolvers/fallback.js

@@ -0,0 +1,28 @@
+import path from 'node:path';
+import parseArgs from 'minimist';
+import { tryResolve } from '../../require.js';
+const resolveArguments = {
+    'ts-node': (parsed) => [parsed._[0], parsed.require].flat(),
+    tsx: (parsed) => parsed._.filter(p => p !== 'watch'),
+    default: (parsed) => [parsed.require].flat(),
+};
+export const resolve = (binary, args, cwd) => {
+    const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader'] } });
+    const resolver = resolveArguments[binary] ?? resolveArguments.default;
+    const resolve = resolver(parsed);
+    return [
+        binary,
+        ...resolve.flatMap(specifier => {
+            if (specifier) {
+                const filePath = path.join(cwd, specifier);
+                if (filePath.startsWith(cwd)) {
+                    const resolvedFilePath = tryResolve(filePath);
+                    if (resolvedFilePath)
+                        return [resolvedFilePath];
+                }
+                return [specifier];
+            }
+            return [];
+        }),
+    ];
+};

package/dist/util/binaries/resolvers/node.d.ts

@@ -0,0 +1 @@
+export declare const resolve: (binary: string, args: string[], cwd: string) => string[];

package/dist/util/binaries/resolvers/node.js

@@ -0,0 +1,19 @@
+import path from 'node:path';
+import parseArgs from 'minimist';
+import { tryResolve } from '../../require.js';
+export const resolve = (binary, args, cwd) => {
+    const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader', 'experimental-loader'] } });
+    const resolve = [parsed._[0], parsed.require].flat();
+    return resolve.flatMap(specifier => {
+        if (specifier) {
+            const filePath = path.join(cwd, specifier);
+            if (filePath.startsWith(cwd)) {
+                const resolvedFilePath = tryResolve(filePath);
+                if (resolvedFilePath)
+                    return [resolvedFilePath];
+            }
+            return [specifier];
+        }
+        return [];
+    });
+};

package/dist/util/binaries/resolvers/npx.d.ts

@@ -0,0 +1,4 @@
+import type { PackageJson } from 'type-fest';
+type FindByArgs = (args: string[]) => string[];
+export declare const resolve: (binary: string, args: string[], cwd: string, manifest: PackageJson, findByArgs: FindByArgs) => string[];
+export {};

package/dist/util/binaries/resolvers/npx.js

@@ -0,0 +1,5 @@
+import parseArgs from 'minimist';
+export const resolve = (binary, args, cwd, manifest, findByArgs) => {
+    const parsed = parseArgs(args, { '--': true, stopEarly: true, boolean: ['yes', 'no'], alias: { yes: 'y', no: 'n' } });
+    return [...(parsed.yes ? [] : findByArgs(parsed._)), ...(parsed['--'] ? findByArgs(parsed['--']) : [])];
+};

package/dist/util/binaries/resolvers/pnpm.d.ts

@@ -0,0 +1,2 @@
+import type { PackageJson } from 'type-fest';
+export declare const resolve: (binary: string, args: string[], cwd: string, manifest: PackageJson) => string[];

package/dist/util/binaries/{globals → resolvers}/pnpm.js

@@ -1,4 +1,4 @@
-import { getFirstPositionalArg } from '../index.js';
+import parseArgs from 'minimist';
 const commands = [
     'add',
     'i',
@@ -31,14 +31,15 @@ const commands = [
     't',
     'tst',
 ];
-export const resolve = (binary, args, manifest) => {
+export const resolve = (binary, args, cwd, manifest) => {
     const scripts = manifest.scripts ? Object.keys(manifest.scripts) : [];
-    const [command, ...commandArgs] = args;
+    const parsed = parseArgs(args, {});
+    const [command, result] = parsed._;
     if (scripts.includes(command) || commands.includes(command))
         return [];
-    if (command === 'run' && scripts.includes(commandArgs[0]))
+    if (command === 'run' && scripts.includes(result))
         return [];
-    if (command === 'run' || command === 'exec')
-        return getFirstPositionalArg(commandArgs);
-    return getFirstPositionalArg(args);
+    if (command === 'exec' || command === 'run')
+        return [result];
+    return command ? [command] : [];
 };

package/dist/util/binaries/resolvers/yarn.d.ts

@@ -0,0 +1,2 @@
+import type { PackageJson } from 'type-fest';
+export declare const resolve: (binary: string, args: string[], cwd: string, manifest: PackageJson) => string[];

package/dist/util/binaries/{globals → resolvers}/yarn.js

@@ -1,4 +1,4 @@
-import { getFirstPositionalArg } from '../index.js';
+import parseArgs from 'minimist';
 const commands = [
     'add',
     'bin',
@@ -30,14 +30,15 @@ const commands = [
     'workspace',
     'workspaces',
 ];
-export const resolve = (binary, args, manifest) => {
+export const resolve = (binary, args, cwd, manifest) => {
     const scripts = manifest.scripts ? Object.keys(manifest.scripts) : [];
-    const [command, ...commandArgs] = args;
+    const parsed = parseArgs(args, {});
+    const [command, result] = parsed._;
     if (scripts.includes(command) || commands.includes(command))
         return [];
-    if (command === 'run' && scripts.includes(commandArgs[0]))
+    if (command === 'run' && scripts.includes(result))
         return [];
     if (command === 'run' || command === 'exec')
-        return getFirstPositionalArg(commandArgs);
-    return getFirstPositionalArg(args);
+        return [result];
+    return command ? [command] : [];
 };

package/dist/util/debug.d.ts

@@ -1,6 +1,4 @@
-import type { Issue } from '../types/issues.js';
 import type { SourceFile } from 'ts-morph';
 export declare const debugLogObject: (name: string, obj: unknown) => void;
 export declare const debugLogFiles: (name: string, filePaths: Set<string> | string[]) => void;
 export declare const debugLogSourceFiles: (name: string, sourceFiles: Set<SourceFile> | SourceFile[]) => void;
-export declare const debugLogIssues: (name: string, issues: Issue[]) => void;

package/dist/util/debug.js

@@ -40,10 +40,3 @@ export const debugLogSourceFiles = (name, sourceFiles) => {
         logArray(files);
     }
 };
-export const debugLogIssues = (name, issues) => {
-    if (!IS_ENABLED)
-        return;
-    const symbols = Array.from(new Set(issues.map(issue => issue.symbol)));
-    console.debug(`[knip] ${name} (${symbols.length})`);
-    logArray(symbols);
-};

package/dist/util/fs.js

@@ -2,6 +2,7 @@ import { statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import stripJsonComments from 'strip-json-comments';
+import { LoaderError } from './errors.js';
 export const isFile = (filePath) => {
     const stat = statSync(filePath, { throwIfNoEntry: false });
     return stat !== undefined && stat.isFile();
@@ -11,6 +12,11 @@ export const findFile = (workingDir, fileName) => {
     return isFile(filePath) ? filePath : undefined;
 };
 export const loadJSON = async (filePath) => {
-    const contents = await readFile(filePath);
-    return JSON.parse(stripJsonComments(contents.toString()));
+    try {
+        const contents = await readFile(filePath);
+        return JSON.parse(stripJsonComments(contents.toString()));
+    }
+    catch (error) {
+        throw new LoaderError(`Error loading ${filePath}`, { cause: error });
+    }
 };

package/dist/util/modules.d.ts

@@ -1,5 +1,6 @@
 export declare const getPackageNameFromModuleSpecifier: (moduleSpecifier: string) => string;
 export declare const getPackageName: (value: string) => string;
+export declare const stripBinary: (command: string) => string;
 export declare const isDefinitelyTyped: (packageName: string) => boolean;
 export declare const getDefinitelyTypedFor: (packageName: string) => string;
 export declare const getPackageFromDefinitelyTyped: (typedDependency: string) => string;

package/dist/util/modules.js

@@ -13,6 +13,10 @@ export const getPackageName = (value) => {
     }
     return value.startsWith('/') ? value : value.split('/')[0];
 };
+export const stripBinary = (command) => command
+    .replace(/(\.\/)?node_modules\/(\.bin\/)?(\w+)/, '$3')
+    .replace(/\$\(npm bin\)\/(\w+)/, '$1')
+    .replace(/(\S+)@.*/, '$1');
 export const isDefinitelyTyped = (packageName) => packageName.startsWith('@types/');
 export const getDefinitelyTypedFor = (packageName) => {
     if (isDefinitelyTyped(packageName))

package/dist/util/require.d.ts

@@ -1,2 +1,3 @@
 /// <reference types="node" resolution-mode="require"/>
 export declare const require: NodeRequire;
+export declare const tryResolve: (specifier: string) => string | undefined;

package/dist/util/require.js

@@ -1,2 +1,9 @@
 import { createRequire } from 'node:module';
 export const require = createRequire(process.cwd());
+export const tryResolve = (specifier) => {
+    try {
+        return require.resolve(specifier);
+    }
+    catch (error) {
+    }
+};

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "1.10.0";
+export declare const version = "1.11.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '1.10.0';
+export const version = '1.11.0';

package/dist/workspace-worker.d.ts

@@ -7,7 +7,6 @@ type WorkspaceManagerOptions = {
     dir: string;
     config: WorkspaceConfiguration;
     manifest: PackageJson;
-    ancestorManifests: (PackageJson | undefined)[];
     rootWorkspaceConfig: WorkspaceConfiguration;
     rootConfig: Configuration;
     negatedWorkspacePatterns: string[];
@@ -15,28 +14,26 @@ type WorkspaceManagerOptions = {
     isProduction: boolean;
 };
 type ReferencedDependencyIssues = Set<Issue>;
-type ReferencedDependencies = Set<string>;
 export default class WorkspaceWorker {
     name: string;
     dir: string;
     config: WorkspaceConfiguration;
-    ancestorManifests: (PackageJson | undefined)[];
     rootWorkspaceConfig: WorkspaceConfiguration;
     rootConfig: Configuration;
-    referencedDependencyIssues: ReferencedDependencyIssues;
     manifest: PackageJson;
     rootWorkspaceDir: string;
-    referencedDependencies: ReferencedDependencies;
+    referencedDependencyIssues: ReferencedDependencyIssues;
     peerDependencies: PeerDependencies;
     installedBinaries: InstalledBinaries;
+    entryFiles: Set<string>;
     negatedWorkspacePatterns: string[];
     enabled: Record<PluginName, boolean>;
+    enabledPlugins: PluginName[];
     isRoot: boolean;
     isProduction: boolean;
-    constructor({ name, dir, config, ancestorManifests, rootWorkspaceConfig, rootConfig, negatedWorkspacePatterns, manifest, rootWorkspaceDir, isProduction, }: WorkspaceManagerOptions);
+    constructor({ name, dir, config, rootWorkspaceConfig, rootConfig, negatedWorkspacePatterns, manifest, rootWorkspaceDir, isProduction, }: WorkspaceManagerOptions);
     getConfigForPlugin(pluginName: PluginName): PluginConfiguration;
-    init(): Promise<void>;
-    setEnabledPlugins(): Promise<void>;
+    setEnabledPlugins(enabledPluginsInAncestors: string[]): Promise<void>;
     initReferencedDependencies(): Promise<void>;
     getEntryFilePatterns(): string[];
     getProjectFilePatterns(): string[];
@@ -48,10 +45,13 @@ export default class WorkspaceWorker {
     getProductionPluginEntryFilePatterns(): string[];
     getConfigurationEntryFilePattern(pluginName: PluginName): string[];
     getWorkspaceIgnorePatterns(): string[];
-    findDependenciesByPlugins(): Promise<{
+    findDependenciesByPlugins(): Promise<void>;
+    getFinalDependencies(): {
+        peerDependencies: PeerDependencies;
+        installedBinaries: InstalledBinaries;
         referencedDependencyIssues: ReferencedDependencyIssues;
-        referencedDependencies: ReferencedDependencies;
-    }>;
-    private findDependenciesByPlugin;
+        entryFiles: Set<string>;
+        enabledPlugins: ("babel" | "capacitor" | "changesets" | "commitlint" | "cypress" | "eslint" | "gatsby" | "husky" | "jest" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "typescript" | "vitest" | "webpack" | "githubActions" | "lintStaged" | "npmPackageJsonLint" | "releaseIt")[];
+    };
 }
 export {};

package/dist/workspace-worker.js

@@ -2,31 +2,30 @@ import path from 'node:path';
 import { ROOT_WORKSPACE_NAME, TEST_FILE_PATTERNS } from './constants.js';
 import * as npm from './manifest/index.js';
 import * as plugins from './plugins/index.js';
-import { debugLogFiles, debugLogIssues, debugLogObject } from './util/debug.js';
+import { debugLogFiles, debugLogObject } from './util/debug.js';
 import { _pureGlob, negate, hasProductionSuffix, hasNoProductionSuffix } from './util/glob.js';
 const negatedTestFilePatterns = TEST_FILE_PATTERNS.map(negate);
 export default class WorkspaceWorker {
     name;
     dir;
     config;
-    ancestorManifests;
     rootWorkspaceConfig;
     rootConfig;
-    referencedDependencyIssues = new Set();
     manifest;
     rootWorkspaceDir;
-    referencedDependencies = new Set();
+    referencedDependencyIssues = new Set();
     peerDependencies = new Map();
     installedBinaries = new Map();
+    entryFiles = new Set();
     negatedWorkspacePatterns = [];
     enabled;
+    enabledPlugins = [];
     isRoot;
     isProduction;
-    constructor({ name, dir, config, ancestorManifests, rootWorkspaceConfig, rootConfig, negatedWorkspacePatterns, manifest, rootWorkspaceDir, isProduction, }) {
+    constructor({ name, dir, config, rootWorkspaceConfig, rootConfig, negatedWorkspacePatterns, manifest, rootWorkspaceDir, isProduction, }) {
         this.name = name;
         this.dir = dir;
         this.config = config;
-        this.ancestorManifests = ancestorManifests;
         this.isRoot = name === ROOT_WORKSPACE_NAME;
         this.isProduction = isProduction;
         this.rootConfig = rootConfig;
@@ -39,27 +38,23 @@ export default class WorkspaceWorker {
     getConfigForPlugin(pluginName) {
         return this.config[pluginName] ?? { config: null, entry: null, project: null };
     }
-    async init() {
-        await this.setEnabledPlugins();
-        await this.initReferencedDependencies();
-    }
-    async setEnabledPlugins() {
-        const dependencies = new Set([this.manifest, ...this.ancestorManifests]
-            .flatMap(manifest => [Object.keys(manifest?.dependencies ?? {}), Object.keys(manifest?.devDependencies ?? {})])
-            .flat());
+    async setEnabledPlugins(enabledPluginsInAncestors) {
+        const { manifest } = this;
+        const dependencies = new Set([Object.keys(manifest?.dependencies ?? {}), Object.keys(manifest?.devDependencies ?? {})].flat());
         const pluginEntries = Object.entries(plugins);
         for (const [pluginName, plugin] of pluginEntries) {
             const hasIsEnabled = typeof plugin.isEnabled === 'function';
             this.enabled[pluginName] =
                 this.config[pluginName] !== false &&
-                    hasIsEnabled &&
-                    (await plugin.isEnabled({ cwd: this.dir, manifest: this.manifest, dependencies }));
+                    (enabledPluginsInAncestors.includes(pluginName) ||
+                        (hasIsEnabled && (await plugin.isEnabled({ cwd: this.dir, manifest: this.manifest, dependencies }))));
         }
-        const enabledPlugins = pluginEntries.filter(([name]) => this.enabled[name]).map(([, plugin]) => plugin.NAME);
-        debugLogObject(`Enabled plugins (${this.name})`, enabledPlugins);
+        this.enabledPlugins = pluginEntries.filter(([name]) => this.enabled[name]).map(([name]) => name);
+        const enabledPluginNames = this.enabledPlugins.map(name => plugins[name].NAME);
+        debugLogObject(`Enabled plugins (${this.name})`, enabledPluginNames);
     }
     async initReferencedDependencies() {
-        const { dependencies, peerDependencies, installedBinaries } = await npm.findDependencies({
+        const { dependencies, peerDependencies, installedBinaries, entryFiles } = await npm.findDependencies({
             rootConfig: this.rootConfig,
             manifest: this.manifest,
             isRoot: this.isRoot,
@@ -68,8 +63,9 @@ export default class WorkspaceWorker {
             cwd: this.rootWorkspaceDir,
         });
         const filePath = path.join(this.dir, 'package.json');
-        dependencies.forEach(dependency => this.referencedDependencyIssues.add({ type: 'unlisted', filePath, symbol: dependency }));
-        dependencies.forEach(dependency => this.referencedDependencies.add(dependency));
+        const issues = this.referencedDependencyIssues;
+        dependencies.forEach(dependency => issues.add({ type: 'unlisted', filePath, symbol: dependency }));
+        entryFiles.forEach(entryFile => this.entryFiles.add(entryFile));
         this.peerDependencies = peerDependencies;
         this.installedBinaries = installedBinaries;
     }
@@ -202,40 +198,49 @@ export default class WorkspaceWorker {
             if (this.enabled[pluginName] && isIncludePlugin) {
                 const hasDependencyFinder = 'findDependencies' in plugin && typeof plugin.findDependencies === 'function';
                 if (hasDependencyFinder) {
-                    const dependencies = await this.findDependenciesByPlugin(pluginName, plugin.NAME, plugin.findDependencies);
-                    dependencies.forEach(dependency => this.referencedDependencyIssues.add(dependency));
-                    dependencies.forEach(dependency => this.referencedDependencies.add(dependency.symbol));
+                    const pluginConfig = this.getConfigForPlugin(pluginName);
+                    if (!pluginConfig)
+                        continue;
+                    const patterns = this.getConfigurationEntryFilePattern(pluginName);
+                    const cwd = this.dir;
+                    const ignore = this.getWorkspaceIgnorePatterns();
+                    const configFilePaths = await _pureGlob({ patterns, cwd, ignore });
+                    debugLogFiles(`Globbed ${plugin.NAME} config file paths`, configFilePaths);
+                    if (configFilePaths.length === 0)
+                        continue;
+                    const pluginDependencies = new Set();
+                    const pluginEntryFiles = new Set();
+                    for (const configFilePath of configFilePaths) {
+                        const results = await plugin.findDependencies(configFilePath, {
+                            cwd,
+                            manifest: this.manifest,
+                            config: pluginConfig,
+                            rootConfig: this.rootConfig,
+                            workspaceConfig: this.config,
+                            isProduction: this.isProduction,
+                        });
+                        const dependencies = Array.isArray(results) ? results : results.dependencies;
+                        const entryFiles = !Array.isArray(results) && results.entryFiles ? results.entryFiles : [];
+                        const issues = this.referencedDependencyIssues;
+                        dependencies.forEach(symbol => issues.add({ type: 'unlisted', filePath: configFilePath, symbol }));
+                        entryFiles.forEach(entryFile => this.entryFiles.add(entryFile));
+                        dependencies.forEach(dependency => pluginDependencies.add(dependency));
+                        entryFiles.forEach(entryFile => pluginEntryFiles.add(entryFile));
+                    }
+                    debugLogFiles(`Dependencies referenced in ${plugin.NAME}`, pluginDependencies);
+                    if (pluginEntryFiles.size > 0)
+                        debugLogFiles(`Entry files referenced in ${plugin.NAME}`, pluginEntryFiles);
                 }
             }
         }
+    }
+    getFinalDependencies() {
         return {
+            peerDependencies: this.peerDependencies,
+            installedBinaries: this.installedBinaries,
             referencedDependencyIssues: this.referencedDependencyIssues,
-            referencedDependencies: this.referencedDependencies,
+            entryFiles: this.entryFiles,
+            enabledPlugins: this.enabledPlugins,
         };
     }
-    async findDependenciesByPlugin(pluginName, pluginTitle, pluginCallback) {
-        const pluginConfig = this.getConfigForPlugin(pluginName);
-        if (!pluginConfig)
-            return [];
-        const patterns = this.getConfigurationEntryFilePattern(pluginName);
-        const cwd = this.dir;
-        const ignore = this.getWorkspaceIgnorePatterns();
-        const configFilePaths = await _pureGlob({ patterns, cwd, ignore });
-        debugLogFiles(`Globbed ${pluginTitle} config file paths`, configFilePaths);
-        if (configFilePaths.length === 0)
-            return [];
-        const referencedDependencyIssues = (await Promise.all(configFilePaths.map(async (configFilePath) => {
-            const dependencies = await pluginCallback(configFilePath, {
-                cwd,
-                manifest: this.manifest,
-                config: pluginConfig,
-                rootConfig: this.rootConfig,
-                workspaceConfig: this.config,
-                isProduction: this.isProduction,
-            });
-            return dependencies.map(symbol => ({ type: 'unlisted', filePath: configFilePath, symbol }));
-        }))).flat();
-        debugLogIssues(`Dependencies used by ${pluginTitle} configuration`, referencedDependencyIssues);
-        return referencedDependencyIssues;
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",
@@ -42,9 +42,10 @@
     "@esbuild-kit/esm-loader": "^2.5.4",
     "@npmcli/map-workspaces": "^3.0.1",
     "@snyk/github-codeowners": "^1.1.0",
+    "bash-parser": "^0.5.0",
     "chalk": "^5.2.0",
     "easy-table": "^1.2.0",
-    "esbuild": "^0.17.3",
+    "esbuild": "^0.17.4",
     "esbuild-register": "3.4.2",
     "eslint": "^8.32.0",
     "fast-glob": "^3.2.12",
@@ -52,6 +53,7 @@
     "globby": "^13.1.3",
     "js-yaml": "^4.1.0",
     "micromatch": "^4.0.5",
+    "minimist": "^1.2.7",
     "nano-memoize": "^2.0.0",
     "patch-package": "^6.5.1",
     "pretty-ms": "^8.0.0",
@@ -62,17 +64,18 @@
     "zod": "^3.20.2"
   },
   "devDependencies": {
-    "@jest/types": "29.3.1",
+    "@jest/types": "^29.4.0",
     "@npmcli/package-json": "3.0.0",
     "@release-it/bumper": "^4.0.2",
     "@types/eslint": "8.4.10",
     "@types/js-yaml": "4.0.5",
     "@types/micromatch": "4.0.2",
+    "@types/minimist": "^1.2.2",
     "@types/node": "18.11.18",
     "@types/npmcli__map-workspaces": "3.0.0",
     "@types/webpack": "5.28.0",
-    "@typescript-eslint/eslint-plugin": "5.48.2",
-    "@typescript-eslint/parser": "5.48.2",
+    "@typescript-eslint/eslint-plugin": "^5.49.0",
+    "@typescript-eslint/parser": "^5.49.0",
     "eslint-import-resolver-typescript": "3.5.3",
     "eslint-plugin-import": "2.27.5",
     "globstar": "1.0.0",
@@ -81,7 +84,7 @@
     "remark-cli": "11.0.0",
     "remark-preset-webpro": "0.0.1",
     "tsx": "3.12.2",
-    "type-fest": "3.5.2",
+    "type-fest": "^3.5.3",
     "typescript": "4.9.4"
   },
   "engines": {

package/dist/util/binaries/binaries/cross-env.d.ts

@@ -1 +0,0 @@
-export declare const resolve: (binary: string, args: string[]) => string[];

package/dist/util/binaries/binaries/cross-env.js

@@ -1,5 +0,0 @@
-import { getDependenciesFromLoaderArguments } from '../index.js';
-export const resolve = (binary, args) => {
-    const dependenciesFromArguments = getDependenciesFromLoaderArguments(args);
-    return [binary, args[0], ...dependenciesFromArguments];
-};

package/dist/util/binaries/binaries/dotenv.d.ts

@@ -1 +0,0 @@
-export declare const resolve: (binary: string, args: string[]) => string[];

package/dist/util/binaries/binaries/dotenv.js

@@ -1,5 +0,0 @@
-import { getDependenciesFromLoaderArguments } from '../index.js';
-export const resolve = (binary, args) => {
-    const dependenciesFromArguments = getDependenciesFromLoaderArguments(args);
-    return [binary, args[0], ...dependenciesFromArguments];
-};

package/dist/util/binaries/binaries/index.d.ts

@@ -1,2 +0,0 @@
-export * as crossEnv from './cross-env.js';
-export * as dotenv from './dotenv.js';

package/dist/util/binaries/binaries/index.js

@@ -1,2 +0,0 @@
-export * as crossEnv from './cross-env.js';
-export * as dotenv from './dotenv.js';

package/dist/util/binaries/globals/node.d.ts

@@ -1 +0,0 @@
-export declare const resolve: (binary: string, args: string[]) => string[];

package/dist/util/binaries/globals/node.js

@@ -1,5 +0,0 @@
-import { getDependenciesFromLoaderArguments } from '../index.js';
-export const resolve = (binary, args) => {
-    const dependenciesFromArguments = getDependenciesFromLoaderArguments(args);
-    return dependenciesFromArguments;
-};

package/dist/util/binaries/globals/npx.d.ts

@@ -1 +0,0 @@
-export declare const resolve: (binary: string, args: string[]) => (string | undefined)[];

package/dist/util/binaries/globals/npx.js

@@ -1,8 +0,0 @@
-import { getDependenciesFromLoaderArguments, getFirstPositionalArg } from '../index.js';
-export const resolve = (binary, args) => {
-    if (/-y|--yes/.test(args[0]))
-        return [];
-    const dependenciesFromArguments = getDependenciesFromLoaderArguments(args);
-    const firstArgument = getFirstPositionalArg(args);
-    return [firstArgument, ...dependenciesFromArguments];
-};

package/dist/util/binaries/globals/pnpm.d.ts

@@ -1,2 +0,0 @@
-import type { PackageJson } from 'type-fest';
-export declare const resolve: (binary: string, args: string[], manifest: PackageJson) => string | never[] | undefined;

package/dist/util/binaries/globals/yarn.d.ts

@@ -1,2 +0,0 @@
-import type { PackageJson } from 'type-fest';
-export declare const resolve: (binary: string, args: string[], manifest: PackageJson) => string | never[] | undefined;