knip 5.70.0 → 5.70.2

package/dist/WorkspaceWorker.js

@@ -89,15 +89,7 @@ export class WorkspaceWorker {
         if (project.length === 0)
             return [];
         const excludeProductionNegations = project.filter(pattern => !(pattern.startsWith('!') && pattern.endsWith('!')));
-        const negatedPluginConfigPatterns = this.getPluginConfigPatterns().map(negate);
-        const negatedPluginProjectFilePatterns = this.getPluginProjectFilePatterns().map(negate);
-        return [
-            excludeProductionNegations,
-            negatedPluginConfigPatterns,
-            negatedPluginProjectFilePatterns,
-            projectFilePatterns,
-            this.negatedWorkspacePatterns,
-        ].flat();
+        return [excludeProductionNegations, projectFilePatterns, this.negatedWorkspacePatterns].flat();
     }
     getPluginProjectFilePatterns(patterns = []) {
         for (const [pluginName, plugin] of PluginEntries) {
@@ -175,18 +167,10 @@ export class WorkspaceWorker {
         const createGetInputsFromScripts = (containingFilePath) => (scripts, options) => _getInputsFromScripts(scripts, { ...baseOptions, ...options, containingFilePath });
         const inputs = [];
         const remainingPlugins = new Set(this.enabledPlugins);
-        const addInput = (input, containingFilePath = input.containingFilePath) => {
-            if (isConfig(input)) {
-                handleConfigInput(input.pluginName, { ...input, containingFilePath });
-            }
-            else {
-                inputs.push({ ...input, containingFilePath });
-            }
-        };
         const configFilesMap = this.configFilesMap;
         const configFiles = this.configFilesMap.get(wsName);
         const seen = new Map();
-        const handleConfigInput = (pluginName, input) => {
+        const storeConfigFilePath = (pluginName, input) => {
             const configFilePath = this.getReferencedInternalFilePath(input);
             if (configFilePath) {
                 const workspace = this.findWorkspaceByFilePath(configFilePath);
@@ -202,20 +186,26 @@ export class WorkspaceWorker {
         };
         for (const input of [...inputsFromManifest, ...productionInputsFromManifest]) {
             if (isConfig(input)) {
-                handleConfigInput(input.pluginName, { ...input, containingFilePath });
+                storeConfigFilePath(input.pluginName, { ...input, containingFilePath });
             }
-            else {
-                if (!isProduction)
-                    addInput(input, containingFilePath);
-                else if (isProduction && (input.production || hasProductionInput(input)))
-                    addInput(input, containingFilePath);
+            else if (!isProduction || (isProduction && (input.production || hasProductionInput(input)))) {
+                inputs.push({ ...input, containingFilePath });
             }
         }
         const runPlugin = async (pluginName, patterns) => {
             const plugin = Plugins[pluginName];
             const config = this.getConfigForPlugin(pluginName);
             if (!config)
-                return;
+                return [];
+            const inputs = [];
+            const addInput = (input, containingFilePath = input.containingFilePath) => {
+                if (isConfig(input)) {
+                    storeConfigFilePath(input.pluginName, { ...input, containingFilePath });
+                }
+                else {
+                    inputs.push(Object.assign(input, { containingFilePath }));
+                }
+            };
             const label = 'config file';
             const configFilePaths = await _glob({ patterns, cwd: rootCwd, dir: cwd, gitignore: false, label });
             const options = {
@@ -229,7 +219,7 @@ export class WorkspaceWorker {
             if (config.entry) {
                 const toInput = isProduction && plugin.production && plugin.production.length > 0 ? toProductionEntry : toEntry;
                 for (const id of config.entry)
-                    addInput(toInput(id));
+                    inputs.push(toInput(id));
             }
             else if ((!plugin.resolveConfig && !plugin.resolveFromAST) ||
                 (configFilePaths.filter(path => basename(path) !== 'package.json').length === 0 &&
@@ -237,10 +227,10 @@ export class WorkspaceWorker {
                         this.configFilesMap.get(wsName)?.get(pluginName)?.size === 0))) {
                 if (plugin.entry)
                     for (const id of plugin.entry)
-                        addInput(toEntry(id));
+                        inputs.push(toEntry(id));
                 if (plugin.production)
                     for (const id of plugin.production)
-                        addInput(toProductionEntry(id));
+                        inputs.push(toProductionEntry(id));
             }
             for (const configFilePath of configFilePaths) {
                 const isManifest = basename(configFilePath) === 'package.json';
@@ -295,8 +285,8 @@ export class WorkspaceWorker {
                     }
                 }
                 if (!isManifest) {
-                    addInput(toEntry(configFilePath));
-                    addInput(toConfig(pluginName, configFilePath));
+                    inputs.push(toEntry(configFilePath));
+                    storeConfigFilePath(pluginName, toConfig(pluginName, configFilePath));
                     cache.configFile = toEntry(configFilePath);
                     if (fd?.changed && fd.meta && !seen.get(key)?.has(configFilePath)) {
                         fd.meta.data = cache;
@@ -311,13 +301,18 @@ export class WorkspaceWorker {
                 for (const id of dependencies)
                     addInput(id, containingFilePath);
             }
+            if (inputs.some(input => input.specifier.startsWith('!')))
+                for (const input of inputs)
+                    input.group = pluginName;
+            return inputs;
         };
         const enabledPluginTitles = this.enabledPlugins.map(name => Plugins[name].title);
         debugLogObject(this.name, 'Enabled plugins', enabledPluginTitles);
         for (const pluginName of this.enabledPlugins) {
             const patterns = [...this.getConfigurationFilePatterns(pluginName), ...(configFiles?.get(pluginName) ?? [])];
             configFiles?.delete(pluginName);
-            await runPlugin(pluginName, compact(patterns));
+            for (const input of await runPlugin(pluginName, compact(patterns)))
+                inputs.push(input);
             remainingPlugins.delete(pluginName);
         }
         {
@@ -326,11 +321,13 @@ export class WorkspaceWorker {
                 do {
                     for (const [pluginName, dependencies] of configFiles.entries()) {
                         configFiles.delete(pluginName);
-                        if (this.enabledPlugins.includes(pluginName))
-                            await runPlugin(pluginName, Array.from(dependencies));
+                        if (this.enabledPlugins.includes(pluginName)) {
+                            for (const input of await runPlugin(pluginName, Array.from(dependencies)))
+                                inputs.push(input);
+                        }
                         else
                             for (const id of dependencies)
-                                addInput(toEntry(id));
+                                inputs.push(toEntry(id));
                     }
                 } while (remainingPlugins.size > 0 && configFiles.size > 0);
             }

package/dist/graph/build.js

@@ -106,33 +106,34 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
         for (const id of inputsFromPlugins)
             inputs.add(Object.assign(id, { skipExportsAnalysis: !id.allowIncludeExports }));
         enabledPluginsStore.set(name, worker.enabledPlugins);
-        const entryPatterns = new Set();
-        const entryPatternsSkipExports = new Set();
-        const productionPatterns = new Set();
-        const productionPatternsSkipExports = new Set();
+        const DEFAULT_GROUP = 'default';
+        const createPatternMap = () => new Map([[DEFAULT_GROUP, new Set()]]);
+        const groups = new Set([DEFAULT_GROUP]);
+        const entryPatterns = createPatternMap();
+        const entryPatternsSkipExports = createPatternMap();
+        const productionPatterns = createPatternMap();
+        const productionPatternsSkipExports = createPatternMap();
         const projectFilePatterns = new Set();
+        const addPattern = (map, input, pattern) => {
+            if (input.group && !map.has(input.group))
+                map.set(input.group, new Set());
+            map.get(input.group ?? DEFAULT_GROUP).add(pattern);
+        };
+        const toWorkspaceRelative = (path) => (isAbsolute(path) ? relative(dir, path) : path);
         for (const input of inputs) {
+            if (input.group)
+                groups.add(input.group);
             const specifier = input.specifier;
             if (isEntry(input)) {
-                const relativePath = isAbsolute(specifier) ? relative(dir, specifier) : specifier;
-                if (!input.skipExportsAnalysis) {
-                    entryPatterns.add(relativePath);
-                }
-                else {
-                    entryPatternsSkipExports.add(relativePath);
-                }
+                const targetMap = input.skipExportsAnalysis ? entryPatternsSkipExports : entryPatterns;
+                addPattern(targetMap, input, toWorkspaceRelative(specifier));
             }
             else if (isProductionEntry(input)) {
-                const relativePath = isAbsolute(specifier) ? relative(dir, specifier) : specifier;
-                if (!input.skipExportsAnalysis) {
-                    productionPatterns.add(relativePath);
-                }
-                else {
-                    productionPatternsSkipExports.add(relativePath);
-                }
+                const targetMap = input.skipExportsAnalysis ? productionPatternsSkipExports : productionPatterns;
+                addPattern(targetMap, input, toWorkspaceRelative(specifier));
             }
             else if (isProject(input)) {
-                projectFilePatterns.add(isAbsolute(specifier) ? relative(dir, specifier) : specifier);
+                projectFilePatterns.add(toWorkspaceRelative(specifier));
             }
             else if (isAlias(input)) {
                 principal.addPaths({ [input.specifier]: input.prefixes }, input.dir ?? dir);
@@ -150,11 +151,11 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                 const resolvedFilePath = getReferencedInternalFilePath(input, ws);
                 if (resolvedFilePath) {
                     if (isDeferResolveProductionEntry(input)) {
-                        productionPatternsSkipExports.add(resolvedFilePath);
+                        addPattern(productionPatternsSkipExports, input, resolvedFilePath);
                     }
                     else if (isDeferResolveEntry(input)) {
                         if (!options.isProduction || !input.optional)
-                            entryPatternsSkipExports.add(resolvedFilePath);
+                            addPattern(entryPatternsSkipExports, input, resolvedFilePath);
                     }
                     else {
                         principal.addEntryPath(resolvedFilePath, { skipExportsAnalysis: true });
@@ -162,82 +163,63 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                 }
             }
         }
+        const negatedEntryPatterns = [];
         if (options.isProduction) {
-            const negatedEntryPatterns = [...entryPatterns, ...entryPatternsSkipExports].map(negate);
-            {
-                const label = 'entry paths';
-                const patterns = worker.getProductionEntryFilePatterns(negatedEntryPatterns);
-                const workspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, gitignore: false, label });
-                principal.addEntryPaths(workspaceEntryPaths);
+            for (const map of [entryPatterns, entryPatternsSkipExports]) {
+                for (const patterns of map.values())
+                    for (const pattern of patterns)
+                        negatedEntryPatterns.push(negate(pattern));
             }
-            {
-                const label = 'production entry paths from plugins (ignore exports)';
-                const patterns = Array.from(productionPatternsSkipExports);
-                const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
-                principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
+        }
+        {
+            const patterns = options.isProduction
+                ? worker.getProductionEntryFilePatterns(negatedEntryPatterns)
+                : worker.getEntryFilePatterns();
+            const entryPaths = await _glob({ ...sharedGlobOptions, patterns, gitignore: false, label: 'entry paths' });
+            if (!options.isProduction) {
+                const hints = worker.getConfigurationHints('entry', patterns, entryPaths, principal.entryPaths);
+                for (const hint of hints)
+                    collector.addConfigurationHint(hint);
             }
+            principal.addEntryPaths(entryPaths);
+        }
+        for (const group of groups) {
             {
-                const label = 'production entry paths from plugins';
-                const patterns = Array.from(productionPatterns);
+                const patterns = worker.getPluginEntryFilePatterns([
+                    ...((!options.isProduction && entryPatterns.get(group)) || []),
+                    ...((!options.isProduction && group === DEFAULT_GROUP && worker.getPluginConfigPatterns()) || []),
+                    ...(productionPatterns.get(group) ?? []),
+                ]);
+                const label = `entry paths from plugins${group !== DEFAULT_GROUP ? ` - ${group}` : ''}`;
                 const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
                 principal.addEntryPaths(pluginWorkspaceEntryPaths);
             }
             {
-                const label = 'project paths';
-                const patterns = worker.getProductionProjectFilePatterns(negatedEntryPatterns);
-                const workspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns, label });
-                for (const projectPath of workspaceProjectPaths)
-                    principal.addProjectPath(projectPath);
-            }
-        }
-        else {
-            {
-                const label = 'entry paths from plugins (ignore exports)';
                 const patterns = worker.getPluginEntryFilePatterns([
-                    ...entryPatternsSkipExports,
-                    ...productionPatternsSkipExports,
+                    ...((!options.isProduction && entryPatternsSkipExports.get(group)) || []),
+                    ...(productionPatternsSkipExports.get(group) ?? []),
                 ]);
+                const label = `entry paths from plugins (ignore exports)${group !== DEFAULT_GROUP ? ` - ${group}` : ''}`;
                 const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
                 principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
             }
-            {
-                const label = 'entry paths from plugins';
-                const patterns = worker.getPluginEntryFilePatterns([...entryPatterns, ...productionPatterns]);
-                const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
-                principal.addEntryPaths(pluginWorkspaceEntryPaths);
-            }
-            {
-                const label = 'entry paths';
-                const patterns = worker.getEntryFilePatterns();
-                const entryPaths = await _glob({ ...sharedGlobOptions, patterns, gitignore: false, label });
-                const hints = worker.getConfigurationHints('entry', patterns, entryPaths, principal.entryPaths);
-                for (const hint of hints)
-                    collector.addConfigurationHint(hint);
-                principal.addEntryPaths(entryPaths);
-            }
-            {
-                const label = 'project paths from plugins';
-                const patterns = worker.getPluginProjectFilePatterns();
-                const pluginWorkspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns, label });
-                for (const projectPath of pluginWorkspaceProjectPaths)
-                    principal.addProjectPath(projectPath);
-            }
-            {
-                const label = 'plugin configuration paths (ignore exports)';
-                const patterns = worker.getPluginConfigPatterns();
-                const configurationEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
-                principal.addEntryPaths(configurationEntryPaths, { skipExportsAnalysis: true });
-            }
-            {
-                const label = 'project paths';
-                const patterns = worker.getProjectFilePatterns([...productionPatternsSkipExports, ...projectFilePatterns]);
-                const projectPaths = await _glob({ ...sharedGlobOptions, patterns, label });
+        }
+        {
+            const patterns = options.isProduction
+                ? worker.getProductionProjectFilePatterns(negatedEntryPatterns)
+                : worker.getProjectFilePatterns([
+                    ...(productionPatternsSkipExports.get(DEFAULT_GROUP) ?? []),
+                    ...projectFilePatterns,
+                    ...worker.getPluginProjectFilePatterns(),
+                ]);
+            const projectPaths = await _glob({ ...sharedGlobOptions, patterns, label: 'project paths' });
+            if (!options.isProduction) {
                 const hints = worker.getConfigurationHints('project', config.project, projectPaths, principal.projectPaths);
                 for (const hint of hints)
                     collector.addConfigurationHint(hint);
-                for (const projectPath of projectPaths)
-                    principal.addProjectPath(projectPath);
             }
+            for (const projectPath of projectPaths)
+                principal.addProjectPath(projectPath);
         }
         if (options.configFilePath) {
             factory.getPrincipals().at(0)?.addEntryPath(options.configFilePath, { skipExportsAnalysis: true });
@@ -294,13 +276,15 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                 if (!isIgnored)
                     principal.addEntryPath(filePath, { skipExportsAnalysis: true });
             }
-            for (const [_import, specifierFilePath] of file.imports.imports) {
-                const packageName = getPackageNameFromModuleSpecifier(_import.specifier);
-                if (packageName && isInternalWorkspace(packageName)) {
-                    file.imports.external.add({ ..._import, specifier: packageName });
-                    const principal = getPrincipalByFilePath(specifierFilePath);
-                    if (principal && !isGitIgnored(specifierFilePath)) {
-                        principal.addNonEntryPath(specifierFilePath);
+            for (const _import of file.imports.imports) {
+                if (_import.filePath) {
+                    const packageName = getPackageNameFromModuleSpecifier(_import.specifier);
+                    if (packageName && isInternalWorkspace(packageName)) {
+                        file.imports.external.add({ ..._import, specifier: packageName });
+                        const principal = getPrincipalByFilePath(_import.filePath);
+                        if (principal && !isGitIgnored(_import.filePath)) {
+                            principal.addNonEntryPath(_import.filePath);
+                        }
                     }
                 }
             }

package/dist/plugins/astro/index.js

@@ -6,7 +6,6 @@ const enablers = ['astro'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 export const config = ['astro.config.{js,cjs,mjs,ts,mts}'];
 const entry = ['src/content/config.ts', 'src/content.config.ts'];
-const project = ['src/**/*'];
 const production = [
     'src/pages/**/*.{astro,mdx,js,ts}',
     '!src/pages/**/_*',
@@ -42,6 +41,5 @@ const plugin = {
     production,
     resolveFromAST,
     resolve,
-    project,
 };
 export default plugin;

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

@@ -21,10 +21,12 @@ export type ImportMaps = {
 export type ImportMap = Map<FilePath, ImportMaps>;
 export type Import = {
     specifier: string;
-    identifier: string;
+    filePath: string | undefined;
+    identifier: string | undefined;
     pos?: number;
     line?: number;
     col?: number;
+    isTypeOnly: boolean;
 };
 export interface Export {
     identifier: Identifier;
@@ -37,6 +39,7 @@ export interface Export {
     refs: [number, boolean];
     fixes: Fixes;
     symbol?: ts.Symbol;
+    isReExport?: boolean;
 }
 export type ExportMember = {
     identifier: Identifier;
@@ -50,7 +53,7 @@ export type ExportMember = {
     jsDocTags: Tags;
 };
 export type ExportMap = Map<Identifier, Export>;
-export type Imports = Set<[Import, FilePath]>;
+export type Imports = Set<Import>;
 export type FileNode = {
     imports: {
         internal: ImportMap;

package/dist/typescript/get-imports-and-exports.js

@@ -79,7 +79,15 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         const { symbol, filePath, namespace, specifier, modifiers } = options;
         const identifier = options.identifier ?? (modifiers & IMPORT_MODIFIERS.OPAQUE ? OPAQUE : SIDE_EFFECTS);
         const isStar = identifier === IMPORT_STAR;
-        imports.add([{ specifier, identifier, pos: options.pos, line: options.line, col: options.col }, filePath]);
+        imports.add({
+            filePath,
+            specifier,
+            identifier: namespace ?? options.identifier,
+            pos: options.pos,
+            line: options.line,
+            col: options.col,
+            isTypeOnly: !!(modifiers & IMPORT_MODIFIERS.TYPE_ONLY),
+        });
         const file = internal.get(filePath);
         const importMaps = file ?? createImports();
         if (!file)
@@ -105,7 +113,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                     addNsValue(importMaps.importedAs, identifier, nsOrAlias, sourceFile.fileName);
                 }
             }
-            else if (identifier !== SIDE_EFFECTS && identifier !== IMPORT_STAR) {
+            else if (identifier !== IMPORT_STAR) {
                 addValue(importMaps.imported, identifier, sourceFile.fileName);
             }
             if (symbol)
@@ -144,11 +152,13 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                     const pos = node.moduleSpecifier?.getStart() ?? opts.pos;
                     const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos);
                     external.add({
+                        filePath,
                         specifier: sanitizedSpecifier,
                         identifier: opts.identifier ?? SIDE_EFFECTS,
                         pos: opts.pos,
                         line: line + 1,
                         col: character + 2,
+                        isTypeOnly: !!(opts.modifiers & IMPORT_MODIFIERS.TYPE_ONLY),
                     });
                 }
             }
@@ -167,11 +177,13 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
             const pos = 'moduleSpecifier' in node ? node.moduleSpecifier.pos : node.pos;
             const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos);
             unresolved.add({
+                filePath: undefined,
                 specifier: opts.specifier,
                 identifier: opts.identifier ?? SIDE_EFFECTS,
                 pos,
                 line: line + 1,
                 col: character + 2,
+                isTypeOnly: !!(opts.modifiers & IMPORT_MODIFIERS.TYPE_ONLY),
             });
         }
     };

package/dist/typescript/pragmas/custom.js

@@ -17,7 +17,7 @@ export const collectCustomImports = (sourceFile) => {
             const isLocal = isInternal(id) || isAbsolute(id);
             const modifiers = isLocal ? IMPORT_MODIFIERS.ENTRY : IMPORT_MODIFIERS.NONE;
             const offset = match[0].length - match[2].length;
-            const specifier = isLocal ? id : getEnvSpecifier(id);
+            const specifier = isLocal || id === 'node' ? id : getEnvSpecifier(id);
             importNodes.push({ specifier, identifier: undefined, pos: comment.pos + match.index + offset, modifiers });
         }
     }

package/dist/typescript/visitors/dynamic-imports/jsDocType.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { IMPORT_MODIFIERS } from '../../../constants.js';
+import { IMPORT_MODIFIERS, IMPORT_STAR } from '../../../constants.js';
 import { importVisitor as visit } from '../index.js';
 const supportsJSDocImportTag = 'isJSDocImportTag' in ts;
 const getImportSpecifiers = (node) => {
@@ -12,19 +12,35 @@ const getImportSpecifiers = (node) => {
                 imports.push({
                     specifier: importClause.literal.text,
                     identifier,
-                    pos: importClause.literal.pos,
-                    modifiers: IMPORT_MODIFIERS.NONE,
+                    pos: node.qualifier?.getStart() ?? importClause.literal.pos,
+                    modifiers: IMPORT_MODIFIERS.TYPE_ONLY,
                 });
             }
         }
         if (supportsJSDocImportTag && ts.isJSDocImportTag(node) && ts.isStringLiteralLike(node.moduleSpecifier)) {
             const moduleSpecifier = node.moduleSpecifier;
-            imports.push({
-                specifier: moduleSpecifier.text,
-                identifier: undefined,
-                pos: moduleSpecifier.pos,
-                modifiers: IMPORT_MODIFIERS.NONE,
-            });
+            const importClause = node.importClause;
+            if (moduleSpecifier && importClause?.namedBindings && ts.isNamedImportBindings(importClause.namedBindings)) {
+                const bindings = importClause.namedBindings;
+                if (ts.isNamespaceImport(bindings)) {
+                    imports.push({
+                        specifier: moduleSpecifier.text,
+                        identifier: IMPORT_STAR,
+                        pos: bindings.name.getStart(),
+                        modifiers: IMPORT_MODIFIERS.TYPE_ONLY,
+                    });
+                }
+                else {
+                    for (const element of bindings.elements) {
+                        imports.push({
+                            specifier: moduleSpecifier.text,
+                            identifier: String((element.propertyName ?? element.name).escapedText),
+                            pos: element.name.getStart(),
+                            modifiers: IMPORT_MODIFIERS.TYPE_ONLY,
+                        });
+                    }
+                }
+            }
         }
         ts.forEachChild(node, visit);
     }

package/dist/typescript/visitors/dynamic-imports/requireCall.js

@@ -15,7 +15,7 @@ export default visit(() => true, node => {
                 });
                 if (propertyAccessExpression) {
                     const identifier = String(propertyAccessExpression.name.escapedText);
-                    return { identifier, specifier, pos: propertyAccessExpression.name.pos, modifiers };
+                    return { identifier, specifier, pos: propertyAccessExpression.name.getStart(), modifiers };
                 }
                 const variableDeclaration = node.parent;
                 if (ts.isVariableDeclaration(variableDeclaration) &&
@@ -28,7 +28,7 @@ export default visit(() => true, node => {
                             alias,
                             symbol: isTLA ? variableDeclaration.symbol : undefined,
                             specifier,
-                            pos: node.arguments[0].pos,
+                            pos: variableDeclaration.name.getStart(),
                             modifiers,
                         };
                     }
@@ -38,7 +38,7 @@ export default visit(() => true, node => {
                             const identifier = (element.propertyName ?? element.name).getText();
                             const alias = element.propertyName ? element.name.getText() : undefined;
                             const symbol = isTLA ? element.symbol : undefined;
-                            return { identifier, specifier, alias, symbol, pos: element.pos, modifiers };
+                            return { identifier, specifier, alias, symbol, pos: element.name.getStart(), modifiers };
                         });
                     }
                     return { identifier: 'default', specifier, pos: node.arguments[0].pos, modifiers };
@@ -53,7 +53,10 @@ export default visit(() => true, node => {
                         modifiers: IMPORT_MODIFIERS.RE_EXPORT,
                     };
                 }
-                return { identifier: 'default', specifier, pos: node.arguments[0].pos, modifiers };
+                if (ts.isCallExpression(node.parent)) {
+                    return { identifier: 'default', specifier, pos: node.getEnd(), modifiers };
+                }
+                return { identifier: 'default', specifier, pos: node.getStart(), modifiers };
             }
         }
     }

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

@@ -9,6 +9,7 @@ export default visit(() => true, node => {
             return { specifier, identifier: undefined, pos: node.pos, modifiers: IMPORT_MODIFIERS.SIDE_EFFECTS };
         }
         const imports = [];
+        const modifiers = node.importClause.isTypeOnly ? IMPORT_MODIFIERS.TYPE_ONLY : IMPORT_MODIFIERS.NONE;
         if (isDefaultImport(node)) {
             imports.push({
                 identifier: 'default',
@@ -16,7 +17,7 @@ export default visit(() => true, node => {
                 specifier,
                 symbol: node.importClause.symbol,
                 pos: node.importClause.name?.getStart() ?? node.getStart(),
-                modifiers: IMPORT_MODIFIERS.NONE,
+                modifiers,
             });
         }
         if (node.importClause?.namedBindings) {
@@ -27,7 +28,7 @@ export default visit(() => true, node => {
                     specifier,
                     identifier: IMPORT_STAR,
                     pos: node.importClause.namedBindings.name.getStart(),
-                    modifiers: node.importClause?.isTypeOnly ? IMPORT_MODIFIERS.TYPE_ONLY : IMPORT_MODIFIERS.NONE,
+                    modifiers,
                 });
             }
             if (ts.isNamedImports(node.importClause.namedBindings)) {
@@ -38,7 +39,7 @@ export default visit(() => true, node => {
                         specifier,
                         symbol: element.symbol,
                         pos: element.name.getStart(),
-                        modifiers: node.importClause?.isTypeOnly ? IMPORT_MODIFIERS.TYPE_ONLY : IMPORT_MODIFIERS.NONE,
+                        modifiers,
                     });
                 }
             }
@@ -47,7 +48,7 @@ export default visit(() => true, node => {
                     specifier,
                     identifier: undefined,
                     pos: node.importClause.namedBindings.pos,
-                    modifiers: node.importClause?.isTypeOnly ? IMPORT_MODIFIERS.TYPE_ONLY : IMPORT_MODIFIERS.NONE,
+                    modifiers,
                 });
             }
         }

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

@@ -8,7 +8,7 @@ export default visit(() => true, node => {
                 return {
                     identifier: IMPORT_STAR,
                     specifier: node.moduleSpecifier.text,
-                    pos: node.pos,
+                    pos: node.moduleSpecifier.getStart() - 7,
                     modifiers: IMPORT_MODIFIERS.RE_EXPORT,
                 };
             }
@@ -17,7 +17,7 @@ export default visit(() => true, node => {
                     identifier: IMPORT_STAR,
                     namespace: String(node.exportClause.name.text),
                     specifier: node.moduleSpecifier.text,
-                    pos: node.exportClause.name.pos,
+                    pos: node.exportClause.name.getStart(),
                     modifiers: IMPORT_MODIFIERS.RE_EXPORT,
                 };
             }
@@ -28,14 +28,14 @@ export default visit(() => true, node => {
                         identifier: String(element.propertyName.text),
                         alias: String(element.name.text),
                         specifier: specifier.text,
-                        pos: element.pos,
+                        pos: element.propertyName.getStart(),
                         modifiers: IMPORT_MODIFIERS.RE_EXPORT,
                     };
                 }
                 return {
                     identifier: (element.propertyName ?? element.name).getText(),
                     specifier: specifier.text,
-                    pos: element.pos,
+                    pos: element.name.getStart(),
                     modifiers: IMPORT_MODIFIERS.RE_EXPORT,
                 };
             });

package/dist/util/input.d.ts

@@ -10,6 +10,7 @@ export interface Input {
     containingFilePath?: string;
     allowIncludeExports?: boolean;
     skipExportsAnalysis?: boolean;
+    group?: string;
 }
 export interface ConfigInput extends Input {
     type: 'config';

package/dist/util/plugin.d.ts

@@ -4,6 +4,6 @@ export declare const hasDependency: (dependencies: Set<string>, values: (string
 export declare const normalizePluginConfig: (pluginConfig: RawPluginConfiguration) => boolean | {
     config: string[] | null;
     entry: string[] | null;
-    project: string[] | null;
+    project: string[];
 };
 export declare const loadConfigForPlugin: (configFilePath: string, plugin: Plugin, options: PluginOptions, pluginName: string) => Promise<any>;

package/dist/util/plugin.js

@@ -16,9 +16,8 @@ export const hasDependency = (dependencies, values) => values.some(value => {
     return false;
 });
 export const normalizePluginConfig = (pluginConfig) => {
-    if (typeof pluginConfig === 'boolean') {
+    if (typeof pluginConfig === 'boolean')
         return pluginConfig;
-    }
     const isObject = typeof pluginConfig !== 'string' && !Array.isArray(pluginConfig);
     const config = isObject
         ? 'config' in pluginConfig
@@ -28,7 +27,9 @@ export const normalizePluginConfig = (pluginConfig) => {
             ? arrayify(pluginConfig)
             : null;
     const entry = isObject && 'entry' in pluginConfig ? arrayify(pluginConfig.entry) : null;
-    const project = isObject && 'project' in pluginConfig ? arrayify(pluginConfig.project) : entry;
+    const project = isObject && 'project' in pluginConfig
+        ? arrayify(pluginConfig.project)
+        : (entry ?? []).filter(pattern => !pattern.startsWith('!'));
     return { config, entry, project };
 };
 export const loadConfigForPlugin = async (configFilePath, plugin, options, pluginName) => {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.70.0";
+export declare const version = "5.70.2";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.70.0';
+export const version = '5.70.2';

package/package.json

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