knip 5.33.3 → 5.34.0

package/dist/util/input.d.ts

@@ -0,0 +1,37 @@
+import type { PluginName } from '../types/PluginNames.js';
+type InputType = 'binary' | 'entry' | 'config' | 'dependency' | 'deferResolve' | 'deferResolveEntry';
+export interface Input {
+    type: InputType;
+    specifier: string;
+    production?: boolean;
+    dir?: string;
+    containingFilePath?: string;
+}
+export interface ConfigInput extends Input {
+    type: 'config';
+    containingFilePath: string;
+    pluginName: PluginName;
+}
+type Options = {
+    production?: boolean;
+    dir?: string;
+    containingFilePath?: string;
+};
+export declare const fromBinary: (input: Input) => string;
+export declare const toBinary: (specifier: string, options?: Options) => Input;
+export declare const isBinary: (input: Input) => boolean;
+export declare const toEntry: (specifier: string) => Input;
+export declare const isEntry: (input: Input) => boolean;
+export declare const toProductionEntry: (specifier: string, options?: Options) => Input;
+export declare const isProductionEntry: (input: Input) => boolean;
+export declare const toConfig: (pluginName: PluginName, specifier: string, containingFilePath: string) => ConfigInput;
+export declare const isConfigPattern: (input: Input) => input is ConfigInput;
+export declare const toDependency: (specifier: string) => Input;
+export declare const isDependency: (input: Input) => boolean;
+export declare const toProductionDependency: (specifier: string) => Input;
+export declare const toDevDependency: (specifier: string) => Input;
+export declare const toDeferResolve: (specifier: string) => Input;
+export declare const toDeferResolveEntry: (specifier: string) => Input;
+export declare const isDeferResolveEntry: (input: Input) => boolean;
+export declare const toDebugString: (input: Input) => string;
+export {};

package/dist/util/input.js

@@ -0,0 +1,36 @@
+import { toRelative } from './path.js';
+export const fromBinary = (input) => input.specifier;
+export const toBinary = (specifier, options = {}) => ({
+    type: 'binary',
+    specifier,
+    ...options,
+});
+export const isBinary = (input) => input.type === 'binary';
+export const toEntry = (specifier) => ({ type: 'entry', specifier });
+export const isEntry = (input) => input.type === 'entry' && !input.production;
+export const toProductionEntry = (specifier, options = {}) => ({
+    type: 'entry',
+    specifier,
+    production: true,
+    ...options,
+});
+export const isProductionEntry = (input) => input.type === 'entry' && input.production === true;
+export const toConfig = (pluginName, specifier, containingFilePath) => ({
+    type: 'config',
+    specifier,
+    pluginName,
+    containingFilePath,
+});
+export const isConfigPattern = (input) => input.type === 'config';
+export const toDependency = (specifier) => ({ type: 'dependency', specifier });
+export const isDependency = (input) => input.type === 'dependency';
+export const toProductionDependency = (specifier) => ({
+    type: 'dependency',
+    specifier,
+    production: true,
+});
+export const toDevDependency = (specifier) => ({ type: 'dependency', specifier });
+export const toDeferResolve = (specifier) => ({ type: 'deferResolve', specifier });
+export const toDeferResolveEntry = (specifier) => ({ type: 'deferResolveEntry', specifier });
+export const isDeferResolveEntry = (input) => input.type === 'deferResolveEntry';
+export const toDebugString = (input) => `${input.type}:${input.specifier} ${input.containingFilePath ? `(${toRelative(input.containingFilePath)})` : ''}`;

package/dist/util/map-workspaces.d.ts

@@ -1,2 +1,5 @@
-import type { Package } from '../ConfigurationChief.js';
-export default function mapWorkspaces(cwd: string, workspaces: string[]): Promise<Map<string, Package>[]>;
+import type { Package } from '../types/package-json.js';
+type Packages = Map<string, Package>;
+type WorkspacePkgNames = Set<string>;
+export default function mapWorkspaces(cwd: string, workspaces: string[]): Promise<[Packages, WorkspacePkgNames]>;
+export {};

