knip 5.61.1 → 5.61.3

package/dist/DependencyDeputy.js

@@ -1,5 +1,5 @@
 import { isBuiltin } from 'node:module';
-import { PackageJsonPeeker } from './PackageJsonPeeker.js';
+import { PackagePeeker } from './PackagePeeker.js';
 import { DT_SCOPE, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES, IGNORED_RUNTIME_DEPENDENCIES, IGNORE_DEFINITELY_TYPED, ROOT_WORKSPACE_NAME, } from './constants.js';
 import { getDependencyMetaData } from './manifest/index.js';
 import { getDefinitelyTypedFor, getPackageFromDefinitelyTyped, getPackageNameFromModuleSpecifier, isDefinitelyTyped, } from './util/modules.js';
@@ -176,12 +176,12 @@ export class DependencyDeputy {
         for (const [workspace, { manifestPath: filePath, manifestStr }] of this._manifests.entries()) {
             const referencedDependencies = this.referencedDependencies.get(workspace);
             const hasTypesIncluded = this.getHasTypesIncluded(workspace);
-            const peeker = new PackageJsonPeeker(manifestStr);
-            const peerDepRecs = {};
+            const peeker = new PackagePeeker(manifestStr);
+            const peerDepCount = {};
             const isReferencedDependency = (dependency, isPeerDep) => {
                 if (referencedDependencies?.has(dependency))
                     return true;
-                if (isPeerDep && peerDepRecs[dependency])
+                if (isPeerDep && peerDepCount[dependency])
                     return false;
                 const [scope, typedDependency] = dependency.split('/');
                 if (scope === DT_SCOPE) {
@@ -202,10 +202,10 @@ export class DependencyDeputy {
                 }
                 const hostDependencies = this.getHostDependenciesFor(workspace, dependency);
                 for (const { name } of hostDependencies) {
-                    if (!peerDepRecs[name])
-                        peerDepRecs[name] = 1;
+                    if (!peerDepCount[name])
+                        peerDepCount[name] = 1;
                     else
-                        peerDepRecs[name]++;
+                        peerDepCount[name]++;
                 }
                 return hostDependencies.some(hostDependency => (isPeerDep === false || !hostDependency.isPeerOptional) && isReferencedDependency(hostDependency.name, true));
             };

package/dist/{PackageJsonPeeker.d.ts → PackagePeeker.d.ts}

@@ -1,4 +1,4 @@
-export declare class PackageJsonPeeker {
+export declare class PackagePeeker {
     private manifestStr;
     private lines;
     private sections;

package/dist/{PackageJsonPeeker.js → PackagePeeker.js}

@@ -1,4 +1,4 @@
-export class PackageJsonPeeker {
+export class PackagePeeker {
     manifestStr;
     lines = [];
     sections = {};

package/dist/ProjectPrincipal.d.ts

@@ -50,7 +50,7 @@ export declare class ProjectPrincipal {
     getUsedResolvedFiles(): string[];
     private getProgramSourceFiles;
     getUnreferencedFiles(): string[];
-    analyzeSourceFile(filePath: string, options: Omit<GetImportsAndExportsOptions, 'skipExports'>, isGitIgnored: (filePath: string) => boolean, isInternalWorkspace: (packageName: string) => boolean, getPrincipalByFilePath: (filePath: string) => undefined | ProjectPrincipal): FileNode;
+    analyzeSourceFile(filePath: string, options: Omit<GetImportsAndExportsOptions, 'skipExports'>): FileNode;
     invalidateFile(filePath: string): void;
     findUnusedMembers(filePath: string, members: ExportMember[]): ExportMember[];
     hasExternalReferences(filePath: string, exportedItem: Export): boolean;

package/dist/ProjectPrincipal.js

@@ -1,14 +1,13 @@
 import ts from 'typescript';
 import { CacheConsultant } from './CacheConsultant.js';
 import { getCompilerExtensions } from './compilers/index.js';
-import { ANONYMOUS, DEFAULT_EXTENSIONS, FOREIGN_FILE_EXTENSIONS, PUBLIC_TAG } from './constants.js';
+import { ANONYMOUS, DEFAULT_EXTENSIONS, PUBLIC_TAG } from './constants.js';
 import { SourceFileManager } from './typescript/SourceFileManager.js';
 import { createHosts } from './typescript/create-hosts.js';
 import { _getImportsAndExports } from './typescript/get-imports-and-exports.js';
 import { timerify } from './util/Performance.js';
 import { compact } from './util/array.js';
-import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpecifier } from './util/modules.js';
-import { dirname, extname, isInNodeModules, join, toAbsolute } from './util/path.js';
+import { extname, isInNodeModules, toAbsolute } from './util/path.js';
 const baseCompilerOptions = {
     allowJs: true,
     allowSyntheticDefaultImports: true,
@@ -156,7 +155,7 @@ export class ProjectPrincipal {
         const sourceFiles = this.getProgramSourceFiles();
         return Array.from(this.projectPaths).filter(filePath => !sourceFiles.has(filePath));
     }
-    analyzeSourceFile(filePath, options, isGitIgnored, isInternalWorkspace, getPrincipalByFilePath) {
+    analyzeSourceFile(filePath, options) {
         const fd = this.cache.getFileDescriptor(filePath);
         if (!fd.changed && fd.meta?.data)
             return fd.meta.data;
@@ -168,43 +167,7 @@ export class ProjectPrincipal {
             throw new Error(`Unable to find ${filePath}`);
         const skipExports = this.skipExportsAnalysis.has(filePath);
         const resolve = (specifier) => this.backend.resolveModuleNames([specifier], sourceFile.fileName)[0];
-        const { imports, ...rest } = _getImportsAndExports(sourceFile, resolve, typeChecker, { ...options, skipExports });
-        const { internal, resolved, specifiers, unresolved, external } = imports;
-        const unresolvedImports = new Set();
-        for (const [specifier, specifierFilePath] of specifiers) {
-            const packageName = getPackageNameFromModuleSpecifier(specifier);
-            if (packageName && isInternalWorkspace(packageName)) {
-                external.add(packageName);
-                const principal = getPrincipalByFilePath(specifierFilePath);
-                if (principal && !isGitIgnored(specifierFilePath))
-                    principal.addNonEntryPath(specifierFilePath);
-            }
-        }
-        for (const filePath of resolved) {
-            const isIgnored = isGitIgnored(filePath);
-            if (!isIgnored)
-                this.addEntryPath(filePath, { skipExportsAnalysis: true });
-        }
-        for (const unresolvedImport of unresolved) {
-            const { specifier } = unresolvedImport;
-            if (specifier.startsWith('http'))
-                continue;
-            const sanitizedSpecifier = sanitizeSpecifier(specifier);
-            if (isStartsLikePackageName(sanitizedSpecifier)) {
-                external.add(sanitizedSpecifier);
-            }
-            else {
-                const isIgnored = isGitIgnored(join(dirname(filePath), sanitizedSpecifier));
-                if (!isIgnored) {
-                    const ext = extname(sanitizedSpecifier);
-                    const hasIgnoredExtension = FOREIGN_FILE_EXTENSIONS.has(ext);
-                    if (!ext || (ext !== '.json' && !hasIgnoredExtension)) {
-                        unresolvedImports.add(unresolvedImport);
-                    }
-                }
-            }
-        }
-        return { imports: { internal, unresolved: unresolvedImports, external }, ...rest };
+        return _getImportsAndExports(sourceFile, resolve, typeChecker, { ...options, skipExports });
     }
     invalidateFile(filePath) {
         this.backend.fileManager.snapshotCache.delete(filePath);

package/dist/WorkspaceWorker.d.ts

@@ -29,6 +29,7 @@ type WorkspaceManagerOptions = {
 type CacheItem = {
     resolveConfig?: Input[];
     resolveFromAST?: Input[];
+    configFile?: Input;
 };
 export declare class WorkspaceWorker {
     name: string;

package/dist/WorkspaceWorker.js

@@ -262,6 +262,8 @@ export class WorkspaceWorker {
                     if (data.resolveFromAST)
                         for (const id of data.resolveFromAST)
                             addInput(id, configFilePath);
+                    if (data.configFile)
+                        addInput(data.configFile);
                     continue;
                 }
                 const resolveOpts = {
@@ -276,7 +278,8 @@ export class WorkspaceWorker {
                 if (plugin.resolveConfig && !seen.get(key)?.has(configFilePath)) {
                     if (typeof plugin.setup === 'function')
                         await plugin.setup(resolveOpts);
-                    const localConfig = await loadConfigForPlugin(configFilePath, plugin, resolveOpts, pluginName);
+                    const isLoad = typeof plugin.isLoadConfig === 'function' ? plugin.isLoadConfig(resolveOpts, this.dependencies) : true;
+                    const localConfig = isLoad && (await loadConfigForPlugin(configFilePath, plugin, resolveOpts, pluginName));
                     if (localConfig) {
                         const inputs = await plugin.resolveConfig(localConfig, resolveOpts);
                         for (const input of inputs)
@@ -300,15 +303,17 @@ export class WorkspaceWorker {
                         cache.resolveFromAST = inputs;
                     }
                 }
-                if (basename(configFilePath) !== 'package.json') {
+                if (!isManifest) {
                     addInput(toEntry(configFilePath));
                     addInput(toConfig(pluginName, configFilePath));
+                    cache.configFile = toEntry(configFilePath);
+                    if (fd?.changed && fd.meta && !seen.get(key)?.has(configFilePath)) {
+                        fd.meta.data = cache;
+                    }
                     if (!seen.has(key))
                         seen.set(key, new Set());
                     seen.get(key)?.add(configFilePath);
                 }
-                if (!isManifest && fd?.changed && fd.meta)
-                    fd.meta.data = cache;
             }
             if (plugin.resolve) {
                 const dependencies = (await plugin.resolve(options)) ?? [];

package/dist/binaries/bash-parser.js

@@ -48,7 +48,7 @@ export const getDependenciesFromScript = (script, options) => {
                     .map(arg => parseNodeArgs(arg.split(' ')))
                     .filter(args => args.require)
                     .flatMap(arg => arg.require)
-                    .map(toDeferResolve) ?? [];
+                    .map(id => toDeferResolve(id)) ?? [];
                 if (binary in PackageManagerResolvers) {
                     const resolver = PackageManagerResolvers[binary];
                     return resolver(binary, args, { ...options, fromArgs });

package/dist/binaries/plugins.js

@@ -61,8 +61,8 @@ export const resolve = (binary, _args, options) => {
     return [
         toBinary(binary, inputOpts),
         ...positionals,
-        ...resolved.map(toDeferResolve),
-        ...resolvedImports.map(toDeferResolve),
+        ...resolved.map(id => toDeferResolve(id)),
+        ...resolvedImports.map(id => toDeferResolve(id)),
         ...resolvedFromArgs,
         ...configFilePaths,
     ];

package/dist/graph/build.js

@@ -1,15 +1,16 @@
 import { WorkspaceWorker } from '../WorkspaceWorker.js';
 import { _getInputsFromScripts } from '../binaries/index.js';
 import { getCompilerExtensions, getIncludedCompilers } from '../compilers/index.js';
-import { DEFAULT_EXTENSIONS } from '../constants.js';
+import { DEFAULT_EXTENSIONS, FOREIGN_FILE_EXTENSIONS } from '../constants.js';
 import { perfObserver } from '../util/Performance.js';
 import { debugLog, debugLogArray } from '../util/debug.js';
 import { getReferencedInputsHandler } from '../util/get-referenced-inputs.js';
 import { _glob, negate } from '../util/glob.js';
 import { isAlias, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isIgnore, isProductionEntry, isProject, toProductionEntry, } from '../util/input.js';
 import { getOrCreateFileNode, updateImportMap } from '../util/module-graph.js';
+import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
 import { getEntryPathsFromManifest } from '../util/package-json.js';
-import { dirname, isAbsolute, join, relative, toRelative } from '../util/path.js';
+import { dirname, extname, isAbsolute, join, relative, toRelative } from '../util/path.js';
 import { augmentWorkspace, getToSourcePathHandler, getToSourcePathsHandler } from '../util/to-source-path.js';
 import { loadTSConfig } from '../util/tsconfig-loader.js';
 export async function build({ cacheLocation, chief, collector, cwd, deputy, factory, gitignore, isCache, isFixExports, isFixTypes, isGitIgnored, isIsolateWorkspaces, isProduction, isSkipLibs, isStrict, isWatch, report, streamer, tags, tsConfigFile, workspaces, }) {
@@ -250,37 +251,68 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
         analyzedFiles.add(filePath);
         const workspace = chief.findWorkspaceByFilePath(filePath);
         if (workspace) {
-            const { imports, exports, duplicates, scripts, traceRefs } = principal.analyzeSourceFile(filePath, {
+            const file = principal.analyzeSourceFile(filePath, {
                 skipTypeOnly: isStrict,
                 isFixExports,
                 isFixTypes,
                 ignoreExportsUsedInFile: chief.config.ignoreExportsUsedInFile,
                 isReportClassMembers,
                 tags,
-            }, isGitIgnored, isInternalWorkspace, getPrincipalByFilePath);
-            const node = getOrCreateFileNode(graph, filePath);
-            node.imports = imports;
-            node.exports = exports;
-            node.duplicates = duplicates;
-            node.scripts = scripts;
-            node.traceRefs = traceRefs;
-            updateImportMap(node, imports.internal, graph);
-            node.internalImportCache = imports.internal;
-            graph.set(filePath, node);
-            if (scripts && scripts.size > 0) {
+            });
+            const _unresolved = new Set();
+            for (const unresolvedImport of file.imports.unresolved) {
+                const { specifier } = unresolvedImport;
+                if (specifier.startsWith('http'))
+                    continue;
+                const sanitizedSpecifier = sanitizeSpecifier(specifier);
+                if (isStartsLikePackageName(sanitizedSpecifier)) {
+                    file.imports.external.add(sanitizedSpecifier);
+                }
+                else {
+                    const isIgnored = isGitIgnored(join(dirname(filePath), sanitizedSpecifier));
+                    if (!isIgnored) {
+                        const ext = extname(sanitizedSpecifier);
+                        const hasIgnoredExtension = FOREIGN_FILE_EXTENSIONS.has(ext);
+                        if (!ext || (ext !== '.json' && !hasIgnoredExtension))
+                            _unresolved.add(unresolvedImport);
+                    }
+                }
+            }
+            for (const filePath of file.imports.resolved) {
+                const isIgnored = isGitIgnored(filePath);
+                if (!isIgnored)
+                    principal.addEntryPath(filePath, { skipExportsAnalysis: true });
+            }
+            for (const [specifier, specifierFilePath] of file.imports.specifiers) {
+                const packageName = getPackageNameFromModuleSpecifier(specifier);
+                if (packageName && isInternalWorkspace(packageName)) {
+                    file.imports.external.add(packageName);
+                    const principal = getPrincipalByFilePath(specifierFilePath);
+                    if (principal && !isGitIgnored(specifierFilePath)) {
+                        principal.addNonEntryPath(specifierFilePath);
+                    }
+                }
+            }
+            if (file.scripts && file.scripts.size > 0) {
                 const dependencies = deputy.getDependencies(workspace.name);
                 const manifestScriptNames = new Set(Object.keys(chief.getManifestForWorkspace(workspace.name)?.scripts ?? {}));
                 const dir = dirname(filePath);
                 const options = { cwd: dir, rootCwd: cwd, containingFilePath: filePath, dependencies, manifestScriptNames };
-                const inputs = _getInputsFromScripts(scripts, options);
+                const inputs = _getInputsFromScripts(file.scripts, options);
                 for (const input of inputs) {
                     input.containingFilePath ??= filePath;
                     input.dir ??= dir;
                     const specifierFilePath = getReferencedInternalFilePath(input, workspace);
                     if (specifierFilePath)
-                        analyzeSourceFile(specifierFilePath, principal);
+                        principal.addEntryPath(specifierFilePath, { skipExportsAnalysis: true });
                 }
             }
+            const node = getOrCreateFileNode(graph, filePath);
+            file.imports.unresolved = _unresolved;
+            Object.assign(node, file);
+            updateImportMap(node, file.imports.internal, graph);
+            node.internalImportCache = file.imports.internal;
+            graph.set(filePath, node);
         }
     };
     for (let i = 0; i < principals.length; ++i) {

package/dist/plugins/_template/index.js

@@ -8,7 +8,7 @@ const entry = [];
 const production = [];
 const resolveConfig = async (config) => {
     const inputs = config?.plugins ?? [];
-    return [...inputs].map(toDeferResolve);
+    return [...inputs].map(id => toDeferResolve(id));
 };
 export default {
     title,

package/dist/plugins/babel/index.js

@@ -5,14 +5,19 @@ import { api, resolveName } from './helpers.js';
 const title = 'Babel';
 const enablers = [/^@babel\//];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['babel.config.{json,js,cjs,mjs,cts}', '.babelrc.{json,js,cjs,mjs,cts}', '.babelrc', 'package.json'];
+const config = ['babel.config.{json,js,cjs,mjs,cts,ts}', '.babelrc.{json,js,cjs,mjs,cts}', '.babelrc', 'package.json'];
 const getName = (value) => [Array.isArray(value) ? value[0] : value].filter(name => typeof name === 'string');
 export const getDependenciesFromConfig = (config) => {
     const presets = config.presets?.flatMap(getName).map(name => resolveName(name, 'preset')) ?? [];
     const plugins = config.plugins?.flatMap(getName).map(name => resolveName(name, 'plugin')) ?? [];
     const nested = config.env ? Object.values(config.env).flatMap(getDependenciesFromConfig) : [];
     const overrides = config.overrides ? [config.overrides].flat().flatMap(getDependenciesFromConfig) : [];
-    return compact([...presets.map(toDeferResolve), ...plugins.map(toDeferResolve), ...nested, ...overrides]);
+    return compact([
+        ...presets.map(id => toDeferResolve(id)),
+        ...plugins.map(id => toDeferResolve(id)),
+        ...nested,
+        ...overrides,
+    ]);
 };
 const resolveConfig = async (config) => {
     if (typeof config === 'function')

package/dist/plugins/biome/index.js

@@ -1,16 +1,11 @@
 import { toConfig } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Biome';
-const enablers = ['@biomejs/biome', 'biome'];
+const enablers = ['@biomejs/biome'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['biome.json', 'biome.jsonc'];
 const resolveExtends = (extendsArray, options) => {
-    return extendsArray.map(specifier => {
-        if (specifier.endsWith('.json') || specifier.endsWith('.jsonc')) {
-            return toConfig('biome', specifier);
-        }
-        return toConfig('biome', specifier, { containingFilePath: options.configFilePath });
-    });
+    return extendsArray.map(specifier => toConfig('biome', specifier, { containingFilePath: options.configFilePath }));
 };
 const resolveConfig = (config, options) => {
     return [...resolveExtends(config.extends || [], options)];

package/dist/plugins/cspell/index.js

@@ -10,7 +10,7 @@ const config = [
     'c{s,S}pell.json',
 ];
 const resolveConfig = config => {
-    return [config?.import ?? []].flat().map(toDeferResolve);
+    return [config?.import ?? []].flat().map(id => toDeferResolve(id));
 };
 export default {
     title,

package/dist/plugins/cucumber/index.js

@@ -9,7 +9,7 @@ const resolveConfig = config => {
     const imports = (config?.import ? config.import : entry).map(id => toEntry(id));
     const formatters = config?.format ? config.format : [];
     const requires = config?.require ? config.require : [];
-    return imports.concat([...formatters, ...requires].map(toDeferResolve));
+    return imports.concat([...formatters, ...requires].map(id => toDeferResolve(id)));
 };
 export default {
     title,

package/dist/plugins/cypress/index.js

@@ -18,7 +18,7 @@ const resolveConfig = async (localConfig, options) => {
     const supportFiles = [localConfig.e2e?.supportFile || [], localConfig.component?.supportFile || []].flat();
     const inputs = await resolveDependencies(localConfig, options);
     return [
-        ...inputs.map(toDeferResolve),
+        ...inputs.map(id => toDeferResolve(id)),
         ...(specPatterns.length > 0 ? specPatterns : TEST_FILE_PATTERNS).map(id => toEntry(id)),
         ...(supportFiles.length > 0 ? supportFiles : SUPPORT_FILE_PATTERNS).map(id => toEntry(id)),
     ];

package/dist/plugins/eslint/helpers.js

@@ -9,7 +9,7 @@ export const getInputs = (config, options) => {
         return getInputsDeprecated(config, options);
     }
     const dependencies = config.flatMap(config => config.settings ? getDependenciesFromSettings(config.settings).filter(id => id !== '@typescript-eslint/parser') : []);
-    return compact(dependencies).map(id => toDeferResolve(id));
+    return compact(dependencies).map(id => toDeferResolve(id, { optional: true }));
 };
 const getInputsDeprecated = (config, options) => {
     const extendsSpecifiers = config.extends ? compact([config.extends].flat().map(resolveExtendSpecifier)) : [];
@@ -24,7 +24,7 @@ const getInputsDeprecated = (config, options) => {
     const settings = config.settings ? getDependenciesFromSettings(config.settings) : [];
     const rules = getDependenciesFromRules({});
     const overrides = config.overrides ? [config.overrides].flat().flatMap(d => getInputsDeprecated(d, options)) : [];
-    const deferred = compact([...extendsSpecifiers, ...plugins, parser, ...settings, ...rules]).map(toDeferResolve);
+    const deferred = compact([...extendsSpecifiers, ...plugins, parser, ...settings, ...rules]).map(id => toDeferResolve(id));
     return [...extendConfigs, ...deferred, ...babelDependencies, ...overrides];
 };
 const isQualifiedSpecifier = (specifier) => specifier === 'eslint' ||

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
+import type { IsLoadConfig, IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { ESLintConfigDeprecated } from './types.js';
 export declare const docs: {
     note: string;
@@ -8,8 +8,8 @@ declare const _default: {
     enablers: string[];
     isEnabled: IsPluginEnabled;
     packageJsonPath: string;
-    entry: string[];
     config: string[];
+    isLoadConfig: IsLoadConfig;
     resolveConfig: ResolveConfig<ESLintConfigDeprecated>;
 };
 export default _default;

package/dist/plugins/eslint/index.js

@@ -5,24 +5,29 @@ const enablers = ['eslint', '@eslint/js'];
 const isEnabled = ({ dependencies, manifest }) => hasDependency(dependencies, enablers) ||
     Boolean(manifest.name && /(^eslint-config|\/eslint-config)/.test(manifest.name));
 const packageJsonPath = 'eslintConfig';
-const entry = ['eslint.config.{js,cjs,mjs,ts,cts,mts}'];
-const config = ['.eslintrc', '.eslintrc.{js,json,cjs}', '.eslintrc.{yml,yaml}', 'package.json'];
+const config = [
+    'eslint.config.{js,cjs,mjs,ts,cts,mts}',
+    '.eslintrc',
+    '.eslintrc.{js,json,cjs}',
+    '.eslintrc.{yml,yaml}',
+    'package.json',
+];
+const isLoadConfig = ({ manifest }, dependencies) => {
+    const version = manifest.devDependencies?.['eslint'] || manifest.dependencies?.['eslint'];
+    if (version) {
+        const major = version.match(/\d+/);
+        if (major && Number.parseInt(major[0], 10) === 9 && dependencies.has('eslint-config-next')) {
+            return false;
+        }
+    }
+    return true;
+};
 const resolveConfig = (localConfig, options) => getInputs(localConfig, options);
 const note = `### ESLint v9
 
-Only regular \`import\` statements are considered by default.
-The configuration object is not resolved to find dependencies for \`settings\` such as \`"eslint-import-resolver-typescript"\`.
-To enable this, lift the \`entry\` to a \`config\` file like so:
-
-\`\`\`json
-{
-  "eslint": ["eslint.config.ts"]
-}
-\`\`\`
-
-This is not enabled by default, since this exception may be thrown by a \`@rushstack/eslint-*\` package:
+The ESLint plugin config resolver is disabled when using \`eslint-config-next\` (\`next lint\`).
 
-> \`Error: Failed to patch ESLint because the calling module was not recognized.\`
+Root cause: [microsoft/rushstack#4965](https://github.com/microsoft/rushstack/issues/4965)/[#5049](https://github.com/microsoft/rushstack/issues/5049)
 
 ### ESLint v8
 
@@ -41,7 +46,7 @@ export default {
     enablers,
     isEnabled,
     packageJsonPath,
-    entry,
     config,
+    isLoadConfig,
     resolveConfig,
 };

package/dist/plugins/gatsby/index.js

@@ -17,7 +17,7 @@ const resolveConfig = async (localConfig, options) => {
     if (/gatsby-config/.test(configFileName)) {
         return localConfig.plugins
             .map(plugin => (typeof plugin === 'string' ? plugin : plugin.resolve))
-            .map(toDeferResolve);
+            .map(id => toDeferResolve(id));
     }
     if (/gatsby-node/.test(configFileName)) {
         const plugins = new Set();

package/dist/plugins/index.d.ts

@@ -179,8 +179,8 @@ export declare const Plugins: {
         enablers: string[];
         isEnabled: import("../types/config.js").IsPluginEnabled;
         packageJsonPath: string;
-        entry: string[];
         config: string[];
+        isLoadConfig: import("../types/config.js").IsLoadConfig;
         resolveConfig: import("../types/config.js").ResolveConfig<import("./eslint/types.js").ESLintConfigDeprecated>;
     };
     expo: {

package/dist/plugins/karma/index.js

@@ -1,5 +1,5 @@
 import { toEntry } from '../../util/input.js';
-import { join } from '../../util/path.js';
+import { isAbsolute, join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { configFiles, inputsFromFrameworks, inputsFromPlugins, loadConfig } from './helpers.js';
 const title = 'Karma';
@@ -19,12 +19,14 @@ const resolveConfig = async (localConfig, options) => {
     if (config.files) {
         for (const fileOrPatternObj of config.files) {
             const fileOrPattern = typeof fileOrPatternObj === 'string' ? fileOrPatternObj : fileOrPatternObj.pattern;
-            inputs.add(toEntry(join(options.configFileDir, basePath, fileOrPattern)));
+            const absPath = isAbsolute(fileOrPattern) ? fileOrPattern : join(options.configFileDir, basePath, fileOrPattern);
+            inputs.add(toEntry(absPath));
         }
     }
     if (config.exclude) {
         for (const fileOrPattern of config.exclude) {
-            inputs.add(toEntry(`!${join(options.configFileDir, basePath, fileOrPattern)}`));
+            const absPath = isAbsolute(fileOrPattern) ? fileOrPattern : join(options.configFileDir, basePath, fileOrPattern);
+            inputs.add(toEntry(`!${absPath}`));
         }
     }
     return Array.from(inputs);

package/dist/plugins/linthtml/index.js

@@ -9,7 +9,7 @@ const config = ['package.json', ...toCosmiconfig('linthtml')];
 const resolveConfig = config => {
     const extensions = config.extends ?? [];
     const plugins = config.plugins ?? [];
-    return [extensions, plugins].flat().map(toDeferResolve);
+    return [extensions, plugins].flat().map(id => toDeferResolve(id));
 };
 export default {
     title,

package/dist/plugins/metro/index.js

@@ -35,7 +35,7 @@ const resolveConfig = async (config) => {
         inputs.push(transformer.minifierPath);
     if (transformer?.babelTransformerPath)
         inputs.push(transformer.babelTransformerPath);
-    return Array.from(i).concat([...inputs].map(toDeferResolve));
+    return Array.from(i).concat([...inputs].map(id => toDeferResolve(id)));
 };
 const note = `False positives for platform-specific unused files?
 Override the default \`entry\` patterns to match platforms and extensions.`;

package/dist/plugins/node/index.js

@@ -21,7 +21,19 @@ const args = {
     positional: true,
     nodeImportArgs: true,
     resolve: ['test-reporter'],
-    boolean: ['deprecation', 'experimental-strip-types', 'harmony', 'test-only', 'test', 'warnings', 'watch'],
+    boolean: [
+        'deprecation',
+        'experimental-strip-types',
+        'experimental-transform-types',
+        'harmony',
+        'inspect-brk',
+        'inspect-wait',
+        'inspect',
+        'test-only',
+        'test',
+        'warnings',
+        'watch',
+    ],
     args: (args) => args.filter(arg => !/--test-reporter[= ](spec|tap|dot|junit|lcov)/.test(arg)),
 };
 export default {

package/dist/plugins/nyc/index.js

@@ -7,7 +7,7 @@ const config = ['.nycrc', '.nycrc.{json,yml,yaml}', 'nyc.config.js', 'package.js
 const resolveConfig = config => {
     const extend = config?.extends ?? [];
     const requires = config?.require ?? [];
-    return [extend, requires].flat().map(toDeferResolve);
+    return [extend, requires].flat().map(id => toDeferResolve(id));
 };
 export default {
     title,

package/dist/plugins/playwright/index.js

@@ -24,7 +24,7 @@ export const resolveConfig = async (localConfig, options) => {
     });
     return projects
         .flatMap(config => toEntryPatterns(config.testMatch ?? entry, cwd, configFileDir, config, localConfig))
-        .concat(reporters.map(toDeferResolve));
+        .concat(reporters.map(id => toDeferResolve(id)));
 };
 const args = {
     binaries: ['playwright'],

package/dist/plugins/postcss/index.js

@@ -19,7 +19,7 @@ const resolveConfig = config => {
             return [];
         })
         : [];
-    const inputs = plugins.map(toDeferResolve);
+    const inputs = plugins.map(id => toDeferResolve(id));
     return ['tailwindcss', '@tailwindcss/postcss'].some(tailwindPlugin => plugins.includes(tailwindPlugin))
         ? [...inputs, toDependency('postcss')]
         : inputs;

package/dist/plugins/react-cosmos/index.js

@@ -18,7 +18,7 @@ const resolveConfig = async (localConfig) => {
     ];
     return [...entries, ...decoratorEntry]
         .map(id => toEntry(id))
-        .concat((localConfig?.plugins ?? []).map(toDeferResolve));
+        .concat((localConfig?.plugins ?? []).map(id => toDeferResolve(id)));
 };
 export default {
     title,

package/dist/plugins/remark/index.js

@@ -15,7 +15,7 @@ const resolveConfig = config => {
         return [];
     })
         .map(plugin => (plugin.startsWith('remark-') ? plugin : `remark-${plugin}`)) ?? [];
-    return plugins.map(toDeferResolve);
+    return plugins.map(id => toDeferResolve(id));
 };
 export default {
     title,

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

@@ -15,7 +15,7 @@ const excludePackages = [
 ];
 const resolveConfig = config => {
     const plugins = (config?.plugins ?? []).map(plugin => (Array.isArray(plugin) ? plugin[0] : plugin));
-    return plugins.filter(plugin => !excludePackages.includes(plugin)).map(toDeferResolve);
+    return plugins.filter(plugin => !excludePackages.includes(plugin)).map(id => toDeferResolve(id));
 };
 export default {
     title,

package/dist/plugins/storybook/index.js

@@ -33,7 +33,7 @@ const resolveConfig = async (localConfig, options) => {
     const frameworks = framework ? [framework] : [];
     return [
         ...patterns.map(id => toEntry(id)),
-        ...addons.map(toDeferResolve),
+        ...addons.map(id => toDeferResolve(id)),
         ...builderPackages.map(id => toDependency(id)),
         ...frameworks.map(id => toDependency(id)),
     ];

package/dist/plugins/stryker/index.js

@@ -10,7 +10,7 @@ const resolveConfig = localConfig => {
         ? localConfig.checkers.map(checker => `@stryker-mutator/${checker}-checker`)
         : [];
     const plugins = localConfig.plugins ?? [];
-    return [...runners, ...checkers, ...plugins].map(toDeferResolve);
+    return [...runners, ...checkers, ...plugins].map(id => toDeferResolve(id));
 };
 export default {
     title,

package/dist/plugins/typedoc/index.js

@@ -16,7 +16,7 @@ const resolveConfig = config => {
     const cfg = 'typedocOptions' in config ? config.typedocOptions : config;
     const plugins = cfg?.plugin ?? [];
     const themes = cfg?.theme ?? [];
-    return [...plugins, ...themes].map(toDeferResolve);
+    return [...plugins, ...themes].map(id => toDeferResolve(id));
 };
 const args = {
     resolve: ['plugin', 'theme'],

package/dist/plugins/typescript/index.js

@@ -24,7 +24,12 @@ const resolveConfig = async (localConfig, options) => {
         ? compilerOptions.plugins.map(plugin => (typeof plugin === 'object' && 'name' in plugin ? plugin.name : ''))
         : [];
     const importHelpers = compilerOptions?.importHelpers ? ['tslib'] : [];
-    return compact([...extend, ...references, ...[...types, ...plugins, ...importHelpers].map(toDeferResolve), ...jsx]);
+    return compact([
+        ...extend,
+        ...references,
+        ...[...types, ...plugins, ...importHelpers].map(id => toDeferResolve(id)),
+        ...jsx,
+    ]);
 };
 const args = {
     binaries: ['tsc'],

package/dist/types/config.d.ts

@@ -92,6 +92,7 @@ export interface PluginOptions extends BaseOptions {
 }
 type PluginSetup = (options: PluginOptions) => Promise<void> | void;
 type PluginTeardown = (options: PluginOptions) => Promise<void> | void;
+export type IsLoadConfig = (options: PluginOptions, dependencies: Set<string>) => boolean;
 export type ResolveConfig<T = any> = (config: T, options: PluginOptions) => Promise<Input[]> | Input[];
 export type Resolve = (options: PluginOptions) => Promise<Input[]> | Input[];
 export type GetSourceFile = (filePath: string) => ts.SourceFile | undefined;
@@ -113,6 +114,7 @@ export interface Plugin {
     project?: string[];
     setup?: PluginSetup;
     teardown?: PluginTeardown;
+    isLoadConfig?: IsLoadConfig;
     resolveConfig?: ResolveConfig;
     resolve?: Resolve;
     resolveFromAST?: ResolveFromAST;

package/dist/types/module-graph.d.ts

@@ -55,6 +55,8 @@ export type FileNode = {
         internal: ImportMap;
         external: Set<string>;
         unresolved: Set<UnresolvedImport>;
+        resolved: Set<FilePath>;
+        specifiers: Set<[string, FilePath]>;
     };
     exports: ExportMap;
     duplicates: Iterable<Array<IssueSymbol>>;

package/dist/typescript/get-imports-and-exports.d.ts

@@ -1,18 +1,5 @@
 import ts from 'typescript';
 import type { GetImportsAndExportsOptions } from '../types/config.js';
-import type { IssueSymbol } from '../types/issues.js';
-import type { ExportMap, ImportMap, UnresolvedImport } from '../types/module-graph.js';
+import type { FileNode } from '../types/module-graph.js';
 import type { BoundSourceFile } from './SourceFile.js';
-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>;
-    };
-    exports: ExportMap;
-    duplicates: IssueSymbol[][];
-    scripts: Set<string>;
-    traceRefs: Set<string>;
-};
+export declare const _getImportsAndExports: (sourceFile: BoundSourceFile, resolveModule: (specifier: string) => ts.ResolvedModuleFull | undefined, typeChecker: ts.TypeChecker, options: GetImportsAndExportsOptions) => FileNode;

package/dist/util/input.d.ts

@@ -44,7 +44,7 @@ export declare const isConfig: (input: Input) => input is ConfigInput;
 export declare const toDependency: (specifier: string, options?: Options) => Input;
 export declare const isDependency: (input: Input) => boolean;
 export declare const toProductionDependency: (specifier: string) => Input;
-export declare const toDeferResolve: (specifier: string) => Input;
+export declare const toDeferResolve: (specifier: string, options?: Options) => Input;
 export declare const isDeferResolve: (input: Input) => boolean;
 export declare const toDeferResolveProductionEntry: (specifier: string, options?: Options) => Input;
 export declare const isDeferResolveProductionEntry: (input: Input) => boolean;

package/dist/util/input.js

@@ -35,7 +35,11 @@ export const toProductionDependency = (specifier) => ({
     specifier,
     production: true,
 });
-export const toDeferResolve = (specifier) => ({ type: 'deferResolve', specifier });
+export const toDeferResolve = (specifier, options = {}) => ({
+    type: 'deferResolve',
+    specifier,
+    ...options,
+});
 export const isDeferResolve = (input) => input.type === 'deferResolve';
 export const toDeferResolveProductionEntry = (specifier, options = {}) => ({
     type: 'deferResolveEntry',

package/dist/util/module-graph.js

@@ -35,6 +35,8 @@ const createFileNode = () => ({
         internal: new Map(),
         external: new Set(),
         unresolved: new Set(),
+        resolved: new Set(),
+        specifiers: new Set(),
     },
     exports: new Map(),
     duplicates: new Set(),

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.61.1";
+export declare const version = "5.61.3";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.61.1';
+export const version = '5.61.3';

package/package.json

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