knip 5.23.1 → 5.23.3

package/dist/plugins/yorkie/index.d.ts

@@ -1,10 +1,11 @@
 import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { LintStagedConfig } from '../lint-staged/types.js';
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     packageJsonPath: string;
     config: string[];
-    resolveConfig: ResolveConfig<any>;
+    resolveConfig: ResolveConfig<LintStagedConfig>;
 };
 export default _default;

package/dist/reporters/index.d.ts

@@ -2,7 +2,7 @@ declare const _default: {
     symbols: ({ report, issues, tagHints, configurationHints, noConfigHints, isShowProgress }: import("../index.js").ReporterOptions) => void;
     compact: ({ report, issues, isShowProgress }: import("../index.js").ReporterOptions) => void;
     codeowners: ({ report, issues, isShowProgress, options }: import("../index.js").ReporterOptions) => void;
-    json: ({ report, issues, options }: import("../index.js").ReporterOptions) => any;
+    json: ({ report, issues, options }: import("../index.js").ReporterOptions) => Promise<void>;
     markdown: ({ report, issues }: import("../index.js").ReporterOptions) => void;
 };
 export default _default;

package/dist/reporters/json.d.ts

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

package/dist/reporters/util.d.ts

@@ -1,7 +1,7 @@
 import { ISSUE_TYPE_TITLE } from '../constants.js';
 import type { Issue, IssueSeverity, IssueSymbol } from '../types/issues.js';
 export declare const identity: (text: string) => string;
