knip 2.9.0 → 2.10.0

package/README.md

@@ -44,12 +44,17 @@ Knip has good defaults and you can run it without any configuration. Here's the
 
 ```json
 {
-  "entry": ["index.{js,ts}", "src/index.{js,ts}"],
-  "project": ["**/*.{js,ts}"]
+  "entry": ["index.js", "src/index.js"],
+  "project": ["**/*.js"]
 }
 ```
 
-Well, almost, this is the full list of default extensions: `js`, `mjs`, `cjs`, `jsx`, `ts`, `mts`, `cts` and `tsx`.
+In addition to `index.js`, the following file names and extensions are also considered entry files:
+
+- `index`, `main` and `cli`
+- `js`, `mjs`, `cjs`, `jsx`, `ts`, `mts`, `cts` and `tsx`
+
+This means files like `main.cjs` and `src/cli.ts` are automatically added as entry files.
 
 ### Entry Files
 
@@ -58,10 +63,9 @@ Knip looks for entry files at those default locations, but also in other places:
 - The `main`, `bin` and `exports` fields of `package.json`.
 - [Plugins][2] such as for Next.js, Remix, Gatsby or Svelte add entry files.
 - The `scripts` in package.json or other scripts may provide entry files.
-- Knip does this for each [workspace][1] it finds.
 
-In other words, Knip looks in many places and you may not need much configuration. In a perfectly boring world where
-everything is according to defaults you don't even need a `knip.json` file.
+Knip does this for each [workspace][1] it finds, trying to minimize the configuration to suit your project. In a
+perfectly boring world where everything is according to defaults you wouldn't even need a `knip.json` file at all.
 
 Larger projects tend to have more things customized, and therefore probably get more out of Knip with a configuration
 file. Let's say you are using `.ts` files exclusively and have all source files only in the `src` directory:

package/dist/ConfigurationChief.d.ts

