knip 5.33.3 → 5.34.0

package/dist/binaries/bash-parser.js

@@ -1,18 +1,25 @@
 import parse, {} from '../../vendor/bash-parser/index.js';
+import { pluginArgsMap } from '../plugins.js';
 import { debugLogObject } from '../util/debug.js';
-import { toBinary } from '../util/protocols.js';
-import * as FallbackResolver from './resolvers/fallback.js';
-import KnownResolvers from './resolvers/index.js';
-import { parseNodeArgs } from './resolvers/node.js';
+import { toBinary, toDeferResolve } from '../util/input.js';
+import { resolve as fallbackResolve } from './fallback.js';
+import PackageManagerResolvers from './package-manager/index.js';
+import { parseNodeArgs } from './package-manager/node.js';
+import { resolve as resolverFromPlugins } from './plugins.js';
 import { trimBinary } from './util.js';
 const spawningBinaries = ['cross-env', 'retry-cli'];
 const isExpansion = (node) => 'expansion' in node;
 const isAssignment = (node) => 'type' in node && node.type === 'AssignmentWord';
-export const getBinariesFromScript = (script, options) => {
+export const getDependenciesFromScript = (script, options) => {
     if (!script)
         return [];
-    const fromArgs = (args) => getBinariesFromScript(args.filter(arg => arg !== '--').join(' '), { ...options, knownGlobalsOnly: false });
-    const getBinariesFromNodes = (nodes) => nodes.flatMap(node => {
+    const fromArgs = (args) => {
+        return getDependenciesFromScript(args.filter(arg => arg !== '--').join(' '), {
+            ...options,
+            knownBinsOnly: false,
+        });
+    };
+    const getDependenciesFromNodes = (nodes) => nodes.flatMap(node => {
         switch (node.type) {
             case 'Command': {
                 const text = node.name?.text;
@@ -22,7 +29,7 @@ export const getBinariesFromScript = (script, options) => {
                     .map(prefix => prefix.expansion)
                     .flatMap(expansion => expansion.filter(expansion => expansion.type === 'CommandExpansion') ?? []) ?? [];
                 if (commandExpansions.length > 0) {
-                    return commandExpansions.flatMap(expansion => getBinariesFromNodes(expansion.commandAST.commands)) ?? [];
+                    return (commandExpansions.flatMap(expansion => getDependenciesFromNodes(expansion.commandAST.commands)) ?? []);
                 }
                 if (!binary || binary === '.' || binary === 'source' || binary === '[')
                     return [];
@@ -37,38 +44,42 @@ export const getBinariesFromScript = (script, options) => {
                     .flatMap(node => node.text.split('=')[1])
                     .map(arg => parseNodeArgs(arg.split(' ')))
                     .filter(args => args.require)
-                    .flatMap(arg => arg.require) ?? [];
-                if (binary in KnownResolvers) {
-                    const resolver = KnownResolvers[binary];
+                    .flatMap(arg => arg.require)
+                    .map(toDeferResolve) ?? [];
+                if (binary in PackageManagerResolvers) {
+                    const resolver = PackageManagerResolvers[binary];
                     return resolver(binary, args, { ...options, fromArgs });
                 }
+                if (pluginArgsMap.has(binary)) {
+                    return [...resolverFromPlugins(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
+                }
                 if (spawningBinaries.includes(binary)) {
-                    const command = script.replace(new RegExp(`.*${node.name?.text ?? binary}(\\s--\\s)?`), '');
-                    return [toBinary(binary), ...getBinariesFromScript(command, options)];
+                    const command = script.replace(new RegExp(`.*${text ?? binary}(\\s--\\s)?`), '');
+                    return [toBinary(binary), ...getDependenciesFromScript(command, options)];
                 }
-                if (options.knownGlobalsOnly && !text?.startsWith('.'))
+                if (options.knownBinsOnly && !text?.startsWith('.'))
                     return [];
-                return [...FallbackResolver.resolve(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
+                return [...fallbackResolve(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
             }
             case 'LogicalExpression':
-                return getBinariesFromNodes([node.left, node.right]);
+                return getDependenciesFromNodes([node.left, node.right]);
             case 'If':
-                return getBinariesFromNodes([node.clause, node.then, ...(node.else ? [node.else] : [])]);
+                return getDependenciesFromNodes([node.clause, node.then, ...(node.else ? [node.else] : [])]);
             case 'For':
-                return getBinariesFromNodes(node.do.commands);
+                return getDependenciesFromNodes(node.do.commands);
             case 'CompoundList':
-                return getBinariesFromNodes(node.commands);
+                return getDependenciesFromNodes(node.commands);
             case 'Pipeline':
-                return getBinariesFromNodes(node.commands);
+                return getDependenciesFromNodes(node.commands);
             case 'Function':
-                return getBinariesFromNodes(node.body.commands);
+                return getDependenciesFromNodes(node.body.commands);
             default:
                 return [];
         }
     });
     try {
         const parsed = parse(script);
-        return parsed?.commands ? getBinariesFromNodes(parsed.commands) : [];
+        return parsed?.commands ? getDependenciesFromNodes(parsed.commands) : [];
     }
     catch (error) {
         debugLogObject('*', 'Bash parser error', error);

package/dist/binaries/fallback.d.ts

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

package/dist/binaries/fallback.js

@@ -0,0 +1,12 @@
+import parseArgs from 'minimist';
+import { compact } from '../util/array.js';
+import { toBinary, toDeferResolve, toEntry } from '../util/input.js';
+const spawningBinaries = ['cross-env', 'retry-cli'];
+const positionals = new Set(['babel-node', 'esbuild', 'execa', 'vite-node', 'zx']);
+export const resolve = (binary, args, { fromArgs }) => {
+    const parsed = parseArgs(args, { boolean: ['quiet', 'verbose'] });
+    const bin = binary.startsWith('.') ? toEntry(binary) : toBinary(binary);
+    const shiftedArgs = spawningBinaries.includes(binary) ? fromArgs(args) : [];
+    const pos = positionals.has(binary) ? [toDeferResolve(parsed._[0])] : [];
+    return compact([bin, ...shiftedArgs, ...pos]);
+};

package/dist/binaries/index.d.ts

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

package/dist/binaries/index.js

@@ -1,28 +1,17 @@
-import { FOREIGN_FILE_EXTENSIONS } from '../constants.js';
 import { timerify } from '../util/Performance.js';
-import { compact } from '../util/array.js';
-import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
-import { extname, isInternal } from '../util/path.js';
-import { fromBinary, isBinary } from '../util/protocols.js';
-import { getBinariesFromScript } from './bash-parser.js';
-const getDependenciesFromScripts = (npmScripts, options) => {
-    const scripts = typeof npmScripts === 'string' ? [npmScripts] : [...npmScripts];
-    const results = scripts.flatMap(script => getBinariesFromScript(script, options));
-    return compact(results.map(identifier => {
-        if (identifier.startsWith('http'))
-            return;
-        if (isBinary(identifier)) {
-            if (!/^\b/.test(fromBinary(identifier)))
-                return;
-            return identifier;
-        }
-        if (isInternal(identifier)) {
-            const ext = extname(identifier);
-            if (ext && FOREIGN_FILE_EXTENSIONS.has(ext))
-                return;
-            return identifier;
-        }
-        return getPackageNameFromModuleSpecifier(identifier);
-    }));
+import { fromBinary, isBinary } from '../util/input.js';
+import { getDependenciesFromScript } from './bash-parser.js';
+const getInputsFromScripts = (npmScripts, options) => {
+    const scripts = typeof npmScripts === 'string' ? [npmScripts] : Array.from(npmScripts);
+    const results = scripts.flatMap(script => getDependenciesFromScript(script, options));
+    const inputs = new Set();
+    for (const input of results) {
+        if (!input.specifier || input.specifier.startsWith('http'))
+            continue;
+        if (isBinary(input) && !/^\b/.test(fromBinary(input)))
+            continue;
+        inputs.add(input);
+    }
+    return Array.from(inputs);
 };
-export const _getDependenciesFromScripts = timerify(getDependenciesFromScripts);
+export const _getInputsFromScripts = timerify(getInputsFromScripts);

package/dist/binaries/package-manager/bun.d.ts

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

package/dist/binaries/{resolvers → package-manager}/bun.js

@@ -1,5 +1,7 @@
 import parseArgs from 'minimist';
-import { tryResolveFilePath } from '../util.js';
+import { isFile } from '../../util/fs.js';
+import { toEntry } from '../../util/input.js';
+import { isAbsolute, join } from '../../util/path.js';
 const commands = ['add', 'create', 'init', 'install', 'link', 'pm', 'remove', 'run', 'test', 'update', 'upgrade'];
 export const resolve = (_binary, args, { manifestScriptNames, cwd, fromArgs }) => {
     const parsed = parseArgs(args);
@@ -9,8 +11,8 @@ export const resolve = (_binary, args, { manifestScriptNames, cwd, fromArgs }) =
     if (manifestScriptNames.has(command) || commands.includes(command))
         return [];
     const filePath = command === 'run' ? script : command;
-    const specifier = tryResolveFilePath(cwd, filePath);
-    if (specifier)
-        return [specifier];
+    const absFilePath = isAbsolute(filePath) ? filePath : join(cwd, filePath);
+    if (isFile(absFilePath))
+        return [toEntry(absFilePath)];
     return fromArgs(args);
 };

package/dist/binaries/package-manager/index.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    bun: import("../../types/config.js").BinaryResolver;
+    npm: import("../../types/config.js").BinaryResolver;
+    npx: import("../../types/config.js").BinaryResolver;
+    pnpm: import("../../types/config.js").BinaryResolver;
+    yarn: import("../../types/config.js").BinaryResolver;
+};
+export default _default;

package/dist/binaries/package-manager/index.js

@@ -0,0 +1,12 @@
+import * as bun from './bun.js';
+import * as npm from './npm.js';
+import * as npx from './npx.js';
+import * as pnpm from './pnpm.js';
+import * as yarn from './yarn.js';
+export default {
+    bun: bun.resolve,
+    npm: npm.resolve,
+    npx: npx.resolve,
+    pnpm: pnpm.resolve,
+    yarn: yarn.resolve,
+};

package/dist/binaries/{resolvers → package-manager}/node.d.ts

@@ -1,4 +1,2 @@
 import parseArgs from 'minimist';
-import type { Resolver } from '../types.js';
 export declare const parseNodeArgs: (args: string[]) => parseArgs.ParsedArgs;
-export declare const resolve: Resolver;

package/dist/binaries/package-manager/node.js

@@ -0,0 +1,5 @@
+import parseArgs from 'minimist';
+export const parseNodeArgs = (args) => parseArgs(args, {
+    string: ['r'],
+    alias: { require: ['r', 'loader', 'experimental-loader', 'test-reporter', 'watch', 'import'] },
+});

package/dist/binaries/package-manager/npm.d.ts

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

package/dist/binaries/package-manager/npm.js

@@ -0,0 +1,8 @@
+import parseArgs from 'minimist';
+import { toBinary } from '../../util/input.js';
+export const resolve = (_binary, args, options) => {
+    const { fromArgs } = options;
+    const parsed = parseArgs(args);
+    const [command] = parsed._;
+    return [toBinary(_binary), ...(command !== 'exec' ? [] : fromArgs(parsed._.slice(1)))];
+};

package/dist/binaries/package-manager/npx.d.ts

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

package/dist/binaries/{resolvers → package-manager}/npx.js

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

package/dist/binaries/package-manager/pnpm.d.ts

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

package/dist/binaries/{resolvers → package-manager}/pnpm.js

@@ -1,5 +1,5 @@
 import parseArgs from 'minimist';
-import { toBinary } from '../../util/protocols.js';
+import { toBinary } from '../../util/input.js';
 const commands = [
     'add',
     'audit',
@@ -51,7 +51,7 @@ const commands = [
     'upgrade',
     'why',
 ];
-export const resolve = (_binary, args, { manifestScriptNames }) => {
+export const resolve = (_binary, args, { manifestScriptNames, fromArgs }) => {
     const parsed = parseArgs(args, {
         boolean: ['recursive', 'silent', 'shell-mode'],
         alias: { recursive: 'r', silent: 's', 'shell-mode': 'c' },
@@ -59,7 +59,10 @@ export const resolve = (_binary, args, { manifestScriptNames }) => {
     const [command, binary] = parsed._;
     if (manifestScriptNames.has(command) || commands.includes(command))
         return [];
-    if (command === 'exec')
+    if (command === 'exec') {
+        if (parsed._.length > 2)
+            return [toBinary(binary), ...fromArgs(parsed._.slice(1))];
         return [toBinary(binary)];
+    }
     return command ? [toBinary(command)] : [];
 };

package/dist/binaries/package-manager/yarn.d.ts

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

package/dist/binaries/{resolvers → package-manager}/yarn.js

@@ -1,5 +1,6 @@
 import parseArgs from 'minimist';
-import { toBinary } from '../../util/protocols.js';
+import { toBinary } from '../../util/input.js';
+import { join } from '../../util/path.js';
 const commands = [
     'add',
     'bin',
@@ -32,16 +33,17 @@ const commands = [
     'workspace',
     'workspaces',
 ];
-export const resolve = (_binary, args, { manifestScriptNames, fromArgs }) => {
-    const parsed = parseArgs(args, {});
+export const resolve = (_binary, args, { manifestScriptNames, fromArgs, cwd, rootCwd }) => {
+    const parsed = parseArgs(args, { boolean: ['top-level'], string: ['cwd'] });
     const [command, binary] = parsed._;
-    if (manifestScriptNames.has(command) || commands.includes(command))
+    const dir = parsed['top-level'] ? rootCwd : parsed.cwd ? join(cwd, parsed.cwd) : undefined;
+    if ((!dir && manifestScriptNames.has(command)) || commands.includes(command))
         return [];
-    if (command === 'run' && manifestScriptNames.has(binary))
+    if (!dir && command === 'run' && manifestScriptNames.has(binary))
         return [];
     if (command === 'run' || command === 'exec')
-        return [toBinary(binary)];
+        return dir ? [{ ...toBinary(binary), dir }] : [toBinary(binary)];
     if (command === 'node')
         return fromArgs(parsed._);
-    return command ? [toBinary(command)] : [];
+    return command ? (dir ? [{ ...toBinary(command), dir }] : [toBinary(command)]) : [];
 };

package/dist/binaries/plugins.d.ts

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

package/dist/binaries/plugins.js

@@ -0,0 +1,61 @@
+import parseArgs from 'minimist';
+import { pluginArgsMap } from '../plugins.js';
+import { compact } from '../util/array.js';
+import { toBinary, toConfig, toDeferResolve, toDeferResolveEntry, toEntry } from '../util/input.js';
+import { resolve as fallbackResolve } from './fallback.js';
+const isGlobLikeMatch = /(^!|[*+\\(|{^$])/;
+const isGlobLike = (value) => isGlobLikeMatch.test(value);
+const nodeLoadersArgs = { import: ['r', 'experimental-loader', 'require', 'loader', 'test-reporter'] };
+export const resolve = (binary, _args, options) => {
+    const { fromArgs, containingFilePath } = options;
+    const [pluginName, pluginArgs] = pluginArgsMap.get(binary) ?? [];
+    if (!pluginArgs)
+        return fallbackResolve(binary, _args, options);
+    const opts = pluginArgs;
+    const args = typeof opts.args === 'function' ? opts.args(_args) : _args;
+    const parsed = parseArgs(args, {
+        string: [
+            ...(opts.nodeImportArgs ? ['import'] : []),
+            ...(opts.config === true ? ['config'] : []),
+            ...(opts.string ?? []),
+        ],
+        boolean: ['quiet', 'verbose', 'watch', ...(opts.boolean ?? [])],
+        alias: {
+            ...(opts.nodeImportArgs ? nodeLoadersArgs : {}),
+            ...(opts.config === true ? { config: ['c'] } : {}),
+            ...opts.alias,
+        },
+    });
+    const positionals = [];
+    if (opts.positional) {
+        const id = parsed._[0];
+        if (isGlobLike(id))
+            positionals.push(toEntry(id));
+        else
+            positionals.push(toDeferResolveEntry(id));
+    }
+    const mapToParsedKey = (id) => parsed[id];
+    const resolved = compact(opts.resolve ? opts.resolve.flatMap(mapToParsedKey) : []);
+    const resolvedImports = opts.nodeImportArgs && parsed.import ? [parsed.import].flat() : [];
+    const resolvedFromArgs = typeof opts.fromArgs === 'function'
+        ? fromArgs(opts.fromArgs(parsed, args))
+        : Array.isArray(opts.fromArgs)
+            ? fromArgs(opts.fromArgs.flatMap(mapToParsedKey))
+            : [];
+    const config = opts.config === true ? ['config'] : opts.config || [];
+    const mapToConfigPattern = (value) => {
+        if (typeof value === 'string')
+            return parsed[value] && pluginName ? [toConfig(pluginName, parsed[value], containingFilePath)] : [];
+        const [id, fn] = value;
+        return parsed[id] && pluginName ? [toConfig(pluginName, fn(parsed[id]), containingFilePath)] : [];
+    };
+    const configFilePaths = config.flatMap(mapToConfigPattern);
+    return [
+        toBinary(binary),
+        ...positionals,
+        ...resolved.map(toDeferResolve),
+        ...resolvedImports.map(toDeferResolve),
+        ...resolvedFromArgs,
+        ...configFilePaths,
+    ];
+};

package/dist/binaries/util.d.ts

@@ -1,5 +1,3 @@
-export declare const tryResolveFilePath: (cwd: string, specifier: string, acceptModuleSpecifier?: boolean) => string | undefined;
-export declare const tryResolveSpecifiers: (cwd: string, specifiers: string[]) => (string | undefined)[];
 export declare const stripVersionFromSpecifier: (specifier: string) => string;
 export declare const trimBinary: (command: string) => string;
 export declare const argsFrom: (args: string[], from: string) => string[];

package/dist/binaries/util.js

@@ -1,28 +1,3 @@
-import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from '../util/modules.js';
-import { isAbsolute, isInNodeModules, join } from '../util/path.js';
-import { toBinary } from '../util/protocols.js';
-import { _resolveSync } from '../util/resolve.js';
-export const tryResolveFilePath = (cwd, specifier, acceptModuleSpecifier) => {
-    if (specifier) {
-        const filePath = isAbsolute(specifier) ? specifier : join(cwd, specifier);
-        if (!isInNodeModules(filePath)) {
-            const resolvedFilePath = _resolveSync(filePath, cwd);
-            if (resolvedFilePath) {
-                return resolvedFilePath;
-            }
-            if (acceptModuleSpecifier) {
-                return getPackageNameFromModuleSpecifier(specifier);
-            }
-        }
-        else if (specifier.includes('node_modules/.bin')) {
-            return toBinary(trimBinary(specifier));
-        }
-        else {
-            return getPackageNameFromFilePath(specifier);
-        }
-    }
-};
-export const tryResolveSpecifiers = (cwd, specifiers) => specifiers.map(specifier => tryResolveFilePath(cwd, specifier, true));
 export const stripVersionFromSpecifier = (specifier) => specifier.replace(/(\S+)@.*/, '$1');
 const stripNodeModulesFromPath = (command) => command.replace(/^(\.\/)?node_modules\//, '');
 export const trimBinary = (command) => stripVersionFromSpecifier(stripNodeModulesFromPath(command)

package/dist/compilers/index.d.ts

@@ -6,6 +6,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     asyncCompilers: Record<string, AsyncCompilerFn>;
     exclude?: ("dependencies" | "exports" | "files" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers")[] | undefined;
     include?: ("dependencies" | "exports" | "files" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers")[] | undefined;
+    node?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     rules?: Partial<Record<"dependencies" | "exports" | "files" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers", "error" | "warn" | "off">> | undefined;
     entry?: string | string[] | undefined;
     project?: string | string[] | undefined;
@@ -38,6 +43,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    c8?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     capacitor?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -73,6 +83,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    dotenv?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     eleventy?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -173,6 +188,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    nodemon?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     'node-test-runner'?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -213,6 +233,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    'playwright-test'?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     postcss?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -318,11 +343,21 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    'ts-node'?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     tsup?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    tsx?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     typedoc?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -399,6 +434,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         project?: string | string[] | undefined;
     } | undefined;
     workspaces?: Record<string, {
+        node?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
         paths?: Record<string, string[]> | undefined;
@@ -427,6 +467,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        c8?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         capacitor?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -462,6 +507,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        dotenv?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         eleventy?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -562,6 +612,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        nodemon?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'node-test-runner'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -602,6 +657,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'playwright-test'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         postcss?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -707,11 +767,21 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'ts-node'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         tsup?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        tsx?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         typedoc?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/constants.d.ts

@@ -10,6 +10,7 @@ export declare const INTERNAL_TAG = "@internal";
 export declare const BETA_TAG = "@beta";
 export declare const ALIAS_TAG = "@alias";
 export declare const DT_SCOPE = "@types";
+export declare const PROTOCOL_VIRTUAL = "virtual:";
 export declare const IGNORED_GLOBAL_BINARIES: Set<string>;
 export declare const IGNORED_DEPENDENCIES: Set<string>;
 export declare const IGNORED_RUNTIME_DEPENDENCIES: Set<string>;

package/dist/constants.js

@@ -18,6 +18,7 @@ export const INTERNAL_TAG = '@internal';
 export const BETA_TAG = '@beta';
 export const ALIAS_TAG = '@alias';
 export const DT_SCOPE = '@types';
+export const PROTOCOL_VIRTUAL = 'virtual:';
 export const IGNORED_GLOBAL_BINARIES = new Set([
     'aws',
     'base64',
@@ -118,7 +119,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'yes',
 ]);
 export const IGNORED_DEPENDENCIES = new Set(['knip', 'typescript']);
-export const IGNORED_RUNTIME_DEPENDENCIES = new Set(['bun', 'deno']);
+export const IGNORED_RUNTIME_DEPENDENCIES = new Set(['node', 'bun', 'deno']);
 export const FOREIGN_FILE_EXTENSIONS = new Set([
     '.avif',
     '.css',