knip 6.36.0 → 6.37.0

package/dist/plugins/eslint/helpers.js

@@ -107,15 +107,35 @@ const getDependenciesFromSettings = (settings = {}) => {
 };
 export const getInputsFromSettings = (settings) => compact(getDependenciesFromSettings(settings)).map(id => toDeferResolve(id, { optional: true }));
 const builtinFormatters = new Set(['html', 'json-with-metadata', 'json', 'stylish']);
-export const resolveFormatters = (formatters) => {
+const builtinFormattersUntilV8 = new Set([
+    'checkstyle',
+    'compact',
+    'jslint-xml',
+    'junit',
+    'tap',
+    'unix',
+    'visualstudio',
+]);
+const normalizeFormatterName = (name) => {
+    if (!name.startsWith('@'))
+        return name.startsWith('eslint-formatter-') ? name : `eslint-formatter-${name}`;
+    const [scope, id] = name.split('/');
+    if (!id)
+        return `${scope}/eslint-formatter`;
+    return /^eslint-formatter(-|$)/.test(id) ? name : name.replace('/', '/eslint-formatter-');
+};
+export const resolveFormatters = (formatters, manifest) => {
     const inputs = new Set();
-    for (const formatter of [formatters].flat()) {
-        if (builtinFormatters.has(formatter))
-            continue;
-        else if (isInternal(formatter))
-            inputs.add(toDeferResolve(formatter));
-        else
-            inputs.add(toDependency(`eslint-formatter-${formatter}`));
+    const isBeforeV9 = (manifest.getMajor('eslint') ?? 9) < 9;
+    for (const rawFormatter of [formatters].flat()) {
+        const formatter = rawFormatter.replace(/\\/g, '/');
+        if (!formatter.startsWith('@') && formatter.includes('/')) {
+            inputs.add(toDeferResolve(isInternal(formatter) ? formatter : `./${formatter}`));
+        }
+        else {
+            const isBuiltin = builtinFormatters.has(formatter) || (isBeforeV9 && builtinFormattersUntilV8.has(formatter));
+            inputs.add(toDependency(normalizeFormatterName(formatter), isBuiltin ? { optional: true } : {}));
+        }
     }
     return inputs;
 };

package/dist/plugins/eslint/index.js

@@ -49,12 +49,12 @@ const args = {
     config: true,
     alias: { format: ['f'] },
     boolean: ['inspect-config'],
-    resolveInputs: (parsed) => {
+    resolveInputs: (parsed, { manifest }) => {
         const inputs = [];
         if (parsed['inspect-config'])
             inputs.push(toDependency('@eslint/config-inspector', { optional: true }));
         if (parsed['format'])
-            for (const input of resolveFormatters(parsed['format']))
+            for (const input of resolveFormatters(parsed['format'], manifest))
                 inputs.push(input);
         return inputs;
     },

package/dist/plugins/github-actions/index.js

@@ -34,7 +34,7 @@ const resolveConfig = async (config, options) => {
                 const manifest = getManifest(dir) ?? options.manifest;
                 const actionPath = relative(dir, configFileDir);
                 const run = step.run.replace(ACTION_PATH_VAR, actionPath ? `./${actionPath}` : '.');
-                for (const input of getInputsFromScripts([run], { knownBinsOnly: true, manifest })) {
+                for (const input of getInputsFromScripts([run], { optionalBinaries: true, manifest })) {
                     if (isDeferResolveEntry(input) && path && !workingDir) {
                         input.specifier = relative(join(dir, path), join(rootCwd, input.specifier));
                     }

package/dist/plugins/graphql-codegen/index.js

@@ -1,8 +1,8 @@
 import { toDependency, toEntry, toProductionEntry } from '../../util/input.js';
 import { get } from '../../util/object.js';
-import { isInternal, join } from '../../util/path.js';
+import { isInternal, join, normalize } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
-import { isConfigurationOutput, isGraphqlConfigTypes, isGraphqlProjectsConfigTypes } from './types.js';
+import { isConfigurationOutput, isGraphqlConfigTypes, isGraphqlProjectsConfigTypes, isNearOperationFilePreset, } from './types.js';
 const title = 'GraphQL Codegen';
 const enablers = [/^@graphql-codegen\//, 'graphql-config'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -24,6 +24,17 @@ const getPluginPackageName = (name) => {
         return name;
     return `@graphql-codegen/${name}`;
 };
+const getOutputPattern = (output, outputConfig) => {
+    if (isConfigurationOutput(outputConfig) && isNearOperationFilePreset(outputConfig.preset)) {
+        const presetConfig = outputConfig.presetConfig ?? {};
+        const { folder = '', extension = '.generated.ts', fileName = '*', filePerOperation = false } = presetConfig;
+        const subfolder = normalize(folder)
+            .split('/')
+            .filter(segment => segment !== '' && segment !== '.' && segment !== '..');
+        return join(output, '**', ...subfolder, `${filePerOperation ? '*' : fileName}${extension}`);
+    }
+    return output.endsWith('/') ? `${output}**` : output;
+};
 const resolveConfig = (config, options) => {
     const codegenConfigs = isGraphqlProjectsConfigTypes(config)
         ? Object.values(config.projects).flatMap(project => project.extensions?.codegen ?? [])
@@ -33,8 +44,8 @@ const resolveConfig = (config, options) => {
     const generateConfigs = codegenConfigs.filter((config) => Boolean(config?.generates));
     const generateSet = generateConfigs.flatMap(config => Object.values(config.generates));
     const outputs = generateConfigs
-        .flatMap(config => Object.keys(config.generates))
-        .map(output => toProductionEntry(join(options.configFileDir, output.endsWith('/') ? `${output}**` : output)));
+        .flatMap(config => Object.entries(config.generates))
+        .map(([output, outputConfig]) => toProductionEntry(join(options.configFileDir, getOutputPattern(output, outputConfig))));
     const configurationOutput = generateSet.filter(isConfigurationOutput);
     const presets = configurationOutput
         .map(configOutput => (configOutput.preset ? configOutput.preset : undefined))

package/dist/plugins/graphql-codegen/types.d.ts

@@ -12,10 +12,20 @@ type OutputPreset = {
     buildGeneratesSection: (options: unknown) => Promise<unknown>;
     prepareDocuments?: (outputFilePath: string, outputSpecificDocuments: unknown) => Promise<unknown>;
 };
+export interface NearOperationFilePresetConfig {
+    baseTypesPath?: string;
+    extension?: string;
+    fileName?: string;
+    filePerOperation?: boolean;
+    folder?: string;
+    [key: string]: unknown;
+}
+export declare const isNearOperationFilePreset: (preset: ConfiguredOutput['preset']) => preset is PresetNames;
 export declare function isConfigurationOutput(config: ConfiguredOutput | ConfiguredPlugin[]): config is ConfiguredOutput;
-interface ConfiguredOutput {
+export interface ConfiguredOutput {
     plugins?: OutputConfig[];
     preset?: PresetNames | OutputPreset;
+    presetConfig?: NearOperationFilePresetConfig;
 }
 export interface GraphqlCodegenTypes {
     generates: {

package/dist/plugins/graphql-codegen/types.js

@@ -1,3 +1,9 @@
+const nearOperationFilePresetNames = new Set([
+    'near-operation-file',
+    'near-operation-file-preset',
+    '@graphql-codegen/near-operation-file-preset',
+]);
+export const isNearOperationFilePreset = (preset) => typeof preset === 'string' && nearOperationFilePresetNames.has(preset);
 export function isConfigurationOutput(config) {
     return 'preset' in config || 'plugins' in config;
 }

package/dist/plugins/husky/index.js

@@ -17,7 +17,7 @@ const resolveConfig = (script, options) => {
             return [toDependency('husky'), ...options.getInputsFromScripts(scripts, { ...options })];
         }
     }
-    return options.getInputsFromScripts(String(script), { knownBinsOnly: true });
+    return options.getInputsFromScripts(String(script), { optionalBinaries: true });
 };
 const plugin = {
     title,

package/dist/plugins/lefthook/index.js

@@ -21,7 +21,7 @@ const resolveConfig = async (localConfig, options) => {
     const inputs = manifest.devDependencies ? Object.keys(manifest.devDependencies).map(id => toDependency(id)) : [];
     if (extname(configFileName) !== '') {
         const scripts = findByKeyDeep(localConfig, 'run').flatMap(command => {
-            const deps = getInputsFromScripts([command.run], { ...options, knownBinsOnly: true });
+            const deps = getInputsFromScripts([command.run], { ...options, optionalBinaries: true });
             const dir = command.root ?? cwd;
             return deps.flatMap(dependency => ({ ...dependency, dir }));
         });

package/dist/plugins/mise/scripts.js

@@ -2,11 +2,11 @@ import { parse } from 'unbash';
 import { getDependenciesFromCommand, getInputsFromNodeOptions } from '../../binaries/command.js';
 import { spawningBinaries } from '../../binaries/fallback.js';
 import { isWrapper } from '../../binaries/plugins.js';
-import KnownResolvers from '../../binaries/resolvers/index.js';
+import { isPackageManager } from '../../binaries/resolvers/index.js';
 import { toScript } from '../../binaries/util.js';
 import { SCRIPT_INTERPOLATION } from '../../constants.js';
 import { isBinary } from '../../util/input.js';
-import { extractBinary } from '../../util/modules.js';
+import { extractBinary, isRelativeNodeModulesBin } from '../../util/modules.js';
 import { walkCommands } from '../../util/scripts.js';
 export const getInputsFromMiseScript = (script, options, hasLocalBinPath) => {
     const inputs = [];
@@ -62,10 +62,10 @@ export const getInputsFromMiseScript = (script, options, hasLocalBinPath) => {
                 if (!name || !word || definedFunctions.has(name))
                     continue;
                 const binary = extractBinary(name);
-                const isPackageManager = binary in KnownResolvers && binary !== 'find';
-                const isExplicit = isPackageManager || name.startsWith('./') || /^(?:\.\.?\/)*node_modules\/\.bin\//.test(name);
+                const isPackageCommand = isPackageManager(binary);
+                const isExplicit = isPackageCommand || name.startsWith('./') || isRelativeNodeModulesBin(name);
                 const isLocal = hasLocalBinPath && !command.prefix.some(assignment => assignment.name === 'PATH');
-                const isWrapperCommand = !isPackageManager && isWrapper(binary);
+                const isWrapperCommand = !isPackageCommand && isWrapper(binary);
                 if (!isExplicit && !isLocal && !isWrapperCommand && binary !== 'node' && binary !== 'find')
                     continue;
                 let commandInputs;

package/dist/plugins/taskfile/index.js

@@ -97,7 +97,7 @@ const resolveConfig = async (localConfig, options) => {
         for (const task of Object.values(localConfig.tasks)) {
             for (const script of extractScriptsFromTask(task)) {
                 for (const input of getInputsFromScripts([script], {
-                    knownBinsOnly: true,
+                    optionalBinaries: true,
                     containingFilePath: configFilePath,
                 })) {
                     if (isProduction)

package/dist/plugins/tauri/index.js

@@ -26,7 +26,7 @@ const resolveConfig = async (localConfig, options) => {
             continue;
         const dir = typeof command === 'string' || !command.cwd ? options.cwd : join(options.cwd, command.cwd);
         const manifest = options.getManifest(dir) ?? options.manifest;
-        for (const input of options.getInputsFromScripts(script, { knownBinsOnly: true, cwd: dir, manifest })) {
+        for (const input of options.getInputsFromScripts(script, { optionalBinaries: true, cwd: dir, manifest })) {
             inputs.push({ ...input, dir });
         }
     }

package/dist/plugins/travis/index.js

@@ -11,7 +11,7 @@ const resolveConfig = async (config, options) => {
     const beforeInstall = config.before_install ?? [];
     const beforeScript = config.before_script ?? [];
     const scripts = [beforeDeploy, beforeInstall, beforeScript].flat();
-    return options.getInputsFromScripts(scripts, { knownBinsOnly: true });
+    return options.getInputsFromScripts(scripts, { optionalBinaries: true });
 };
 const plugin = {
     title,

package/dist/plugins/vite-plus/resolveFromAST.js

@@ -30,7 +30,7 @@ export const resolveFromAST = (program, options) => {
     visitor.visit(program);
     const inputs = [];
     for (const command of commands) {
-        for (const input of options.getInputsFromScripts(command, { knownBinsOnly: true }))
+        for (const input of options.getInputsFromScripts(command, { optionalBinaries: true }))
             inputs.push(input);
     }
     return inputs;

package/dist/schema/configuration.d.ts

@@ -932,6 +932,7 @@ export declare const workspaceConfigurationSchema: z.ZodMiniObject<{
     ignore: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     ignoreFiles: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     ignoreBinaries: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
+    ignoreGlobalBinaries: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     ignoreDependencies: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
     ignoreMembers: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
     ignoreUnresolved: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
@@ -1879,6 +1880,7 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
     ignore: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     ignoreFiles: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     ignoreBinaries: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
+    ignoreGlobalBinaries: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     ignoreDependencies: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
     ignoreMembers: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
     ignoreUnresolved: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
@@ -2833,6 +2835,7 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
         ignore: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         ignoreFiles: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         ignoreBinaries: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
+        ignoreGlobalBinaries: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
         ignoreDependencies: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
         ignoreMembers: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
         ignoreUnresolved: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;

package/dist/schema/configuration.js

@@ -42,6 +42,7 @@ const rootConfigurationSchema = z.object({
     ignore: z.optional(globSchema),
     ignoreFiles: z.optional(globSchema),
     ignoreBinaries: z.optional(stringOrRegexSchema),
+    ignoreGlobalBinaries: z.optional(z.boolean()),
     ignoreDependencies: z.optional(stringOrRegexSchema),
     ignoreMembers: z.optional(stringOrRegexSchema),
     ignoreUnresolved: z.optional(stringOrRegexSchema),
@@ -69,6 +70,7 @@ const baseWorkspaceConfigurationSchema = z.object({
     ignore: z.optional(globSchema),
     ignoreFiles: z.optional(globSchema),
     ignoreBinaries: z.optional(stringOrRegexSchema),
+    ignoreGlobalBinaries: z.optional(z.boolean()),
     ignoreDependencies: z.optional(stringOrRegexSchema),
     ignoreMembers: z.optional(stringOrRegexSchema),
     ignoreUnresolved: z.optional(stringOrRegexSchema),

package/dist/types/config.d.ts

@@ -13,7 +13,8 @@ import type { Tags } from './options.ts';
 import type { PluginName } from './PluginNames.ts';
 import type { PackageJson } from './package-json.ts';
 export interface GetInputsFromScriptsOptions extends BaseOptions {
-    knownBinsOnly?: boolean;
+    isForwardedArgs?: boolean;
+    optionalBinaries?: boolean;
     containingFilePath: string;
     expandedScripts?: Set<string>;
 }
@@ -47,6 +48,7 @@ export type GetImportsAndExportsOptions = {
 export interface Configuration {
     ignore: NormalizedGlob;
     ignoreBinaries: IgnorePatterns;
+    ignoreGlobalBinaries: boolean;
     ignoreDependencies: IgnorePatterns;
     ignoreExportsUsedInFile: IgnoreExportsUsedInFile;
     ignoreFiles: NormalizedGlob;
@@ -71,6 +73,7 @@ interface BaseWorkspaceConfiguration {
     paths: Record<string, string[]>;
     ignore: NormalizedGlob;
     ignoreFiles: NormalizedGlob;
+    ignoreGlobalBinaries: boolean;
     ignoreExportsUsedInFile: IgnoreExportsUsedInFile;
     isIncludeEntryExports: boolean;
 }

package/dist/types/package-json.d.ts

@@ -18,7 +18,7 @@ type WithPackageJsonPathAsKey<T> = {
     [K in keyof T]: PackageJsonPath<T[K]> extends never ? K : PackageJsonPath<T[K]>;
 };
 type PluginConfig<P> = {
-    [K in keyof P as WithPackageJsonPathAsKey<P>[K]]: unknown;
+    [K in keyof P as WithPackageJsonPathAsKey<P>[K]]?: unknown;
 };
 type Plugins = PluginConfig<PluginMap>;
 export type Scripts = Record<string, string>;

package/dist/util/create-input-handler.js

@@ -1,4 +1,4 @@
-import { IGNORED_RUNTIME_DEPENDENCIES } from '../constants.js';
+import { IGNORED_GLOBAL_BINARIES, IGNORED_RUNTIME_DEPENDENCIES } from '../constants.js';
 import { debugLog } from './debug.js';
 import { fromBinary, isBinary, isConfig, isDeferResolve, isDeferResolveEntry, isDependency, toDebugString, } from './input.js';
 import { getPackageNameFromSpecifier } from './modules.js';
@@ -32,12 +32,12 @@ export const createInputHandler = (deputy, chief, isGitIgnored, addIssue, extern
             }
             return;
         }
-        if (dependencies || input.optional)
+        if (input.optional || (inputWorkspace.config.ignoreGlobalBinaries && IGNORED_GLOBAL_BINARIES.has(binaryName)))
             return;
         addIssue({
             type: 'binaries',
             filePath: containingFilePath,
-            workspace: workspace.name,
+            workspace: inputWorkspace.name,
             symbol: binaryName,
             specifier,
             fixes: [],

package/dist/util/create-options.d.ts

@@ -979,10 +979,13 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
         ignore?: string | string[] | undefined;
         ignoreFiles?: string | string[] | undefined;
         ignoreBinaries?: (string | RegExp)[] | undefined;
+        ignoreGlobalBinaries?: boolean | undefined;
         ignoreDependencies?: (string | RegExp)[] | undefined;
         ignoreMembers?: (string | RegExp)[] | undefined;
         ignoreUnresolved?: (string | RegExp)[] | undefined;
-        ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
+        ignoreExportsUsedInFile?: boolean | {
+            [x: string]: boolean | undefined;
+        } | undefined;
         ignoreIssues?: Record<string, ("binaries" | "catalog" | "catalogReferences" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
         cycles?: {
             allow?: string[][] | undefined;
@@ -1931,10 +1934,13 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             ignore?: string | string[] | undefined;
             ignoreFiles?: string | string[] | undefined;
             ignoreBinaries?: (string | RegExp)[] | undefined;
+            ignoreGlobalBinaries?: boolean | undefined;
             ignoreDependencies?: (string | RegExp)[] | undefined;
             ignoreMembers?: (string | RegExp)[] | undefined;
             ignoreUnresolved?: (string | RegExp)[] | undefined;
-            ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
+            ignoreExportsUsedInFile?: boolean | {
+                [x: string]: boolean | undefined;
+            } | undefined;
             ignoreIssues?: Record<string, ("binaries" | "catalog" | "catalogReferences" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
             includeEntryExports?: boolean | undefined;
         }> | undefined;

package/dist/util/jiti.js

@@ -8,6 +8,7 @@ const options = {
         '@rushstack/eslint-patch/modern-module-resolution': empty,
     },
     tsconfigPaths: true,
+    jsx: true,
 };
 const createLoader = (options) => createJiti(process.cwd(), options);
 export const jiti = createLoader(options);

package/dist/util/modules.d.ts

@@ -3,6 +3,8 @@ 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 stripVersionFromSpecifier: (specifier: string) => string;
+export declare const isInNodeModulesBin: (value: string) => boolean;
+export declare const isRelativeNodeModulesBin: (value: string) => boolean;
 export declare const extractBinary: (command: string) => string;
 export declare const isValidBinary: (str: string) => boolean;
 export declare const isDefinitelyTyped: (packageName: string) => boolean;

package/dist/util/modules.js

@@ -38,7 +38,7 @@ const getPackageNameFromYarnPnpmStore = (posixPath) => {
 };
 export const getPackageNameFromFilePath = (value) => {
     const name = value.startsWith('file://') ? value.slice(7) : value;
-    if (name.includes('node_modules/.bin/'))
+    if (isInNodeModulesBin(name))
         return extractBinary(name);
     const posixPath = toPosix(name);
     const match = posixPath.match(lastPackageNameMatch);
@@ -56,6 +56,8 @@ export const isStartsLikePackageName = (specifier) => {
     return ch === 64 ? isPackageScopeStart(specifier.charCodeAt(1)) : isPackageNameStart(ch);
 };
 export const stripVersionFromSpecifier = (specifier) => specifier.replace(/(\S+)@.*/, '$1');
+export const isInNodeModulesBin = (value) => value.includes('node_modules/.bin/');
+export const isRelativeNodeModulesBin = (value) => /^(?:\.\.?\/)*node_modules\/\.bin\//.test(value);
 const stripNodeModulesFromPath = (command) => command.replace(/(?:\.{0,2}\/)*node_modules\//, '');
 export const extractBinary = (command) => stripVersionFromSpecifier(stripNodeModulesFromPath(command)
     .replace(/^(\.bin\/)/, '')