knip 6.31.0 → 6.32.1

package/dist/ConfigurationChief.d.ts

@@ -97,6 +97,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        borp?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         bumpp?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -552,6 +557,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'pre-commit'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         preconstruct?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -782,6 +792,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        tsd?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         tsdown?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -987,6 +1002,7 @@ export declare class ConfigurationChief {
         ava?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         babel?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         biome?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        borp?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         bumpp?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         bun?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         c8?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1078,6 +1094,7 @@ export declare class ConfigurationChief {
         pm2?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         pnpm?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         postcss?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        "pre-commit"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         preconstruct?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         prettier?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         prisma?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1124,6 +1141,7 @@ export declare class ConfigurationChief {
         temporal?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         travis?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "ts-node"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        tsd?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsdown?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsup?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsx?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/DependencyDeputy.d.ts

@@ -4,6 +4,7 @@ import type { PackageJson } from './types/package-json.ts';
 import type { DependencyArray, DependencySet, HostDependencies, InstalledBinaries, WorkspaceManifests } from './types/workspace.ts';
 import type { MainOptions } from './util/create-options.ts';
 interface DependencyReferenceOptions {
+    specifier: string;
     isDevOnly?: boolean;
     isTypeOnly?: boolean;
     isResolved?: boolean;
@@ -64,7 +65,7 @@ export declare class DependencyDeputy {
         isPeerOptional: boolean;
     }[];
     getOptionalPeerDependencies(workspaceName: string): DependencySet;
-    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string, { isDevOnly, isTypeOnly, isResolved, isPublishedType }?: DependencyReferenceOptions): boolean;
+    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string, { specifier, isDevOnly, isTypeOnly, isResolved, isPublishedType }: DependencyReferenceOptions): boolean;
     maybeAddReferencedBinary(workspace: Workspace, binaryName: string): Set<string> | undefined;
     private isInDependencies;
     settleDependencyIssues(): {

package/dist/DependencyDeputy.js

@@ -122,10 +122,10 @@ export class DependencyDeputy {
     getOptionalPeerDependencies(workspaceName) {
         return this._manifests.get(workspaceName)?.optionalPeerDependencies ?? new Set();
     }
-    maybeAddReferencedExternalDependency(workspace, packageName, { isDevOnly, isTypeOnly, isResolved, isPublishedType } = {}) {
+    maybeAddReferencedExternalDependency(workspace, packageName, { specifier, isDevOnly, isTypeOnly, isResolved, isPublishedType }) {
         if (!this.isReportDependencies)
             return true;
-        if (packageName.startsWith('node:') || isBuiltin(packageName))
+        if (specifier.startsWith('node:') || isBuiltin(specifier))
             return true;
         if (IGNORED_RUNTIME_DEPENDENCIES.has(packageName))
             return true;

package/dist/WorkspaceWorker.js

@@ -223,7 +223,6 @@ export class WorkspaceWorker {
         const hasProductionInput = (input) => productionInputsFromManifest.find(d => d.specifier === input.specifier && d.type === input.type);
         const createGetInputsFromScripts = (containingFilePath) => (scripts, options) => _getInputsFromScripts(scripts, { ...baseOptions, ...options, containingFilePath });
         const inputs = [];
-        const enabledPlugins = new Set(this.enabledPlugins);
         const configFilesMap = this.configFilesMap;
         const seen = new Map();
         const parsedConfigCache = new Map();
@@ -434,21 +433,20 @@ export class WorkspaceWorker {
                         break;
                     const [pluginName, dependencies] = entry;
                     configFiles.delete(pluginName);
-                    if (enabledPlugins.has(pluginName)) {
-                        const seenConfigFiles = getSeenConfigFiles(pluginName);
-                        const unprocessed = [];
-                        for (const filePath of dependencies) {
-                            if (!seenConfigFiles.has(filePath))
-                                unprocessed.push(filePath);
-                        }
-                        if (unprocessed.length > 0) {
-                            for (const input of await runPlugin(pluginName, unprocessed, true))
-                                inputs.push(input);
-                        }
-                    }
-                    else {
+                    if (this.config[pluginName] === false) {
                         for (const id of dependencies)
                             inputs.push(toEntry(id));
+                        continue;
+                    }
+                    const seenConfigFiles = getSeenConfigFiles(pluginName);
+                    const unprocessed = [];
+                    for (const filePath of dependencies) {
+                        if (!seenConfigFiles.has(filePath))
+                            unprocessed.push(filePath);
+                    }
+                    if (unprocessed.length > 0) {
+                        for (const input of await runPlugin(pluginName, unprocessed, true))
+                            inputs.push(input);
                     }
                 }
             }

package/dist/binaries/bash-parser.js

@@ -30,9 +30,21 @@ export const getDependenciesFromScript = (script, options) => {
     if (!script)
         return [];
     const fromArgs = (args, opts) => {
-        if (args.length === 0 || !isValidBinary(substringBefore(args[0], ' ')))
+        if (args.length === 0)
             return [];
-        return getDependenciesFromScript(args.filter(arg => arg !== '--').join(' '), {
+        const first = typeof args[0] === 'string' ? args[0] : args[0].value;
+        if (!isValidBinary(substringBefore(first, ' ')))
+            return [];
+        const parts = [];
+        for (const arg of args) {
+            if (typeof arg === 'string') {
+                if (arg !== '--')
+                    parts.push(arg);
+            }
+            else if (arg.value !== '--')
+                parts.push(arg.text);
+        }
+        return getDependenciesFromScript(parts.join(' '), {
             ...options,
             knownBinsOnly: false,
             ...opts,
@@ -71,9 +83,9 @@ export const getDependenciesFromScript = (script, options) => {
             return [];
         if (definedFunctions.has(binary))
             return [];
-        const args = node.suffix.map(w => w.value);
+        const words = node.suffix;
         if (binary === '!' || binary === 'test')
-            return fromArgs(args);
+            return fromArgs(words);
         const fromNodeOptions = node.prefix
             .filter(a => a.name === 'NODE_OPTIONS' && a.value)
             .map(a => a.value.value)
@@ -83,10 +95,10 @@ export const getDependenciesFromScript = (script, options) => {
             .map(id => toDeferResolve(id));
         if (binary in KnownResolvers) {
             const resolver = KnownResolvers[binary];
-            return resolver(binary, args, { ...options, fromArgs });
+            return resolver(binary, words, { ...options, fromArgs });
         }
         if (pluginArgsMap.has(binary)) {
-            return [...resolverFromPlugins(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
+            return [...resolverFromPlugins(binary, words, { ...options, fromArgs }), ...fromNodeOptions];
         }
         if (spawningBinaries.includes(binary)) {
             const rest = node.suffix
@@ -96,7 +108,7 @@ export const getDependenciesFromScript = (script, options) => {
             return [toBinary(binary), ...getDependenciesFromScript(rest, options)];
         }
         if (binary in Plugins) {
-            const inputs = fallbackResolve(binary, args, { ...options, fromArgs });
+            const inputs = fallbackResolve(binary, words, { ...options, fromArgs });
             if (options.knownBinsOnly)
                 for (const input of inputs)
                     input.optional = true;
@@ -104,7 +116,7 @@ export const getDependenciesFromScript = (script, options) => {
         }
         if (options.knownBinsOnly && !text?.startsWith('.'))
             return [];
-        return [...fallbackResolve(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
+        return [...fallbackResolve(binary, words, { ...options, fromArgs }), ...fromNodeOptions];
     };
     try {
         const parsed = parse(script);

package/dist/binaries/fallback.js

@@ -2,18 +2,20 @@ import parseArgs from '../util/parse-args.js';
 import { compact } from '../util/array.js';
 import { toBinary, toDeferResolve, toEntry } from '../util/input.js';
 import { isValidBinary } from '../util/modules.js';
+import { isAbsolute } from '../util/path.js';
+import { argsAfter } from './util.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('.') || binary.includes('/')
+export const resolve = (binary, words, { fromArgs }) => {
+    const parsed = parseArgs(words, { boolean: ['quiet', 'verbose'], '--': endOfCommandBinaries.includes(binary) });
+    const bin = binary.startsWith('.') || (binary.includes('/') && !isAbsolute(binary))
         ? toEntry(binary)
         : isValidBinary(binary)
             ? toBinary(binary)
             : undefined;
     const pos = positionals.has(binary) ? [toDeferResolve(parsed._[0])] : [];
-    const newCommand = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--']) : [];
+    const newCommand = parsed['--'] && parsed['--'].length > 0 ? fromArgs(argsAfter(words, '--')) : [];
     const commands = positionalBinaries.has(binary) ? parsed._.flatMap(cmd => fromArgs([cmd])) : [];
     return compact([bin, ...pos, ...newCommand, ...commands]);
 };

package/dist/binaries/plugins.js

@@ -5,18 +5,22 @@ import { toBinary, toConfig, toDeferResolve, toDeferResolveEntry, toEntry } from
 import { extractBinary } from '../util/modules.js';
 import { dirname } from '../util/path.js';
 import { resolve as fallbackResolve } from './fallback.js';
+import { toWordArgs } from './util.js';
 const isGlobLikeMatch = /(^!|[*+\\(|{^$])/;
 const isGlobLike = (value) => isGlobLikeMatch.test(value);
 const nodeLoadersArgs = { import: ['r', 'experimental-loader', 'require', 'loader'] };
-export const resolve = (binary, _args, options) => {
+export const resolve = (binary, words, options) => {
     const { cwd, fromArgs, containingFilePath, manifest } = options;
     const [pluginName, pluginArgs] = pluginArgsMap.get(binary) ?? [];
     if (!pluginArgs)
-        return fallbackResolve(binary, _args, options);
+        return fallbackResolve(binary, words, options);
     const inputOpts = {};
     if (cwd && dirname(containingFilePath) !== cwd)
         Object.assign(inputOpts, { dir: cwd });
-    const args = typeof pluginArgs.args === 'function' ? pluginArgs.args(_args) : _args;
+    const values = [];
+    for (const word of words)
+        values.push(word.value);
+    const args = typeof pluginArgs.args === 'function' ? pluginArgs.args(values) : values;
     const parsed = parseArgs(args, {
         string: [
             ...(pluginArgs.nodeImportArgs ? ['import'] : []),
@@ -47,7 +51,7 @@ export const resolve = (binary, _args, options) => {
     const resolved = compact(pluginArgs.resolve ? pluginArgs.resolve.flatMap(mapToParsedKey) : []);
     const resolvedImports = pluginArgs.nodeImportArgs && parsed.import ? [parsed.import].flat() : [];
     const resolvedFromArgs = typeof pluginArgs.fromArgs === 'function'
-        ? fromArgs(pluginArgs.fromArgs(parsed, args))
+        ? fromArgs(toWordArgs(pluginArgs.fromArgs(parsed, args), words))
         : Array.isArray(pluginArgs.fromArgs)
             ? fromArgs(pluginArgs.fromArgs.flatMap(mapToParsedKey).filter(Boolean))
             : [];

package/dist/binaries/resolvers/bun.js

@@ -51,20 +51,20 @@ const commands = new Set([
     'why',
     'x',
 ]);
-export const resolve = (_binary, args, options) => {
+export const resolve = (_binary, words, options) => {
     const binary = toBinary(_binary);
-    const parsed = parseArgs(args, { string: ['cwd'] });
+    const parsed = parseArgs(words, { string: ['cwd'] });
     const [command, script] = parsed._;
     if (command === 'x') {
-        const argsForX = args.filter(arg => arg !== 'x');
-        return [binary, ...resolveX(argsForX, options)];
+        const wordsForX = words.filter(word => word.value !== 'x');
+        return [binary, ...resolveX(wordsForX, options)];
     }
     const { manifest, cwd, fromArgs } = options;
     if (command === 'run' && manifest.scriptNames.has(script)) {
-        return [binary, ...(expandScript(script, argsAfter(args, script), manifest.scripts, options) ?? [])];
+        return [binary, ...(expandScript(script, argsAfter(words, script), manifest.scripts, options) ?? [])];
     }
     if (manifest.scriptNames.has(command)) {
-        return [binary, ...(expandScript(command, argsAfter(args, command), manifest.scripts, options) ?? [])];
+        return [binary, ...(expandScript(command, argsAfter(words, command), manifest.scripts, options) ?? [])];
     }
     if (command !== 'run' && commands.has(command))
         return [binary];
@@ -78,7 +78,7 @@ export const resolve = (_binary, args, options) => {
     const dir = parsed.cwd ? join(cwd, parsed.cwd) : undefined;
     const opts = dir ? { cwd: dir } : {};
     if (command !== 'run')
-        return [binary, ...fromArgs(args, opts)];
+        return [binary, ...fromArgs(words, opts)];
     const input = toBinary(filePath, { optional: true });
     if (dir)
         input.dir = dir;

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

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

package/dist/binaries/resolvers/bunx.js

@@ -3,19 +3,23 @@ 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) => {
+export const resolveX = (words, options) => {
     const { fromArgs } = options;
-    const parsed = parseArgs(args, { boolean: ['bun'] });
+    const parsed = parseArgs(words, { boolean: ['bun'] });
     const packageSpecifier = parsed._[0];
     const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
     const packages = parsed.package && !parsed.yes ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
     const command = parsed['shell-mode'] ? fromArgs([parsed['shell-mode']]) : [];
-    const restArgs = argsFrom(args, packageSpecifier);
     const isBinary = specifier && !packageSpecifier.includes('@') && !isInternal(specifier);
     const dependency = isBinary ? toBinary(specifier, { optional: true }) : toDependency(specifier, { optional: true });
     const specifiers = specifier ? [dependency] : [];
-    return [...specifiers, ...packages.map(id => toDependency(id)), ...command, ...fromArgs(restArgs).slice(1)];
+    return [
+        ...specifiers,
+        ...packages.map(id => toDependency(id)),
+        ...command,
+        ...fromArgs(argsFrom(words, packageSpecifier)).slice(1),
+    ];
 };
-export const resolve = (_binary, args, options) => {
-    return resolveX(args, options);
+export const resolve = (_binary, words, options) => {
+    return resolveX(words, options);
 };

package/dist/binaries/resolvers/find.js

@@ -1,16 +1,16 @@
 import { toBinary } from '../../util/input.js';
 const execFlags = new Set(['-exec', '-execdir']);
 const execTerminators = new Set([';', '\\;', '+']);
-export const resolve = (binary, args, { fromArgs }) => {
-    const execIdx = args.findIndex(a => execFlags.has(a));
+export const resolve = (binary, words, { fromArgs }) => {
+    const execIdx = words.findIndex(word => execFlags.has(word.value));
     if (execIdx >= 0) {
         const cmdWords = [];
-        for (let i = execIdx + 1; i < args.length; i++) {
-            const v = args[i];
+        for (let i = execIdx + 1; i < words.length; i++) {
+            const v = words[i].value;
             if (execTerminators.has(v))
                 break;
             if (v !== '{}')
-                cmdWords.push(v);
+                cmdWords.push(words[i]);
         }
         if (cmdWords.length > 0)
             return [toBinary(binary), ...fromArgs(cmdWords)];

package/dist/binaries/resolvers/npm.js

@@ -1,14 +1,14 @@
 import parseArgs from '../../util/parse-args.js';
-import { expandScript } from '../util.js';
-export const resolve = (_binary, args, options) => {
+import { argsAfter, expandScript } from '../util.js';
+export const resolve = (_binary, words, options) => {
     const { fromArgs, manifest } = options;
-    const parsed = parseArgs(args, { '--': true });
+    const parsed = parseArgs(words, { '--': true });
     const [command, script] = parsed._;
-    const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
+    const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(argsAfter(words, '--'), { knownBinsOnly: true }) : [];
     if (command === 'exec')
         return _childArgs;
     if (command === 'run' && manifest.scriptNames.has(script)) {
-        return expandScript(script, parsed['--'] ?? [], manifest.scripts, options) ?? _childArgs;
+        return expandScript(script, argsAfter(words, '--'), manifest.scripts, options) ?? _childArgs;
     }
     return [];
 };

package/dist/binaries/resolvers/npx.js

@@ -3,9 +3,9 @@ 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) => {
+export const resolve = (_binary, words, options) => {
     const { fromArgs } = options;
-    const parsed = parseArgs(args, {
+    const parsed = parseArgs(words, {
         boolean: ['yes', 'no', 'quiet'],
         alias: { yes: 'y', no: 'no-install', package: 'p', call: 'c' },
     });
@@ -13,7 +13,6 @@ export const resolve = (_binary, args, options) => {
     const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
     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);
     const opts = parsed.no ? undefined : { optional: true };
     const dependency = isBinary ? toBinary(specifier, opts) : toDependency(specifier, opts);
@@ -22,6 +21,6 @@ export const resolve = (_binary, args, options) => {
         ...specifiers,
         ...packages.map(id => toDependency(id, { optional: true })),
         ...command,
-        ...fromArgs(restArgs).slice(1),
+        ...fromArgs(argsFrom(words, packageSpecifier)).slice(1),
     ];
 };

package/dist/binaries/resolvers/nub.js

@@ -23,13 +23,13 @@ const commands = new Set([
     'update',
     'why',
 ]);
-export const resolve = (_binary, args, options) => {
+export const resolve = (_binary, words, options) => {
     const binary = toBinary(_binary);
     const { manifest, cwd, fromArgs } = options;
-    const parsed = parseArgs(args, { string: ['filter'], boolean: ['recursive'], alias: { recursive: 'r' } });
+    const parsed = parseArgs(words, { string: ['filter'], boolean: ['recursive'], alias: { recursive: 'r' } });
     const [command, script] = parsed._;
     if (runtimes.has(command)) {
-        const rest = args.filter(arg => arg !== command);
+        const rest = words.filter(word => word.value !== command);
         return [binary, ...resolveX(rest, options)];
     }
     if (parsed.recursive || parsed.filter)
@@ -42,5 +42,5 @@ export const resolve = (_binary, args, options) => {
     }
     if (command && (commands.has(command) || manifest.scriptNames.has(command)))
         return [binary];
-    return [binary, ...fromArgs(['node', ...args])];
+    return [binary, ...fromArgs(['node', ...words])];
 };

package/dist/binaries/resolvers/pnpm.js

@@ -1,7 +1,7 @@
 import parseArgs from '../../util/parse-args.js';
 import { toBinary } from '../../util/input.js';
 import { isValidBinary } from '../../util/modules.js';
-import { argsAfter, expandScript } from '../util.js';
+import { argsAfter, expandScript, toWordArgs } from '../util.js';
 import { resolveDlx } from './pnpx.js';
 const commands = [
     'add',
@@ -81,34 +81,37 @@ const commands = [
     'why',
     'with',
 ];
-export const resolve = (_binary, args, options) => {
-    const parsed = parseArgs(args, {
+export const resolve = (_binary, words, options) => {
+    const parsed = parseArgs(words, {
         boolean: ['aggregate-output', 'if-present', 'parallel', 'recursive', 'reverse', 'shell-mode', 'silent', 'stream'],
         alias: { recursive: 'r', silent: 's', 'shell-mode': 'c', filter: 'F' },
         '--': true,
     });
     const [command] = parsed._;
     if (command === 'dlx') {
-        const argsForDlx = args.filter(arg => arg !== 'dlx');
-        return resolveDlx(argsForDlx, options);
+        const wordsForDlx = words.filter(word => word.value !== 'dlx');
+        return resolveDlx(wordsForDlx, options);
     }
     const { manifest, fromArgs } = options;
     if (parsed.filter && !parsed.recursive)
         return [];
-    const childInputs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
+    const childInputs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(argsAfter(words, '--'), { knownBinsOnly: true }) : [];
     if (command === 'exec') {
-        return childInputs.length > 0 ? childInputs : fromArgs(parsed._.slice(1));
+        if (childInputs.length > 0)
+            return childInputs;
+        const rest = parsed._.slice(1);
+        return rest.length === 1 ? fromArgs(rest.map(String)) : fromArgs(toWordArgs(rest, words));
     }
     if (command === 'run') {
         const script = parsed._[1];
         if (script && manifest.scriptNames.has(script)) {
-            return expandScript(script, argsAfter(args, script), manifest.scripts, options) ?? childInputs;
+            return expandScript(script, argsAfter(words, script), manifest.scripts, options) ?? childInputs;
         }
         return childInputs;
     }
     const isScript = manifest.scriptNames.has(command);
     if (isScript)
-        return expandScript(command, argsAfter(args, command), manifest.scripts, options) ?? childInputs;
+        return expandScript(command, argsAfter(words, command), manifest.scripts, options) ?? childInputs;
     if (commands.includes(command))
         return childInputs;
     return command && isValidBinary(command) ? [toBinary(command)] : [];

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

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

package/dist/binaries/resolvers/pnpx.js

@@ -7,8 +7,8 @@ const toDependencyInputs = (packageSpecifier) => {
     const reference = getCatalogReference(packageSpecifier);
     return reference ? [dependency, toCatalog(reference.packageName, reference.catalogName)] : [dependency];
 };
-export const resolveDlx = (args, options) => {
-    const parsed = parseArgs(args, {
+export const resolveDlx = (words, options) => {
+    const parsed = parseArgs(words, {
         boolean: ['silent'],
         alias: { package: 'p', 'shell-mode': 'c' },
     });
@@ -18,6 +18,6 @@ export const resolveDlx = (args, options) => {
     const dependencyInputs = packageSpecifier ? toDependencyInputs(packageSpecifier) : [];
     return [...dependencyInputs, ...packages.flatMap(toDependencyInputs), ...command];
 };
-export const resolve = (_binary, args, options) => {
-    return resolveDlx(args, options);
+export const resolve = (_binary, words, options) => {
+    return resolveDlx(words, options);
 };

package/dist/binaries/resolvers/yarn.js

@@ -2,7 +2,7 @@ import parseArgs from '../../util/parse-args.js';
 import { isBinary, isDependency, toBinary, toDependency } from '../../util/input.js';
 import { stripVersionFromSpecifier } from '../../util/modules.js';
 import { join } from '../../util/path.js';
-import { argsAfter, argsFrom, expandScript } from '../util.js';
+import { argsAfter, argsFrom, expandScript, toWordArgs } from '../util.js';
 const commands = [
     'add',
     'bin',
@@ -37,30 +37,30 @@ const commands = [
     'workspace',
     'workspaces',
 ];
-const resolveDlx = (args, options) => {
-    const parsed = parseArgs(args, {
+const resolveDlx = (words, options) => {
+    const parsed = parseArgs(words, {
         boolean: ['quiet'],
         alias: { package: 'p', quiet: 'q' },
     });
     const packageSpecifier = parsed._[0];
     const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
     const packages = parsed.package && !parsed.yes ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
-    const command = specifier ? options.fromArgs(parsed._) : [];
+    const command = specifier ? options.fromArgs(toWordArgs(parsed._, words)) : [];
     return [...packages.map(id => toDependency(id)), ...command].map(id => isDependency(id) || isBinary(id) ? Object.assign(id, { optional: true }) : id);
 };
-export const resolve = (_binary, args, options) => {
+export const resolve = (_binary, words, options) => {
     const { manifest, fromArgs, cwd, rootCwd, getManifest } = options;
-    const parsed = parseArgs(args, { boolean: ['top-level'], string: ['cwd'], '--': true });
+    const parsed = parseArgs(words, { boolean: ['top-level'], string: ['cwd'], '--': true });
     const dir = parsed['top-level'] ? rootCwd : parsed.cwd ? join(cwd, parsed.cwd) : undefined;
     const [command, binary] = parsed._;
     if (!command && !binary)
         return [];
     const dirManifest = (dir && getManifest(dir)) || manifest;
-    const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
+    const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(argsAfter(words, '--'), { knownBinsOnly: true }) : [];
     if (command === 'run') {
         if (dirManifest.scriptNames.has(binary)) {
             const opts = dir ? { cwd: dir, manifest: dirManifest } : {};
-            return expandScript(binary, argsAfter(args, binary), dirManifest.scripts, options, opts) ?? _childArgs;
+            return expandScript(binary, argsAfter(words, binary), dirManifest.scripts, options, opts) ?? _childArgs;
         }
         const bin = toBinary(binary, { optional: true });
         if (dir)
@@ -68,17 +68,21 @@ export const resolve = (_binary, args, options) => {
         return [bin, ..._childArgs];
     }
     if (command === 'node')
-        return fromArgs(parsed._);
+        return fromArgs(toWordArgs(parsed._, words));
     if (command === 'dlx') {
-        const argsForDlx = args.filter(arg => arg !== 'dlx');
-        return resolveDlx(argsForDlx, options);
+        const wordsForDlx = words.filter(word => word.value !== 'dlx');
+        return resolveDlx(wordsForDlx, options);
     }
     if (dirManifest.scriptNames.has(command)) {
         const opts = dir ? { cwd: dir, manifest: dirManifest } : {};
-        return expandScript(command, argsAfter(args, command), dirManifest.scripts, options, opts) ?? _childArgs;
+        return expandScript(command, argsAfter(words, command), dirManifest.scripts, options, opts) ?? _childArgs;
     }
     if (commands.includes(command))
         return _childArgs;
     const opts = dir ? { cwd: dir } : {};
-    return fromArgs(argsFrom(args, command === 'exec' ? binary : command), opts);
+    if (command === 'exec') {
+        const rest = argsFrom(words, binary);
+        return rest.length === 1 ? fromArgs([rest[0].value], opts) : fromArgs(rest, opts);
+    }
+    return fromArgs(argsFrom(words, command), opts);
 };

package/dist/binaries/util.d.ts

@@ -1,6 +1,8 @@
-import type { BinaryResolverOptions, GetInputsFromScriptsOptions } from '../types/config.ts';
+import type { Word } from 'unbash';
+import type { BinaryResolverOptions, GetInputsFromScriptsOptions, ScriptArg } from '../types/config.ts';
 import type { Input } from '../util/input.ts';
-export declare const argsFrom: (args: string[], from: string) => string[];
-export declare const argsAfter: (args: string[], token: string) => string[];
-export declare const expandScript: (name: string, forwardedArgs: string[], scripts: Record<string, string> | undefined, options: BinaryResolverOptions, opts?: Partial<GetInputsFromScriptsOptions>) => Input[] | undefined;
+export declare const argsFrom: <T extends string | Word>(args: readonly T[], from: string) => T[];
+export declare const argsAfter: <T extends string | Word>(args: readonly T[], token: string) => T[];
+export declare const toWordArgs: (values: (string | number)[], words: Word[]) => ScriptArg[];
+export declare const expandScript: (name: string, forwardedArgs: ScriptArg[], scripts: Record<string, string> | undefined, options: BinaryResolverOptions, opts?: Partial<GetInputsFromScriptsOptions>) => Input[] | undefined;
 export declare const parseNodeArgs: (args: string[]) => import("../util/parse-args.ts").ParsedArgs;