knip 5.84.1 → 5.86.0

package/dist/IssueFixer.js

@@ -1,13 +1,22 @@
 import { readFile, rm, writeFile } from 'node:fs/promises';
 import { formatly } from 'formatly';
-import { DEFAULT_CATALOG } from './util/catalog.js';
-import { debugLogArray, debugLogObject } from './util/debug.js';
-import { load, save } from './util/package-json.js';
-import { extname, join } from './util/path.js';
-import { removeExport } from './util/remove-export.js';
-export const fix = async (issues, options) => {
+import { DEFAULT_CATALOG } from "./util/catalog.js";
+import { debugLogArray, debugLogObject } from "./util/debug.js";
+import { load, save } from "./util/package-json.js";
+import { extname, join } from "./util/path.js";
+import { removeExport } from "./util/remove-export.js";
+export const fix = async (issues, counters, options) => {
     const fixer = new IssueFixer(options);
     const touchedFiles = await fixer.fixIssues(issues);
+    for (const type in issues) {
+        const group = issues[type];
+        if (group instanceof Set)
+            continue;
+        for (const filePath in group)
+            for (const key in group[filePath])
+                if (group[filePath][key].isFixed)
+                    counters[type]--;
+    }
     if (options.isFormat) {
         const report = await formatly(Array.from(touchedFiles));
         if (report.ran && report.result && (report.result.runner === 'virtual' || report.result.code === 0)) {
@@ -60,6 +69,8 @@ class IssueFixer {
             }
         }
         for (const [filePath, fixes] of allFixes) {
+            if (fixes.length === 0)
+                continue;
             const absFilePath = join(this.options.cwd, filePath);
             const sourceFileText = fixes
                 .sort((a, b) => b[0] - a[0])

package/dist/JsonCatalogPeeker.d.ts

@@ -1,8 +1,8 @@
 export declare class JsonCatalogPeeker {
-    private fileContent;
     private lines;
     private sections;
     private ready;
+    private fileContent;
     constructor(fileContent: string);
     private init;
     getLocation(parentSymbol: string, symbol: string): {

package/dist/JsonCatalogPeeker.js

@@ -1,9 +1,9 @@
-import { DEFAULT_CATALOG } from './util/catalog.js';
+import { DEFAULT_CATALOG } from "./util/catalog.js";
 export class JsonCatalogPeeker {
-    fileContent;
     lines = [];
     sections = {};
     ready = false;
+    fileContent;
     constructor(fileContent) {
         this.fileContent = fileContent;
     }

package/dist/PackagePeeker.d.ts

@@ -1,8 +1,8 @@
 export declare class PackagePeeker {
-    private manifestStr;
     private lines;
     private sections;
     private ready;
+    private manifestStr;
     constructor(manifestStr: string);
     private init;
     getLocation(type: 'dependencies' | 'devDependencies' | 'optionalPeerDependencies', packageName: string): {

package/dist/PackagePeeker.js

@@ -1,8 +1,8 @@
 export class PackagePeeker {
-    manifestStr;
     lines = [];
     sections = {};
     ready = false;
+    manifestStr;
     constructor(manifestStr) {
         this.manifestStr = manifestStr;
     }

package/dist/PrincipalFactory.d.ts

@@ -1,6 +1,6 @@
-import { ProjectPrincipal } from './ProjectPrincipal.js';
-import type { PrincipalOptions } from './types/project.js';
-import type { MainOptions } from './util/create-options.js';
+import { ProjectPrincipal } from './ProjectPrincipal.ts';
+import type { PrincipalOptions } from './types/project.ts';
+import type { MainOptions } from './util/create-options.ts';
 export declare class PrincipalFactory {
     private principals;
     getPrincipalCount(): number;

package/dist/PrincipalFactory.js

@@ -1,7 +1,7 @@
 import ts from 'typescript';
-import { ProjectPrincipal } from './ProjectPrincipal.js';
-import { debugLog } from './util/debug.js';
-import { toRelative } from './util/path.js';
+import { ProjectPrincipal } from "./ProjectPrincipal.js";
+import { debugLog } from "./util/debug.js";
+import { toRelative } from "./util/path.js";
 export class PrincipalFactory {
     principals = new Set();
     getPrincipalCount() {

package/dist/ProjectPrincipal.d.ts

@@ -1,13 +1,13 @@
 import ts from 'typescript';
-import { CacheConsultant } from './CacheConsultant.js';
-import type { AsyncCompilers, SyncCompilers } from './compilers/types.js';
-import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile, Visitors } from './types/config.js';
-import type { Export, ExportMember, FileNode, ModuleGraph } from './types/module-graph.js';
-import type { Paths, PrincipalOptions } from './types/project.js';
-import type { ResolveModuleNames } from './typescript/resolve-module-names.js';
-import { SourceFileManager } from './typescript/SourceFileManager.js';
-import type { MainOptions } from './util/create-options.js';
-import type { ToSourceFilePath } from './util/to-source-path.js';
+import { CacheConsultant } from './CacheConsultant.ts';
+import type { AsyncCompilers, SyncCompilers } from './compilers/types.ts';
+import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile, Visitors } from './types/config.ts';
+import type { Export, ExportMember, FileNode, ModuleGraph } from './types/module-graph.ts';
+import type { Paths, PrincipalOptions } from './types/project.ts';
+import type { ResolveModuleNames } from './typescript/resolve-module-names.ts';
+import { SourceFileManager } from './typescript/SourceFileManager.ts';
+import type { MainOptions } from './util/create-options.ts';
+import type { ToSourceFilePath } from './util/to-source-path.ts';
 export declare class ProjectPrincipal {
     entryPaths: Set<string>;
     projectPaths: Set<string>;

package/dist/ProjectPrincipal.js

@@ -1,13 +1,13 @@
 import ts from 'typescript';
-import { CacheConsultant } from './CacheConsultant.js';
-import { getCompilerExtensions } from './compilers/index.js';
-import { ANONYMOUS, DEFAULT_EXTENSIONS, MEMBER_FLAGS, PUBLIC_TAG } from './constants.js';
-import { createHosts } from './typescript/create-hosts.js';
-import { _getImportsAndExports } from './typescript/get-imports-and-exports.js';
-import { SourceFileManager } from './typescript/SourceFileManager.js';
-import { compact } from './util/array.js';
-import { timerify } from './util/Performance.js';
-import { extname, isInNodeModules, toAbsolute } from './util/path.js';
+import { CacheConsultant } from "./CacheConsultant.js";
+import { getCompilerExtensions } from "./compilers/index.js";
+import { ANONYMOUS, DEFAULT_EXTENSIONS, MEMBER_FLAGS, PUBLIC_TAG } from "./constants.js";
+import { createHosts } from "./typescript/create-hosts.js";
+import { _getImportsAndExports } from "./typescript/get-imports-and-exports.js";
+import { SourceFileManager } from "./typescript/SourceFileManager.js";
+import { compact } from "./util/array.js";
+import { timerify } from "./util/Performance.js";
+import { extname, isInNodeModules, toAbsolute } from "./util/path.js";
 const baseCompilerOptions = {
     allowJs: true,
     allowSyntheticDefaultImports: true,
@@ -165,6 +165,12 @@ export class ProjectPrincipal {
         if (!sourceFile)
             throw new Error(`Unable to find ${filePath}`);
         const skipExports = this.skipExportsAnalysis.has(filePath);
+        if (options.isFixExports || options.isFixTypes) {
+            const ext = extname(filePath);
+            if (!DEFAULT_EXTENSIONS.includes(ext) && (this.syncCompilers.has(ext) || this.asyncCompilers.has(ext))) {
+                options = { ...options, isFixExports: false, isFixTypes: false };
+            }
+        }
         const resolve = (specifier) => this.backend.resolveModuleNames([specifier], sourceFile.fileName)[0];
         return _getImportsAndExports(sourceFile, resolve, typeChecker, options, ignoreExportsUsedInFile, skipExports, this.visitors);
     }

package/dist/WorkspaceWorker.d.ts

@@ -1,12 +1,12 @@
-import { CacheConsultant } from './CacheConsultant.js';
-import { type Workspace } from './ConfigurationChief.js';
-import type { GetSourceFile, HandleInput, RegisterCompiler, RegisterVisitor, WorkspaceConfiguration } from './types/config.js';
-import type { ConfigurationHint } from './types/issues.js';
-import type { PluginName } from './types/PluginNames.js';
-import type { PackageJson } from './types/package-json.js';
-import type { DependencySet } from './types/workspace.js';
-import type { MainOptions } from './util/create-options.js';
-import { type Input } from './util/input.js';
+import { CacheConsultant } from './CacheConsultant.ts';
+import { type Workspace } from './ConfigurationChief.ts';
+import type { GetSourceFile, HandleInput, RegisterCompiler, RegisterVisitor, WorkspaceConfiguration } from './types/config.ts';
+import type { ConfigurationHint } from './types/issues.ts';
+import type { PluginName } from './types/PluginNames.ts';
+import type { PackageJson } from './types/package-json.ts';
+import type { DependencySet } from './types/workspace.ts';
+import type { MainOptions } from './util/create-options.ts';
+import { type Input } from './util/input.ts';
 type WorkspaceManagerOptions = {
     name: string;
     dir: string;

package/dist/WorkspaceWorker.js

@@ -1,21 +1,21 @@
 import picomatch from 'picomatch';
-import { _getInputsFromScripts } from './binaries/index.js';
-import { CacheConsultant } from './CacheConsultant.js';
-import { isDefaultPattern } from './ConfigurationChief.js';
-import { ROOT_WORKSPACE_NAME } from './constants.js';
-import { getFilteredScripts } from './manifest/helpers.js';
-import { PluginEntries, Plugins } from './plugins.js';
-import { collectStringLiterals, isExternalReExportsOnly } from './typescript/ast-helpers.js';
-import { compact } from './util/array.js';
-import { debugLogArray, debugLogObject } from './util/debug.js';
-import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate } from './util/glob.js';
-import { isConfig, isDeferResolve, isDependency, toConfig, toDebugString, toEntry, toProductionEntry, } from './util/input.js';
-import { getPackageNameFromSpecifier } from './util/modules.js';
-import { getKeysByValue } from './util/object.js';
-import { timerify } from './util/Performance.js';
-import { basename, dirname, extname, isInternal, join } from './util/path.js';
-import { loadConfigForPlugin } from './util/plugin.js';
-import { ELLIPSIS } from './util/string.js';
+import { _getInputsFromScripts } from "./binaries/index.js";
+import { CacheConsultant } from "./CacheConsultant.js";
+import { isDefaultPattern } from "./ConfigurationChief.js";
+import { ROOT_WORKSPACE_NAME } from "./constants.js";
+import { getFilteredScripts } from "./manifest/helpers.js";
+import { PluginEntries, Plugins } from "./plugins.js";
+import { collectStringLiterals, isExternalReExportsOnly } from "./typescript/ast-helpers.js";
+import { compact } from "./util/array.js";
+import { debugLogArray, debugLogObject } from "./util/debug.js";
+import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate } from "./util/glob.js";
+import { isConfig, isDeferResolve, isDependency, toConfig, toDebugString, toEntry, toProductionEntry, } from "./util/input.js";
+import { getPackageNameFromSpecifier } from "./util/modules.js";
+import { getKeysByValue } from "./util/object.js";
+import { timerify } from "./util/Performance.js";
+import { basename, dirname, extname, isInternal, join } from "./util/path.js";
+import { loadConfigForPlugin } from "./util/plugin.js";
+import { ELLIPSIS } from "./util/string.js";
 const nullConfig = { config: null, entry: null, project: null };
 const initEnabledPluginsMap = () => Object.keys(Plugins).reduce((enabled, pluginName) => ({ ...enabled, [pluginName]: false }), {});
 export class WorkspaceWorker {

package/dist/YamlCatalogPeeker.d.ts

@@ -1,8 +1,8 @@
 export declare class YamlCatalogPeeker {
-    private fileContent;
     private lines;
     private sections;
     private ready;
+    private fileContent;
     constructor(fileContent: string);
     private init;
     getLocation(parentSymbol: string, symbol: string): {

package/dist/YamlCatalogPeeker.js

@@ -1,14 +1,14 @@
-import { DEFAULT_CATALOG } from './util/catalog.js';
+import { DEFAULT_CATALOG } from "./util/catalog.js";
 function matchesKey(line, indent, key) {
     return (line.startsWith(`${indent}${key}:`) ||
         line.startsWith(`${indent}"${key}":`) ||
         line.startsWith(`${indent}'${key}':`));
 }
 export class YamlCatalogPeeker {
-    fileContent;
     lines = [];
     sections = {};
     ready = false;
+    fileContent;
     constructor(fileContent) {
         this.fileContent = fileContent;
     }

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

@@ -1,3 +1,3 @@
-import type { GetInputsFromScriptsOptions } from '../types/config.js';
-import { type Input } from '../util/input.js';
+import type { GetInputsFromScriptsOptions } from '../types/config.ts';
+import { type Input } from '../util/input.ts';
 export declare const getDependenciesFromScript: (script: string, options: GetInputsFromScriptsOptions) => Input[];

package/dist/binaries/bash-parser.js

@@ -1,17 +1,30 @@
-import parse, {} from '../../vendor/bash-parser/index.js';
-import { Plugins, pluginArgsMap } from '../plugins.js';
-import { debugLogObject } from '../util/debug.js';
-import { toBinary, toDeferResolve } from '../util/input.js';
-import { extractBinary, isValidBinary } from '../util/modules.js';
-import { relative } from '../util/path.js';
-import { truncate } from '../util/string.js';
-import { resolve as fallbackResolve } from './fallback.js';
-import PackageManagerResolvers from './package-manager/index.js';
-import { resolve as resolverFromPlugins } from './plugins.js';
-import { parseNodeArgs } from './util.js';
+import { parse } from 'unbash';
+import { Plugins, pluginArgsMap } from "../plugins.js";
+import { debugLogObject } from "../util/debug.js";
+import { toBinary, toDeferResolve } from "../util/input.js";
+import { extractBinary, isValidBinary } from "../util/modules.js";
+import { relative } from "../util/path.js";
+import { truncate } from "../util/string.js";
+import { resolve as fallbackResolve } from "./fallback.js";
+import PackageManagerResolvers from "./package-manager/index.js";
+import { resolve as resolverFromPlugins } from "./plugins.js";
+import { parseNodeArgs } from "./util.js";
 const spawningBinaries = ['cross-env', 'retry-cli'];
-const isExpansion = (node) => 'expansion' in node;
-const isAssignment = (node) => 'type' in node && node.type === 'AssignmentWord';
+const collectExpansionScripts = (word, out) => {
+    if (!word.parts)
+        return;
+    for (const part of word.parts) {
+        if ((part.type === 'CommandExpansion' || part.type === 'ProcessSubstitution') && part.script) {
+            out.push(part.script);
+        }
+        else if (part.type === 'DoubleQuoted' || part.type === 'LocaleString') {
+            for (const child of part.parts) {
+                if (child.type === 'CommandExpansion' && child.script)
+                    out.push(child.script);
+            }
+        }
+    }
+};
 export const getDependenciesFromScript = (script, options) => {
     if (!script)
         return [];
@@ -25,40 +38,47 @@ export const getDependenciesFromScript = (script, options) => {
         });
     };
     const definedFunctions = new Set();
-    const collectFunctionNames = (nodes) => {
-        for (const node of nodes)
-            if (node.type === 'Function')
-                definedFunctions.add(node.name.text);
+    const collectFunctionNames = (statements) => {
+        for (const stmt of statements)
+            if (stmt.command.type === 'Function')
+                definedFunctions.add(stmt.command.name.text);
+    };
+    const processScript = (s) => {
+        collectFunctionNames(s.commands);
+        const pending = [];
+        const mainDeps = getDependenciesFromStatements(s.commands, pending);
+        const expansionDeps = pending.flatMap(inner => processScript(inner));
+        return [...mainDeps, ...expansionDeps];
     };
-    const getDependenciesFromNodes = (nodes) => nodes.flatMap(node => {
+    const getDependenciesFromStatements = (statements, pending) => statements.flatMap(stmt => getDependenciesFromNode(stmt.command, pending));
+    const getDependenciesFromNode = (node, pending) => {
         switch (node.type) {
             case 'Command': {
-                const text = node.name?.text;
+                const text = node.name?.value;
                 const binary = text ? extractBinary(text) : text;
-                const commandExpansions = node.prefix
-                    ?.filter(isExpansion)
-                    .map(prefix => prefix.expansion)
-                    .flatMap(expansion => expansion.filter(expansion => expansion.type === 'CommandExpansion') ?? []) ?? [];
-                if (commandExpansions.length > 0) {
-                    return (commandExpansions.flatMap(expansion => getDependenciesFromNodes(expansion.commandAST.commands)) ?? []);
-                }
+                if (node.name)
+                    collectExpansionScripts(node.name, pending);
+                for (const prefix of node.prefix)
+                    if (prefix.value)
+                        collectExpansionScripts(prefix.value, pending);
+                for (const suffix of node.suffix)
+                    collectExpansionScripts(suffix, pending);
                 if (!binary || binary === '.' || binary === 'source' || binary === '[')
                     return [];
-                if (binary.startsWith('-') || binary.startsWith('"') || binary.startsWith('..'))
+                if (binary.startsWith('-') || binary.startsWith('..'))
                     return [];
                 if (definedFunctions.has(binary))
                     return [];
-                const args = node.suffix?.map(arg => arg.text) ?? [];
+                const args = node.suffix.map(w => w.value);
                 if (['!', 'test'].includes(binary))
                     return fromArgs(args);
                 const fromNodeOptions = node.prefix
-                    ?.filter(isAssignment)
-                    .filter(node => node.text.startsWith('NODE_OPTIONS='))
-                    .flatMap(node => node.text.split('=')[1])
+                    .filter(a => a.name === 'NODE_OPTIONS' && a.value)
+                    .map(a => a.value.value)
                     .map(arg => parseNodeArgs(arg.split(' ')))
                     .filter(args => args.require)
                     .flatMap(arg => arg.require)
-                    .map(id => toDeferResolve(id)) ?? [];
+                    .map(id => toDeferResolve(id));
                 if (binary in PackageManagerResolvers) {
                     const resolver = PackageManagerResolvers[binary];
                     return resolver(binary, args, { ...options, fromArgs });
@@ -67,8 +87,11 @@ export const getDependenciesFromScript = (script, options) => {
                     return [...resolverFromPlugins(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
                 }
                 if (spawningBinaries.includes(binary)) {
-                    const command = script.replace(new RegExp(`.*${text ?? binary}(\\s--\\s)?`), '');
-                    return [toBinary(binary), ...getDependenciesFromScript(command, options)];
+                    const rest = node.suffix
+                        .filter(w => w.text !== '--')
+                        .map(w => w.text)
+                        .join(' ');
+                    return [toBinary(binary), ...getDependenciesFromScript(rest, options)];
                 }
                 if (binary in Plugins) {
                     return [...fallbackResolve(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
@@ -77,30 +100,41 @@ export const getDependenciesFromScript = (script, options) => {
                     return [];
                 return [...fallbackResolve(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
             }
-            case 'LogicalExpression':
-                return getDependenciesFromNodes([node.left, node.right]);
+            case 'AndOr':
+            case 'Pipeline':
+                return node.commands.flatMap(n => getDependenciesFromNode(n, pending));
             case 'If':
-                return getDependenciesFromNodes([node.clause, node.then, ...(node.else ? [node.else] : [])]);
+                return [
+                    ...getDependenciesFromStatements(node.clause.commands, pending),
+                    ...getDependenciesFromStatements(node.then.commands, pending),
+                    ...(node.else ? getDependenciesFromNode(node.else, pending) : []),
+                ];
+            case 'While':
+                return [
+                    ...getDependenciesFromStatements(node.clause.commands, pending),
+                    ...getDependenciesFromStatements(node.body.commands, pending),
+                ];
             case 'For':
-                return getDependenciesFromNodes(node.do.commands);
+            case 'Select':
+            case 'Subshell':
+            case 'BraceGroup':
+                return getDependenciesFromStatements(node.body.commands, pending);
             case 'CompoundList':
-                return getDependenciesFromNodes(node.commands);
-            case 'Pipeline':
-                return getDependenciesFromNodes(node.commands);
+                return getDependenciesFromStatements(node.commands, pending);
             case 'Function':
-                return getDependenciesFromNodes(node.body.commands);
-            case 'Subshell':
-                return getDependenciesFromNodes(node.list.commands);
+            case 'Coproc':
+                return getDependenciesFromNode(node.body, pending);
+            case 'Statement':
+                return getDependenciesFromNode(node.command, pending);
             default:
                 return [];
         }
-    });
+    };
     try {
         const parsed = parse(script);
-        if (!parsed?.commands)
+        if (!parsed.commands)
             return [];
-        collectFunctionNames(parsed.commands);
-        return getDependenciesFromNodes(parsed.commands);
+        return processScript(parsed);
     }
     catch (error) {
         const msg = `Warning: failed to parse and ignoring script in ${relative(options.cwd, options.containingFilePath)} (${truncate(script, 30)})`;

package/dist/binaries/fallback.d.ts

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

package/dist/binaries/fallback.js

@@ -1,17 +1,15 @@
 import parseArgs from 'minimist';
-import { compact } from '../util/array.js';
-import { toBinary, toDeferResolve, toEntry } from '../util/input.js';
-import { isValidBinary } from '../util/modules.js';
-const spawningBinaries = ['cross-env', 'retry-cli'];
+import { compact } from "../util/array.js";
+import { toBinary, toDeferResolve, toEntry } from "../util/input.js";
+import { isValidBinary } from "../util/modules.js";
 const endOfCommandBinaries = ['dotenvx', 'env-cmd', 'op'];
 const positionals = new Set(['babel-node', 'esbuild', 'execa', 'jiti', 'oxnode', 'vite-node', 'zx']);
 const positionalBinaries = new Set(['concurrently']);
 export const resolve = (binary, args, { fromArgs }) => {
     const parsed = parseArgs(args, { boolean: ['quiet', 'verbose'], '--': endOfCommandBinaries.includes(binary) });
     const bin = binary.startsWith('.') ? toEntry(binary) : isValidBinary(binary) ? toBinary(binary) : undefined;
-    const shiftedArgs = spawningBinaries.includes(binary) ? fromArgs(args) : [];
     const pos = positionals.has(binary) ? [toDeferResolve(parsed._[0])] : [];
     const newCommand = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--']) : [];
     const commands = positionalBinaries.has(binary) ? parsed._.flatMap(cmd => fromArgs([cmd])) : [];
-    return compact([bin, ...shiftedArgs, ...pos, ...newCommand, ...commands]);
+    return compact([bin, ...pos, ...newCommand, ...commands]);
 };

package/dist/binaries/index.d.ts

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

package/dist/binaries/index.js

@@ -1,6 +1,6 @@
-import { fromBinary, isBinary, isDependency } from '../util/input.js';
-import { timerify } from '../util/Performance.js';
-import { getDependenciesFromScript } from './bash-parser.js';
+import { fromBinary, isBinary, isDependency } from "../util/input.js";
+import { timerify } from "../util/Performance.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));

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

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

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

@@ -1,8 +1,8 @@
 import parseArgs from 'minimist';
-import { toEntry } from '../../util/input.js';
-import { isAbsolute, join } from '../../util/path.js';
-import { _resolveSync } from '../../util/resolve.js';
-import { resolveX } from './bunx.js';
+import { toEntry } from "../../util/input.js";
+import { isAbsolute, join } from "../../util/path.js";
+import { _resolveSync } from "../../util/resolve.js";
+import { resolveX } from "./bunx.js";
 const commands = new Set([
     'add',
     'audit',
@@ -62,8 +62,6 @@ export const resolve = (_binary, args, options) => {
         return [];
     if (manifestScriptNames.has(command))
         return [];
-    if (command === 'test')
-        return parsed._.filter(id => id !== command).map(toEntry);
     if (command !== 'run' && commands.has(command))
         return [];
     const filePath = command === 'run' ? script : command;

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

@@ -1,3 +1,3 @@
-import type { BinaryResolver, BinaryResolverOptions } from '../../types/config.js';
-export declare const resolveX: (args: string[], options: BinaryResolverOptions) => import("../../util/input.js").Input[];
+import type { BinaryResolver, BinaryResolverOptions } from '../../types/config.ts';
+export declare const resolveX: (args: string[], options: BinaryResolverOptions) => import("../../util/input.ts").Input[];
 export declare const resolve: BinaryResolver;

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

@@ -1,8 +1,8 @@
 import parseArgs from 'minimist';
-import { toBinary, toDependency } from '../../util/input.js';
-import { stripVersionFromSpecifier } from '../../util/modules.js';
-import { isInternal } from '../../util/path.js';
-import { argsFrom } from '../util.js';
+import { toBinary, toDependency } from "../../util/input.js";
+import { stripVersionFromSpecifier } from "../../util/modules.js";
+import { isInternal } from "../../util/path.js";
+import { argsFrom } from "../util.js";
 export const resolveX = (args, options) => {
     const { fromArgs } = options;
     const parsed = parseArgs(args, { boolean: ['bun'] });

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

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

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

@@ -1,10 +1,10 @@
-import * as bun from './bun.js';
-import * as bunx from './bunx.js';
-import * as npm from './npm.js';
-import * as npx from './npx.js';
-import * as pnpm from './pnpm.js';
-import * as pnpx from './pnpx.js';
-import * as yarn from './yarn.js';
+import * as bun from "./bun.js";
+import * as bunx from "./bunx.js";
+import * as npm from "./npm.js";
+import * as npx from "./npx.js";
+import * as pnpm from "./pnpm.js";
+import * as pnpx from "./pnpx.js";
+import * as yarn from "./yarn.js";
 export default {
     bun: bun.resolve,
     bunx: bunx.resolve,

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

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

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

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

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

@@ -1,8 +1,8 @@
 import parseArgs from 'minimist';
-import { toBinary, toDependency } from '../../util/input.js';
-import { stripVersionFromSpecifier } from '../../util/modules.js';
-import { isInternal } from '../../util/path.js';
-import { argsFrom } from '../util.js';
+import { toBinary, toDependency } from "../../util/input.js";
+import { stripVersionFromSpecifier } from "../../util/modules.js";
+import { isInternal } from "../../util/path.js";
+import { argsFrom } from "../util.js";
 export const resolve = (_binary, args, options) => {
     const { fromArgs } = options;
     const parsed = parseArgs(args, {

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

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