-export declare const getTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => Record<keyof import("../types/issues.js").Issues, string>;
+export declare const getTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => string;
 export declare const logTitle: (title: string, count: number) => void;
 type LogIssueLine = {
     owner?: string;

package/dist/typescript/SourceFileManager.d.ts

@@ -6,14 +6,14 @@ interface SourceFileManagerOptions {
 }
 export declare class SourceFileManager {
     isSkipLibs: boolean;
-    sourceFileCache: any;
-    snapshotCache: any;
+    sourceFileCache: Map<string, ts.SourceFile | undefined>;
+    snapshotCache: Map<string, ts.IScriptSnapshot | undefined>;
     syncCompilers: SyncCompilers;
     asyncCompilers: AsyncCompilers;
     constructor({ compilers, isSkipLibs }: SourceFileManagerOptions);
     createSourceFile(filePath: string, contents: string): ts.SourceFile;
-    getSourceFile(filePath: string): any;
-    getSnapshot(filePath: string): any;
-    compileAndAddSourceFile(filePath: string): any;
+    getSourceFile(filePath: string): ts.SourceFile | undefined;
+    getSnapshot(filePath: string): ts.IScriptSnapshot | undefined;
+    compileAndAddSourceFile(filePath: string): Promise<void>;
 }
 export {};

package/dist/typescript/ast-helpers.d.ts

@@ -6,11 +6,11 @@ export declare function isAccessExpression(node: ts.Node): node is ts.AccessExpr
 export declare function isImportCall(node: ts.Node): node is ts.ImportCall;
 export declare function isRequireCall(callExpression: ts.Node): callExpression is ts.CallExpression;
 export declare function isPropertyAccessCall(node: ts.Node, identifier: string): node is ts.CallExpression;
-export declare function stripQuotes(name: string): any;
+export declare function stripQuotes(name: string): string;
 export declare function findAncestor<T>(node: ts.Node | undefined, callback: (element: ts.Node) => boolean | 'STOP'): T | undefined;
 export declare function findDescendants<T>(node: ts.Node | undefined, callback: (element: ts.Node) => boolean | 'STOP'): T[];
 export declare const isDeclarationFileExtension: (extension: string) => extension is ".d.ts" | ".d.mts" | ".d.cts";
-export declare const getJSDocTags: (node: ts.Node) => any;
+export declare const getJSDocTags: (node: ts.Node) => Set<string>;
 export declare const getLineAndCharacterOfPosition: (node: ts.Node, pos: number) => {
     line: number;
     col: number;
@@ -18,11 +18,11 @@ export declare const getLineAndCharacterOfPosition: (node: ts.Node, pos: number)
 };
 export declare const getAccessMembers: (typeChecker: ts.TypeChecker, node: ts.Identifier) => string[];
 export declare const isDestructuring: (node: ts.Node) => boolean;
-export declare const getDestructuredIds: (name: ts.ObjectBindingPattern) => any;
-export declare const isConsiderReferencedNS: (node: ts.Identifier) => any;
+export declare const getDestructuredIds: (name: ts.ObjectBindingPattern) => string[];
+export declare const isConsiderReferencedNS: (node: ts.Identifier) => boolean;
 export declare const isTopLevel: (node: ts.Node) => boolean;
 export declare const getTypeName: (node: ts.Identifier) => ts.QualifiedName | undefined;
 export declare const isImportSpecifier: (node: ts.Node) => boolean;
-export declare const isReferencedInExportedType: (node: ts.Node) => any;
-export declare const getExportKeywordNode: (node: ts.Node) => any;
-export declare const getDefaultKeywordNode: (node: ts.Node) => any;
+export declare const isReferencedInExportedType: (node: ts.Node) => boolean;
+export declare const getExportKeywordNode: (node: ts.Node) => ts.ExportKeyword | undefined;
+export declare const getDefaultKeywordNode: (node: ts.Node) => ts.DefaultKeyword | undefined;

package/dist/typescript/getImportsAndExports.d.ts

@@ -1,6 +1,7 @@
 import ts from 'typescript';
 import type { Tags } from '../types/cli.js';
-import type { Export } from '../types/dependency-graph.js';
+import type { ExportMap, ImportMap, UnresolvedImport } from '../types/dependency-graph.js';
+import type { IssueSymbol } from '../types/issues.js';
 import type { BoundSourceFile } from './SourceFile.js';
 export type GetImportsAndExportsOptions = {
     skipTypeOnly: boolean;
@@ -13,16 +14,16 @@ export type GetImportsAndExportsOptions = {
 };
 export declare const _getImportsAndExports: (sourceFile: BoundSourceFile, resolveModule: (specifier: string) => ts.ResolvedModuleFull | undefined, typeChecker: ts.TypeChecker, options: GetImportsAndExportsOptions) => {
     imports: {
-        internal: Map<string, import("../types/dependency-graph.js").ImportDetails>;
-        external: any;
-        resolved: any;
-        specifiers: any;
-        unresolved: any;
+        internal: ImportMap;
+        external: Set<string>;
+        resolved: Set<string>;
+        specifiers: Set<[string, string]>;
+        unresolved: Set<UnresolvedImport>;
     };
     exports: {
-        exported: Map<string, Export>;
-        duplicate: any[];
+        exported: ExportMap;
+        duplicate: IssueSymbol[][];
     };
-    scripts: any;
-    traceRefs: any;
+    scripts: Set<string>;
+    traceRefs: Set<string>;
 };

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

@@ -1,3 +1,3 @@
 import type ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => any;
+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[])[];
 export default _default;

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

@@ -79,7 +79,7 @@ export default visit(() => true, (node, { isFixExports, isFixTypes, isReportClas
             return { node, identifier, type: SymbolType.TYPE, pos, fix };
         }
         if (ts.isInterfaceDeclaration(node)) {
-            const identifier = node.name.getText();
+            const identifier = defaultKeyword ? 'default' : node.name.getText();
             const pos = node.name.getStart();
             const fix = getTypeFix(exportKeyword);
             return { node, identifier, type: SymbolType.INTERFACE, pos, fix };

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

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

package/dist/util/Performance.d.ts

@@ -15,11 +15,11 @@ declare class Performance {
     private clearMark;
     private flush;
     private getEntriesByName;
-    getTable(): any;
+    getTable(): string;
     getCurrentDurationInMs(startTime?: number): number;
     getMemHeapUsage(): number;
     getCurrentMemUsageInMb(): number;
-    finalize(): any;
+    finalize(): Promise<void>;
     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>) => any;
-export declare const arrayify: (value?: string[] | string) => string | string[] | undefined;
+export declare const compact: <T>(collection: Collection<T | undefined>) => T[];
+export declare const arrayify: (value?: string[] | string) => string[];
 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) => any;
+export declare const getKnownError: (error: Error) => Error;
 export {};

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

@@ -13,14 +13,17 @@ export type FileDescriptor<T> = {
 };
 export declare class FileEntryCache<T> {
     filePath: string;
-    cache: any;
-    normalizedEntries: any;
+    cache: Map<string, MetaData<T>>;
+    normalizedEntries: Map<string, FileDescriptor<T>>;
     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>): any;
+    _getMetaForFileUsingMtimeAndSize(cacheEntry: FileDescriptor<T>): {
+        size: number;
+        mtime: number;
+    };
     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) => 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 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 parseYAML: (contents: string) => unknown;
 export declare function isTypeModule(path: string): boolean;
-export declare const _loadJSON: (filePath: string) => unknown;
+export declare const _loadJSON: (filePath: string) => Promise<any>;

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

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

package/dist/util/get-included-issue-types.js

@@ -16,7 +16,7 @@ export const getIncludedIssueTypes = (cliArgs, { include = [], exclude = [], isP
         incl = [...incl, 'dependencies', 'optionalPeerDependencies', 'unlisted', 'binaries', 'unresolved'];
     }
     if (cliArgs.exports) {
-        incl = [...incl, 'exports', 'nsExports', 'classMembers', 'types', 'nsTypes', 'enumMembers', 'duplicates'];
+        incl = [...incl, 'exports', 'types', 'enumMembers', 'duplicates'];
     }
     if (cliArgs.files) {
         incl = [...incl, 'files'];

package/dist/util/git.d.ts

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

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) => any;
-export declare const hasProductionSuffix: (pattern: string) => any;
+export declare const negate: (pattern: string) => string;
+export declare const hasProductionSuffix: (pattern: string) => boolean;
 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) => 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 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 {};

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) => any;
+export declare const getHandler: (collector: IssueCollector, deputy: DependencyDeputy, chief: ConfigurationChief) => (specifier: string, containingFilePath: string, workspace: Workspace) => string | undefined;

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?: any) => Result;
+export declare const getIsIdentifierReferencedHandler: (graph: DependencyGraph, entryPaths: Set<string>) => (filePath: string, id: string, isIncludeEntryExports?: boolean, traceNode?: TraceNode, seen?: Set<string>) => Result;
 export {};