@@ -49,6 +49,8 @@ export declare class ConfigurationChief {
         include: string[];
         exclude: string[];
         ignore: string[];
+        ignoreBinaries: string[];
+        ignoreDependencies: string[];
         ignoreWorkspaces: string[];
         syncCompilers: Map<string, (args_0: string, ...args_1: unknown[]) => string>;
         asyncCompilers: Map<string, (args_0: string, ...args_1: unknown[]) => Promise<string>>;

package/dist/ConfigurationChief.js

@@ -21,7 +21,7 @@ const workspaceArg = rawWorkspaceArg ? toPosix(rawWorkspaceArg).replace(/^\.\//,
 const getDefaultWorkspaceConfig = (extensions) => {
     const exts = [...DEFAULT_EXTENSIONS, ...(extensions ?? [])].map(ext => ext.slice(1)).join(',');
     return {
-        entry: [`index.{${exts}}!`, `src/index.{${exts}}!`],
+        entry: [`{index,cli,main}.{${exts}}!`, `src/{index,cli,main}.{${exts}}!`],
         project: [`**/*.{${exts}}!`],
         paths: {},
         ignore: [],
@@ -34,6 +34,8 @@ const defaultConfig = {
     include: [],
     exclude: [],
     ignore: [],
+    ignoreBinaries: [],
+    ignoreDependencies: [],
     ignoreWorkspaces: [],
     syncCompilers: new Map(),
     asyncCompilers: new Map(),
@@ -122,8 +124,8 @@ export class ConfigurationChief {
                 project,
                 paths,
                 ignore: arrayify(workspaceConfig.ignore),
-                ignoreBinaries: compact([...ignoreBinaries, ...arrayify(workspaceConfig.ignoreBinaries)]),
-                ignoreDependencies: compact([...ignoreDependencies, ...arrayify(workspaceConfig.ignoreDependencies)]),
+                ignoreBinaries: arrayify(workspaceConfig.ignoreBinaries),
+                ignoreDependencies: arrayify(workspaceConfig.ignoreDependencies),
             };
             for (const [name, pluginConfig] of Object.entries(workspaceConfig)) {
                 const pluginName = toCamelCase(name);
@@ -151,6 +153,8 @@ export class ConfigurationChief {
             include,
             exclude,
             ignore,
+            ignoreBinaries,
+            ignoreDependencies,
             ignoreWorkspaces,
             syncCompilers: new Map(Object.entries(syncCompilers ?? {})),
             asyncCompilers: new Map(Object.entries(asyncCompilers ?? {})),
@@ -172,7 +176,6 @@ export class ConfigurationChief {
         const workspaces = await mapWorkspaces({
             pkg: this.manifest ?? {},
             cwd: this.cwd,
-            ignore: this.config.ignoreWorkspaces,
         });
         const manifestWorkspaces = new Map();
         for (const [pkgName, dir] of workspaces.entries()) {

package/dist/DependencyDeputy.d.ts

@@ -13,6 +13,8 @@ export declare class DependencyDeputy {
     referencedBinaries: Map<string, Set<string>>;
     peerDependencies: Map<string, PeerDependencies>;
     installedBinaries: Map<string, InstalledBinaries>;
+    ignoreBinaries: string[];
+    ignoreDependencies: string[];
     constructor({ isStrict }: Options);
     addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, ignoreBinaries, }: {
         name: string;
@@ -22,6 +24,7 @@ export declare class DependencyDeputy {
         ignoreDependencies: string[];
         ignoreBinaries: string[];
     }): void;
+    addIgnored(ignoreBinaries: string[], ignoreDependencies: string[]): void;
     getWorkspaceManifest(workspaceName: string): {
         workspaceDir: string;
         manifestPath: string;
@@ -48,6 +51,8 @@ export declare class DependencyDeputy {
     settleDependencyIssues(): {
         dependencyIssues: Issue[];
         devDependencyIssues: Issue[];
+    };
+    getConfigurationHints(): {
         configurationHints: ConfigurationHints;
     };
 }

package/dist/DependencyDeputy.js

@@ -8,6 +8,8 @@ export class DependencyDeputy {
     referencedBinaries;
     peerDependencies;
     installedBinaries;
+    ignoreBinaries = [];
+    ignoreDependencies = [];
     constructor({ isStrict }) {
         this.isStrict = isStrict;
         this.referencedDependencies = new Map();
@@ -35,6 +37,10 @@ export class DependencyDeputy {
             allDependencies,
         });
     }
+    addIgnored(ignoreBinaries, ignoreDependencies) {
+        this.ignoreBinaries = ignoreBinaries;
+        this.ignoreDependencies = ignoreDependencies;
+    }
     getWorkspaceManifest(workspaceName) {
         return this._manifests.get(workspaceName);
     }
@@ -80,8 +86,6 @@ export class DependencyDeputy {
             return true;
         const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
         const closestWorkspaceName = workspaceNames.find(name => this.isInDependencies(name, packageName));
-        if (this.getWorkspaceManifest(workspace.name)?.ignoreDependencies.includes(packageName))
-            return true;
         const typesPackageName = !isDefinitelyTyped(packageName) && getDefinitelyTypedFor(packageName);
         const closestWorkspaceNameForTypes = typesPackageName && workspaceNames.find(name => this.isInDependencies(name, typesPackageName));
         if (closestWorkspaceName || closestWorkspaceNameForTypes) {
@@ -89,14 +93,19 @@ export class DependencyDeputy {
             closestWorkspaceNameForTypes && this.addReferencedDependency(closestWorkspaceNameForTypes, typesPackageName);
             return true;
         }
+        else {
+            this.addReferencedDependency(workspace.name, packageName);
+        }
+        if (this.getWorkspaceManifest(workspace.name)?.ignoreDependencies.includes(packageName))
+            return true;
+        if (this.ignoreDependencies.includes(packageName))
+            return true;
         return false;
     }
     maybeAddReferencedBinary(workspace, binaryName) {
         if (IGNORED_GLOBAL_BINARIES.includes(binaryName))
             return true;
         this.addReferencedBinary(workspace.name, binaryName);
-        if (this.getWorkspaceManifest(workspace.name)?.ignoreBinaries.includes(binaryName))
-            return true;
         const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
         for (const name of workspaceNames) {
             const binaries = this.getInstalledBinaries(name);
@@ -108,6 +117,10 @@ export class DependencyDeputy {
                 }
             }
         }
+        if (this.getWorkspaceManifest(workspace.name)?.ignoreBinaries.includes(binaryName))
+            return true;
+        if (this.ignoreBinaries.includes(binaryName))
+            return true;
         return false;
     }
     isInDependencies(workspaceName, packageName) {
@@ -120,25 +133,28 @@ export class DependencyDeputy {
     settleDependencyIssues() {
         const dependencyIssues = [];
         const devDependencyIssues = [];
-        const configurationHints = new Set();
         for (const [workspaceName, { manifestPath, ignoreDependencies, ignoreBinaries }] of this._manifests.entries()) {
             const referencedDependencies = this.referencedDependencies.get(workspaceName);
-            const referencedBinaries = this.referencedBinaries.get(workspaceName);
             const installedBinaries = this.getInstalledBinaries(workspaceName);
-            const ignoreBins = [...IGNORED_GLOBAL_BINARIES, ...ignoreBinaries];
-            const ignoreDeps = [...IGNORED_DEPENDENCIES, ...ignoreDependencies];
+            const ignoreBins = [...IGNORED_GLOBAL_BINARIES, ...this.ignoreBinaries, ...ignoreBinaries];
+            const ignoreDeps = [...IGNORED_DEPENDENCIES, ...this.ignoreDependencies, ...ignoreDependencies];
             const isNotIgnoredDependency = (packageName) => !ignoreDeps.includes(packageName);
             const isNotIgnoredBinary = (packageName) => {
                 if (installedBinaries?.has(packageName)) {
                     const binaryNames = installedBinaries.get(packageName);
-                    if (binaryNames && ignoreBins.some(ignoredBinary => binaryNames.has(ignoredBinary)))
-                        return false;
+                    if (binaryNames) {
+                        if (ignoreBins.some(ignoredBinary => binaryNames.has(ignoredBinary)))
+                            return false;
+                    }
                 }
                 return true;
             };
-            const isNotReferencedDependency = (dependency) => {
+            const peerDepRecs = {};
+            const isNotReferencedDependency = (dependency, isPeerDep) => {
                 if (referencedDependencies?.has(dependency))
                     return false;
+                if (isPeerDep && peerDepRecs[dependency])
+                    return true;
                 const [scope, typedDependency] = dependency.split('/');
                 if (scope === '@types') {
                     const typedPackageName = getPackageFromDefinitelyTyped(typedDependency);
@@ -146,35 +162,56 @@ export class DependencyDeputy {
                         return false;
                     const peerDependencies = this.getPeerDependencies(workspaceName, typedPackageName);
                     if (peerDependencies.length) {
-                        return !peerDependencies.find(peerDependency => !isNotReferencedDependency(peerDependency));
+                        return !peerDependencies.find(peerDependency => !isNotReferencedDependency(peerDependency, true));
                     }
                     return !referencedDependencies?.has(typedPackageName);
                 }
-                if (!referencedDependencies?.has(dependency)) {
-                    const peerDependencies = this.getPeerDependencies(workspaceName, dependency);
-                    return !peerDependencies.find(peerDependency => !isNotReferencedDependency(peerDependency));
-                }
-                return false;
+                const peerDependencies = this.getPeerDependencies(workspaceName, dependency);
+                peerDependencies.forEach(dep => (!peerDepRecs[dep] ? (peerDepRecs[dep] = 1) : peerDepRecs[dep]++));
+                return !peerDependencies.find(peerDependency => !isNotReferencedDependency(peerDependency, true));
             };
             const pd = this.getProductionDependencies(workspaceName);
             const dd = this.getDevDependencies(workspaceName);
             pd.filter(isNotIgnoredDependency)
                 .filter(isNotIgnoredBinary)
-                .filter(isNotReferencedDependency)
+                .filter(d => isNotReferencedDependency(d))
                 .forEach(symbol => dependencyIssues.push({ type: 'dependencies', filePath: manifestPath, symbol }));
             dd.filter(isNotIgnoredDependency)
                 .filter(isNotIgnoredBinary)
-                .filter(isNotReferencedDependency)
+                .filter(d => isNotReferencedDependency(d))
                 .forEach(symbol => devDependencyIssues.push({ type: 'devDependencies', filePath: manifestPath, symbol }));
-            const isReferencedDep = (name) => !([...pd, ...dd].includes(name) && referencedDependencies?.has(name));
+        }
+        return { dependencyIssues, devDependencyIssues };
+    }
+    getConfigurationHints() {
+        const configurationHints = new Set();
+        const rootIgnoreBinaries = Object.fromEntries(this.ignoreBinaries.map(key => [key, 0]));
+        const rootIgnoreDependencies = Object.fromEntries(this.ignoreDependencies.map(key => [key, 0]));
+        for (const [workspaceName, { ignoreDependencies, ignoreBinaries }] of this._manifests.entries()) {
+            const referencedDependencies = this.referencedDependencies.get(workspaceName);
+            const referencedBinaries = this.referencedBinaries.get(workspaceName);
+            const installedBinaries = this.getInstalledBinaries(workspaceName);
+            referencedBinaries?.forEach(binaryName => binaryName in rootIgnoreBinaries && rootIgnoreBinaries[binaryName]++);
+            const allDeps = [...this.getProductionDependencies(workspaceName), ...this.getDevDependencies(workspaceName)];
+            const isReferencedDep = (name) => referencedDependencies?.has(name) || (allDeps.includes(name) && !referencedDependencies?.has(name));
             const isReferencedBin = (name) => !installedBinaries?.has(name) && referencedBinaries?.has(name);
             ignoreDependencies
-                .filter(packageName => IGNORED_DEPENDENCIES.includes(packageName) || !isReferencedDep(packageName))
+                .filter(packageName => IGNORED_DEPENDENCIES.includes(packageName) ||
+                (workspaceName !== '.' && this.ignoreDependencies.includes(packageName)) ||
+                !isReferencedDep(packageName))
                 .forEach(identifier => configurationHints.add({ workspaceName, identifier, type: 'ignoreDependencies' }));
             ignoreBinaries
-                .filter(binaryName => IGNORED_GLOBAL_BINARIES.includes(binaryName) || !isReferencedBin(binaryName))
+                .filter(binaryName => IGNORED_GLOBAL_BINARIES.includes(binaryName) ||
+                (workspaceName !== '.' && this.ignoreBinaries.includes(binaryName)) ||
+                !isReferencedBin(binaryName))
                 .forEach(identifier => configurationHints.add({ workspaceName, identifier, type: 'ignoreBinaries' }));
         }
-        return { dependencyIssues, devDependencyIssues, configurationHints };
+        Object.keys(rootIgnoreBinaries)
+            .filter(key => rootIgnoreBinaries[key] === 0)
+            .forEach(identifier => configurationHints.add({ workspaceName: '.', identifier, type: 'ignoreBinaries' }));
+        Object.keys(rootIgnoreDependencies)
+            .filter(key => rootIgnoreDependencies[key] === 0)
+            .forEach(identifier => configurationHints.add({ workspaceName: '.', identifier, type: 'ignoreDependencies' }));
+        return { configurationHints };
     }
 }

package/dist/IssueCollector.d.ts

@@ -21,7 +21,7 @@ export declare class IssueCollector {
     getIssues(): {
         issues: import("./types/issues.js").Issues;
         counters: import("./types/issues.js").Counters;
-        configurationHints: Set<unknown>;
+        configurationHints: Set<ConfigurationHint>;
     };
 }
 export {};

package/dist/IssueCollector.js

@@ -1,5 +1,9 @@
 import { initIssues, initCounters } from './issues/initializers.js';
 import { relative } from './util/path.js';
+function objectInSet(set, obj) {
+    const objJSON = JSON.stringify(obj);
+    return Array.from(set).some(item => JSON.stringify(item) === objJSON);
+}
 export class IssueCollector {
     cwd;
     rules;
@@ -34,7 +38,9 @@ export class IssueCollector {
         }
     }
     addConfigurationHint(issue) {
-        this.configurationHints.add(issue);
+        if (!objectInSet(this.configurationHints, issue)) {
+            this.configurationHints.add(issue);
+        }
     }
     getIssues() {
         return {

package/dist/index.d.ts

@@ -6,5 +6,5 @@ export declare const main: (unresolvedConfiguration: CommandLineOptions) => Prom
     issues: import("./types/issues.js").Issues;
     counters: import("./types/issues.js").Counters;
     rules: import("./types/issues.js").Rules;
-    configurationHints: Set<unknown>;
+    configurationHints: Set<import("./types/issues.js").ConfigurationHint>;
 }>;

package/dist/index.js

@@ -35,6 +35,7 @@ export const main = async (unresolvedConfiguration) => {
     const isReportTypes = report.types || report.nsTypes || report.enumMembers;
     const collector = new IssueCollector({ cwd, rules });
     const enabledPluginsStore = new Map();
+    deputy.addIgnored(chief.config.ignoreBinaries, chief.config.ignoreDependencies);
     debugLogObject('Included workspaces', workspaces);
     const handleReferencedDependency = ({ specifier, containingFilePath, principal, workspace, }) => {
         if (isInternal(specifier)) {
@@ -102,7 +103,7 @@ export const main = async (unresolvedConfiguration) => {
         });
         await worker.init();
         const sharedGlobOptions = { cwd, workingDir: dir, gitignore, ignore: worker.getIgnorePatterns() };
-        const entryPathsFromManifest = await getEntryPathFromManifest(dir, manifest);
+        const entryPathsFromManifest = await getEntryPathFromManifest(cwd, dir, manifest);
         debugLogArray(`Found entry paths from manifest (${name})`, entryPathsFromManifest);
         principal.addEntryPaths(entryPathsFromManifest);
         if (isProduction) {
@@ -199,8 +200,8 @@ export const main = async (unresolvedConfiguration) => {
                         for (const identifier of importItems.symbols) {
                             importedModule.symbols.add(identifier);
                         }
-                        if (importItems.isReExported) {
-                            importedModule.isReExported = importItems.isReExported;
+                        if (importItems.isReExport) {
+                            importedModule.isReExport = importItems.isReExport;
                             importedModule.isReExportedBy.add(filePath);
                         }
                         if (importItems.isDynamic) {
@@ -229,10 +230,10 @@ export const main = async (unresolvedConfiguration) => {
         const isExportedInEntryFile = (importedModule) => {
             if (!importedModule)
                 return false;
-            const { isReExported, isReExportedBy } = importedModule;
+            const { isReExport, isReExportedBy } = importedModule;
             const { entryPaths } = principal;
             const hasFile = (file) => entryPaths.has(file) || isExportedInEntryFile(importedSymbols.get(file));
-            return isReExported ? Array.from(isReExportedBy).some(hasFile) : false;
+            return isReExport ? Array.from(isReExportedBy).some(hasFile) : false;
         };
         streamer.cast('Running async compilers...');
         await principal.runAsyncCompilers();
@@ -262,6 +263,8 @@ export const main = async (unresolvedConfiguration) => {
                         if (principal.isPublicExport(exportedItem))
                             continue;
                         if (importedModule.symbols.has(symbol)) {
+                            if (importedModule.isReExport && isExportedInEntryFile(importedModule))
+                                continue;
                             if (report.enumMembers && exportedItem.type === 'enum' && exportedItem.members) {
                                 principal.findUnusedMembers(filePath, exportedItem.members).forEach(member => {
                                     collector.addIssue({ type: 'enumMembers', filePath, symbol: member, parentSymbol: symbol });
@@ -274,7 +277,7 @@ export const main = async (unresolvedConfiguration) => {
                             }
                             continue;
                         }
-                        if (importedModule.isReExported || importedModule.isStar) {
+                        if (importedModule.isReExport || importedModule.isStar) {
                             const isReExportedByEntryFile = isExportedInEntryFile(importedModule);
                             if (!isReExportedByEntryFile && !principal.hasExternalReferences(filePath, exportedItem)) {
                                 if (['enum', 'type', 'interface'].includes(exportedItem.type)) {
@@ -299,7 +302,8 @@ export const main = async (unresolvedConfiguration) => {
         }
     }
     if (isReportDependencies) {
-        const { dependencyIssues, devDependencyIssues, configurationHints } = deputy.settleDependencyIssues();
+        const { dependencyIssues, devDependencyIssues } = deputy.settleDependencyIssues();
+        const { configurationHints } = deputy.getConfigurationHints();
         dependencyIssues.forEach(issue => collector.addIssue(issue));
         if (!isProduction)
             devDependencyIssues.forEach(issue => collector.addIssue(issue));

package/dist/plugins/eslint/helpers.js

@@ -60,19 +60,15 @@ const resolveExtendsSpecifier = (specifier) => {
         return;
     return resolvePackageName(specifier.startsWith('plugin:') ? 'eslint-plugin' : 'eslint-config', pluginName);
 };
-const getImportPluginDependencies = (settings) => {
-    const knownKeys = ['typescript'];
-    if (Array.isArray(settings))
-        return [];
-    return Object.keys(settings)
-        .filter(key => key !== 'node')
-        .map(key => (knownKeys.includes(key) ? `eslint-import-resolver-${key}` : key));
-};
 const getDependenciesFromSettings = (settings = {}) => {
-    return compact(Object.entries(settings).reduce((packageNames, [settingKey, settings]) => {
-        if (/^import\/(parsers|resolvers)?/.test(settingKey) && typeof settings !== 'string') {
-            return [...packageNames, ...getImportPluginDependencies(settings)];
+    return compact(Object.entries(settings).flatMap(([settingKey, settings]) => {
+        if (settingKey === 'import/resolver') {
+            return (typeof settings === 'string' ? [settings] : Object.keys(settings))
+                .filter(key => key !== 'node')
+                .map(key => `eslint-import-resolver-${key}`);
+        }
+        if (settingKey === 'import/parsers') {
+            return typeof settings === 'string' ? [settings] : Object.keys(settings);
         }
-        return packageNames;
-    }, []));
+    }));
 };

package/dist/types/config.d.ts

@@ -27,6 +27,8 @@ export interface Configuration {
     include: string[];
     exclude: string[];
     ignore: NormalizedGlob;
+    ignoreBinaries: string[];
+    ignoreDependencies: string[];
     ignoreWorkspaces: string[];
     workspaces: Record<string, WorkspaceConfiguration>;
     syncCompilers: SyncCompilers;

package/dist/types/imports.d.ts

@@ -6,7 +6,7 @@ export type ImportedModule = {
     specifier: Specifier;
     symbols: ImportItems;
     isStar: boolean;
-    isReExported: boolean;
+    isReExport: boolean;
     isReExportedBy: Set<string>;
     isDynamic: boolean;
 };

package/dist/typescript/getImportsAndExports.d.ts

@@ -11,6 +11,7 @@ export type AddImportOptions = {
     symbol?: ts.Symbol;
     identifier?: string;
     isDynamic?: boolean;
+    isReExport?: boolean;
 };
 export type AddExportOptions = ExportItem & {
     identifier: string;

package/dist/typescript/getImportsAndExports.js

@@ -20,32 +20,32 @@ export const getImportsAndExports = (sourceFile, options) => {
     const scripts = new Set();
     const importedInternalSymbols = new Map();
     const visitors = getVisitors(sourceFile);
-    const addInternalImport = ({ identifier, specifier, symbol, filePath, isDynamic }) => {
+    const addInternalImport = (options) => {
+        const { identifier, specifier, symbol, filePath, isDynamic, isReExport } = options;
         const isStar = identifier === '*';
-        const isReExported = Boolean(isStar && !symbol);
         const internalImport = getOrSet(internalImports, filePath, {
             specifier,
             isStar,
-            isReExported,
+            isReExport,
             isReExportedBy: new Set(),
             symbols: new Set(),
             isDynamic,
         });
-        if (isReExported) {
-            internalImport.isReExported = isReExported;
+        if (isReExport) {
+            internalImport.isReExport = isReExport;
             internalImport.isReExportedBy.add(sourceFile.fileName);
         }
         if (isStar)
             internalImport.isStar = isStar;
         if (!isStar)
             internalImport.symbols.add(identifier);
-        if (isStar && symbol) {
+        if (isStar && symbol)
             importedInternalSymbols.set(symbol, filePath);
-        }
         if (isDynamic)
             internalImport.isDynamic = isDynamic;
     };
-    const addImport = ({ specifier, symbol, identifier = '__anonymous', isDynamic = false }) => {
+    const addImport = (options) => {
+        const { specifier, symbol, identifier = '__anonymous', isDynamic = false, isReExport = false } = options;
         if (isBuiltin(specifier))
             return;
         const module = sourceFile.resolvedModules?.get(specifier, undefined);
@@ -54,7 +54,7 @@ export const getImportsAndExports = (sourceFile, options) => {
             if (filePath) {
                 if (module.resolvedModule.isExternalLibraryImport) {
                     if (!isInNodeModules(filePath)) {
-                        addInternalImport({ identifier, specifier, symbol, filePath, isDynamic });
+                        addInternalImport({ identifier, specifier, symbol, filePath, isDynamic, isReExport });
                     }
                     else if (isDeclarationFileExtension(module.resolvedModule.extension)) {
                         externalImports.add(specifier);
@@ -64,7 +64,7 @@ export const getImportsAndExports = (sourceFile, options) => {
                     }
                 }
                 else {
-                    addInternalImport({ identifier, specifier, symbol, filePath, isDynamic });
+                    addInternalImport({ identifier, specifier, symbol, filePath, isDynamic, isReExport });
                 }
             }
         }

package/dist/typescript/visitors/imports/reExportDeclaration.js

@@ -4,16 +4,16 @@ export default visit(() => true, node => {
     if (ts.isExportDeclaration(node)) {
         if (node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)) {
             if (!node.exportClause) {
-                return { identifier: '*', specifier: node.moduleSpecifier.text };
+                return { identifier: '*', specifier: node.moduleSpecifier.text, isReExport: true };
             }
             else if (node.exportClause.kind === ts.SyntaxKind.NamespaceExport) {
-                return { identifier: '*', specifier: node.moduleSpecifier.text };
+                return { identifier: '*', specifier: node.moduleSpecifier.text, isReExport: true };
             }
             else {
                 const specifier = node.moduleSpecifier;
                 return node.exportClause.elements.map(element => {
                     const identifier = (element.propertyName ?? element.name).getText();
-                    return { identifier, specifier: specifier.text };
+                    return { identifier, specifier: specifier.text, isReExport: true };
                 });
             }
         }

package/dist/util/modules.d.ts

@@ -4,4 +4,4 @@ export declare const getPackageNameFromFilePath: (value: string) => string;
 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: (dir: string, manifest: PackageJson) => Promise<string[]>;
+export declare const getEntryPathFromManifest: (cwd: string, dir: string, manifest: PackageJson) => Promise<string[]>;

package/dist/util/modules.js

@@ -1,4 +1,4 @@
-import { _pureGlob } from './glob.js';
+import { _glob } from './glob.js';
 import { getStringValues } from './object.js';
 import { toPosix } from './path.js';
 export const getPackageNameFromModuleSpecifier = (moduleSpecifier) => {
@@ -26,7 +26,7 @@ export const getPackageFromDefinitelyTyped = (typedDependency) => {
     }
     return typedDependency;
 };
-export const getEntryPathFromManifest = (dir, manifest) => {
+export const getEntryPathFromManifest = (cwd, dir, manifest) => {
     const { main, bin, exports } = manifest;
     const entryPaths = new Set();
     if (typeof main === 'string')
@@ -45,5 +45,5 @@ export const getEntryPathFromManifest = (dir, manifest) => {
             getStringValues(exports).forEach(item => entryPaths.add(item));
         }
     }
-    return _pureGlob({ cwd: dir, patterns: Array.from(entryPaths) });
+    return _glob({ cwd, workingDir: dir, patterns: Array.from(entryPaths) });
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.9.0";
+export declare const version = "2.10.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.9.0';
+export const version = '2.10.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.9.0",
+  "version": "2.10.0",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",