knip 5.23.0 → 5.23.2

package/dist/index.js

@@ -317,8 +317,17 @@ export const main = async (unresolvedConfiguration) => {
                         if (shouldIgnore(exportedItem.jsDocTags))
                             continue;
                         const isIgnored = shouldIgnoreTags(exportedItem.jsDocTags);
-                        if (!isIgnored && importsForExport) {
+                        if (importsForExport) {
                             const { isReferenced, reExportingEntryFile, traceNode } = isIdentifierReferenced(filePath, identifier, isIncludeEntryExports);
+                            if ((isReferenced || exportedItem.refs[1]) && isIgnored) {
+                                for (const tagName of exportedItem.jsDocTags) {
+                                    if (tags[1].includes(tagName.replace(/^\@/, ''))) {
+                                        collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
+                                    }
+                                }
+                            }
+                            if (isIgnored)
+                                continue;
                             if (reExportingEntryFile) {
                                 if (!isIncludeEntryExports) {
                                     createAndPrintTrace(filePath, { identifier, isEntry, hasRef: isReferenced });
@@ -339,7 +348,7 @@ export const main = async (unresolvedConfiguration) => {
                                             continue;
                                         if (member.refs[0] === 0) {
                                             const id = `${identifier}.${member.identifier}`;
-                                            const { isReferenced } = isIdentifierReferenced(filePath, id);
+                                            const { isReferenced } = isIdentifierReferenced(filePath, id, true);
                                             const isIgnored = shouldIgnoreTags(member.jsDocTags);
                                             if (!isReferenced) {
                                                 if (isIgnored)
@@ -413,20 +422,13 @@ export const main = async (unresolvedConfiguration) => {
                                 line: exportedItem.line,
                                 col: exportedItem.col,
                             });
-                            if (isIssueAdded) {
+                            if (isFix && isIssueAdded) {
                                 if (isType)
                                     fixer.addUnusedTypeNode(filePath, exportedItem.fixes);
                                 else
                                     fixer.addUnusedExportNode(filePath, exportedItem.fixes);
                             }
                         }
-                        else if (isIgnored) {
-                            for (const tagName of exportedItem.jsDocTags) {
-                                if (tags[1].includes(tagName.replace(/^\@/, ''))) {
-                                    collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
-                                }
-                            }
-                        }
                     }
                 }
             }

package/dist/plugins/commitlint/index.js

@@ -1,13 +1,8 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { hasDependency, toCosmiconfig } from '#p/util/plugin.js';
 const title = 'commitlint';
 const enablers = ['@commitlint/cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = [
-    '.commitlintrc',
-    '.commitlintrc.{json,yaml,yml,js,cjs,ts,cts}',
-    'commitlint.config.{js,cjs,ts,cts}',
-    'package.json',
-];
+const config = ['package.json', 'package.yaml', ...toCosmiconfig('commitlint', { additionalExtensions: ['cts'] })];
 const resolveConfig = async (config) => {
     const extendsConfigs = config.extends
         ? [config.extends]

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

@@ -9,7 +9,7 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const packageJsonPath = manifest => get(manifest, 'codegen') ?? get(manifest, 'graphql');
 const config = [
     'package.json',
-    'codegen.{json,yml,yaml,js,ts,mjs,cts}',
+    'codegen.{json,yml,yaml,js,ts}',
     '.codegenrc.{json,yml,yaml,js,ts}',
     'codegen.config.js',
     '.graphqlrc',

package/dist/plugins/lint-staged/index.js

@@ -1,15 +1,14 @@
-import { getDependenciesFromScripts, hasDependency } from '#p/util/plugin.js';
+import { getDependenciesFromScripts, hasDependency, toLilconfig } from '#p/util/plugin.js';
 const title = 'lint-staged';
 const enablers = ['lint-staged'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const packageJsonPath = 'lint-staged';
 const config = [
-    '.lintstagedrc',
-    '.lintstagedrc.json',
-    '.lintstagedrc.{yml,yaml}',
-    '.lintstagedrc.{js,mjs,cjs}',
-    'lint-staged.config.{js,mjs,cjs}',
     'package.json',
+    'package.yaml',
+    'package.yml',
+    ...toLilconfig('lint-staged'),
+    ...toLilconfig('lintstaged'),
 ];
 const resolveConfig = async (config, options) => {
     if (typeof config === 'function')

package/dist/plugins/linthtml/index.js

@@ -1,18 +1,11 @@
 import { isInternal } from '#p/util/path.js';
-import { hasDependency } from '#p/util/plugin.js';
+import { hasDependency, toCosmiconfig } from '#p/util/plugin.js';
 import { toEntryPattern } from '#p/util/protocols.js';
 const title = 'LintHTML';
 const packageJsonPath = 'linthtmlConfig';
 const enablers = ['@linthtml/linthtml'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = [
-    '.linthtmlrc',
-    '.linthtmlrc.json',
-    '.linthtmlrc.yml',
-    '.linthtmlrc.{js,cjs}',
-    'linthtml.config.js',
-    'package.json',
-];
+const config = ['package.json', ...toCosmiconfig('linthtml')];
 const resolveConfig = config => {
     const extensions = [config.extends ?? []]
         .flat()

package/dist/plugins/lockfile-lint/index.js

@@ -1,8 +1,8 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { hasDependency, toCosmiconfig } from '#p/util/plugin.js';
 const title = 'lockfile-lint';
 const enablers = ['lockfile-lint'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.lockfile-lintrc', '.lockfile-lint.{js,toml}', 'lockfile-lint.config.js', 'package.json'];
+const config = ['package.json', ...toCosmiconfig('lockfile-lint', { additionalExtensions: ['toml'] })];
 export default {
     title,
     enablers,

package/dist/plugins/npm-package-json-lint/index.js

@@ -1,9 +1,9 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { hasDependency, toCosmiconfig } from '#p/util/plugin.js';
 const title = 'npm-package-json-lint';
 const enablers = ['npm-package-json-lint'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const packageJsonPath = 'npmpackagejsonlint';
-const config = ['.npmpackagejsonlintrc.json', 'npmpackagejsonlint.config.js', 'package.json'];
+const config = ['package.json', ...toCosmiconfig('npmpackagejsonlint')];
 const resolveConfig = localConfig => {
     return localConfig?.extends ? [localConfig.extends] : [];
 };

package/dist/plugins/postcss/index.js

@@ -1,8 +1,12 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { hasDependency, toLilconfig } from '#p/util/plugin.js';
 const title = 'PostCSS';
 const enablers = ['postcss', 'postcss-cli', 'next'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['postcss.config.{cjs,js}', 'postcss.config.json', 'package.json'];
+const config = [
+    'package.json',
+    'postcss.config.json',
+    ...toLilconfig('postcss', { configDir: false, additionalExtensions: ['ts', 'mts', 'cts', 'yaml', 'yml'] }),
+];
 const resolveConfig = config => {
     return config.plugins
         ? (Array.isArray(config.plugins) ? config.plugins : Object.keys(config.plugins)).flatMap(plugin => {

package/dist/plugins/prettier/index.js

@@ -4,9 +4,9 @@ const enablers = ['prettier'];
 const isEnabled = ({ dependencies, config }) => hasDependency(dependencies, enablers) || 'prettier' in config;
 const config = [
     '.prettierrc',
-    '.prettierrc.{json,js,cjs,mjs,yml,yaml}',
+    '.prettierrc.{json,js,cjs,mjs,yml,yaml,toml,json5}',
     'prettier.config.{js,cjs,mjs}',
-    'package.json',
+    'package.{json,yaml}',
 ];
 const resolveConfig = config => {
     if (typeof config === 'string') {

package/dist/plugins/release-it/index.js

@@ -3,7 +3,7 @@ const title = 'Release It';
 const enablers = ['release-it'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const packageJsonPath = 'release-it';
-const config = ['.release-it.json', '.release-it.{js,cjs}', '.release-it.{yml,yaml}', 'package.json'];
+const config = ['.release-it.{json,js,cjs,ts,yml,yaml,toml}', 'package.json'];
 const resolveConfig = (config, options) => {
     const plugins = config.plugins ? Object.keys(config.plugins) : [];
     const scripts = config.hooks ? Object.values(config.hooks).flat() : [];

package/dist/plugins/semantic-release/index.js

@@ -1,9 +1,9 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { hasDependency, toCosmiconfig } from '#p/util/plugin.js';
 const title = 'Semantic Release';
 const enablers = ['semantic-release'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const packageJsonPath = 'release';
-const config = ['.releaserc', '.releaserc.{yaml,yml,json,js,cjs}', 'release.config.{js,cjs}', 'package.json'];
+const config = ['package.json', ...toCosmiconfig('release')];
 const resolveConfig = config => {
     const plugins = (config?.plugins ?? []).map(plugin => (Array.isArray(plugin) ? plugin[0] : plugin));
     return plugins;

package/dist/plugins/size-limit/index.js

@@ -1,8 +1,11 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { hasDependency, toLilconfig } from '#p/util/plugin.js';
 const title = 'size-limit';
 const enablers = ['size-limit'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.size-limit.{json,js,cjs,ts}', 'package.json'];
+const config = [
+    'package.json',
+    ...toLilconfig('size-limit', { configDir: false, additionalExtensions: ['ts', 'mts', 'cts'], rcSuffix: '' }),
+];
 export default {
     title,
     enablers,

package/dist/plugins/stylelint/index.js

@@ -1,9 +1,9 @@
 import { isInternal } from '#p/util/path.js';
-import { hasDependency } from '#p/util/plugin.js';
+import { hasDependency, toCosmiconfig } from '#p/util/plugin.js';
 const title = 'Stylelint';
 const enablers = ['stylelint'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.stylelintrc', '.stylelintrc.{cjs,js,json,yaml,yml}', 'stylelint.config.{cjs,mjs,js}'];
+const config = ['package.json', ...toCosmiconfig('stylelint')];
 const resolve = (config) => {
     const extend = config.extends ? [config.extends].flat().filter(id => !isInternal(id)) : [];
     const plugins = config.plugins ? [config.plugins].flat().filter(id => !isInternal(id)) : [];

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

@@ -4,5 +4,6 @@ declare const _default: {
     enablers: import("#p/types/config.js").IgnorePatterns;
     isEnabled: IsPluginEnabled;
     config: string[];
+    packageJsonPath: (manifest: import("../../types/package-json.js").PackageJson) => string;
 };
 export default _default;

package/dist/plugins/syncpack/index.js

@@ -1,11 +1,14 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { get } from '#p/util/object.js';
+import { hasDependency, toCosmiconfig } from '#p/util/plugin.js';
 const title = 'Syncpack';
 const enablers = ['syncpack'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.syncpackrc', '.syncpackrc.{json,yaml,yml,js,cjs}', '.syncpack.config.{js,cjs}'];
+const config = ['package.json', ...toCosmiconfig('syncpack')];
+const packageJsonPath = manifest => get(manifest, 'syncpack');
 export default {
     title,
     enablers,
     isEnabled,
     config,
+    packageJsonPath,
 };

package/dist/plugins/tsup/index.js

@@ -3,7 +3,7 @@ import { toProductionEntryPattern } from '#p/util/protocols.js';
 const title = 'tsup';
 const enablers = ['tsup'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['tsup.config.{js,ts,cjs,json}', 'package.json'];
+const config = ['tsup.config.{js,ts,cjs,mjs,json}', 'package.json'];
 const resolveConfig = async (config) => {
     if (typeof config === 'function')
         config = await config({});

package/dist/plugins/typedoc/index.js

@@ -4,10 +4,10 @@ const enablers = ['typedoc'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const packageJsonPath = 'typedocOptions';
 const config = [
-    'typedoc.{js,cjs,json,jsonc}',
-    'typedoc.config.{js,cjs}',
-    '.config/typedoc.{js,cjs,json,jsonc}',
-    '.config/typedoc.config.{js,cjs}',
+    'typedoc.{js,cjs,mjs,json,jsonc}',
+    'typedoc.config.{js,cjs,mjs}',
+    '.config/typedoc.{js,cjs,mjs,json,jsonc}',
+    '.config/typedoc.config.{js,cjs,mjs}',
     'package.json',
     'tsconfig.json',
 ];

package/dist/plugins/unocss/index.js

@@ -1,8 +1,8 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { hasDependency, toUnconfig } from '#p/util/plugin.js';
 const title = 'UnoCSS';
 const enablers = ['unocss'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['uno.config.{js,ts,mjs,mts}', 'unocss.config.{js,ts,mjs,mts}'];
+const config = [...toUnconfig('uno.config'), ...toUnconfig('unocss.config')];
 export default {
     title,
     enablers,

package/dist/plugins/xo/index.js

@@ -4,8 +4,8 @@ const title = 'xo';
 const enablers = ['xo'];
 const isEnabled = ({ dependencies, config }) => hasDependency(dependencies, enablers) || 'xo' in config;
 const packageJsonPath = 'xo';
-const config = ['{.,}xo-config.{js,cjs,json,}', 'package.json'];
-const entry = ['{.,}xo-config.{js,cjs}'];
+const config = ['package.json', '.xo-config', '.xo-config.{js,cjs,json}', 'xo.config.{js,cjs}'];
+const entry = ['.xo-config.{js,cjs}', 'xo.config.{js,cjs}'];
 const resolveConfig = async (config, options) => {
     const dependencies = await getDependenciesDeep(config, options);
     return [...dependencies];

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

@@ -23,4 +23,6 @@ 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, symbol: ts.Symbol) => 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/ast-helpers.js

@@ -152,11 +152,21 @@ export const isImportSpecifier = (node) => ts.isImportSpecifier(node.parent) ||
     ts.isImportClause(node.parent) ||
     ts.isNamespaceImport(node.parent);
 const isExported = (node) => {
-    if (node.modifiers?.find(mod => mod.kind === ts.SyntaxKind.ExportKeyword))
+    if (getExportKeywordNode(node))
         return true;
     return node.parent ? isExported(node.parent) : false;
 };
-export const isReferencedInExportedType = (node, symbol) => symbol.exportSymbol &&
-    !(node.transformFlags & ts.TransformFlags.ContainsTypeScript) &&
-    Boolean(node.parent.transformFlags & ts.TransformFlags.ContainsTypeScript) &&
-    isExported(node.parent);
+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.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/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/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/plugin.d.ts

@@ -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 type { RawPluginConfiguration } from '../types/config.js';
 import type { Plugin, PluginOptions } from '../types/plugins.js';
 export declare const toCamelCase: (name: string) => string;
@@ -13,3 +13,27 @@ export declare const normalizePluginConfig: (pluginConfig: RawPluginConfiguratio
 };
 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/version.d.ts

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

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.23.0",
+  "version": "5.23.2",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {
@@ -21,7 +21,11 @@
     },
     {
       "type": "opencollective",
-      "url": "https://opencollective.com/webpro"
+      "url": "https://opencollective.com/knip"
+    },
+    {
+      "type": "polar",
+      "url": "https://polar.sh/webpro-nl"
     }
   ],
   "main": "./dist/index.js",