knip 5.23.0 → 5.23.1

package/dist/typescript/getImportsAndExports.js

@@ -49,14 +49,14 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
     const referencedSymbolsInExportedTypes = new Set();
     const visitors = getVisitors(sourceFile);
     const addInternalImport = (options) => {
-        const { identifier, symbol, filePath, namespace, specifier, isReExport } = options;
+        const { identifier, symbol, filePath, namespace, alias, specifier, isReExport } = options;
         const isStar = identifier === IMPORT_STAR;
         specifiers.add([specifier, filePath]);
         const file = internalImports.get(filePath);
         const imports = file ?? createImports();
         if (!file)
             internalImports.set(filePath, imports);
-        const nsOrAlias = symbol ? String(symbol.escapedName) : options.alias;
+        const nsOrAlias = symbol ? String(symbol.escapedName) : alias;
         if (isReExport) {
             if (isStar && namespace) {
                 addValue(imports.reExportedNs, namespace, sourceFile.fileName);
@@ -224,7 +224,10 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
             const result = visitor(node, options);
             result && (Array.isArray(result) ? result.forEach(addImportWithNode) : addImportWithNode(result));
         }
-        const isTopLevel = node.parent === sourceFile || node.parent?.parent === sourceFile;
+        const isTopLevel = node.parent &&
+            ('commonJsModuleIndicator' in sourceFile
+                ? node.parent.parent === sourceFile || node.parent === sourceFile
+                : node.parent === sourceFile);
         if (isTopLevel) {
             for (const visitor of visitors.import) {
                 const result = visitor(node, options);
@@ -285,7 +288,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
                         }
                     }
                 }
-                if (ignoreExportsUsedInFile && !isTopLevel && isReferencedInExportedType(node, symbol)) {
+                if (ignoreExportsUsedInFile && !isTopLevel && isReferencedInExportedType(node)) {
                     referencedSymbolsInExportedTypes.add(symbol.exportSymbol);
                 }
             }
@@ -308,14 +311,18 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
     const setRefs = (item) => {
         if (!item.symbol)
             return;
+        if (item.symbol.flags & ts.SymbolFlags.AliasExcludes) {
+            item.refs = [1, false];
+            return;
+        }
         const symbols = new Set();
         let index = 0;
         const text = sourceFile.text;
         const id = item.identifier;
         while (index < text.length && (index = text.indexOf(id, index)) !== -1) {
             if (!isIdChar(text.charAt(index - 1)) && !isIdChar(text.charAt(index + id.length))) {
-                const isDeclaration = index === item.pos || index === item.pos + 1;
-                if (!isDeclaration) {
+                const isExportDeclaration = index === item.pos || index === item.pos + 1;
+                if (!isExportDeclaration) {
                     const symbol = typeChecker.getSymbolAtLocation(ts.getTokenAtPosition(sourceFile, index));
                     if (symbol) {
                         const isInExportedType = referencedSymbolsInExportedTypes.has(symbol);
@@ -342,9 +349,11 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
             index += id.length;
         }
     };
+    const isSetRefs = ignoreExportsUsedInFile;
     for (const item of exports.values()) {
-        if (ignoreExportsUsedInFile)
+        if (isSetRefs === true || (typeof isSetRefs === 'object' && item.type !== 'unknown' && !!isSetRefs[item.type])) {
             setRefs(item);
+        }
         for (const member of item.members) {
             setRefs(member);
             member.symbol = undefined;

package/dist/typescript/visitors/dynamic-imports/index.d.ts

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

package/dist/typescript/visitors/exports/exportKeyword.js

@@ -1,17 +1,20 @@
 import ts from 'typescript';
 import { SymbolType } from '../../../types/issues.js';
 import { compact } from '../../../util/array.js';
-import { isGetOrSetAccessorDeclaration, isPrivateMember, stripQuotes } from '../../ast-helpers.js';
+import { getDefaultKeywordNode, getExportKeywordNode, isGetOrSetAccessorDeclaration, isPrivateMember, stripQuotes, } from '../../ast-helpers.js';
 import { exportVisitor as visit } from '../index.js';
 export default visit(() => true, (node, { isFixExports, isFixTypes, isReportClassMembers }) => {
-    const exportKeyword = node.modifiers?.find(mod => mod.kind === ts.SyntaxKind.ExportKeyword);
+    const exportKeyword = getExportKeywordNode(node);
     if (exportKeyword) {
+        const getFix = (node, defaultKeyword) => isFixExports ? [node.getStart(), (defaultKeyword ?? node).getEnd() + 1] : undefined;
+        const getElementFix = (node) => (isFixExports ? [node.getStart(), node.getEnd()] : undefined);
+        const getTypeFix = (node) => (isFixTypes ? [node.getStart(), node.getEnd() + 1] : undefined);
         if (ts.isVariableStatement(node)) {
             return node.declarationList.declarations.flatMap(declaration => {
                 if (ts.isObjectBindingPattern(declaration.name)) {
                     return compact(declaration.name.elements.map(element => {
                         if (ts.isIdentifier(element.name)) {
-                            const fix = isFixExports ? [element.getStart(), element.getEnd()] : undefined;
+                            const fix = getElementFix(element);
                             return {
                                 node: element,
                                 identifier: element.name.escapedText.toString(),
@@ -25,7 +28,7 @@ export default visit(() => true, (node, { isFixExports, isFixTypes, isReportClas
                 if (ts.isArrayBindingPattern(declaration.name)) {
                     return compact(declaration.name.elements.map(element => {
                         if (ts.isBindingElement(element)) {
-                            const fix = isFixExports ? [element.getStart(), element.getEnd()] : undefined;
+                            const fix = getElementFix(element);
                             return {
                                 node: element,
                                 identifier: element.getText(),
@@ -37,34 +40,22 @@ export default visit(() => true, (node, { isFixExports, isFixTypes, isReportClas
                     }));
                 }
                 const identifier = declaration.name.getText();
-                const fix = isFixExports ? [exportKeyword.getStart(), exportKeyword.getEnd() + 1] : undefined;
-                return {
-                    node: declaration,
-                    identifier,
-                    type: SymbolType.UNKNOWN,
-                    pos: declaration.name.getStart(),
-                    fix,
-                };
+                const pos = declaration.name.getStart();
+                const fix = getFix(exportKeyword);
+                return { node: declaration, identifier, type: SymbolType.UNKNOWN, pos, fix };
             });
         }
-        const defaultKeyword = node.modifiers?.find(mod => mod.kind === ts.SyntaxKind.DefaultKeyword);
+        const defaultKeyword = getDefaultKeywordNode(node);
         if (ts.isFunctionDeclaration(node) && node.name) {
             const identifier = defaultKeyword ? 'default' : node.name.getText();
             const pos = (node.name ?? node.body ?? node).getStart();
-            const fix = isFixExports
-                ? [exportKeyword.getStart(), (defaultKeyword ?? exportKeyword).getEnd() + 1]
-                : undefined;
-            return {
-                node,
-                identifier,
-                pos,
-                type: SymbolType.FUNCTION,
-                fix,
-            };
+            const fix = getFix(exportKeyword, defaultKeyword);
+            return { node, identifier, pos, type: SymbolType.FUNCTION, fix };
         }
         if (ts.isClassDeclaration(node) && node.name) {
             const identifier = defaultKeyword ? 'default' : node.name.getText();
             const pos = (node.name ?? node).getStart();
+            const fix = getFix(exportKeyword, defaultKeyword);
             const members = isReportClassMembers
                 ? node.members
                     .filter((member) => (ts.isPropertyDeclaration(member) ||
@@ -79,43 +70,24 @@ export default visit(() => true, (node, { isFixExports, isFixTypes, isReportClas
                     fix: undefined,
                 }))
                 : [];
-            const fix = isFixExports
-                ? [exportKeyword.getStart(), (defaultKeyword ?? exportKeyword).getEnd() + 1]
-                : undefined;
-            return {
-                node,
-                identifier,
-                type: SymbolType.CLASS,
-                pos,
-                members,
-                fix,
-            };
+            return { node, identifier, type: SymbolType.CLASS, pos, members, fix };
         }
         if (ts.isTypeAliasDeclaration(node)) {
-            const identifier = defaultKeyword ? 'default' : node.name.getText();
-            const fix = isFixTypes ? [exportKeyword.getStart(), exportKeyword.getEnd() + 1] : undefined;
-            return {
-                node,
-                identifier,
-                type: SymbolType.TYPE,
-                pos: node.name.getStart(),
-                fix,
-            };
+            const identifier = node.name.getText();
+            const pos = node.name.getStart();
+            const fix = getTypeFix(exportKeyword);
+            return { node, identifier, type: SymbolType.TYPE, pos, fix };
         }
         if (ts.isInterfaceDeclaration(node)) {
-            const identifier = defaultKeyword ? 'default' : node.name.getText();
-            const fix = isFixTypes ? [exportKeyword.getStart(), exportKeyword.getEnd() + 1] : undefined;
-            return {
-                node,
-                identifier,
-                type: SymbolType.INTERFACE,
-                pos: node.name.getStart(),
-                fix,
-            };
+            const identifier = node.name.getText();
+            const pos = node.name.getStart();
+            const fix = getTypeFix(exportKeyword);
+            return { node, identifier, type: SymbolType.INTERFACE, pos, fix };
         }
         if (ts.isEnumDeclaration(node)) {
-            const identifier = defaultKeyword ? 'default' : node.name.getText();
+            const identifier = node.name.getText();
             const pos = node.name.getStart();
+            const fix = getTypeFix(exportKeyword);
             const members = node.members.map(member => ({
                 node: member,
                 identifier: stripQuotes(member.name.getText()),
@@ -123,15 +95,7 @@ export default visit(() => true, (node, { isFixExports, isFixTypes, isReportClas
                 type: SymbolType.MEMBER,
                 fix: undefined,
             }));
-            const fix = isFixTypes ? [exportKeyword.getStart(), exportKeyword.getEnd() + 1] : undefined;
-            return {
-                node,
-                identifier,
-                type: SymbolType.ENUM,
-                pos,
-                members,
-                fix,
-            };
+            return { node, identifier, type: SymbolType.ENUM, pos, members, fix };
         }
     }
 });

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

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

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

@@ -1,3 +1,3 @@
 import type ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[])[];
+declare const _default: (sourceFile: ts.SourceFile) => any;
 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("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | string | string[])[];
+declare const _default: (sourceFile: ts.SourceFile) => any;
 export default _default;

package/dist/util/Performance.d.ts

@@ -15,11 +15,11 @@ declare class Performance {
     private clearMark;
     private flush;
     private getEntriesByName;
-    getTable(): string;
+    getTable(): any;
     getCurrentDurationInMs(startTime?: number): number;
     getMemHeapUsage(): number;
     getCurrentMemUsageInMb(): number;
-    finalize(): Promise<void>;
+    finalize(): any;
     reset(): void;
 }
 export declare const perfObserver: Performance;

package/dist/util/array.d.ts

@@ -1,5 +1,5 @@
 type Collection<T> = Array<T> | Set<T>;
-export declare const compact: <T>(collection: Collection<T | undefined>) => T[];
-export declare const arrayify: (value?: string[] | string) => string[];
+export declare const compact: <T>(collection: Collection<T | undefined>) => any;
+export declare const arrayify: (value?: string[] | string) => string | string[] | undefined;
 export declare const partition: <T>(collection: T[], predicate: (item: T) => unknown) => [T[], T[]];
 export {};

package/dist/util/errors.d.ts

@@ -9,5 +9,5 @@ export declare class LoaderError extends Error {
 export declare const isKnownError: (error: Error) => error is ConfigurationError | LoaderError | ZodError<any>;
 export declare const hasCause: (error: Error) => error is ErrorWithCause;
 export declare const isConfigurationError: (error: Error) => error is ConfigurationError;
-export declare const getKnownError: (error: Error) => Error;
+export declare const getKnownError: (error: Error) => any;
 export {};

package/dist/util/file-entry-cache.d.ts

@@ -13,17 +13,14 @@ export type FileDescriptor<T> = {
 };
 export declare class FileEntryCache<T> {
     filePath: string;
-    cache: Map<string, MetaData<T>>;
-    normalizedEntries: Map<string, FileDescriptor<T>>;
+    cache: any;
+    normalizedEntries: any;
     constructor(cacheId: string, _path: string);
     removeNotFoundFiles(): void;
     getFileDescriptor(filePath: string): FileDescriptor<T>;
     _getFileDescriptorUsingMtimeAndSize(filePath: string, fstat: fs.Stats): FileDescriptor<T>;
     removeEntry(entryName: string): void;
-    _getMetaForFileUsingMtimeAndSize(cacheEntry: FileDescriptor<T>): {
-        size: number;
-        mtime: number;
-    };
+    _getMetaForFileUsingMtimeAndSize(cacheEntry: FileDescriptor<T>): any;
     reconcile(): void;
 }
 export {};

package/dist/util/fs.d.ts

@@ -1,11 +1,11 @@
 export declare const isDirectory: (filePath: string) => boolean;
 export declare const isFile: (filePath: string) => boolean;
 export declare const findFile: (workingDir: string, fileName: string) => string | undefined;
-export declare const loadFile: (filePath: string) => Promise<string>;
-export declare const loadJSON: (filePath: string) => Promise<any>;
-export declare const loadYAML: (filePath: string) => Promise<unknown>;
-export declare const loadTOML: (filePath: string) => Promise<Record<string, import("smol-toml").TomlPrimitive>>;
-export declare const parseJSON: (filePath: string, contents: string) => Promise<any>;
+export declare const loadFile: (filePath: string) => unknown;
+export declare const loadJSON: (filePath: string) => unknown;
+export declare const loadYAML: (filePath: string) => unknown;
+export declare const loadTOML: (filePath: string) => unknown;
+export declare const parseJSON: (filePath: string, contents: string) => unknown;
 export declare const parseYAML: (contents: string) => unknown;
 export declare function isTypeModule(path: string): boolean;
-export declare const _loadJSON: (filePath: string) => Promise<any>;
+export declare const _loadJSON: (filePath: string) => unknown;

package/dist/util/get-included-issue-types.d.ts

@@ -1,4 +1,3 @@
-import type { Report } from '../types/issues.js';
 type CLIArguments = {
     include: string[];
     exclude: string[];
@@ -14,5 +13,5 @@ type Options = {
     exports?: boolean;
 };
 export declare const defaultExcludedIssueTypes: string[];
-export declare const getIncludedIssueTypes: (cliArgs: CLIArguments, { include, exclude, isProduction }?: Options) => Report;
+export declare const getIncludedIssueTypes: (cliArgs: CLIArguments, { include, exclude, isProduction }?: Options) => any;
 export {};

package/dist/util/git.d.ts

@@ -1 +1 @@
-export declare const getGitHookPaths: (defaultPath?: string, followGitConfig?: boolean) => string[];
+export declare const getGitHookPaths: (defaultPath?: string, followGitConfig?: boolean) => any;

package/dist/util/glob.d.ts

@@ -1,6 +1,6 @@
 export declare const prependDirToPattern: (workingDir: string, pattern: string) => string;
-export declare const negate: (pattern: string) => string;
-export declare const hasProductionSuffix: (pattern: string) => boolean;
+export declare const negate: (pattern: string) => any;
+export declare const hasProductionSuffix: (pattern: string) => any;
 export declare const hasNoProductionSuffix: (pattern: string) => boolean;
 interface BaseGlobOptions {
     cwd: string;
@@ -10,8 +10,8 @@ interface BaseGlobOptions {
 interface GlobOptions extends BaseGlobOptions {
     workingDir?: string;
 }
-export declare const _glob: ({ cwd, workingDir, patterns, gitignore }: GlobOptions) => Promise<string[]>;
-export declare const _pureGlob: ({ cwd, patterns, gitignore }: BaseGlobOptions) => Promise<string[]>;
-export declare const _firstGlob: ({ cwd, patterns }: BaseGlobOptions) => Promise<string | Buffer | undefined>;
-export declare const _dirGlob: ({ cwd, patterns, gitignore }: BaseGlobOptions) => Promise<string[]>;
+export declare const _glob: ({ cwd, workingDir, patterns, gitignore }: GlobOptions) => unknown;
+export declare const _pureGlob: ({ cwd, patterns, gitignore }: BaseGlobOptions) => unknown;
+export declare const _firstGlob: ({ cwd, patterns }: BaseGlobOptions) => unknown;
+export declare const _dirGlob: ({ cwd, patterns, gitignore }: BaseGlobOptions) => unknown;
 export {};

package/dist/util/handle-dependency.d.ts

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

package/dist/util/is-identifier-referenced.d.ts

@@ -5,5 +5,5 @@ type Result = {
     reExportingEntryFile: undefined | string;
     traceNode: TraceNode;
 };
-export declare const getIsIdentifierReferencedHandler: (graph: DependencyGraph, entryPaths: Set<string>) => (filePath: string, id: string, isIncludeEntryExports?: boolean, traceNode?: TraceNode, seen?: Set<string>) => Result;
+export declare const getIsIdentifierReferencedHandler: (graph: DependencyGraph, entryPaths: Set<string>) => (filePath: string, id: string, isIncludeEntryExports?: boolean, traceNode?: TraceNode, seen?: any) => Result;
 export {};

package/dist/util/loader.d.ts

@@ -1 +1 @@
-export declare const _load: (filePath: string) => Promise<any>;
+export declare const _load: (filePath: string) => unknown;

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

@@ -1,2 +1 @@
-import type { Package } from '../ConfigurationChief.js';
-export default function mapWorkspaces(cwd: string, workspaces: string[]): Promise<Map<string, Package>[]>;
+export default function mapWorkspaces(cwd: string, workspaces: string[]): unknown;

package/dist/util/modules.d.ts

@@ -1,9 +1,9 @@
 import type { PackageJson } from '../types/package-json.js';
-export declare const getPackageNameFromModuleSpecifier: (moduleSpecifier: string) => string | undefined;
-export declare const getPackageNameFromFilePath: (value: string) => string;
-export declare const normalizeSpecifierFromFilePath: (value: string) => string;
-export declare const isStartsLikePackageName: (specifier: string) => boolean;
-export declare const isDefinitelyTyped: (packageName: string) => boolean;
+export declare const getPackageNameFromModuleSpecifier: (moduleSpecifier: string) => any;
+export declare const getPackageNameFromFilePath: (value: string) => any;
+export declare const normalizeSpecifierFromFilePath: (value: string) => any;
+export declare const isStartsLikePackageName: (specifier: string) => any;
+export declare const isDefinitelyTyped: (packageName: string) => any;
 export declare const getDefinitelyTypedFor: (packageName: string) => string;
 export declare const getPackageFromDefinitelyTyped: (typedDependency: string) => string;
 export declare const getEntryPathFromManifest: (manifest: PackageJson, sharedGlobOptions: {
@@ -11,5 +11,5 @@ export declare const getEntryPathFromManifest: (manifest: PackageJson, sharedGlo
     workingDir: string;
     gitignore: boolean;
     ignore: string[];
-}) => Promise<string[]>;
-export declare const sanitizeSpecifier: (specifier: string) => string;
+}) => unknown;
+export declare const sanitizeSpecifier: (specifier: string) => any;

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

@@ -1,10 +1,6 @@
 import type { PackageJson } from '../types/package-json.js';
-declare const INDENT: unique symbol;
-declare const NEWLINE: unique symbol;
 interface ExtendedPackageJson extends PackageJson {
-    [INDENT]?: string;
-    [NEWLINE]?: string;
 }
-export declare const load: (filePath: string) => Promise<ExtendedPackageJson>;
-export declare const save: (filePath: string, content: ExtendedPackageJson) => Promise<void>;
+export declare const load: (filePath: string) => unknown;
+export declare const save: (filePath: string, content: ExtendedPackageJson) => any;
 export {};

package/dist/util/path.d.ts

@@ -3,11 +3,11 @@ export declare const dirname: (path: string) => string;
 export declare const extname: (path: string) => string;
 export declare const basename: (path: string, suffix?: string) => string;
 export declare const join: (...paths: string[]) => string;
-export declare const toPosix: (value: string) => string;
-export declare const cwd: string;
+export declare const toPosix: (value: string) => any;
+export declare const cwd: any;
 export declare const resolve: (...paths: string[]) => string;
-export declare const relative: (from: string, to?: string) => string;
-export declare const isInNodeModules: (filePath: string) => boolean;
+export declare const relative: (from: string, to?: string) => any;
+export declare const isInNodeModules: (filePath: string) => any;
 export declare const toAbsolute: (id: string, base?: string) => string;
-export declare const toRelative: (id: string) => string;
-export declare const isInternal: (id: string) => boolean;
+export declare const toRelative: (id: string) => any;
+export declare const isInternal: (id: string) => any;

package/dist/util/pkgs-graph.d.ts

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

package/dist/util/plugin.d.ts

@@ -4,12 +4,12 @@ export { _tryResolve as tryResolve } from './require.js';
 export { _getDependenciesFromScripts as getDependenciesFromScripts } from '../binaries/index.js';
 import type { RawPluginConfiguration } from '../types/config.js';
 import type { Plugin, PluginOptions } from '../types/plugins.js';
-export declare const toCamelCase: (name: string) => string;
-export declare const hasDependency: (dependencies: Set<string>, values: (string | RegExp)[]) => boolean;
+export declare const toCamelCase: (name: string) => any;
+export declare const hasDependency: (dependencies: Set<string>, values: (string | RegExp)[]) => any;
 export declare const normalizePluginConfig: (pluginConfig: RawPluginConfiguration) => boolean | {
-    config: string[] | null;
-    entry: string[] | null;
-    project: string[] | null;
+    config: string | string[] | null | undefined;
+    entry: string | string[] | null | undefined;
+    project: string | string[] | null | undefined;
 };
-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 loadConfigForPlugin: (configFilePath: string, plugin: Plugin, options: PluginOptions, pluginName: string) => unknown;
+export declare const getFinalEntryPaths: (plugin: Plugin, options: PluginOptions, configEntryPaths: string[]) => any;

package/dist/util/protocols.d.ts

@@ -1,9 +1,9 @@
-export declare const toBinary: (specifier: string) => string;
-export declare const fromBinary: (specifier: string) => string;
-export declare const isBinary: (specifier: string) => boolean;
-export declare const toEntryPattern: (specifier: string) => string;
-export declare const fromEntryPattern: (specifier: string) => string;
-export declare const isEntryPattern: (specifier: string) => boolean;
-export declare const toProductionEntryPattern: (specifier: string) => string;
-export declare const fromProductionEntryPattern: (specifier: string) => string;
-export declare const isProductionEntryPattern: (specifier: string) => boolean;
+export declare const toBinary: (specifier: string) => any;
+export declare const fromBinary: (specifier: string) => any;
+export declare const isBinary: (specifier: string) => any;
+export declare const toEntryPattern: (specifier: string) => any;
+export declare const fromEntryPattern: (specifier: string) => any;
+export declare const isEntryPattern: (specifier: string) => any;
+export declare const toProductionEntryPattern: (specifier: string) => any;
+export declare const fromProductionEntryPattern: (specifier: string) => any;
+export declare const isProductionEntryPattern: (specifier: string) => any;

package/dist/util/regex.d.ts

@@ -1,3 +1,3 @@
-export declare const toRegexOrString: (value: string | RegExp) => string | RegExp;
-export declare const findMatch: (haystack: undefined | (string | RegExp)[], needle: string) => string | RegExp | undefined;
-export declare const isIdChar: (text: string) => boolean;
+export declare const toRegexOrString: (value: string | RegExp) => any;
+export declare const findMatch: (haystack: undefined | (string | RegExp)[], needle: string) => any;
+export declare const isIdChar: (text: string) => any;

package/dist/util/reporter.d.ts

@@ -1,3 +1,3 @@
 import type { ReporterOptions } from '../types/issues.js';
 export declare const runPreprocessors: (data: ReporterOptions, processors?: any) => Promise<ReporterOptions>;
-export declare const runReporters: (options: ReporterOptions) => Promise<void>;
+export declare const runReporters: (options: ReporterOptions) => any;

package/dist/util/require.d.ts

@@ -1,5 +1,5 @@
 export declare const _require: NodeRequire;
 export declare const _loadESLintConfig: (configFilePath: string) => any;
-export declare const _resolve: (specifier: string) => string;
-export declare const _tryResolve: (specifier: string, from: string) => string | undefined;
-export declare const _resolveSpecifier: (dir: string, specifier: string) => string | undefined;
+export declare const _resolve: (specifier: string) => any;
+export declare const _tryResolve: (specifier: string, from: string) => any;
+export declare const _resolveSpecifier: (dir: string, specifier: string) => any;

package/dist/util/resolve.d.ts

@@ -1 +1 @@
-export declare const resolveSync: (specifier: string, containingFile: string, extensions?: string[]) => string | undefined;
+export declare const resolveSync: (specifier: string, containingFile: string, extensions?: string[]) => any;

package/dist/util/tag.d.ts

@@ -1,5 +1,5 @@
 import type { Tags } from '../types/cli.js';
-export declare const splitTags: (rawTags: string[]) => Tags;
+export declare const splitTags: (rawTags: string[]) => any;
 export declare const shouldIgnore: (jsDocTags: Set<string>, tags: Tags) => boolean;
-export declare const getShouldIgnoreHandler: (isProduction: boolean) => (jsDocTags: Set<string>) => boolean;
+export declare const getShouldIgnoreHandler: (isProduction: boolean) => (jsDocTags: Set<string>) => any;
 export declare const getShouldIgnoreTagHandler: (tags: Tags) => (jsDocTags: Set<string>) => boolean;

package/dist/util/trace.d.ts

@@ -1,5 +1,5 @@
 import type { DependencyGraph } from '../types/dependency-graph.js';
-declare const isTrace: boolean;
+declare const isTrace: any;
 type CreateNode = {
     identifier?: string;
     hasRef?: boolean;
@@ -16,5 +16,5 @@ export type TraceNode = {
 export { isTrace };
 export declare const printTrace: (node: TraceNode, filePath: string, identifier?: string) => void;
 export declare const createNode: Create;
-export declare const addNodes: (node: TraceNode, id: string, importedSymbols: DependencyGraph, filePaths?: Set<string>) => void;
+export declare const addNodes: (node: TraceNode, id: string, importedSymbols: DependencyGraph, filePaths?: any) => void;
 export declare const createAndPrintTrace: (filePath: string, options?: CreateNode) => void;

package/dist/util/tsconfig-loader.d.ts

@@ -1,6 +1 @@
-import ts from 'typescript';
-export declare const loadTSConfig: (tsConfigFilePath: string) => Promise<{
-    isFile: boolean;
-    compilerOptions: ts.CompilerOptions;
-    definitionPaths: string[];
-}>;
+export declare const loadTSConfig: (tsConfigFilePath: string) => unknown;

package/dist/util/unwrap-function.d.ts

@@ -1 +1 @@
-export declare const unwrapFunction: (maybeFunction: unknown) => Promise<any>;
+export declare const unwrapFunction: (maybeFunction: unknown) => unknown;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.23.0";
+export declare const version = "5.23.1";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.23.0';
+export const version = '5.23.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.23.0",
+  "version": "5.23.1",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {