knip 5.33.2 → 5.34.0

package/dist/typescript/visitors/index.d.ts

@@ -1,7 +1,7 @@
 import type ts from 'typescript';
+import type { GetImportsAndExportsOptions } from '../../types/config.js';
 import type { ExportNode } from '../../types/exports.js';
 import type { ImportNode } from '../../types/imports.js';
-import type { GetImportsAndExportsOptions } from '../get-imports-and-exports.js';
 type FileCondition = (sourceFile: ts.SourceFile) => boolean;
 type VisitorFactory<T> = (fileCondition: FileCondition, fn: Visitor<T>) => VisitorCondition<T>;
 type VisitorCondition<T> = (sourceFile: ts.SourceFile) => Visitor<T>;

package/dist/typescript/visitors/scripts/bun.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => string | string[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.js").GetImportsAndExportsOptions) => string | string[] | undefined;
 export default _default;

package/dist/typescript/visitors/scripts/execa.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => string | string[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.js").GetImportsAndExportsOptions) => string | string[] | undefined;
 export default _default;

package/dist/typescript/visitors/scripts/index.d.ts

@@ -1,3 +1,3 @@
 import type ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => string | string[] | undefined)[];
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../../types/config.js").GetImportsAndExportsOptions) => string | string[] | undefined)[];
 export default _default;

package/dist/typescript/visitors/scripts/zx.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => string | string[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.js").GetImportsAndExportsOptions) => string | string[] | undefined;
 export default _default;

package/dist/util/create-workspace-graph.d.ts

@@ -4,5 +4,5 @@ interface Package {
     dir: string;
 }
 export type WorkspaceGraph = Record<string, Set<string>>;
-export declare function createWorkspaceGraph(cwd: string, wsNames: string[], wsPkgNames: Set<string>, byPkgName: Map<string, Package>, byName: Map<string, Package>): WorkspaceGraph;
+export declare function createWorkspaceGraph(cwd: string, wsNames: string[], wsPkgNames: Set<string>, wsPackages: Map<string, Package>): WorkspaceGraph;
 export {};

package/dist/util/create-workspace-graph.js

@@ -1,16 +1,16 @@
 import { join } from './path.js';
 const types = ['peerDependencies', 'devDependencies', 'optionalDependencies', 'dependencies'];
-export function createWorkspaceGraph(cwd, wsNames, wsPkgNames, byPkgName, byName) {
+export function createWorkspaceGraph(cwd, wsNames, wsPkgNames, wsPackages) {
     const graph = {};
-    const getWorkspaceDirs = (pkg) => {
+    const getWorkspaceDirs = (pkg, name) => {
         const dirs = new Set();
         for (const type of types) {
             if (pkg.manifest[type]) {
                 for (const pkgName in pkg.manifest[type]) {
                     if (wsPkgNames.has(pkgName)) {
-                        const workspace = byPkgName.get(pkgName);
-                        if (workspace)
-                            dirs.add(workspace.dir);
+                        const wsPackage = wsPackages.get(name);
+                        if (wsPackage)
+                            dirs.add(wsPackage.dir);
                     }
                 }
             }
@@ -18,9 +18,9 @@ export function createWorkspaceGraph(cwd, wsNames, wsPkgNames, byPkgName, byName
         return dirs;
     };
     for (const name of wsNames) {
-        const pkg = byName.get(name);
+        const pkg = wsPackages.get(name);
         if (pkg)
-            graph[join(cwd, name)] = getWorkspaceDirs(pkg);
+            graph[join(cwd, name)] = getWorkspaceDirs(pkg, name);
     }
     return graph;
 }

package/dist/util/debug.d.ts

@@ -1,4 +1,4 @@
 export declare const inspect: (obj: unknown) => void;
 export declare const debugLog: (context: string, message: string) => void;
-export declare const debugLogObject: (context: string, name: string, obj: unknown | (() => unknown)) => void;
-export declare const debugLogArray: (context: string | [string, string], message: string, elements: string[] | Set<string>) => void;
+export declare const debugLogObject: (context: string | [string, string], name: string, obj: unknown | (() => unknown)) => void;
+export declare const debugLogArray: (context: string | [string, string], message: string, elements: string[] | Set<string> | (() => string[] | Set<string>)) => void;

package/dist/util/debug.js

@@ -23,7 +23,7 @@ export const debugLogObject = IS_DEBUG_ENABLED
     : noop;
 export const debugLogArray = IS_DEBUG_ENABLED
     ? (context, message, elements) => {
-        const collection = Array.from(elements);
+        const collection = Array.from(typeof elements === 'function' ? elements() : elements);
         console.debug(`${ctx(context)} ${message} (${collection.length})`);
         logArray(collection);
     }

package/dist/util/glob.js

@@ -3,10 +3,10 @@ import { GLOBAL_IGNORE_PATTERNS } from '../constants.js';
 import { timerify } from './Performance.js';
 import { compact } from './array.js';
 import { globby } from './glob-core.js';
-import { join, relative } from './path.js';
+import { isAbsolute, join, relative } from './path.js';
 const prependDirToPatterns = (cwd, dir, patterns) => {
     const relativePath = relative(cwd, dir);
-    const prepend = (pattern) => prependDirToPattern(relativePath, pattern);
+    const prepend = (pattern) => isAbsolute(pattern.replace(/^!/, '')) ? pattern : prependDirToPattern(relativePath, pattern);
     return compact([patterns].flat().map(prepend).map(removeProductionSuffix)).sort(negatedLast);
 };
 const removeProductionSuffix = (pattern) => pattern.replace(/!$/, '');

package/dist/util/{handle-dependency.d.ts → handle-referenced-dependency.d.ts}

@@ -1,4 +1,5 @@
 import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
 import type { DependencyDeputy } from '../DependencyDeputy.js';
 import type { IssueCollector } from '../IssueCollector.js';
-export declare const getReferencedDependencyHandler: (collector: IssueCollector, deputy: DependencyDeputy, chief: ConfigurationChief) => (specifier: string, containingFilePath: string, workspace: Workspace) => string | undefined;
+import { type Input } from './input.js';
+export declare const getReferencedDependencyHandler: (collector: IssueCollector, deputy: DependencyDeputy, chief: ConfigurationChief, isGitIgnored: (s: string) => boolean) => (input: Input, workspace: Workspace) => string | undefined;

package/dist/util/handle-referenced-dependency.js

@@ -0,0 +1,82 @@
+import { IGNORED_RUNTIME_DEPENDENCIES } from '../constants.js';
+import { debugLog } from './debug.js';
+import { toDebugString } from './input.js';
+import { fromBinary, isBinary, isConfigPattern, isDeferResolveEntry, isDependency } from './input.js';
+import { getPackageNameFromSpecifier } from './modules.js';
+import { dirname, isAbsolute, isInternal, join } from './path.js';
+import { _resolveSync } from './resolve.js';
+export const getReferencedDependencyHandler = (collector, deputy, chief, isGitIgnored) => (input, workspace) => {
+    const { specifier, containingFilePath } = input;
+    if (!containingFilePath || IGNORED_RUNTIME_DEPENDENCIES.has(specifier))
+        return;
+    if (isBinary(input)) {
+        const binaryName = fromBinary(input);
+        const ws = (input.dir && chief.findWorkspaceByFilePath(`${input.dir}/`)) || workspace;
+        const isHandled = deputy.maybeAddReferencedBinary(ws, binaryName);
+        if (isHandled)
+            return;
+        collector.addIssue({
+            type: 'binaries',
+            filePath: containingFilePath,
+            workspace: workspace.name,
+            symbol: binaryName,
+        });
+        return;
+    }
+    const packageName = getPackageNameFromSpecifier(specifier);
+    if (packageName) {
+        const isWorkspace = chief.workspacesByPkgName.has(packageName);
+        const specifierWorkspace = chief.findWorkspaceByFilePath(containingFilePath) ?? workspace;
+        if (specifierWorkspace) {
+            const isHandled = deputy.maybeAddReferencedExternalDependency(specifierWorkspace, packageName);
+            if (isWorkspace || isDependency(input)) {
+                if (!isHandled) {
+                    if ((deputy.isProduction && input.production) || !deputy.isProduction) {
+                        collector.addIssue({
+                            type: 'unlisted',
+                            filePath: containingFilePath,
+                            workspace: specifierWorkspace.name,
+                            symbol: specifier,
+                        });
+                    }
+                    return;
+                }
+                const ref = _resolveSync(specifier, dirname(containingFilePath));
+                if (ref && !isGitIgnored(ref))
+                    return ref;
+            }
+            if (isHandled)
+                return;
+        }
+    }
+    if (!isConfigPattern(input) && deputy.isProduction && !input.production) {
+        return;
+    }
+    const baseDir = input.dir ?? dirname(containingFilePath);
+    const filePath = isAbsolute(specifier) ? specifier : join(baseDir, specifier);
+    const resolvedFilePath = _resolveSync(filePath, baseDir);
+    if (resolvedFilePath && isInternal(resolvedFilePath)) {
+        return isGitIgnored(resolvedFilePath) ? undefined : resolvedFilePath;
+    }
+    if (!isInternal(filePath)) {
+        collector.addIssue({
+            type: 'unlisted',
+            filePath: containingFilePath,
+            workspace: workspace.name,
+            symbol: packageName ?? specifier,
+        });
+    }
+    else if (!isGitIgnored(filePath)) {
+        if (!isDeferResolveEntry(input) && !isConfigPattern(input)) {
+            collector.addIssue({
+                type: 'unresolved',
+                filePath: containingFilePath,
+                workspace: workspace.name,
+                symbol: specifier,
+            });
+        }
+        else {
+            debugLog(workspace.name, `Unable to resolve ${toDebugString(input)}`);
+        }
+    }
+};

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.2";
+export declare const version = "5.34.0";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.33.2",
+  "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": {