package/dist/util/map-workspaces.js

@@ -7,10 +7,10 @@ import { join } from './path.js';
 import { _require } from './require.js';
 export default async function mapWorkspaces(cwd, workspaces) {
     const [negatedPatterns, patterns] = partition(workspaces, p => p.match(/^!/));
-    const byPkgDir = new Map();
-    const byPkgName = new Map();
+    const packages = new Map();
+    const wsPkgNames = new Set();
     if (patterns.length === 0 && negatedPatterns.length === 0)
-        return [byPkgDir, byPkgName];
+        return [packages, wsPkgNames];
     const matches = await fg.glob(patterns, {
         cwd,
         onlyDirectories: true,
@@ -23,9 +23,9 @@ export default async function mapWorkspaces(cwd, workspaces) {
             const manifest = _require(filePath);
             const pkgName = getPackageName(manifest, dir);
             const pkg = { dir, name, pkgName, manifest };
-            byPkgDir.set(name, pkg);
+            packages.set(name, pkg);
             if (pkgName)
-                byPkgName.set(pkgName, pkg);
+                wsPkgNames.add(pkgName);
             else
                 throw new ConfigurationError(`Missing package name in ${filePath}`);
         }
@@ -36,5 +36,5 @@ export default async function mapWorkspaces(cwd, workspaces) {
                 throw error;
         }
     }
-    return [byPkgDir, byPkgName];
+    return [packages, wsPkgNames];
 }

package/dist/util/modules.d.ts

@@ -1,5 +1,6 @@
 export declare const getPackageNameFromModuleSpecifier: (moduleSpecifier: string) => string | undefined;
 export declare const getPackageNameFromFilePath: (value: string) => string;
+export declare const getPackageNameFromSpecifier: (specifier: string) => string | undefined;
 export declare const isStartsLikePackageName: (specifier: string) => boolean;
 export declare const isDefinitelyTyped: (packageName: string) => boolean;
 export declare const getDefinitelyTypedFor: (packageName: string) => string;

package/dist/util/modules.js

@@ -1,6 +1,6 @@
 import { isBuiltin } from 'node:module';
-import { DT_SCOPE } from '../constants.js';
-import { isAbsolute, toPosix } from './path.js';
+import { DT_SCOPE, PROTOCOL_VIRTUAL } from '../constants.js';
+import { isAbsolute, isInNodeModules, toPosix } from './path.js';
 export const getPackageNameFromModuleSpecifier = (moduleSpecifier) => {
     if (!isStartsLikePackageName(moduleSpecifier))
         return;
@@ -14,6 +14,7 @@ export const getPackageNameFromFilePath = (value) => {
         return match[match.length - 1];
     return value;
 };
+export const getPackageNameFromSpecifier = (specifier) => isInNodeModules(specifier) ? getPackageNameFromFilePath(specifier) : getPackageNameFromModuleSpecifier(specifier);
 export const isStartsLikePackageName = (specifier) => /^(@[a-z0-9._]|[a-z0-9])/.test(specifier);
 export const isDefinitelyTyped = (packageName) => packageName.startsWith(`${DT_SCOPE}/`);
 export const getDefinitelyTypedFor = (packageName) => {
@@ -36,7 +37,7 @@ export const sanitizeSpecifier = (specifier) => {
         return specifier;
     if (isAbsolute(specifier))
         return specifier;
-    if (specifier.startsWith('virtual:'))
+    if (specifier.startsWith(PROTOCOL_VIRTUAL))
         return specifier;
     return specifier.replace(matchDirectives, '$2');
 };

package/dist/util/object.d.ts

@@ -1,4 +1,5 @@
 export declare const getValuesByKeyDeep: (obj: any, key: string) => unknown[];
+export declare const findByKeyDeep: <T>(obj: any, key: string) => T[];
 export declare const getStringValues: (obj: any) => string[];
 export declare const getKeysByValue: <T>(obj: T, value: unknown) => (keyof T)[];
 export declare const get: <T>(obj: T, path: string) => any;

package/dist/util/object.js

@@ -13,6 +13,25 @@ export const getValuesByKeyDeep = (obj, key) => {
     }
     return objects;
 };
+export const findByKeyDeep = (obj, key) => {
+    const objects = [];
+    if (obj && typeof obj === 'object') {
+        if (key in obj) {
+            objects.push(obj);
+        }
+        for (const value of Object.values(obj)) {
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    objects.push(...findByKeyDeep(item, key));
+                }
+            }
+            else if (typeof value === 'object') {
+                objects.push(...findByKeyDeep(value, key));
+            }
+        }
+    }
+    return objects;
+};
 export const getStringValues = (obj) => {
     if (typeof obj === 'string')
         return [obj];

package/dist/util/plugin-config.d.ts

@@ -0,0 +1,24 @@
+export declare const toCosmiconfig: (moduleName: string, options?: {
+    rcPrefix?: string;
+    rcSuffix?: string;
+    configDir?: boolean;
+    configFiles?: boolean;
+    configFilesAllExtensions?: boolean;
+    additionalExtensions?: string[];
+}) => string[];
+export declare const toLilconfig: (moduleName: string, options?: {
+    rcPrefix?: string;
+    rcSuffix?: string;
+    configDir?: boolean;
+    configFiles?: boolean;
+    configFilesAllExtensions?: boolean;
+    additionalExtensions?: string[];
+}) => string[];
+export declare const toUnconfig: (moduleName: string, options?: {
+    rcPrefix?: string;
+    rcSuffix?: string;
+    configDir?: boolean;
+    configFiles?: boolean;
+    configFilesAllExtensions?: boolean;
+    additionalExtensions?: string[];
+}) => string[];

package/dist/util/plugin-config.js

@@ -0,0 +1,32 @@
+const toConfigMap = (defaultExtensions, builderConfig) => (moduleName, options) => {
+    const config = {
+        rcPrefix: '.',
+        rcSuffix: 'rc',
+        configDir: true,
+        configFiles: true,
+        configFilesAllExtensions: false,
+        additionalExtensions: [],
+        ...builderConfig,
+        ...options,
+    };
+    const { rcPrefix, rcSuffix } = config;
+    const jsTypeExtensions = ['js', 'ts', 'cjs', 'mjs', 'cts', 'mts'];
+    const extensions = [...defaultExtensions, ...config.additionalExtensions];
+    const baseFiles = [
+        `${rcPrefix}${moduleName}${rcSuffix}`,
+        ...(config.configDir ? [`.config/${moduleName}${rcSuffix}`] : []),
+    ];
+    const rcFiles = `${rcPrefix}${moduleName}${rcSuffix}.{${extensions.join(',')}}`;
+    const configExtensions = extensions.filter(ext => config.configFilesAllExtensions || jsTypeExtensions.includes(ext));
+    const configFiles = config.configFiles ? [`${moduleName}.config.{${configExtensions.join(',')}}`] : [];
+    const configDirFiles = config.configDir ? [`.config/${moduleName}${rcSuffix}.{${extensions.join(',')}}`] : [];
+    return [...baseFiles, rcFiles, ...configFiles, ...configDirFiles];
+};
+export const toCosmiconfig = toConfigMap(['json', 'yaml', 'yml', 'js', 'ts', 'cjs', 'mjs'], { configDir: true });
+export const toLilconfig = toConfigMap(['json', 'js', 'cjs', 'mjs'], { configDir: true });
+export const toUnconfig = toConfigMap(['json', 'ts', 'mts', 'cts', 'js', 'mjs', 'cjs'], {
+    configDir: false,
+    rcPrefix: '',
+    rcSuffix: '',
+    configFiles: false,
+});

package/dist/util/plugin.d.ts

@@ -1,10 +1,7 @@
-export { _getDependenciesFromScripts as getDependenciesFromScripts } from '../binaries/index.js';
 export { _loadJSON as loadJSON } from './fs.js';
 export { _load as load } from './loader.js';
-export { _resolveSync as resolve } from './resolve.js';
-import type { RawPluginConfiguration } from '../types/config.js';
-import type { Plugin, PluginOptions } from '../types/plugins.js';
-export declare const toCamelCase: (name: string) => string;
+import type { Plugin, PluginOptions, RawPluginConfiguration } from '../types/config.js';
+import { type Input } from './input.js';
 export declare const hasDependency: (dependencies: Set<string>, values: (string | RegExp)[]) => boolean;
 export declare const normalizePluginConfig: (pluginConfig: RawPluginConfiguration) => boolean | {
     config: string[] | null;
@@ -12,29 +9,4 @@ export declare const normalizePluginConfig: (pluginConfig: RawPluginConfiguratio
     project: string[] | null;
 };
 export declare const loadConfigForPlugin: (configFilePath: string, plugin: Plugin, options: PluginOptions, pluginName: string) => Promise<any>;
-export declare const getFinalEntryPaths: (plugin: Plugin, options: PluginOptions, configEntryPaths: string[]) => string[];
-export declare const toCosmiconfig: (moduleName: string, options?: {
-    rcPrefix?: string;
-    rcSuffix?: string;
-    configDir?: boolean;
-    configFiles?: boolean;
-    configFilesAllExtensions?: boolean;
-    additionalExtensions?: string[];
-}) => string[];
-export declare const toLilconfig: (moduleName: string, options?: {
-    rcPrefix?: string;
-    rcSuffix?: string;
-    configDir?: boolean;
-    configFiles?: boolean;
-    configFilesAllExtensions?: boolean;
-    additionalExtensions?: string[];
-}) => string[];
-export declare const toUnconfig: (moduleName: string, options?: {
-    rcPrefix?: string;
-    rcSuffix?: string;
-    configDir?: boolean;
-    configFiles?: boolean;
-    configFilesAllExtensions?: boolean;
-    additionalExtensions?: string[];
-}) => string[];
-export declare const resolveEntry: (options: PluginOptions, specifier: string, rootDir?: string) => string;
+export declare const getFinalEntryPaths: (plugin: Plugin, options: PluginOptions, configEntryPaths: Input[]) => Input[];

package/dist/util/plugin.js

@@ -1,14 +1,10 @@
-export { _getDependenciesFromScripts as getDependenciesFromScripts } from '../binaries/index.js';
 export { _loadJSON as loadJSON } from './fs.js';
 export { _load as load } from './loader.js';
-export { _resolveSync as resolve } from './resolve.js';
 import { arrayify } from './array.js';
+import { toEntry, toProductionEntry } from './input.js';
 import { _load as load } from './loader.js';
 import { get } from './object.js';
-import { basename, isAbsolute, join, relative } from './path.js';
-import { toEntryPattern, toProductionEntryPattern } from './protocols.js';
-import { _resolveSync } from './resolve.js';
-export const toCamelCase = (name) => name.toLowerCase().replace(/(-[a-z])/g, group => group.toUpperCase().replace('-', ''));
+import { basename } from './path.js';
 export const hasDependency = (dependencies, values) => values.some(value => {
     if (typeof value === 'string') {
         return dependencies.has(value);
@@ -50,52 +46,11 @@ export const loadConfigForPlugin = async (configFilePath, plugin, options, plugi
 export const getFinalEntryPaths = (plugin, options, configEntryPaths) => {
     const { config, isProduction } = options;
     if (plugin.title === 'Storybook')
-        return [...(config.entry ?? []).map(toEntryPattern), ...configEntryPaths];
-    const toEntryPathProtocol = isProduction && plugin.production && plugin.production.length > 0 ? toProductionEntryPattern : toEntryPattern;
-    return config.entry
-        ? config.entry.map(toEntryPathProtocol)
-        : configEntryPaths.length > 0
-            ? configEntryPaths
-            : [...(plugin.entry ?? []).map(toEntryPattern), ...(plugin.production ?? []).map(toProductionEntryPattern)];
-};
-const toConfigMap = (defaultExtensions, builderConfig) => (moduleName, options) => {
-    const config = {
-        rcPrefix: '.',
-        rcSuffix: 'rc',
-        configDir: true,
-        configFiles: true,
-        configFilesAllExtensions: false,
-        additionalExtensions: [],
-        ...builderConfig,
-        ...options,
-    };
-    const { rcPrefix, rcSuffix } = config;
-    const jsTypeExtensions = ['js', 'ts', 'cjs', 'mjs', 'cts', 'mts'];
-    const extensions = [...defaultExtensions, ...config.additionalExtensions];
-    const baseFiles = [
-        `${rcPrefix}${moduleName}${rcSuffix}`,
-        ...(config.configDir ? [`.config/${moduleName}${rcSuffix}`] : []),
-    ];
-    const rcFiles = `${rcPrefix}${moduleName}${rcSuffix}.{${extensions.join(',')}}`;
-    const configExtensions = extensions.filter(ext => config.configFilesAllExtensions || jsTypeExtensions.includes(ext));
-    const configFiles = config.configFiles ? [`${moduleName}.config.{${configExtensions.join(',')}}`] : [];
-    const configDirFiles = config.configDir ? [`.config/${moduleName}${rcSuffix}.{${extensions.join(',')}}`] : [];
-    return [...baseFiles, rcFiles, ...configFiles, ...configDirFiles];
-};
-export const toCosmiconfig = toConfigMap(['json', 'yaml', 'yml', 'js', 'ts', 'cjs', 'mjs'], { configDir: true });
-export const toLilconfig = toConfigMap(['json', 'js', 'cjs', 'mjs'], { configDir: true });
-export const toUnconfig = toConfigMap(['json', 'ts', 'mts', 'cts', 'js', 'mjs', 'cjs'], {
-    configDir: false,
-    rcPrefix: '',
-    rcSuffix: '',
-    configFiles: false,
-});
-export const resolveEntry = (options, specifier, rootDir = '.') => {
-    const { configFileDir } = options;
-    const resolvedPath = isAbsolute(specifier)
-        ? specifier
-        : _resolveSync(join(configFileDir, rootDir, specifier), join(configFileDir, rootDir));
-    if (resolvedPath)
-        return toEntryPattern(relative(configFileDir, resolvedPath));
-    return specifier;
+        return [...(config.entry ?? []).map(toEntry), ...configEntryPaths];
+    const toEntryPathProtocol = isProduction && plugin.production && plugin.production.length > 0 ? toProductionEntry : toEntry;
+    if (config.entry)
+        return config.entry.map(id => toEntryPathProtocol(id));
+    if (configEntryPaths.length > 0)
+        return configEntryPaths;
+    return [...(plugin.entry ?? []).map(toEntry), ...(plugin.production ?? []).map(id => toProductionEntry(id))];
 };

package/dist/util/regex.js

@@ -1,5 +1,6 @@
-const isRegexLike = /[*+\\(|{^$]/;
-export const toRegexOrString = (value) => typeof value === 'string' && isRegexLike.test(value) ? new RegExp(value) : value;
+const isRegexLikeMatch = /[*+\\(|{^$]/;
+const isRegexLike = (value) => isRegexLikeMatch.test(value);
+export const toRegexOrString = (value) => typeof value === 'string' && isRegexLike(value) ? new RegExp(value) : value;
 export const findMatch = (haystack, needle) => haystack?.find(n => (typeof n === 'string' ? n === needle : n.test(needle)));
 const idCharMatch = /[a-zA-Z0-9$_]/;
 export const isIdChar = (text) => idCharMatch.test(text);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.33.3";
+export declare const version = "5.34.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.33.3';
+export const version = '5.34.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.33.3",
+  "version": "5.34.0",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {
@@ -35,10 +35,6 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "imports": {
-    "#p/*.ts": "./src/*.ts",
-    "#p/*.js": "./dist/*.js"
-  },
   "scripts": {
     "knip": "node ./dist/cli.js --directory ../..",
     "knip:production": "node ./dist/cli.js --directory ../.. --production --strict",
@@ -52,7 +48,8 @@
     "qa": "bun lint && bun run build && bun knip && bun knip:production && bun run test",
     "release": "release-it",
     "create-plugin": "bun ./scripts/create-new-plugin.ts",
-    "postcreate-plugin": "biome format --write schema.json schema-jsonc.json src/ConfigurationValidator.ts"
+    "postcreate-plugin": "biome format --write schema.json schema-jsonc.json src/ConfigurationValidator.ts",
+    "generate-plugin-types": "bun ./scripts/generate-plugin-types.ts"
   },
   "files": [
     "dist",
@@ -85,15 +82,15 @@
   "devDependencies": {
     "@jest/types": "^29.6.3",
     "@release-it/bumper": "^6.0.1",
-    "@types/bun": "^1.1.10",
+    "@types/bun": "^1.1.11",
     "@types/js-yaml": "^4.0.9",
     "@types/minimist": "^1.2.5",
     "@types/picomatch": "3.0.1",
     "@types/webpack": "^5.28.5",
-    "@wdio/types": "^9.1.2",
+    "@wdio/types": "^9.1.3",
     "glob": "^10.4.2",
-    "release-it": "^17.6.0",
-    "type-fest": "^4.20.0",
+    "release-it": "^17.10.0",
+    "type-fest": "^4.26.1",
     "typescript": "^5.5.2"
   },
   "engines": {

package/schema.json

@@ -296,6 +296,10 @@
           "title": "Babel plugin configuration (https://knip.dev/reference/plugins/babel)",
           "$ref": "#/definitions/plugin"
         },
+        "c8": {
+          "title": "c8 plugin configuration (https://knip.dev/reference/plugins/c8)",
+          "$ref": "#/definitions/plugin"
+        },
         "capacitor": {
           "title": "Capacitor plugin configuration (https://knip.dev/reference/plugins/capacitor)",
           "$ref": "#/definitions/plugin"
@@ -324,6 +328,10 @@
           "title": "Cypress plugin configuration (https://knip.dev/reference/plugins/cypress)",
           "$ref": "#/definitions/plugin"
         },
+        "dotenv": {
+          "title": "dotenv plugin configuration (https://knip.dev/reference/plugins/dotenv)",
+          "$ref": "#/definitions/plugin"
+        },
         "drizzle": {
           "title": "Drizzle plugin configuration (https://knip.dev/reference/plugins/drizzle)",
           "$ref": "#/definitions/plugin"
@@ -408,10 +416,18 @@
           "title": "Next.js plugin configuration (https://knip.dev/reference/plugins/main)",
           "$ref": "#/definitions/plugin"
         },
+        "node": {
+          "title": "node plugin configuration (https://knip.dev/reference/plugins/node)",
+          "$ref": "#/definitions/plugin"
+        },
         "node-test-runner": {
           "title": "node-test-runner plugin configuration (https://knip.dev/reference/plugins/node-test-runner)",
           "$ref": "#/definitions/plugin"
         },
+        "nodemon": {
+          "title": "nodemon plugin configuration (https://knip.dev/reference/plugins/nodemon)",
+          "$ref": "#/definitions/plugin"
+        },
         "npm-package-json-lint": {
           "title": "npm-package-json-lint plugin configuration (https://knip.dev/reference/plugins/npm-package-json-lint)",
           "$ref": "#/definitions/plugin"
@@ -440,6 +456,10 @@
           "title": "Playwright for components plugin configuration (https://knip.dev/reference/plugins/playwright-ct)",
           "$ref": "#/definitions/plugin"
         },
+        "playwright-test": {
+          "title": "playwright-test plugin configuration (https://knip.dev/reference/plugins/playwright-test)",
+          "$ref": "#/definitions/plugin"
+        },
         "postcss": {
           "title": "PostCSS plugin configuration (https://knip.dev/reference/plugins/postcss)",
           "$ref": "#/definitions/plugin"
@@ -524,10 +544,18 @@
           "title": "travis plugin configuration (https://knip.dev/reference/plugins/travis)",
           "$ref": "#/definitions/plugin"
         },
+        "ts-node": {
+          "title": "ts-node plugin configuration (https://knip.dev/reference/plugins/ts-node)",
+          "$ref": "#/definitions/plugin"
+        },
         "tsup": {
           "title": "tsup plugin configuration (https://knip.dev/reference/plugins/tsup)",
           "$ref": "#/definitions/plugin"
         },
+        "tsx": {
+          "title": "tsx plugin configuration (https://knip.dev/reference/plugins/tsx)",
+          "$ref": "#/definitions/plugin"
+        },
         "typedoc": {
           "title": "typedoc plugin configuration (https://knip.dev/reference/plugins/typedoc)",
           "$ref": "#/definitions/plugin"

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

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

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

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

package/dist/binaries/resolvers/c8.js

@@ -1,11 +0,0 @@
-import parseArgs from 'minimist';
-import { toBinary } from '../../util/protocols.js';
-import { argsFrom } from '../util.js';
-export const resolve = (binary, args, { fromArgs }) => {
-    const parsed = parseArgs(args, {
-        boolean: ['all', 'check-coverage', 'clean', 'exclude-after-remap', 'per-file', 'skip-full'],
-    });
-    parsed._ = parsed._.filter(a => a !== 'check-coverage');
-    const rest = argsFrom(args, parsed._[0]);
-    return [toBinary(binary), ...fromArgs(rest)];
-};

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

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

package/dist/binaries/resolvers/dotenv.js

@@ -1,7 +0,0 @@
-import parseArgs from 'minimist';
-import { toBinary } from '../../util/protocols.js';
-import { argsFrom } from '../util.js';
-export const resolve = (binary, args, { fromArgs }) => {
-    const parsed = parseArgs(args);
-    return [toBinary(binary), ...fromArgs(argsFrom(args, parsed._[0]))];
-};

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

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

package/dist/binaries/resolvers/fallback.js

@@ -1,26 +0,0 @@
-import parseArgs from 'minimist';
-import { compact } from '../../util/array.js';
-import { toBinary } from '../../util/protocols.js';
-import { tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
-const withPositional = parsed => [parsed._[0], parsed.require].flat();
-const withoutPositional = parsed => [parsed.require].flat();
-const withoutRequire = () => [];
-const argFilters = {
-    adb: withoutRequire,
-    deploy: withoutRequire,
-    'babel-node': withPositional,
-    esbuild: withPositional,
-    execa: withPositional,
-    vitest: withoutRequire,
-    'vite-node': withPositional,
-    zx: withPositional,
-    default: withoutPositional,
-};
-const spawningBinaries = ['cross-env', 'retry-cli'];
-export const resolve = (binary, args, { cwd, fromArgs }) => {
-    const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader'] }, boolean: ['quiet', 'verbose'] });
-    const bin = binary.startsWith('.') ? tryResolveFilePath(cwd, binary) : toBinary(binary);
-    const filteredArgs = binary in argFilters ? argFilters[binary](parsed) : argFilters.default(parsed);
-    const shiftedArgs = spawningBinaries.includes(binary) ? fromArgs(args) : [];
-    return compact([bin, ...tryResolveSpecifiers(cwd, filteredArgs), ...shiftedArgs]);
-};

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

@@ -1,15 +0,0 @@
-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,26 +0,0 @@
-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/node.js

@@ -1,11 +0,0 @@
-import parseArgs from 'minimist';
-import { compact } from '../../util/array.js';
-import { tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
-export const parseNodeArgs = (args) => parseArgs(args, {
-    string: ['r'],
-    alias: { require: ['r', 'loader', 'experimental-loader', 'test-reporter', 'watch', 'import'] },
-});
-export const resolve = (_binary, args, { cwd }) => {
-    const parsed = parseNodeArgs(args);
-    return compact([tryResolveFilePath(cwd, parsed._[0]), ...tryResolveSpecifiers(cwd, [parsed.require].flat())]);
-};

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

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