knip 5.22.3 → 5.23.1

package/dist/typescript/SourceFileManager.d.ts

@@ -6,14 +6,14 @@ interface SourceFileManagerOptions {
 }
 export declare class SourceFileManager {
     isSkipLibs: boolean;
-    sourceFileCache: Map<string, ts.SourceFile | undefined>;
-    snapshotCache: Map<string, ts.IScriptSnapshot | undefined>;
+    sourceFileCache: any;
+    snapshotCache: any;
     syncCompilers: SyncCompilers;
     asyncCompilers: AsyncCompilers;
     constructor({ compilers, isSkipLibs }: SourceFileManagerOptions);
     createSourceFile(filePath: string, contents: string): ts.SourceFile;
-    getSourceFile(filePath: string): ts.SourceFile | undefined;
-    getSnapshot(filePath: string): ts.IScriptSnapshot | undefined;
-    compileAndAddSourceFile(filePath: string): Promise<void>;
+    getSourceFile(filePath: string): any;
+    getSnapshot(filePath: string): any;
+    compileAndAddSourceFile(filePath: string): any;
 }
 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): string;
+export declare function stripQuotes(name: string): any;
 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) => Set<string>;
+export declare const getJSDocTags: (node: ts.Node) => any;
 export declare const getLineAndCharacterOfPosition: (node: ts.Node, pos: number) => {
     line: number;
     col: number;
@@ -18,8 +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) => string[];
-export declare const isConsiderReferencedNS: (node: ts.Identifier) => boolean;
+export declare const getDestructuredIds: (name: ts.ObjectBindingPattern) => any;
+export declare const isConsiderReferencedNS: (node: ts.Identifier) => any;
 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;

package/dist/typescript/ast-helpers.js

@@ -151,3 +151,22 @@ export const isImportSpecifier = (node) => ts.isImportSpecifier(node.parent) ||
     ts.isImportEqualsDeclaration(node.parent) ||
     ts.isImportClause(node.parent) ||
     ts.isNamespaceImport(node.parent);
+const isExported = (node) => {
+    if (getExportKeywordNode(node))
+        return true;
+    return node.parent ? isExported(node.parent) : false;
+};
+const isTypeDeclaration = (node) => ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node);
+const getAncestorTypeDeclaration = (node) => {
+    while (node) {
+        if (isTypeDeclaration(node))
+            return node;
+        node = node.parent;
+    }
+};
+export const isReferencedInExportedType = (node) => {
+    const typeNode = getAncestorTypeDeclaration(node);
+    return Boolean(typeNode && isExported(typeNode));
+};
+export const getExportKeywordNode = (node) => node.modifiers?.find(mod => mod.kind === ts.SyntaxKind.ExportKeyword);
+export const getDefaultKeywordNode = (node) => node.modifiers?.find(mod => mod.kind === ts.SyntaxKind.DefaultKeyword);

package/dist/typescript/getImportsAndExports.d.ts

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

package/dist/typescript/getImportsAndExports.js

@@ -5,8 +5,9 @@ import { timerify } from '../util/Performance.js';
 import { addNsValue, addValue, createImports } from '../util/dependency-graph.js';
 import { isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
 import { extname, isInNodeModules } from '../util/path.js';
+import { isIdChar } from '../util/regex.js';
 import { shouldIgnore } from '../util/tag.js';
-import { getAccessMembers, getDestructuredIds, getJSDocTags, getLineAndCharacterOfPosition, getTypeName, isAccessExpression, isConsiderReferencedNS, isDestructuring, isImportSpecifier, } from './ast-helpers.js';
+import { getAccessMembers, getDestructuredIds, getJSDocTags, getLineAndCharacterOfPosition, getTypeName, isAccessExpression, isConsiderReferencedNS, isDestructuring, isImportSpecifier, isReferencedInExportedType, } from './ast-helpers.js';
 import getDynamicImportVisitors from './visitors/dynamic-imports/index.js';
 import getExportVisitors from './visitors/exports/index.js';
 import { getImportsFromPragmas } from './visitors/helpers.js';
@@ -28,12 +29,13 @@ const createMember = (node, member, pos) => {
         line: line + 1,
         col: character + 1,
         fix: member.fix,
-        refs: 0,
+        refs: [0, false],
         jsDocTags: getJSDocTags(member.node),
     };
 };
+const isType = (item) => item.type === 'type' || item.type === 'interface' || item.type === 'member';
 const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) => {
-    const { skipTypeOnly, tags } = options;
+    const { skipTypeOnly, tags, ignoreExportsUsedInFile } = options;
     const internalImports = new Map();
     const externalImports = new Set();
     const unresolvedImports = new Set();
@@ -44,16 +46,17 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
     const scripts = new Set();
     const traceRefs = new Set();
     const importedInternalSymbols = new Map();
+    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);
@@ -186,7 +189,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
                 line: line + 1,
                 col: character + 1,
                 fixes: fix ? [fix] : [],
-                refs: 0,
+                refs: [0, false],
                 isReExport,
             });
         }
@@ -221,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);
@@ -282,6 +288,9 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
                         }
                     }
                 }
+                if (ignoreExportsUsedInFile && !isTopLevel && isReferencedInExportedType(node)) {
+                    referencedSymbolsInExportedTypes.add(symbol.exportSymbol);
+                }
             }
         }
         if (isTopLevel &&
@@ -302,37 +311,49 @@ 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;
-        while (index < sourceFile.text.length && (index = sourceFile.text.indexOf(item.identifier, index)) !== -1) {
-            const isDeclaration = index === item.pos || index === item.pos + 1;
-            if (!isDeclaration) {
-                const symbol = typeChecker.getSymbolAtLocation(ts.getTokenAtPosition(sourceFile, index));
-                if (symbol) {
-                    if (item.symbol === symbol) {
-                        item.refs = 1;
-                        break;
-                    }
-                    const declaration = symbol.declarations?.[0];
-                    if (declaration) {
-                        if (item.symbol === declaration.name?.flowNode?.node?.symbol) {
-                            item.refs = 1;
-                            break;
+        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 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);
+                        if (item.symbol === symbol) {
+                            item.refs = [1, isInExportedType];
+                            if (isInExportedType || isType(item))
+                                break;
                         }
-                        if (ts.isImportSpecifier(declaration) && symbols.has(symbol)) {
-                            item.refs = 1;
-                            break;
+                        const declaration = symbol.declarations?.[0];
+                        if (declaration) {
+                            if (item.symbol === declaration.name?.flowNode?.node?.symbol) {
+                                item.refs = [1, isInExportedType];
+                                break;
+                            }
+                            if (ts.isImportSpecifier(declaration) && symbols.has(symbol)) {
+                                item.refs = [1, isInExportedType];
+                                break;
+                            }
                         }
+                        symbols.add(symbol);
                     }
-                    symbols.add(symbol);
                 }
             }
-            index += item.identifier.length;
+            index += id.length;
         }
     };
+    const isSetRefs = ignoreExportsUsedInFile;
     for (const item of exports.values()) {
-        if (options.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;