knip 4.1.0 → 4.2.1

package/dist/ProjectPrincipal.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { dummyCompilers, getExtensions } from './compilers/index.js';
+import { dummyCompilers, getCompilerExtensions } from './compilers/index.js';
 import { DEFAULT_EXTENSIONS } from './constants.js';
 import { IGNORED_FILE_EXTENSIONS } from './constants.js';
 import { createHosts } from './typescript/createHosts.js';
@@ -51,7 +51,7 @@ export class ProjectPrincipal {
             allowNonTsExtensions: true,
         };
         const [syncCompilers, asyncCompilers] = compilers;
-        this.extensions = new Set([...DEFAULT_EXTENSIONS, ...getExtensions(compilers)]);
+        this.extensions = new Set([...DEFAULT_EXTENSIONS, ...getCompilerExtensions(compilers)]);
         this.syncCompilers = syncCompilers;
         this.asyncCompilers = asyncCompilers;
     }
@@ -76,7 +76,7 @@ export class ProjectPrincipal {
     addCompilers(compilers) {
         this.syncCompilers = new Map([...this.syncCompilers, ...compilers[0]]);
         this.asyncCompilers = new Map([...this.asyncCompilers, ...compilers[1]]);
-        this.extensions = new Set([...this.extensions, ...getExtensions(compilers)]);
+        this.extensions = new Set([...this.extensions, ...getCompilerExtensions(compilers)]);
     }
     createProgram() {
         this.backend.program = tsCreateProgram(Array.from(this.entryPaths), this.compilerOptions, this.backend.compilerHost, this.backend.program);
@@ -102,7 +102,7 @@ export class ProjectPrincipal {
             this.projectPaths.add(filePath);
         }
     }
-    addReferencedDependencies(referencedDependencies, workspaceName) {
+    addReferencedDependencies(workspaceName, referencedDependencies) {
         referencedDependencies.forEach(referencedDependency => this.referencedDependencies.add([...referencedDependency, workspaceName]));
     }
     async runAsyncCompilers() {

package/dist/WorkspaceWorker.d.ts

@@ -1,12 +1,13 @@
 import type { Configuration, PluginName, WorkspaceConfiguration } from './types/config.js';
-import type { PackageJsonWithPlugins } from './types/package-json.js';
-import type { InstalledBinaries, HostDependencies } from './types/workspace.js';
+import type { PackageJson } from './types/package-json.js';
+import type { DependencySet } from './types/workspace.js';
 type WorkspaceManagerOptions = {
     name: string;
     dir: string;
     cwd: string;
     config: WorkspaceConfiguration;
-    manifest: PackageJsonWithPlugins;
+    manifest: PackageJson;
+    dependencies: DependencySet;
     rootIgnore: Configuration['ignore'];
     negatedWorkspacePatterns: string[];
     enabledPluginsInAncestors: string[];
@@ -19,24 +20,19 @@ export declare class WorkspaceWorker {
     dir: string;
     cwd: string;
     config: WorkspaceConfiguration;
-    manifest: PackageJsonWithPlugins;
+    manifest: PackageJson;
+    manifestScriptNames: Set<string>;
+    dependencies: DependencySet;
     isProduction: boolean;
     isStrict: boolean;
     rootIgnore: Configuration['ignore'];
     negatedWorkspacePatterns: string[];
-    enabledPluginsInAncestors: string[];
-    enabled: Record<PluginName, boolean>;
+    enabledPluginsMap: Record<"typescript" | "astro" | "svelte" | "vue" | "angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eleventy" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "linthtml" | "markdownlint" | "mocha" | "netlify" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "tailwind" | "tsup" | "typedoc" | "unbuild" | "vite" | "vitest" | "webpack" | "wireit" | "drizzle" | "githubActions" | "graphqlCodegen" | "lintStaged" | "nodeTestRunner" | "npmPackageJsonLint" | "playwrightCt" | "releaseIt" | "semanticRelease", boolean>;
     enabledPlugins: PluginName[];
-    referencedDependencies: ReferencedDependencies;
-    hostDependencies: HostDependencies;
-    installedBinaries: InstalledBinaries;
-    hasTypesIncluded: Set<string>;
-    entryFilePatterns: Set<string>;
-    productionEntryFilePatterns: Set<string>;
-    constructor({ name, dir, cwd, config, manifest, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, }: WorkspaceManagerOptions);
+    enabledPluginsInAncestors: string[];
+    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, }: WorkspaceManagerOptions);
     init(): Promise<void>;
-    private setEnabledPlugins;
-    private initReferencedDependencies;
+    private determineEnabledPlugins;
     private getConfigForPlugin;
     getEntryFilePatterns(): string[];
     getProjectFilePatterns(testFilePatterns: string[]): string[];
@@ -46,15 +42,11 @@ export declare class WorkspaceWorker {
     getProductionProjectFilePatterns(negatedTestFilePatterns: string[]): string[];
     private getConfigurationFilePatterns;
     getIgnorePatterns(): string[];
-    private findDependenciesByPlugins;
-    findAllDependencies(): Promise<{
-        hostDependencies: HostDependencies;
-        installedBinaries: InstalledBinaries;
+    findDependenciesByPlugins(): Promise<{
+        entryFilePatterns: Set<string>;
+        productionEntryFilePatterns: Set<string>;
         referencedDependencies: ReferencedDependencies;
-        hasTypesIncluded: Set<string>;
-        enabledPlugins: ("typescript" | "astro" | "svelte" | "vue" | "angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eleventy" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "linthtml" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "tailwind" | "tsup" | "typedoc" | "unbuild" | "vite" | "vitest" | "webpack" | "wireit" | "drizzle" | "githubActions" | "graphqlCodegen" | "lintStaged" | "nodeTestRunner" | "npmPackageJsonLint" | "playwrightCt" | "releaseIt" | "semanticRelease")[];
-        entryFilePatterns: string[];
-        productionEntryFilePatterns: string[];
+        enabledPlugins: ("typescript" | "astro" | "svelte" | "vue" | "angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eleventy" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "linthtml" | "markdownlint" | "mocha" | "netlify" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "tailwind" | "tsup" | "typedoc" | "unbuild" | "vite" | "vitest" | "webpack" | "wireit" | "drizzle" | "githubActions" | "graphqlCodegen" | "lintStaged" | "nodeTestRunner" | "npmPackageJsonLint" | "playwrightCt" | "releaseIt" | "semanticRelease")[];
     }>;
 }
 export {};

package/dist/WorkspaceWorker.js

@@ -1,85 +1,64 @@
-import * as npm from './manifest/index.js';
 import * as plugins from './plugins/index.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _pureGlob, negate, hasProductionSuffix, hasNoProductionSuffix, prependDirToPattern } from './util/glob.js';
 import { FAKE_PATH } from './util/loader.js';
 import { get, getKeysByValue } from './util/object.js';
-import { basename, join, toPosix } from './util/path.js';
+import { basename, toPosix } from './util/path.js';
 import { fromEntryPattern, fromProductionEntryPattern, isEntryPattern, isProductionEntryPattern, } from './util/protocols.js';
 const nullConfig = { config: null, entry: null, project: null };
+const initEnabledPluginsMap = () => Object.keys(plugins).reduce((enabled, pluginName) => ({ ...enabled, [pluginName]: false }), {});
 export class WorkspaceWorker {
     name;
     dir;
     cwd;
     config;
     manifest;
+    manifestScriptNames;
+    dependencies;
     isProduction;
     isStrict;
     rootIgnore;
     negatedWorkspacePatterns = [];
-    enabledPluginsInAncestors;
-    enabled;
+    enabledPluginsMap = initEnabledPluginsMap();
     enabledPlugins = [];
-    referencedDependencies = new Set();
-    hostDependencies = new Map();
-    installedBinaries = new Map();
-    hasTypesIncluded = new Set();
-    entryFilePatterns = new Set();
-    productionEntryFilePatterns = new Set();
-    constructor({ name, dir, cwd, config, manifest, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, }) {
+    enabledPluginsInAncestors;
+    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, }) {
         this.name = name;
         this.dir = dir;
         this.cwd = cwd;
         this.config = config;
         this.manifest = manifest;
+        this.manifestScriptNames = new Set(Object.keys(manifest.scripts ?? {}));
+        this.dependencies = dependencies;
         this.isProduction = isProduction;
         this.isStrict = isStrict;
         this.rootIgnore = rootIgnore;
         this.negatedWorkspacePatterns = negatedWorkspacePatterns;
         this.enabledPluginsInAncestors = enabledPluginsInAncestors;
-        this.enabled = Object.keys(plugins).reduce((enabled, pluginName) => ({ ...enabled, [pluginName]: false }), {});
     }
     async init() {
-        await this.setEnabledPlugins();
-        await this.initReferencedDependencies();
+        this.enabledPlugins = await this.determineEnabledPlugins();
     }
-    async setEnabledPlugins() {
+    async determineEnabledPlugins() {
         const manifest = this.manifest;
-        const deps = Object.keys(manifest.dependencies ?? {});
-        const devDeps = Object.keys(manifest.devDependencies ?? {});
-        const dependencies = new Set([...deps, ...devDeps]);
         const pluginEntries = Object.entries(plugins);
         for (const [pluginName, plugin] of pluginEntries) {
             if (this.config[pluginName] === false)
                 continue;
             if (this.config[pluginName]) {
-                this.enabled[pluginName] = true;
+                this.enabledPluginsMap[pluginName] = true;
                 continue;
             }
             const isEnabledInAncestor = this.enabledPluginsInAncestors.includes(pluginName);
             if (isEnabledInAncestor ||
-                (await plugin.isEnabled({ cwd: this.dir, manifest, dependencies, config: this.config }))) {
-                this.enabled[pluginName] = true;
+                (await plugin.isEnabled({ cwd: this.dir, manifest, dependencies: this.dependencies, config: this.config }))) {
+                this.enabledPluginsMap[pluginName] = true;
             }
         }
-        this.enabledPlugins = getKeysByValue(this.enabled, true);
-        const enabledPluginNames = this.enabledPlugins.map(name => plugins[name].NAME);
+        const enabledPlugins = getKeysByValue(this.enabledPluginsMap, true);
+        const enabledPluginNames = enabledPlugins.map(name => plugins[name].NAME);
         debugLogObject(this.name, 'Enabled plugins', enabledPluginNames);
-    }
-    async initReferencedDependencies() {
-        const { dependencies, hostDependencies, installedBinaries, hasTypesIncluded } = await npm.findDependencies({
-            manifest: this.manifest,
-            isProduction: this.isProduction,
-            isStrict: this.isStrict,
-            dir: this.dir,
-            cwd: this.cwd,
-        });
-        const filePath = join(this.dir, 'package.json');
-        dependencies.forEach(dependency => this.referencedDependencies.add([filePath, dependency]));
-        this.hostDependencies = hostDependencies;
-        this.installedBinaries = installedBinaries;
-        this.hasTypesIncluded = hasTypesIncluded;
-        this.hasTypesIncluded = hasTypesIncluded;
+        return enabledPlugins;
     }
     getConfigForPlugin(pluginName) {
         const config = this.config[pluginName];
@@ -111,7 +90,7 @@ export class WorkspaceWorker {
         const patterns = [];
         for (const [pluginName, plugin] of Object.entries(plugins)) {
             const pluginConfig = this.getConfigForPlugin(pluginName);
-            if (this.enabled[pluginName]) {
+            if (this.enabledPluginsMap[pluginName]) {
                 const { entry, project } = pluginConfig;
                 patterns.push(...(project ?? entry ?? ('PROJECT_FILE_PATTERNS' in plugin ? plugin.PROJECT_FILE_PATTERNS : [])));
             }
@@ -122,7 +101,7 @@ export class WorkspaceWorker {
         const patterns = [];
         for (const [pluginName, plugin] of Object.entries(plugins)) {
             const pluginConfig = this.getConfigForPlugin(pluginName);
-            if (this.enabled[pluginName] && pluginConfig) {
+            if (this.enabledPluginsMap[pluginName] && pluginConfig) {
                 const { config } = pluginConfig;
                 const defaultConfigFiles = 'CONFIG_FILE_PATTERNS' in plugin ? plugin.CONFIG_FILE_PATTERNS : [];
                 patterns.push(...(config ?? defaultConfigFiles));
@@ -171,10 +150,13 @@ export class WorkspaceWorker {
         return [...this.rootIgnore, ...this.config.ignore.map(pattern => prependDirToPattern(this.name, pattern))];
     }
     async findDependenciesByPlugins() {
+        const entryFilePatterns = new Set();
+        const productionEntryFilePatterns = new Set();
+        const referencedDependencies = new Set();
         const name = this.name;
         const cwd = this.dir;
         for (const [pluginName, plugin] of Object.entries(plugins)) {
-            if (this.enabled[pluginName]) {
+            if (this.enabledPluginsMap[pluginName]) {
                 const hasDependencyFinder = 'findDependencies' in plugin && typeof plugin.findDependencies === 'function';
                 if (hasDependencyFinder) {
                     const pluginConfig = this.getConfigForPlugin(pluginName);
@@ -192,6 +174,8 @@ export class WorkspaceWorker {
                         const dependencies = await plugin.findDependencies(configFilePath, {
                             cwd,
                             manifest: this.manifest,
+                            manifestScriptNames: this.manifestScriptNames,
+                            dependencies: this.dependencies,
                             config: pluginConfig,
                             isProduction: this.isProduction,
                             enabledPlugins: this.enabledPlugins,
@@ -199,13 +183,13 @@ export class WorkspaceWorker {
                         dependencies.forEach(specifier => {
                             pluginDependencies.add(specifier);
                             if (isEntryPattern(specifier)) {
-                                this.entryFilePatterns.add(fromEntryPattern(specifier));
+                                entryFilePatterns.add(fromEntryPattern(specifier));
                             }
                             else if (isProductionEntryPattern(specifier)) {
-                                this.productionEntryFilePatterns.add(fromProductionEntryPattern(specifier));
+                                productionEntryFilePatterns.add(fromProductionEntryPattern(specifier));
                             }
                             else {
-                                this.referencedDependencies.add([configFilePath, toPosix(specifier)]);
+                                referencedDependencies.add([configFilePath, toPosix(specifier)]);
                             }
                         });
                     }
@@ -213,17 +197,11 @@ export class WorkspaceWorker {
                 }
             }
         }
-    }
-    async findAllDependencies() {
-        await this.findDependenciesByPlugins();
         return {
-            hostDependencies: this.hostDependencies,
-            installedBinaries: this.installedBinaries,
-            referencedDependencies: this.referencedDependencies,
-            hasTypesIncluded: this.hasTypesIncluded,
+            entryFilePatterns,
+            productionEntryFilePatterns,
+            referencedDependencies,
             enabledPlugins: this.enabledPlugins,
-            entryFilePatterns: Array.from(this.entryFilePatterns),
-            productionEntryFilePatterns: Array.from(this.productionEntryFilePatterns),
         };
     }
 }

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

@@ -1,6 +1,2 @@
-import type { PackageJson } from '@npmcli/package-json';
-export declare const getBinariesFromScript: (script: string, { cwd, manifest, knownGlobalsOnly }: {
-    cwd: string;
-    manifest: PackageJson;
-    knownGlobalsOnly?: boolean | undefined;
-}) => string[];
+import type { GetDependenciesFromScriptsOptions } from './types.js';
+export declare const getBinariesFromScript: (script: string, options: GetDependenciesFromScriptsOptions) => string[];

package/dist/binaries/bash-parser.js

@@ -1,12 +1,12 @@
 import parse from '@ericcornelissen/bash-parser';
 import { debugLogObject } from '../util/debug.js';
 import * as FallbackResolver from './resolvers/fallback.js';
-import * as KnownResolvers from './resolvers/index.js';
+import KnownResolvers from './resolvers/index.js';
 import { stripBinaryPath } from './util.js';
-export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly = false }) => {
+export const getBinariesFromScript = (script, options) => {
     if (!script)
         return [];
-    const fromArgs = (args) => getBinariesFromScript(args.filter(arg => arg !== '--').join(' '), { cwd, manifest });
+    const fromArgs = (args) => getBinariesFromScript(args.filter(arg => arg !== '--').join(' '), { ...options, knownGlobalsOnly: false });
     const getBinariesFromNodes = (nodes) => nodes.flatMap(node => {
         switch (node.type) {
             case 'Command': {
@@ -25,11 +25,12 @@ export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly
                 if (['!', 'test'].includes(binary))
                     return fromArgs(args);
                 if (binary in KnownResolvers) {
-                    return KnownResolvers[binary].resolve(binary, args, { cwd, manifest, fromArgs });
+                    const resolver = KnownResolvers[binary];
+                    return resolver(binary, args, { ...options, fromArgs });
                 }
-                if (knownGlobalsOnly)
+                if (options.knownGlobalsOnly)
                     return [];
-                return FallbackResolver.resolve(binary, args, { cwd, manifest, fromArgs });
+                return FallbackResolver.resolve(binary, args, { ...options, fromArgs });
             }
             case 'LogicalExpression':
                 return getBinariesFromNodes([node.left, node.right]);

package/dist/binaries/index.js

@@ -5,11 +5,9 @@ import { extname, isInternal } from '../util/path.js';
 import { timerify } from '../util/Performance.js';
 import { fromBinary, isBinary } from '../util/protocols.js';
 import { getBinariesFromScript } from './bash-parser.js';
-const defaultCwd = process.cwd();
-const getDependenciesFromScripts = (npmScripts, options = {}) => {
-    const { cwd = defaultCwd, manifest = {}, knownGlobalsOnly = false } = options;
+const getDependenciesFromScripts = (npmScripts, options) => {
     const scripts = typeof npmScripts === 'string' ? [npmScripts] : [...npmScripts];
-    const results = scripts.flatMap(script => getBinariesFromScript(script, { cwd, manifest, knownGlobalsOnly }));
+    const results = scripts.flatMap(script => getBinariesFromScript(script, options));
     return compact(results.map(identifier => {
         if (identifier.startsWith('http'))
             return;

package/dist/binaries/resolvers/bun.js

@@ -1,11 +1,10 @@
 import parseArgs from 'minimist';
 import { tryResolveFilePath } from '../util.js';
 const commands = ['add', 'create', 'init', 'install', 'link', 'pm', 'remove', 'run', 'update'];
-export const resolve = (_binary, args, { manifest, cwd, fromArgs }) => {
-    const scripts = manifest.scripts ? Object.keys(manifest.scripts) : [];
+export const resolve = (_binary, args, { manifestScriptNames, cwd, fromArgs }) => {
     const parsed = parseArgs(args);
     const [command, script] = parsed._;
-    if (command === 'run' && scripts.includes(script))
+    if (command === 'run' && manifestScriptNames.has(script))
         return [];
     if (commands.includes(command))
         return [];

package/dist/binaries/resolvers/fallback.js

@@ -11,7 +11,6 @@ const argFilters = {
     esbuild: withPositional,
     execa: withPositional,
     vitest: withoutRequire,
-    'ts-node': withPositional,
     zx: withPositional,
     default: withoutPositional,
 };

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

@@ -1,11 +1,15 @@
-export * as bun from './bun.js';
-export * as c8 from './c8.js';
-export * as dotenv from './dotenv.js';
-export * as node from './node.js';
-export * as nodemon from './nodemon.js';
-export * as npx from './npx.js';
-export * as nx from './nx.js';
-export * as pnpm from './pnpm.js';
-export * as rollup from './rollup.js';
-export * as tsx from './tsx.js';
-export * as yarn from './yarn.js';
+declare const _default: {
+    bun: import("../types.js").Resolver;
+    c8: import("../types.js").Resolver;
+    dotenv: import("../types.js").Resolver;
+    node: import("../types.js").Resolver;
+    nodemon: import("../types.js").Resolver;
+    npx: import("../types.js").Resolver;
+    nx: import("../types.js").Resolver;
+    pnpm: import("../types.js").Resolver;
+    rollup: import("../types.js").Resolver;
+    'ts-node': import("../types.js").Resolver;
+    tsx: import("../types.js").Resolver;
+    yarn: import("../types.js").Resolver;
+};
+export default _default;

package/dist/binaries/resolvers/index.js

@@ -1,11 +1,26 @@
-export * as bun from './bun.js';
-export * as c8 from './c8.js';
-export * as dotenv from './dotenv.js';
-export * as node from './node.js';
-export * as nodemon from './nodemon.js';
-export * as npx from './npx.js';
-export * as nx from './nx.js';
-export * as pnpm from './pnpm.js';
-export * as rollup from './rollup.js';
-export * as tsx from './tsx.js';
-export * as yarn from './yarn.js';
+import * as bun from './bun.js';
+import * as c8 from './c8.js';
+import * as dotenv from './dotenv.js';
+import * as node from './node.js';
+import * as nodemon from './nodemon.js';
+import * as npx from './npx.js';
+import * as nx from './nx.js';
+import * as pnpm from './pnpm.js';
+import * as rollup from './rollup.js';
+import * as tsNode from './ts-node.js';
+import * as tsx from './tsx.js';
+import * as yarn from './yarn.js';
+export default {
+    bun: bun.resolve,
+    c8: c8.resolve,
+    dotenv: dotenv.resolve,
+    node: node.resolve,
+    nodemon: nodemon.resolve,
+    npx: npx.resolve,
+    nx: nx.resolve,
+    pnpm: pnpm.resolve,
+    rollup: rollup.resolve,
+    'ts-node': tsNode.resolve,
+    tsx: tsx.resolve,
+    yarn: yarn.resolve,
+};

package/dist/binaries/resolvers/npx.js

@@ -1,9 +1,9 @@
 import parseArgs from 'minimist';
 import { isInternal } from '../../util/path.js';
 import { toBinary } from '../../util/protocols.js';
-import { getBinariesFromScript } from '../bash-parser.js';
 import { argsFrom, stripVersionFromSpecifier } from '../util.js';
-export const resolve = (binary, args, { cwd, fromArgs, manifest }) => {
+export const resolve = (binary, args, options) => {
+    const { fromArgs, dependencies } = options;
     const parsed = parseArgs(args, {
         boolean: ['yes', 'no'],
         alias: { yes: 'y', no: 'no-install', package: 'p', call: 'c' },
@@ -11,10 +11,9 @@ export const resolve = (binary, args, { cwd, fromArgs, manifest }) => {
     const packageSpecifier = parsed._[0];
     const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
     const packages = parsed.package ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
-    const command = parsed.call ? getBinariesFromScript(parsed.call, { cwd, manifest }) : [];
+    const command = parsed.call ? fromArgs([parsed.call]) : [];
     const restArgs = argsFrom(args, packageSpecifier);
-    const dependencies = manifest ? Object.keys({ ...manifest.dependencies, ...manifest.devDependencies }) : [];
-    const isBinary = specifier && !packageSpecifier.includes('@') && !isInternal(specifier) && !dependencies.includes(specifier);
+    const isBinary = specifier && !packageSpecifier.includes('@') && !isInternal(specifier) && !dependencies.has(specifier);
     const dependency = isBinary ? toBinary(specifier) : specifier;
     const specifiers = dependency && !parsed.yes ? [dependency] : [];
     return [...specifiers, ...packages, ...command, ...fromArgs(restArgs).slice(1)];

package/dist/binaries/resolvers/pnpm.js

@@ -51,11 +51,10 @@ const commands = [
     'upgrade',
     'why',
 ];
-export const resolve = (_binary, args, { manifest }) => {
-    const scripts = manifest.scripts ? Object.keys(manifest.scripts) : [];
+export const resolve = (_binary, args, { manifestScriptNames }) => {
     const parsed = parseArgs(args, { alias: { recursive: 'r' }, boolean: ['recursive'] });
     const [command, binary] = parsed._;
-    if (scripts.includes(command) || commands.includes(command))
+    if (manifestScriptNames.has(command) || commands.includes(command))
         return [];
     if (command === 'exec')
         return [toBinary(binary)];

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

@@ -0,0 +1,2 @@
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/binaries/resolvers/ts-node.js

@@ -0,0 +1,16 @@
+import parseArgs from 'minimist';
+import { compact } from '../../util/array.js';
+import { toBinary } from '../../util/protocols.js';
+import { tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
+export const resolve = (binary, args, { cwd }) => {
+    const parsed = parseArgs(args, {
+        string: ['r'],
+        boolean: ['transpileOnly', 'compilerHost', 'ignoreDiagnostics', 'swc', 'preferTsExts'],
+        alias: { require: ['r'], transpileOnly: ['T'], compilerHost: ['H'], ignoreDiagnostics: ['D'] },
+    });
+    return compact([
+        toBinary(binary),
+        tryResolveFilePath(cwd, parsed._[0]),
+        ...tryResolveSpecifiers(cwd, [parsed.require].flat()),
+    ]);
+};

package/dist/binaries/resolvers/yarn.js

@@ -32,13 +32,12 @@ const commands = [
     'workspace',
     'workspaces',
 ];
-export const resolve = (_binary, args, { manifest, fromArgs }) => {
-    const scripts = manifest.scripts ? Object.keys(manifest.scripts) : [];
+export const resolve = (_binary, args, { manifestScriptNames, fromArgs }) => {
     const parsed = parseArgs(args, {});
     const [command, binary] = parsed._;
-    if (scripts.includes(command) || commands.includes(command))
+    if (manifestScriptNames.has(command) || commands.includes(command))
         return [];
-    if (command === 'run' && scripts.includes(binary))
+    if (command === 'run' && manifestScriptNames.has(binary))
         return [];
     if (command === 'run' || command === 'exec')
         return [toBinary(binary)];

package/dist/binaries/types.d.ts

@@ -1,15 +1,11 @@
-/// <reference types="npmcli__package-json" />
-import type { PackageJson } from '@npmcli/package-json';
-type Options = {
-    cwd?: string;
-    manifest?: PackageJson;
+import type { BaseOptions } from '../types/plugins.js';
+export interface GetDependenciesFromScriptsOptions extends BaseOptions {
     knownGlobalsOnly?: boolean;
-};
-export type GetDependenciesFromScripts = (npmScripts: string | string[] | Set<string>, options?: Options) => string[];
+}
+export type GetDependenciesFromScripts = (npmScripts: string | string[] | Set<string>, options: GetDependenciesFromScriptsOptions) => string[];
 type FromArgs = (args: string[]) => string[];
-export type Resolver = (binary: string, args: string[], options: {
-    cwd: string;
-    manifest: PackageJson;
+interface BinaryResolverOptions extends GetDependenciesFromScriptsOptions {
     fromArgs: FromArgs;
-}) => string[];
+}
+export type Resolver = (binary: string, args: string[], options: BinaryResolverOptions) => string[];
 export {};

package/dist/compilers/index.d.ts

@@ -1,6 +1,6 @@
 import type { AsyncCompilerFn, AsyncCompilers, SyncCompilerFn, SyncCompilers } from './types.js';
 import type { RawConfiguration } from '../types/config.js';
-import type { PackageJson } from '@npmcli/package-json';
+import type { DependencySet } from '../types/workspace.js';
 export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     syncCompilers: Record<string, SyncCompilerFn>;
     asyncCompilers: Record<string, AsyncCompilerFn>;
@@ -140,6 +140,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        netlify?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         next?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -391,6 +396,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    netlify?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     next?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -528,5 +538,5 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     } | undefined;
 };
 export declare const dummyCompilers: Map<string, SyncCompilerFn>;
-export declare const mergeCompilers: (syncCompilers: SyncCompilers, asyncCompilers: AsyncCompilers, manifest: PackageJson) => [SyncCompilers, AsyncCompilers];
-export declare const getExtensions: (compilers: [SyncCompilers, AsyncCompilers]) => string[];
+export declare const getIncludedCompilers: (syncCompilers: SyncCompilers, asyncCompilers: AsyncCompilers, dependencies: DependencySet) => [SyncCompilers, AsyncCompilers];
+export declare const getCompilerExtensions: (compilers: [SyncCompilers, AsyncCompilers]) => string[];

package/dist/compilers/index.js

@@ -31,13 +31,8 @@ const compilers = new Map([
 ]);
 const dummyCompiler = () => '';
 export const dummyCompilers = new Map(Array.from(DUMMY_VIRTUAL_FILE_EXTENSIONS).map(ext => [ext, dummyCompiler]));
-const getDependencies = (manifest) => [
-    ...Object.keys(manifest?.dependencies ?? {}),
-    ...Object.keys(manifest?.devDependencies ?? {}),
-];
-export const mergeCompilers = (syncCompilers, asyncCompilers, manifest) => {
-    const dependencies = getDependencies(manifest);
-    const hasDependency = (packageName) => dependencies.includes(packageName);
+export const getIncludedCompilers = (syncCompilers, asyncCompilers, dependencies) => {
+    const hasDependency = (packageName) => dependencies.has(packageName);
     for (const [extension, { condition, compiler }] of compilers.entries()) {
         if (!syncCompilers.has(extension) && condition(hasDependency)) {
             syncCompilers.set(extension, compiler);
@@ -45,7 +40,7 @@ export const mergeCompilers = (syncCompilers, asyncCompilers, manifest) => {
     }
     return [syncCompilers, asyncCompilers];
 };
-export const getExtensions = (compilers) => [
+export const getCompilerExtensions = (compilers) => [
     ...compilers[0].keys(),
     ...compilers[1].keys(),
 ];