knip 2.1.3 → 2.2.1

package/README.md

@@ -20,7 +20,7 @@ The dots don't connect themselves. This is where Knip comes in:
 - [x] Built-in support for [workspaces (monorepos)][1]
 - [x] Growing list of [built-in plugins][2]
 - [x] Use [compilers][3] to include other file types (e.g. `.mdx`, `.vue`, `.svelte`)
-- [x] Checks npm scripts for used and unlisted dependencies
+- [x] Finds binaries and dependencies in npm scripts, and a lot more locations
 - [x] Finds unused members of classes and enums
 - [x] Finds duplicate exports
 - [x] Supports any combination of JavaScript and TypeScript
@@ -237,9 +237,9 @@ As always, make sure to backup files or use Git before deleting files or making
 
 Workspaces and monorepos are handled out-of-the-box by Knip. Every workspace is part of the analysis.
 
-Here's an example configuration with some custom `entry` and `project` patterns:
+Here's an example `knip.json` configuration with some custom `entry` and `project` patterns:
 
-```jsonc
+```json
 {
   "workspaces": {
     ".": {
@@ -280,6 +280,9 @@ Here's some example output when running Knip in a workspace:
 
 Use `--debug` to get more verbose output.
 
+Use `ignoreBinaries` and `ignoreDependencies` at the root of `knip.json` for global effect, or inside any workspace
+config for local effect.
+
 ## Plugins
 
 Plugins tell Knip where to look for configuration and entry files, and if necessary have a custom dependency finder.
@@ -439,10 +442,9 @@ use the `--production` flag. Here's an example:
 Here's what's included in production mode analysis:
 
 - Only `entry` and `project` patterns suffixed with `!`.
-- Only `entry` patterns from plugins exported as `PRODUCTION_ENTRY_FILE_PATTERNS` (such as Next.js and Gatsby).
-- Only the `postinstall` and `start` script (e.g. not the `test` or other npm scripts in `package.json`).
-- Only `exports`, `nsExports` and `classMembers` are included in the report (`types`, `nsTypes`, `enumMembers` are
-  ignored).
+- Only production `entry` file patterns exported for plugins (such as Next.js and Gatsby).
+- Only the `start` and `postinstall` scripts (e.g. not the `test` or other npm scripts in `package.json`).
+- Only unused `exports`, `nsExports` and `classMembers` are reported (not `types`, `nsTypes`, `enumMembers`).
 
 ### Strict
 
@@ -587,7 +589,7 @@ This table is an ongoing comparison. Based on their docs (please report any mist
 | Custom reporters        |    ✅    |       -        |        -         |            -            |       -        |
 | JavaScript support      |    ✅    |       ✅       |        ✅        |            -            |       -        |
 | Configure entry files   |    ✅    |       ❌       |        ✅        |           ❌            |       ❌       |
-| [Support workspaces][1] |    ✅    |       ❌       |        ❌        |            -            |       -        |
+| [Workspaces][1]         |    ✅    |       ❌       |        ❌        |            -            |       -        |
 | ESLint plugin available |    -     |       -        |        -         |           ✅            |       -        |
 
 ✅ = Supported, ❌ = Not supported, - = Out of scope

package/dist/{configuration-chief.js → ConfigurationChief.js}

@@ -1,6 +1,6 @@
 import mapWorkspaces from '@npmcli/map-workspaces';
 import micromatch from 'micromatch';
-import { ConfigurationValidator } from './configuration-validator.js';
+import { ConfigurationValidator } from './ConfigurationValidator.js';
 import { ROOT_WORKSPACE_NAME, DEFAULT_EXTENSIONS, KNIP_CONFIG_LOCATIONS } from './constants.js';
 import * as plugins from './plugins/index.js';
 import { arrayify, compact } from './util/array.js';
@@ -88,7 +88,7 @@ export class ConfigurationChief {
         return [this.config.syncCompilers, this.config.asyncCompilers];
     }
     normalize(rawLocalConfig) {
-        const workspaces = rawLocalConfig.workspaces ?? {
+        const initialWorkspaces = rawLocalConfig.workspaces ?? {
             [ROOT_WORKSPACE_NAME]: {
                 ...rawLocalConfig,
             },
@@ -102,6 +102,42 @@ export class ConfigurationChief {
         const { syncCompilers, asyncCompilers } = rawLocalConfig;
         const extensions = [...Object.keys(syncCompilers ?? {}), ...Object.keys(asyncCompilers ?? {})];
         const defaultWorkspaceConfig = getDefaultWorkspaceConfig(extensions);
+        const workspaces = Object.entries(initialWorkspaces)
+            .filter(([workspaceName]) => !ignoreWorkspaces.includes(workspaceName))
+            .reduce((workspaces, workspace) => {
+            const [workspaceName, workspaceConfig] = workspace;
+            const entry = workspaceConfig.entry ? arrayify(workspaceConfig.entry) : defaultWorkspaceConfig.entry;
+            const project = workspaceConfig.project ? arrayify(workspaceConfig.project) : defaultWorkspaceConfig.project;
+            const paths = workspaceConfig.paths ?? defaultWorkspaceConfig.paths;
+            workspaces[workspaceName] = {
+                entry,
+                project,
+                paths,
+                ignore: arrayify(workspaceConfig.ignore),
+                ignoreBinaries: compact([...ignoreBinaries, ...arrayify(workspaceConfig.ignoreBinaries)]),
+                ignoreDependencies: compact([...ignoreDependencies, ...arrayify(workspaceConfig.ignoreDependencies)]),
+            };
+            for (const [name, pluginConfig] of Object.entries(workspaceConfig)) {
+                const pluginName = toCamelCase(name);
+                if (PLUGIN_NAMES.includes(pluginName)) {
+                    if (pluginConfig === false) {
+                        workspaces[workspaceName][pluginName] = false;
+                    }
+                    else {
+                        const isObject = typeof pluginConfig !== 'string' && !Array.isArray(pluginConfig);
+                        const config = isObject ? arrayify(pluginConfig.config) : pluginConfig ? arrayify(pluginConfig) : null;
+                        const entry = isObject && 'entry' in pluginConfig ? arrayify(pluginConfig.entry) : null;
+                        const project = isObject && 'project' in pluginConfig ? arrayify(pluginConfig.project) : entry;
+                        workspaces[workspaceName][pluginName] = {
+                            config,
+                            entry,
+                            project,
+                        };
+                    }
+                }
+            }
+            return workspaces;
+        }, {});
         return {
             include,
             exclude,
@@ -109,42 +145,7 @@ export class ConfigurationChief {
             ignoreWorkspaces,
             syncCompilers: new Map(Object.entries(syncCompilers ?? {})),
             asyncCompilers: new Map(Object.entries(asyncCompilers ?? {})),
-            workspaces: Object.entries(workspaces)
-                .filter(([workspaceName]) => !ignoreWorkspaces.includes(workspaceName))
-                .reduce((workspaces, workspace) => {
-                const [workspaceName, workspaceConfig] = workspace;
-                const entry = workspaceConfig.entry ? arrayify(workspaceConfig.entry) : defaultWorkspaceConfig.entry;
-                const project = workspaceConfig.project ? arrayify(workspaceConfig.project) : defaultWorkspaceConfig.project;
-                const paths = workspaceConfig.paths ?? defaultWorkspaceConfig.paths;
-                workspaces[workspaceName] = {
-                    entry,
-                    project,
-                    paths,
-                    ignore: arrayify(workspaceConfig.ignore),
-                    ignoreBinaries: compact([...ignoreBinaries, ...arrayify(workspaceConfig.ignoreBinaries)]),
-                    ignoreDependencies: compact([...ignoreDependencies, ...arrayify(workspaceConfig.ignoreDependencies)]),
-                };
-                for (const [name, pluginConfig] of Object.entries(workspaceConfig)) {
-                    const pluginName = toCamelCase(name);
-                    if (PLUGIN_NAMES.includes(pluginName)) {
-                        if (pluginConfig === false) {
-                            workspaces[workspaceName][pluginName] = false;
-                        }
-                        else {
-                            const isObject = typeof pluginConfig !== 'string' && !Array.isArray(pluginConfig);
-                            const config = isObject ? arrayify(pluginConfig.config) : pluginConfig ? arrayify(pluginConfig) : null;
-                            const entry = isObject && 'entry' in pluginConfig ? arrayify(pluginConfig.entry) : null;
-                            const project = isObject && 'project' in pluginConfig ? arrayify(pluginConfig.project) : entry;
-                            workspaces[workspaceName][pluginName] = {
-                                config,
-                                entry,
-                                project,
-                            };
-                        }
-                    }
-                }
-                return workspaces;
-            }, {}),
+            workspaces,
         };
     }
     async setWorkspaces() {

package/dist/{dependency-deputy.d.ts → DependencyDeputy.d.ts}

@@ -1,4 +1,4 @@
-import { Workspace } from './configuration-chief.js';
+import { Workspace } from './ConfigurationChief.js';
 import type { Issue } from './types/issues.js';
 import type { WorkspaceManifests } from './types/workspace.js';
 import type { PeerDependencies, InstalledBinaries } from './types/workspace.js';
@@ -13,12 +13,13 @@ export declare class DependencyDeputy {
     peerDependencies: Map<string, PeerDependencies>;
     installedBinaries: Map<string, InstalledBinaries>;
     constructor({ isStrict }: Options);
-    addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, }: {
+    addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, ignoreBinaries, }: {
         name: string;
         dir: string;
         manifestPath: string;
         manifest: PackageJson;
         ignoreDependencies: string[];
+        ignoreBinaries: string[];
     }): void;
     getWorkspaceManifest(workspaceName: string): {
         workspaceDir: string;
@@ -30,6 +31,7 @@ export declare class DependencyDeputy {
         devDependencies: string[];
         allDependencies: string[];
         ignoreDependencies: string[];
+        ignoreBinaries: string[];
     } | undefined;
     getProductionDependencies(workspaceName: string): string[];
     getDevDependencies(workspaceName: string): string[];

package/dist/{dependency-deputy.js → DependencyDeputy.js}

@@ -1,5 +1,5 @@
 import { isBuiltin } from 'node:module';
-import { IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES } from './constants.js';
+import { IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES } from './constants.js';
 import { isDefinitelyTyped, getDefinitelyTypedFor, getPackageFromDefinitelyTyped } from './util/modules.js';
 export class DependencyDeputy {
     isStrict;
@@ -13,7 +13,7 @@ export class DependencyDeputy {
         this.peerDependencies = new Map();
         this.installedBinaries = new Map();
     }
-    addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, }) {
+    addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, ignoreBinaries, }) {
         const scripts = Object.values(manifest.scripts ?? {});
         const dependencies = Object.keys(manifest.dependencies ?? {});
         const peerDependencies = Object.keys(manifest.peerDependencies ?? {});
@@ -24,6 +24,7 @@ export class DependencyDeputy {
             workspaceDir: dir,
             manifestPath,
             ignoreDependencies,
+            ignoreBinaries,
             scripts,
             dependencies,
             peerDependencies,
@@ -80,6 +81,10 @@ export class DependencyDeputy {
             closestWorkspaceNameForTypes && this.addReferencedDependency(closestWorkspaceNameForTypes, typesPackageName);
             return true;
         }
+        if (IGNORED_GLOBAL_BINARIES.includes(packageName))
+            return true;
+        if (this.getWorkspaceManifest(workspace.name)?.ignoreBinaries.includes(packageName))
+            return true;
         for (const name of workspaceNames) {
             const binaries = this.getInstalledBinaries(name);
             if (binaries?.has(packageName)) {
@@ -102,9 +107,21 @@ export class DependencyDeputy {
     settleDependencyIssues() {
         const dependencyIssues = [];
         const devDependencyIssues = [];
-        for (const [workspaceName, { manifestPath, ignoreDependencies }] of this._manifests.entries()) {
+        for (const [workspaceName, { manifestPath, ignoreDependencies, ignoreBinaries }] of this._manifests.entries()) {
             const referencedDependencies = this.referencedDependencies.get(workspaceName);
-            const isUnreferencedDependency = (dependency) => {
+            const installedBinaries = this.getInstalledBinaries(workspaceName);
+            const ignoreBins = [...IGNORED_GLOBAL_BINARIES, ...ignoreBinaries];
+            const ignoreDeps = [...IGNORED_DEPENDENCIES, ...ignoreDependencies];
+            const isNotIgnoredDependency = (packageName) => !ignoreDeps.includes(packageName);
+            const isNotIgnoredBinary = (packageName) => {
+                if (installedBinaries?.has(packageName)) {
+                    const binaryNames = installedBinaries.get(packageName);
+                    if (binaryNames && ignoreBins.some(ignoredBinary => binaryNames.has(ignoredBinary)))
+                        return false;
+                }
+                return true;
+            };
+            const isNotReferencedDependency = (dependency) => {
                 if (referencedDependencies?.has(dependency))
                     return false;
                 const [scope, typedDependency] = dependency.split('/');
@@ -114,23 +131,25 @@ export class DependencyDeputy {
                         return false;
                     const peerDependencies = this.getPeerDependencies(workspaceName, typedPackageName);
                     if (peerDependencies.length) {
-                        return !peerDependencies.find(peerDependency => !isUnreferencedDependency(peerDependency));
+                        return !peerDependencies.find(peerDependency => !isNotReferencedDependency(peerDependency));
                     }
                     return !referencedDependencies?.has(typedPackageName);
                 }
                 if (!referencedDependencies?.has(dependency)) {
                     const peerDependencies = this.getPeerDependencies(workspaceName, dependency);
-                    return !peerDependencies.find(peerDependency => !isUnreferencedDependency(peerDependency));
+                    return !peerDependencies.find(peerDependency => !isNotReferencedDependency(peerDependency));
                 }
                 return false;
             };
             this.getProductionDependencies(workspaceName)
-                .filter(symbol => !IGNORED_DEPENDENCIES.includes(symbol) && !ignoreDependencies.includes(symbol))
-                .filter(isUnreferencedDependency)
+                .filter(isNotIgnoredDependency)
+                .filter(isNotIgnoredBinary)
+                .filter(isNotReferencedDependency)
                 .forEach(symbol => dependencyIssues.push({ type: 'dependencies', filePath: manifestPath, symbol }));
             this.getDevDependencies(workspaceName)
-                .filter(symbol => !IGNORED_DEPENDENCIES.includes(symbol) && !ignoreDependencies.includes(symbol))
-                .filter(isUnreferencedDependency)
+                .filter(isNotIgnoredDependency)
+                .filter(isNotIgnoredBinary)
+                .filter(isNotReferencedDependency)
                 .forEach(symbol => devDependencyIssues.push({ type: 'devDependencies', filePath: manifestPath, symbol }));
         }
         return { dependencyIssues, devDependencyIssues };

package/dist/{principal-factory.d.ts → PrincipalFactory.d.ts}

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { ProjectPrincipal } from './project-principal.js';
+import { ProjectPrincipal } from './ProjectPrincipal.js';
 import type { SyncCompilers, AsyncCompilers } from './types/compilers.js';
 import type { Report } from './types/issues.js';
 type Paths = ts.CompilerOptions['paths'];

package/dist/{principal-factory.js → PrincipalFactory.js}

@@ -1,4 +1,4 @@
-import { ProjectPrincipal } from './project-principal.js';
+import { ProjectPrincipal } from './ProjectPrincipal.js';
 import { join, isAbsolute } from './util/path.js';
 const mergePaths = (cwd, compilerOptions, paths = {}) => {
     const overridePaths = Object.keys(paths).reduce((overridePaths, key) => {

package/dist/{project-principal.d.ts → ProjectPrincipal.d.ts}

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { SourceFileManager } from './typescript/SourceFileManager.js';
-import type { ExportItem, ExportItemMember } from './types/ast.js';
 import type { SyncCompilers, AsyncCompilers } from './types/compilers.js';
+import type { ExportItem, ExportItemMember } from './types/exports.js';
 import type { Report } from './types/issues.js';
 type ProjectPrincipalOptions = {
     compilerOptions: ts.CompilerOptions;
@@ -39,12 +39,15 @@ export declare class ProjectPrincipal {
     getUnreferencedFiles(): string[];
     analyzeSourceFile(filePath: string): {
         imports: {
-            internal: import("./types/ast.js").Imports;
+            internal: import("./types/imports.js").Imports;
             unresolved: Set<string>;
             external: Set<string>;
         };
-        exports: import("./types/ast.js").ExportItems;
-        duplicateExports: string[][];
+        exports: {
+            exported: import("./types/exports.js").ExportItems;
+            duplicate: string[][];
+        };
+        scripts: Set<string>;
     };
     private resolveModule;
     hasExternalReferences(filePath: string, exportedItem: ExportItem): boolean;

package/dist/{project-principal.js → ProjectPrincipal.js}

@@ -1,10 +1,10 @@
 import ts from 'typescript';
 import { DEFAULT_EXTENSIONS } from './constants.js';
 import { IGNORED_FILE_EXTENSIONS } from './constants.js';
-import { getImportsAndExports } from './typescript/ast-walker.js';
 import { createHosts } from './typescript/createHosts.js';
+import { getImportsAndExports } from './typescript/getImportsAndExports.js';
 import { extname, isInNodeModules } from './util/path.js';
-import { timerify } from './util/performance.js';
+import { timerify } from './util/Performance.js';
 const baseCompilerOptions = {
     allowJs: true,
     jsx: ts.JsxEmit.Preserve,
@@ -109,7 +109,7 @@ export class ProjectPrincipal {
             throw new Error(`Unable to find ${filePath}`);
         const skipTypeOnly = !this.isReportTypes;
         const skipExports = this.skipExportsAnalysis.has(filePath);
-        const { imports, exports, duplicateExports } = getImportsAndExports(sourceFile, { skipTypeOnly, skipExports });
+        const { imports, exports, scripts } = getImportsAndExports(sourceFile, { skipTypeOnly, skipExports });
         const { internal, unresolved, external } = imports;
         const unresolvedImports = new Set();
         unresolved.forEach(specifier => {
@@ -144,7 +144,7 @@ export class ProjectPrincipal {
                 external,
             },
             exports,
-            duplicateExports,
+            scripts,
         };
     }
     resolveModule(specifier, filePath = specifier) {
@@ -159,6 +159,8 @@ export class ProjectPrincipal {
     findUnusedMembers(filePath, members) {
         return members
             .filter(member => {
+            if (this.isPublicExport(member))
+                return false;
             const referencedSymbols = this.findReferences(filePath, member.node);
             const files = referencedSymbols
                 .flatMap(refs => refs.references)

package/dist/{workspace-worker.d.ts → WorkspaceWorker.d.ts}

@@ -50,7 +50,7 @@ export declare class WorkspaceWorker {
         peerDependencies: PeerDependencies;
         installedBinaries: InstalledBinaries;
         referencedDependencies: ReferencedDependencies;
-        enabledPlugins: ("typescript" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "tailwind" | "typedoc" | "vite" | "vitest" | "webpack" | "githubActions" | "lintStaged" | "npmPackageJsonLint" | "releaseIt" | "semanticRelease" | "svelte")[];
+        enabledPlugins: ("ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "tailwind" | "typedoc" | "typescript" | "vite" | "vitest" | "webpack" | "githubActions" | "lintStaged" | "npmPackageJsonLint" | "releaseIt" | "semanticRelease" | "svelte")[];
     }>;
 }
 export {};

package/dist/{workspace-worker.js → WorkspaceWorker.js}

@@ -58,7 +58,6 @@ export class WorkspaceWorker {
     }
     async initReferencedDependencies() {
         const { dependencies, peerDependencies, installedBinaries } = await npm.findDependencies({
-            config: this.config,
             manifest: this.manifest,
             isProduction: this.isProduction,
             isStrict: this.isStrict,
@@ -218,7 +217,6 @@ export class WorkspaceWorker {
                             cwd,
                             manifest: this.manifest,
                             config: pluginConfig,
-                            workspaceConfig: this.config,
                             isProduction: this.isProduction,
                         });
                         dependencies.forEach(specifier => {

package/dist/binaries/index.d.ts

@@ -1,2 +1,2 @@
-import type { GetReferencesFromScripts } from './types.js';
-export declare const _getReferencesFromScripts: GetReferencesFromScripts;
+import type { GetDependenciesFromScripts } from './types.js';
+export declare const _getDependenciesFromScripts: GetDependenciesFromScripts;

package/dist/binaries/index.js

@@ -1,23 +1,19 @@
-import { IGNORED_GLOBAL_BINARIES } from '../constants.js';
 import { compact } from '../util/array.js';
-import { partition } from '../util/array.js';
 import { getPackageNameFromModuleSpecifier, stripBinary } from '../util/modules.js';
 import { isInternal } from '../util/path.js';
-import { timerify } from '../util/performance.js';
+import { timerify } from '../util/Performance.js';
 import { getBinariesFromScript } from './bash-parser.js';
 const defaultCwd = process.cwd();
-const getReferencesFromScripts = (npmScripts, options = {}) => {
-    const { cwd = defaultCwd, manifest = {}, ignore = [], knownGlobalsOnly = false } = options;
-    const scripts = [npmScripts].flat();
+const getDependenciesFromScripts = (npmScripts, options = {}) => {
+    const { cwd = defaultCwd, manifest = {}, knownGlobalsOnly = false } = options;
+    const scripts = typeof npmScripts === 'string' ? [npmScripts] : [...npmScripts];
     const results = scripts.flatMap(script => getBinariesFromScript(script, { cwd, manifest, knownGlobalsOnly }));
-    const [entryFiles, binaries] = partition(compact(results), isInternal);
-    return {
-        entryFiles,
-        binaries: binaries
-            .map(stripBinary)
-            .map(getPackageNameFromModuleSpecifier)
-            .filter(binaryName => !binaryName.startsWith('.'))
-            .filter(binaryName => !IGNORED_GLOBAL_BINARIES.includes(binaryName) && !ignore.includes(binaryName)),
-    };
+    return compact(results.map(identifier => {
+        if (isInternal(identifier))
+            return identifier;
+        const packageName = getPackageNameFromModuleSpecifier(stripBinary(identifier));
+        if (!packageName.startsWith('.'))
+            return packageName;
+    }));
 };
-export const _getReferencesFromScripts = timerify(getReferencesFromScripts);
+export const _getDependenciesFromScripts = timerify(getDependenciesFromScripts);

package/dist/binaries/resolvers/fallback.js

@@ -1,14 +1,18 @@
 import parseArgs from 'minimist';
 import { compact } from '../../util/array.js';
 import { tryResolveFilePaths } from './util.js';
+const withPositional = parsed => [parsed._[0], parsed.require].flat();
+const withoutPositional = parsed => [parsed.require].flat();
 const argFilters = {
-    'babel-node': parsed => [parsed._[0], parsed.require].flat(),
-    'ts-node': parsed => [parsed._[0], parsed.require].flat(),
+    'babel-node': withPositional,
+    nodemon: withPositional,
+    'ts-node': withPositional,
+    zx: withPositional,
     tsx: parsed => parsed._.filter(p => p !== 'watch'),
-    default: parsed => [parsed.require].flat(),
+    default: withoutPositional,
 };
 export const resolve = (binary, args, { cwd }) => {
-    const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader'] } });
+    const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader'] }, boolean: ['quiet', 'verbose'] });
     const argFilter = argFilters[binary] ?? argFilters.default;
     const filteredArgs = compact(argFilter(parsed));
     return [binary, ...tryResolveFilePaths(cwd, filteredArgs)];

package/dist/binaries/resolvers/npx.js

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

package/dist/binaries/types.d.ts

@@ -2,13 +2,9 @@ import type { PackageJson } from 'type-fest';
 type Options = {
     cwd?: string;
     manifest?: PackageJson;
-    ignore?: string[];
     knownGlobalsOnly?: boolean;
 };
-export type GetReferencesFromScripts = (npmScripts: string | string[], options?: Options) => {
-    entryFiles: string[];
-    binaries: string[];
-};
+export type GetDependenciesFromScripts = (npmScripts: string | string[] | Set<string>, options?: Options) => string[];
 type FromArgs = (args: string[]) => string[];
 export type Resolver = (binary: string, args: string[], options: {
     cwd: string;

package/dist/cli.js

@@ -6,7 +6,7 @@ import parsedArgs, { helpText } from './util/cli-arguments.js';
 import { isKnownError, ConfigurationError } from './util/errors.js';
 import { _load } from './util/loader.js';
 import { cwd, resolve } from './util/path.js';
-import { Performance } from './util/performance.js';
+import { Performance } from './util/Performance.js';
 import { version } from './version.js';
 import { main } from './index.js';
 const { debug: isDebug = false, help: isHelp, 'max-issues': maxIssues = '0', 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = false, performance: isObservePerf = false, production: isProduction = false, reporter = 'symbols', 'reporter-options': reporterOptions = '', strict: isStrict = false, tsConfig, version: isVersion, } = parsedArgs.values;