package/dist/util/loader.d.ts

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

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

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

package/dist/util/modules.d.ts

@@ -1,9 +1,9 @@
 import type { PackageJson } from '../types/package-json.js';
-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 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 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[];
-}) => unknown;
-export declare const sanitizeSpecifier: (specifier: string) => any;
+}) => Promise<string[]>;
+export declare const sanitizeSpecifier: (specifier: string) => string;

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

@@ -1,6 +1,10 @@
 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) => unknown;
-export declare const save: (filePath: string, content: ExtendedPackageJson) => any;
+export declare const load: (filePath: string) => Promise<ExtendedPackageJson>;
+export declare const save: (filePath: string, content: ExtendedPackageJson) => Promise<void>;
 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) => any;
-export declare const cwd: any;
+export declare const toPosix: (value: string) => string;
+export declare const cwd: string;
 export declare const resolve: (...paths: string[]) => string;
-export declare const relative: (from: string, to?: string) => any;
-export declare const isInNodeModules: (filePath: string) => any;
+export declare const relative: (from: string, to?: string) => string;
+export declare const isInNodeModules: (filePath: string) => boolean;
 export declare const toAbsolute: (id: string, base?: string) => string;
-export declare const toRelative: (id: string) => any;
-export declare const isInternal: (id: string) => any;
+export declare const toRelative: (id: string) => string;
+export declare const isInternal: (id: string) => boolean;

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>): 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 {};

package/dist/util/plugin.d.ts

@@ -1,15 +1,39 @@
-export { _load as load } from './loader.js';
+export { _getDependenciesFromScripts as getDependenciesFromScripts } from '../binaries/index.js';
 export { _loadJSON as loadJSON } from './fs.js';
+export { _load as load } from './loader.js';
 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) => any;
-export declare const hasDependency: (dependencies: Set<string>, values: (string | RegExp)[]) => any;
+export declare const toCamelCase: (name: string) => string;
+export declare const hasDependency: (dependencies: Set<string>, values: (string | RegExp)[]) => boolean;
 export declare const normalizePluginConfig: (pluginConfig: RawPluginConfiguration) => boolean | {
-    config: string | string[] | null | undefined;
-    entry: string | string[] | null | undefined;
-    project: string | string[] | null | undefined;
+    config: string[] | null;
+    entry: string[] | null;
+    project: string[] | null;
 };
-export declare const loadConfigForPlugin: (configFilePath: string, plugin: Plugin, options: PluginOptions, pluginName: string) => unknown;
-export declare const getFinalEntryPaths: (plugin: Plugin, options: PluginOptions, configEntryPaths: string[]) => any;
+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[];

package/dist/util/plugin.js

@@ -1,7 +1,7 @@
-export { _load as load } from './loader.js';
+export { _getDependenciesFromScripts as getDependenciesFromScripts } from '../binaries/index.js';
 export { _loadJSON as loadJSON } from './fs.js';
+export { _load as load } from './loader.js';
 export { _tryResolve as tryResolve } from './require.js';
-export { _getDependenciesFromScripts as getDependenciesFromScripts } from '../binaries/index.js';
 import { arrayify } from './array.js';
 import { _load as load } from './loader.js';
 import { get } from './object.js';
@@ -61,3 +61,35 @@ export const getFinalEntryPaths = (plugin, options, configEntryPaths) => {
             ? 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].filter(item => item !== false);
+};
+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/protocols.d.ts

@@ -1,9 +1,9 @@
-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;
+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;

package/dist/util/regex.d.ts

@@ -1,3 +1,3 @@
-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;
+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;

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) => any;
+export declare const runReporters: (options: ReporterOptions) => Promise<void>;

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) => any;
-export declare const _tryResolve: (specifier: string, from: string) => any;
-export declare const _resolveSpecifier: (dir: string, specifier: 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;

package/dist/util/resolve.d.ts

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

package/dist/util/tag.d.ts

@@ -1,5 +1,5 @@
 import type { Tags } from '../types/cli.js';
-export declare const splitTags: (rawTags: string[]) => any;
+export declare const splitTags: (rawTags: string[]) => Tags;
 export declare const shouldIgnore: (jsDocTags: Set<string>, tags: Tags) => boolean;
-export declare const getShouldIgnoreHandler: (isProduction: boolean) => (jsDocTags: Set<string>) => any;
+export declare const getShouldIgnoreHandler: (isProduction: boolean) => (jsDocTags: Set<string>) => boolean;
 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: any;
+declare const isTrace: boolean;
 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?: any) => void;
+export declare const addNodes: (node: TraceNode, id: string, importedSymbols: DependencyGraph, filePaths?: Set<string>) => void;
 export declare const createAndPrintTrace: (filePath: string, options?: CreateNode) => void;

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

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

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

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

package/dist/version.d.ts

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

package/dist/version.js

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