knip 5.77.3 → 5.78.0

package/dist/IssueCollector.js

@@ -1,8 +1,16 @@
 import picomatch from 'picomatch';
+import { partition } from './util/array.js';
 import { initCounters, initIssues } from './util/issue-initializers.js';
-import { timerify } from './util/Performance.js';
 import { join, relative } from './util/path.js';
-const isMatch = timerify(picomatch.isMatch, 'isMatch');
+const createMatcher = (patterns) => {
+    const [negated, positive] = partition(patterns, p => p[0] === '!');
+    if (positive.length === 0) {
+        if (negated.length === 0)
+            return () => false;
+        return picomatch(negated, { dot: true });
+    }
+    return picomatch(positive, { dot: true, ignore: negated.map(p => p.slice(1)) });
+};
 export class IssueCollector {
     cwd;
     rules;
@@ -27,14 +35,12 @@ export class IssueCollector {
     addIgnorePatterns(patterns) {
         for (const pattern of patterns)
             this.ignorePatterns.add(pattern);
-        const p = [...this.ignorePatterns];
-        this.isMatch = (filePath) => isMatch(filePath, p, { dot: true });
+        this.isMatch = createMatcher(this.ignorePatterns);
     }
     addIgnoreFilesPatterns(patterns) {
         for (const pattern of patterns)
             this.ignoreFilesPatterns.add(pattern);
-        const p = [...this.ignoreFilesPatterns];
-        this.isFileMatch = (filePath) => isMatch(filePath, p, { dot: true });
+        this.isFileMatch = createMatcher(this.ignoreFilesPatterns);
     }
     setIgnoreIssues(ignoreIssues) {
         if (!ignoreIssues)
@@ -49,7 +55,7 @@ export class IssueCollector {
             }
         }
         for (const [issueType, patterns] of issueTypePatterns) {
-            this.issueMatchers.set(issueType, (filePath) => isMatch(filePath, patterns, { dot: true }));
+            this.issueMatchers.set(issueType, picomatch(patterns, { dot: true }));
         }
     }
     shouldIgnoreIssue(filePath, issueType) {

package/dist/IssueFixer.d.ts

@@ -1,11 +1,3 @@
 import type { Issues } from './types/issues.js';
 import type { MainOptions } from './util/create-options.js';
-export declare class IssueFixer {
-    options: MainOptions;
-    constructor(options: MainOptions);
-    fixIssues(issues: Issues): Promise<Set<string>>;
-    private removeUnusedFiles;
-    private removeUnusedExports;
-    private removeUnusedDependencies;
-    private removeUnusedCatalogEntries;
-}
+export declare const fix: (issues: Issues, options: MainOptions) => Promise<void>;

package/dist/IssueFixer.js

@@ -1,9 +1,24 @@
 import { readFile, rm, writeFile } from 'node:fs/promises';
+import { formatly } from 'formatly';
 import { DEFAULT_CATALOG } from './util/catalog.js';
+import { debugLogArray, debugLogObject } from './util/debug.js';
 import { load, save } from './util/package-json.js';
 import { extname, join } from './util/path.js';
 import { removeExport } from './util/remove-export.js';
-export class IssueFixer {
+export const fix = async (issues, options) => {
+    const fixer = new IssueFixer(options);
+    const touchedFiles = await fixer.fixIssues(issues);
+    if (options.isFormat) {
+        const report = await formatly(Array.from(touchedFiles));
+        if (report.ran && report.result && (report.result.runner === 'virtual' || report.result.code === 0)) {
+            debugLogArray('*', `Formatted files using ${report.formatter.name} (${report.formatter.runner})`, touchedFiles);
+        }
+        else {
+            debugLogObject('*', 'Formatting files failed', report);
+        }
+    }
+};
+class IssueFixer {
     options;
     constructor(options) {
         this.options = options;

package/dist/WorkspaceWorker.d.ts

@@ -53,6 +53,7 @@ export declare class WorkspaceWorker {
     getEntryFilePatterns(): string[];
     getProjectFilePatterns(projectFilePatterns: string[]): string[];
     getPluginProjectFilePatterns(patterns?: string[]): string[];
+    private getPluginConfig;
     getPluginConfigPatterns(): string[];
     getPluginEntryFilePatterns(patterns: string[]): string[];
     getProductionEntryFilePatterns(negatedTestFilePatterns: string[]): string[];

package/dist/WorkspaceWorker.js

@@ -103,13 +103,15 @@ export class WorkspaceWorker {
         }
         return [patterns, this.negatedWorkspacePatterns].flat();
     }
+    getPluginConfig(plugin) {
+        return typeof plugin.config === 'function' ? plugin.config({ cwd: this.dir }) : plugin.config;
+    }
     getPluginConfigPatterns() {
         const patterns = [];
         for (const [pluginName, plugin] of PluginEntries) {
             const pluginConfig = this.getConfigForPlugin(pluginName);
             if (this.enabledPluginsMap[pluginName] && pluginConfig) {
-                const { config } = pluginConfig;
-                patterns.push(...(config ?? plugin.config ?? []));
+                patterns.push(...(pluginConfig.config ?? this.getPluginConfig(plugin) ?? []));
             }
         }
         return patterns;
@@ -149,7 +151,7 @@ export class WorkspaceWorker {
     getConfigurationFilePatterns(pluginName) {
         const plugin = Plugins[pluginName];
         const pluginConfig = this.getConfigForPlugin(pluginName);
-        return pluginConfig.config ?? plugin.config ?? [];
+        return pluginConfig.config ?? this.getPluginConfig(plugin) ?? [];
     }
     async runPlugins() {
         const wsName = this.name;

package/dist/cli.js

@@ -1,4 +1,5 @@
-import { main } from './index.js';
+import { fix } from './IssueFixer.js';
+import { run } from './run.js';
 import parseArgs, { helpText } from './util/cli-arguments.js';
 import { createOptions } from './util/create-options.js';
 import { getKnownErrors, hasErrorCause, isConfigurationError, isKnownError } from './util/errors.js';
@@ -19,7 +20,7 @@ catch (error) {
     }
     throw error;
 }
-const run = async () => {
+const main = async () => {
     try {
         if (args.help) {
             console.log(helpText);
@@ -30,7 +31,8 @@ const run = async () => {
             process.exit(0);
         }
         const options = await createOptions({ args });
-        const { issues, counters, tagHints, configurationHints, includedWorkspaceDirs, enabledPlugins } = await main(options);
+        const { results } = await run(options);
+        const { issues, counters, tagHints, configurationHints, includedWorkspaceDirs, enabledPlugins } = results;
         if (options.isWatch || options.isTrace)
             return;
         const initialData = {
@@ -52,6 +54,8 @@ const run = async () => {
             preprocessorOptions: args['preprocessor-options'] ?? '',
         };
         const finalData = await runPreprocessors(args.preprocessor ?? [], initialData);
+        if (options.isFix)
+            await fix(finalData.issues, options);
         await runReporters(args.reporter ?? ['symbols'], finalData);
         const totalErrorCount = Object.keys(finalData.report)
             .filter(reportGroup => finalData.report[reportGroup] && options.rules[reportGroup] === 'error')
@@ -94,4 +98,4 @@ const run = async () => {
     }
     process.exit(0);
 };
-await run();
+await main();

package/dist/compilers/astro.d.ts

@@ -1,6 +1,6 @@
 import type { HasDependency } from './types.js';
 declare const _default: {
     condition: (hasDependency: HasDependency) => boolean;
-    compiler: (text: string) => string;
+    compiler: (text: string, path: string) => string;
 };
 export default _default;

package/dist/compilers/astro.js

@@ -1,8 +1,13 @@
-import { fencedCodeBlockMatcher, importMatcher } from './compilers.js';
+import { frontmatterMatcher, scriptBodies } from './compilers.js';
 const condition = (hasDependency) => hasDependency('astro');
-const taggedTemplateMatcher = /\w+(?:\.\w+)*`[\s\S]*?`/g;
-const compiler = (text) => {
-    const cleanedText = text.replace(fencedCodeBlockMatcher, '').replace(taggedTemplateMatcher, '""');
-    return [...cleanedText.matchAll(importMatcher)].join('\n');
+const compiler = (text, path) => {
+    const scripts = [];
+    const frontmatter = text.match(frontmatterMatcher);
+    if (frontmatter?.[1])
+        scripts.push(frontmatter[1]);
+    const scriptContent = scriptBodies(text, path);
+    if (scriptContent)
+        scripts.push(scriptContent);
+    return scripts.join('\n');
 };
 export default { condition, compiler };

package/dist/compilers/compilers.d.ts

@@ -3,4 +3,5 @@ export declare const fencedCodeBlockMatcher: RegExp;
 export declare const importMatcher: RegExp;
 export declare const importsWithinScripts: SyncCompilerFn;
 export declare const scriptBodies: SyncCompilerFn;
+export declare const frontmatterMatcher: RegExp;
 export declare const importsWithinFrontmatter: (text: string, keys?: string[]) => string;

package/dist/compilers/compilers.js

@@ -21,9 +21,9 @@ export const scriptBodies = (text) => {
     }
     return scripts.join(';\n');
 };
-const frontmatterMatcher = /---[\s\S]*?---/;
+export const frontmatterMatcher = /^---\r?\n([\s\S]*?)\r?\n---/;
 export const importsWithinFrontmatter = (text, keys = []) => {
-    const frontmatter = text.match(frontmatterMatcher)?.[0];
+    const frontmatter = text.match(frontmatterMatcher)?.[1];
     if (!frontmatter)
         return '';
     const imports = keys.flatMap(key => {

package/dist/graph/analyze.d.ts

@@ -3,7 +3,6 @@ import type { ConfigurationChief } from '../ConfigurationChief.js';
 import type { ConsoleStreamer } from '../ConsoleStreamer.js';
 import type { DependencyDeputy } from '../DependencyDeputy.js';
 import type { IssueCollector } from '../IssueCollector.js';
-import type { IssueFixer } from '../IssueFixer.js';
 import type { PrincipalFactory } from '../PrincipalFactory.js';
 import type { ModuleGraph } from '../types/module-graph.js';
 import type { MainOptions } from '../util/create-options.js';
@@ -15,7 +14,6 @@ interface AnalyzeOptions {
     deputy: DependencyDeputy;
     entryPaths: Set<string>;
     factory: PrincipalFactory;
-    fixer: IssueFixer;
     graph: ModuleGraph;
     streamer: ConsoleStreamer;
     unreferencedFiles: Set<string>;

package/dist/graph/build.js

@@ -39,8 +39,8 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
         });
         counselor.addWorkspace(manifest);
     }
-    collector.addIgnorePatterns(chief.config.ignore.map(p => join(options.cwd, p)));
-    collector.addIgnoreFilesPatterns(chief.config.ignoreFiles.map(p => join(options.cwd, p)));
+    collector.addIgnorePatterns(chief.config.ignore.map(p => prependDirToPattern(options.cwd, p)));
+    collector.addIgnoreFilesPatterns(chief.config.ignoreFiles.map(p => prependDirToPattern(options.cwd, p)));
     for (const workspace of workspaces) {
         const { name, dir, ancestors, pkgName, manifestPath: filePath } = workspace;
         streamer.cast('Analyzing workspace', name);
@@ -81,8 +81,8 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                 inputs.add(toProductionEntry(id, { containingFilePath: tsConfigFilePath }));
         }
         const sharedGlobOptions = { cwd: options.cwd, dir, gitignore: options.gitignore };
-        collector.addIgnorePatterns(config.ignore.map(p => join(options.cwd, prependDirToPattern(name, p))));
-        collector.addIgnoreFilesPatterns(config.ignoreFiles.map(p => join(options.cwd, prependDirToPattern(name, p))));
+        collector.addIgnorePatterns(config.ignore.map(p => prependDirToPattern(options.cwd, prependDirToPattern(name, p))));
+        collector.addIgnoreFilesPatterns(config.ignoreFiles.map(p => prependDirToPattern(options.cwd, prependDirToPattern(name, p))));
         const entrySpecifiersFromManifest = getEntrySpecifiersFromManifest(manifest);
         const label = 'entry paths from package.json';
         for (const filePath of await toSourceFilePaths(entrySpecifiersFromManifest, dir, extensionGlobStr, label)) {

package/dist/index.js

@@ -1,2 +1,8 @@
+import { fix } from './IssueFixer.js';
 import { run } from './run.js';
-export const main = async (options) => (await run(options)).results;
+export const main = async (options) => {
+    const { results } = await run(options);
+    if (options.isFix)
+        await fix(results.issues, options);
+    return results;
+};

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

@@ -16,6 +16,11 @@ const config = [
     '.graphqlrc.{json,yml,yaml,toml,js,ts}',
     'graphql.config.{json,yml,yaml,toml,js,cjs,ts}',
 ];
+const getPluginPackageName = (name) => {
+    if (name.startsWith('@') || name.includes('codegen-'))
+        return name;
+    return `@graphql-codegen/${name}`;
+};
 const resolveConfig = config => {
     const codegenConfigs = isGraphqlProjectsConfigTypes(config)
         ? Object.values(config.projects).flatMap(project => project.extensions?.codegen ?? [])
@@ -35,7 +40,7 @@ const resolveConfig = config => {
     const flatPlugins = generateSet
         .filter((config) => !isConfigurationOutput(config))
         .flatMap(item => Object.keys(item))
-        .map(plugin => plugin.includes('codegen-') ? plugin : `@graphql-codegen/${plugin}`);
+        .map(plugin => getPluginPackageName(plugin));
     const nestedPlugins = configurationOutput
         .flatMap(configOutput => (configOutput.plugins ? configOutput.plugins : []))
         .flatMap(plugin => {
@@ -48,7 +53,7 @@ const resolveConfig = config => {
             return [];
         if (isInternal(plugin))
             return [toEntry(plugin)];
-        return [plugin.includes('codegen-') ? plugin : `@graphql-codegen/${plugin}`].map(id => toDependency(id));
+        return [toDependency(getPluginPackageName(plugin))];
     });
     return [...presets, ...flatPlugins, ...nestedPlugins].map(id => (typeof id === 'string' ? toDependency(id) : id));
 };

package/dist/plugins/lefthook/index.js

@@ -6,8 +6,6 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Lefthook';
 const enablers = ['lefthook', '@arkweid/lefthook', '@evilmartians/lefthook'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const gitHookPaths = getGitHookPaths();
-const config = ['lefthook.yml', ...gitHookPaths];
 const resolveConfig = async (localConfig, options) => {
     if (options.isProduction)
         return [];
@@ -35,7 +33,7 @@ const plugin = {
     title,
     enablers,
     isEnabled,
-    config,
+    config: options => ['lefthook.yml', ...getGitHookPaths('.git/hooks', true, options.cwd)],
     resolveConfig,
 };
 export default plugin;

package/dist/plugins/moonrepo/index.js

@@ -9,6 +9,7 @@ const resolveConfig = async (config, options) => {
     const inputs = tasks
         .map(task => task.command)
         .filter(command => command)
+        .map(command => (Array.isArray(command) ? command.join(' ') : command))
         .map(command => command.replace('$workspaceRoot', options.rootCwd))
         .map(command => command.replace('$projectRoot', options.cwd))
         .flatMap(command => options.getInputsFromScripts(command));

package/dist/plugins/moonrepo/types.d.ts

@@ -1,7 +1,7 @@
 export interface MoonConfiguration {
     tasks?: {
         [taskName: string]: {
-            command: string;
+            command: string | string[];
         };
     };
 }

package/dist/plugins/playwright-ct/index.js

@@ -1,9 +1,17 @@
+import { toEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
-import { entry, resolveConfig } from '../playwright/index.js';
+import { entry as playwrightEntry, resolveConfig as playwrightResolveConfig } from '../playwright/index.js';
 const title = 'Playwright for components';
 const enablers = [/^@playwright\/experimental-ct-/];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['playwright-ct.config.{js,ts}', 'playwright/index.{js,ts,jsx,tsx}'];
+const config = ['playwright-ct.config.{js,ts}'];
+const ctEntry = 'playwright/index.{js,ts,jsx,tsx}';
+const entry = [...playwrightEntry, ctEntry];
+const resolveConfig = async (localConfig, options) => {
+    const inputs = await playwrightResolveConfig(localConfig, options);
+    inputs.push(toEntry(ctEntry));
+    return inputs;
+};
 const plugin = {
     title,
     enablers,

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

@@ -9,7 +9,8 @@ const isWindows = os.platform() === 'win32';
 const title = 'React Router';
 const enablers = ['@react-router/dev'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['react-router.config.{js,ts}', ...(vite.config ?? [])];
+const viteConfig = typeof vite.config === 'function' ? [] : (vite.config ?? []);
+const config = ['react-router.config.{js,ts}', ...viteConfig];
 const resolveConfig = async (localConfig, options) => {
     const { configFileDir } = options;
     const appDirectory = localConfig.appDirectory ?? 'app';

package/dist/plugins/webpack/index.js

@@ -100,7 +100,7 @@ export const findWebpackDependenciesFromConfig = async (config, options) => {
             if (entries.length === 0 && opts.context)
                 entries.push('./src/index');
             for (const entry of entries) {
-                if (isInternal(entry)) {
+                if (isInternal(entry) || entry.startsWith('#')) {
                     const dir = opts.context ? opts.context : cwd;
                     const input = isProduction
                         ? toDeferResolveProductionEntry(entry, { dir })

package/dist/run.js

@@ -1,5 +1,4 @@
 import { watch } from 'node:fs';
-import { formatly } from 'formatly';
 import { CatalogCounselor } from './CatalogCounselor.js';
 import { ConfigurationChief } from './ConfigurationChief.js';
 import { ConsoleStreamer } from './ConsoleStreamer.js';
@@ -7,10 +6,9 @@ import { DependencyDeputy } from './DependencyDeputy.js';
 import { analyze } from './graph/analyze.js';
 import { build } from './graph/build.js';
 import { IssueCollector } from './IssueCollector.js';
-import { IssueFixer } from './IssueFixer.js';
 import { PrincipalFactory } from './PrincipalFactory.js';
 import watchReporter from './reporters/watch.js';
-import { debugLogArray, debugLogObject } from './util/debug.js';
+import { debugLogObject } from './util/debug.js';
 import { getGitIgnoredHandler } from './util/glob-core.js';
 import { getSessionHandler } from './util/watch.js';
 export const run = async (options) => {
@@ -20,7 +18,6 @@ export const run = async (options) => {
     const deputy = new DependencyDeputy(options);
     const factory = new PrincipalFactory();
     const streamer = new ConsoleStreamer(options);
-    const fixer = new IssueFixer(options);
     const collector = new IssueCollector(options);
     const counselor = new CatalogCounselor(options);
     streamer.cast('Reading workspace configuration');
@@ -48,7 +45,6 @@ export const run = async (options) => {
         deputy,
         entryPaths,
         factory,
-        fixer,
         graph,
         streamer,
         unreferencedFiles,
@@ -79,18 +75,6 @@ export const run = async (options) => {
             watch('.', { recursive: true }, session.listener);
     }
     const { issues, counters, tagHints, configurationHints } = collector.getIssues();
-    if (options.isFix && !options.isSession) {
-        const touchedFiles = await fixer.fixIssues(issues);
-        if (options.isFormat) {
-            const report = await formatly(Array.from(touchedFiles));
-            if (report.ran && report.result && (report.result.runner === 'virtual' || report.result.code === 0)) {
-                debugLogArray('*', `Formatted files using ${report.formatter.name} (${report.formatter.runner})`, touchedFiles);
-            }
-            else {
-                debugLogObject('*', 'Formatting files failed', report);
-            }
-        }
-    }
     if (!options.isWatch)
         streamer.clear();
     return {

package/dist/types/config.d.ts

@@ -110,7 +110,9 @@ export interface Plugin {
     enablers?: IgnorePatterns | string;
     isEnabled?: IsPluginEnabled;
     isRootOnly?: boolean;
-    config?: string[];
+    config?: string[] | ((options: {
+        cwd: string;
+    }) => string[]);
     entry?: string[];
     production?: string[];
     project?: string[];

package/dist/types.d.ts

@@ -1,3 +1,2 @@
-export type { RawConfigurationOrFn as KnipConfig } from './types/config.js';
+export type { RawConfigurationOrFn as KnipConfig, WorkspaceProjectConfig } from './types/config.js';
 export type { Preprocessor, Reporter, ReporterOptions } from './types/issues.js';
-export type { WorkspaceProjectConfig } from './types/config.js';

package/dist/typescript/find-internal-references.d.ts

@@ -1,4 +1,3 @@
 import ts from 'typescript';
 import type { Export, ExportMember } from '../types/module-graph.js';
-export declare const isType: (item: Export | ExportMember) => boolean;
 export declare const findInternalReferences: (item: Export | ExportMember, sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker, referencedSymbolsInExport: Set<ts.Symbol>, isBindingElement?: boolean) => [number, boolean];

package/dist/typescript/find-internal-references.js

@@ -1,6 +1,5 @@
 import ts from 'typescript';
 import { isIdChar } from '../util/regex.js';
-export const isType = (item) => item.type === 'type' || item.type === 'interface' || item.type === 'enum';
 const findInFlow = (flowNode, targetSymbol) => {
     if (!flowNode?.node)
         return false;

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

@@ -7,7 +7,7 @@ import { timerify } from '../util/Performance.js';
 import { dirname, isInNodeModules, resolve } from '../util/path.js';
 import { shouldIgnore } from '../util/tag.js';
 import { getAccessMembers, getDestructuredNames, getJSDocTags, getLineAndCharacterOfPosition, getTypeRef, isAccessExpression, isConsiderReferencedNS, isDestructuring, isImportSpecifier, isInForIteration, isObjectEnumerationCallExpressionArgument, isReferencedInExport, } from './ast-helpers.js';
-import { findInternalReferences, isType } from './find-internal-references.js';
+import { findInternalReferences } from './find-internal-references.js';
 import { getImportsFromPragmas } from './pragmas/index.js';
 import getDynamicImportVisitors from './visitors/dynamic-imports/index.js';
 import getExportVisitors from './visitors/exports/index.js';
@@ -426,7 +426,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         for (const node of pragmaImports)
             addImport(node, sourceFile);
     for (const item of exports.values()) {
-        if (!isType(item) && item.symbol && referencedSymbolsInExport.has(item.symbol)) {
+        if (item.symbol && referencedSymbolsInExport.has(item.symbol)) {
             item.self = [1, true];
         }
         else {

package/dist/util/array.d.ts

@@ -1,5 +1,5 @@
 type Collection<T> = Array<T> | Set<T>;
 export declare const compact: <T>(collection: Collection<T | undefined>) => T[];
 export declare const arrayify: (value?: string[] | string) => string[];
-export declare const partition: <T>(collection: T[], predicate: (item: T) => unknown) => [T[], T[]];
+export declare const partition: <T>(collection: Collection<T>, predicate: (item: T) => unknown) => [T[], T[]];
 export {};

package/dist/util/create-input-handler.js

@@ -2,7 +2,7 @@ import { IGNORED_RUNTIME_DEPENDENCIES } from '../constants.js';
 import { debugLog } from './debug.js';
 import { fromBinary, isBinary, isConfig, isDeferResolve, isDeferResolveEntry, isDependency, toDebugString, } from './input.js';
 import { getPackageNameFromSpecifier } from './modules.js';
-import { dirname, isAbsolute, isInternal, join } from './path.js';
+import { dirname, isAbsolute, isInNodeModules, isInternal, join } from './path.js';
 import { _resolveSync } from './resolve.js';
 const getWorkspaceFor = (input, chief, workspace) => (input.dir && chief.findWorkspaceByFilePath(`${input.dir}/`)) ||
     (input.containingFilePath && chief.findWorkspaceByFilePath(input.containingFilePath)) ||
@@ -41,7 +41,11 @@ export const createInputHandler = (deputy, chief, isGitIgnored, addIssue, extern
         return;
     }
     const packageName = getPackageNameFromSpecifier(specifier);
-    if (packageName && (isDependency(input) || isDeferResolve(input) || isConfig(input))) {
+    if (packageName &&
+        (isDependency(input) ||
+            isDeferResolve(input) ||
+            (isDeferResolveEntry(input) && isInNodeModules(specifier)) ||
+            isConfig(input))) {
         const isWorkspace = chief.workspacesByPkgName.has(packageName);
         const inputWorkspace = getWorkspaceFor(input, chief, workspace);
         if (inputWorkspace) {
@@ -75,7 +79,7 @@ export const createInputHandler = (deputy, chief, isGitIgnored, addIssue, extern
         return;
     }
     const baseDir = input.dir ?? dirname(containingFilePath);
-    const filePath = isAbsolute(specifier) ? specifier : join(baseDir, specifier);
+    const filePath = isAbsolute(specifier) || specifier.startsWith('#') ? specifier : join(baseDir, specifier);
     const resolvedFilePath = _resolveSync(filePath, baseDir);
     if (resolvedFilePath && isInternal(resolvedFilePath)) {
         return isGitIgnored(resolvedFilePath) ? undefined : resolvedFilePath;

package/dist/util/create-options.js

@@ -11,9 +11,9 @@ import { _load } from './loader.js';
 import { getKeysByValue } from './object.js';
 import { isAbsolute, join, normalize, toAbsolute, toPosix } from './path.js';
 import { splitTags } from './tag.js';
-const pcwd = process.cwd();
 export const createOptions = async (options) => {
     const { args = {} } = options;
+    const pcwd = process.cwd();
     const cwd = normalize(toPosix(toAbsolute(options.cwd ?? args.directory ?? pcwd, pcwd)));
     const manifestPath = findFile(cwd, 'package.json');
     const manifest = manifestPath && (await loadJSON(manifestPath));

package/dist/util/git.d.ts

@@ -1 +1 @@
-export declare const getGitHookPaths: (defaultPath?: string, followGitConfig?: boolean) => string[];
+export declare const getGitHookPaths: (defaultPath?: string, followGitConfig?: boolean, cwd?: string) => string[];

package/dist/util/git.js

@@ -6,15 +6,19 @@ const hookFileNames = [
     'pre-{applypatch,commit,merge-commit,push,rebase,receive}',
     'post-{checkout,commit,merge,rewrite}',
 ];
-const getGitHooksPath = (defaultPath = '.git/hooks') => {
+const getGitHooksPath = (defaultPath = '.git/hooks', cwd) => {
     try {
-        return execSync('git config --get core.hooksPath', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        return execSync('git rev-parse --git-path hooks', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+            cwd,
+        }).trim();
     }
     catch (_error) {
         return defaultPath;
     }
 };
-export const getGitHookPaths = (defaultPath = '.git/hooks', followGitConfig = true) => {
-    const gitHooksPath = followGitConfig ? getGitHooksPath(defaultPath) : defaultPath;
+export const getGitHookPaths = (defaultPath = '.git/hooks', followGitConfig = true, cwd) => {
+    const gitHooksPath = followGitConfig ? getGitHooksPath(defaultPath, cwd) : defaultPath;
     return hookFileNames.map(fileName => join(gitHooksPath, fileName));
 };

package/dist/util/glob.js

@@ -34,7 +34,7 @@ const defaultGlob = async ({ cwd, dir = cwd, patterns, gitignore = true, label }
         label,
     });
 };
-const syncGlob = ({ cwd, patterns }) => fg.sync(patterns, { cwd });
+const syncGlob = ({ cwd, patterns }) => fg.sync(patterns, { cwd, followSymbolicLinks: false });
 const firstGlob = async ({ cwd, patterns }) => {
     const stream = fg.globStream(patterns.map(removeProductionSuffix), { cwd, ignore: GLOBAL_IGNORE_PATTERNS });
     for await (const entry of stream) {

package/dist/util/jiti.d.ts

@@ -1 +1,5 @@
-export declare const jiti: import("jiti").Jiti;
+export declare const jiti: {
+    import: (id: string, opts?: {
+        default?: true;
+    }) => Promise<unknown>;
+};

package/dist/util/jiti.js

@@ -8,5 +8,10 @@ const options = {
         '@rushstack/eslint-patch/modern-module-resolution': empty,
     },
 };
-const createLoader = (options) => createJiti(process.cwd(), options);
-export const jiti = createLoader(options);
+let _jiti;
+export const jiti = {
+    import: (id, opts) => {
+        _jiti ??= createJiti(process.cwd(), options);
+        return _jiti.import(id, opts);
+    },
+};

package/dist/util/to-source-path.js

@@ -5,11 +5,11 @@ import { _glob, _syncGlob, prependDirToPattern } from './glob.js';
 import { isAbsolute, isInternal, join, toRelative } from './path.js';
 const defaultExtensions = `.{${DEFAULT_EXTENSIONS.map(ext => ext.slice(1)).join(',')}}`;
 const hasTSExt = /(?<!\.d)\.(m|c)?tsx?$/;
-const hasDTSExt = /.d\.(m|c)?ts$/;
 const matchExt = /(\.d)?\.(m|c)?(j|t)s$/;
 export const augmentWorkspace = (workspace, dir, compilerOptions) => {
     const srcDir = join(dir, 'src');
-    workspace.srcDir = compilerOptions.rootDir ?? (isDirectory(srcDir) ? srcDir : dir);
+    const outDirHasSrc = compilerOptions.outDir && isDirectory(join(compilerOptions.outDir, 'src'));
+    workspace.srcDir = compilerOptions.rootDir ?? (outDirHasSrc ? dir : isDirectory(srcDir) ? srcDir : dir);
     workspace.outDir = compilerOptions.outDir || workspace.srcDir;
 };
 export const getModuleSourcePathHandler = (chief) => {
@@ -21,8 +21,7 @@ export const getModuleSourcePathHandler = (chief) => {
             return toSourceMapCache.get(filePath);
         const workspace = chief.findWorkspaceByFilePath(filePath);
         if (workspace?.srcDir && workspace.outDir) {
-            if ((!filePath.startsWith(workspace.srcDir) && filePath.startsWith(workspace.outDir)) ||
-                (workspace.srcDir === workspace.outDir && hasDTSExt.test(filePath))) {
+            if (filePath.startsWith(workspace.outDir) || workspace.srcDir === workspace.outDir) {
                 const pattern = filePath.replace(workspace.outDir, workspace.srcDir).replace(matchExt, defaultExtensions);
                 const srcFilePath = _syncGlob({ patterns: pattern })[0];
                 toSourceMapCache.set(filePath, srcFilePath);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.77.3";
+export declare const version = "5.78.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.77.3';
+export const version = '5.78.0';

package/package.json

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