knip 6.12.2 → 6.13.0

package/dist/DependencyDeputy.d.ts

@@ -14,7 +14,7 @@ export declare class DependencyDeputy {
     installedBinaries: Map<string, InstalledBinaries>;
     hasTypesIncluded: Map<string, Set<string>>;
     constructor({ isProduction, isStrict, isReportDependencies }: MainOptions);
-    addWorkspace({ name, cwd, dir, manifestPath, manifestStr, manifest, ignoreDependencies: id, ignoreBinaries: ib, ignoreUnresolved: iu }: {
+    addWorkspace({ name, cwd, dir, manifestPath, manifestStr, manifest, ignoreDependencies: id, ignoreBinaries: ib, ignoreUnresolved: iu, }: {
         name: string;
         cwd: string;
         dir: string;

package/dist/ProjectPrincipal.d.ts

@@ -6,7 +6,7 @@ import type { FileNode, ModuleGraph } from './types/module-graph.ts';
 import type { Paths } from './types/project.ts';
 import { SourceFileManager } from './typescript/SourceFileManager.ts';
 import type { MainOptions } from './util/create-options.ts';
-import type { ToSourceFilePath } from './util/to-source-path.ts';
+import type { ToSourceFilePath, WorkspaceManifestHandler } from './util/to-source-path.ts';
 export declare class ProjectPrincipal {
     entryPaths: Set<string>;
     projectPaths: Set<string>;
@@ -22,11 +22,12 @@ export declare class ProjectPrincipal {
     private extensions;
     cache: CacheConsultant<FileNode>;
     toSourceFilePath: ToSourceFilePath;
+    private findWorkspaceManifestImports;
     fileManager: SourceFileManager;
     private resolveModule;
     resolvedFiles: Set<string>;
     deletedFiles: Set<string>;
-    constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath);
+    constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath, findWorkspaceManifestImports?: WorkspaceManifestHandler);
     addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
     addPaths(paths: Paths, basePath: string): void;
     addRootDirs(rootDirs: string[]): void;

package/dist/ProjectPrincipal.js

@@ -1,5 +1,5 @@
 import { extractSpecifiers } from './typescript/follow-imports.js';
-import { parseFile } from './typescript/visitors/helpers.js';
+import { parseFile } from './typescript/ast-nodes.js';
 import { CacheConsultant } from './CacheConsultant.js';
 import { getCompilerExtensions } from './compilers/index.js';
 import { DEFAULT_EXTENSIONS } from './constants.js';
@@ -31,13 +31,15 @@ export class ProjectPrincipal {
     extensions = new Set(DEFAULT_EXTENSIONS);
     cache;
     toSourceFilePath;
+    findWorkspaceManifestImports;
     fileManager;
     resolveModule = () => undefined;
     resolvedFiles = new Set();
     deletedFiles = new Set();
-    constructor(options, toSourceFilePath) {
+    constructor(options, toSourceFilePath, findWorkspaceManifestImports) {
         this.cache = new CacheConsultant('root', options);
         this.toSourceFilePath = toSourceFilePath;
+        this.findWorkspaceManifestImports = findWorkspaceManifestImports;
         this.pluginVisitorObjects.push(createBunShellVisitor(this.pluginCtx));
         this.fileManager = new SourceFileManager({
             compilers: [this.syncCompilers, this.asyncCompilers],
@@ -84,7 +86,7 @@ export class ProjectPrincipal {
         const customCompilerExtensions = getCompilerExtensions([this.syncCompilers, this.asyncCompilers]);
         const pathsOrUndefined = Object.keys(this.paths).length > 0 ? this.paths : undefined;
         const rootDirsOrUndefined = this.rootDirs.length > 1 ? this.rootDirs : undefined;
-        this.resolveModule = createCustomModuleResolver({ paths: pathsOrUndefined, rootDirs: rootDirsOrUndefined }, customCompilerExtensions, this.toSourceFilePath);
+        this.resolveModule = createCustomModuleResolver({ paths: pathsOrUndefined, rootDirs: rootDirsOrUndefined }, customCompilerExtensions, this.toSourceFilePath, this.findWorkspaceManifestImports);
     }
     readFile(filePath) {
         return this.fileManager.readFile(filePath);

package/dist/WorkspaceWorker.d.ts

@@ -47,7 +47,7 @@ export declare class WorkspaceWorker {
     enabledPluginsInAncestors: string[];
     cache: CacheConsultant<CacheItem>;
     configFilesMap: Map<string, Map<PluginName, Set<string>>>;
-    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, readFile, configFilesMap, options }: WorkspaceManagerOptions);
+    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, readFile, configFilesMap, options, }: WorkspaceManagerOptions);
     init(): Promise<void>;
     private determineEnabledPlugins;
     private getConfigForPlugin;

package/dist/WorkspaceWorker.js

@@ -7,7 +7,7 @@ import { getFilteredScripts } from './manifest/helpers.js';
 import { PluginEntries, Plugins } from './plugins.js';
 import { createManifest } from './util/package-json.js';
 import { collectStringLiterals, isExternalReExportsOnly } from './typescript/ast-helpers.js';
-import { parseFile } from './typescript/visitors/helpers.js';
+import { parseFile } from './typescript/ast-nodes.js';
 import { compact } from './util/array.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate } from './util/glob.js';

package/dist/compilers/compilers.js

@@ -1,12 +1,15 @@
 export const fencedCodeBlockMatcher = /```[\s\S]*?```/g;
 export const inlineCodeMatcher = /`[^`]+`/g;
 const scriptExtractor = /<script\b(?:[^>"']|"[^"]*"|'[^']*')*>([\s\S]*?)<\/script>/gm;
+const blockCommentMatcher = /\/\*[\s\S]*?\*\//g;
+const lineCommentMatcher = /^[ \t]*\/\/.*$/gm;
 export const importMatcher = /import[^'"]+['"][^'"]+['"]/g;
 export const importsWithinScripts = (text) => {
     const scripts = [];
     let scriptMatch;
     while ((scriptMatch = scriptExtractor.exec(text))) {
-        for (const importMatch of scriptMatch[1].matchAll(importMatcher)) {
+        const body = scriptMatch[1].replace(blockCommentMatcher, '').replace(lineCommentMatcher, '');
+        for (const importMatch of body.matchAll(importMatcher)) {
             scripts.push(importMatch);
         }
     }

package/dist/constants.js

@@ -65,6 +65,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'groups',
     'gzip',
     'head',
+    'hg',
     'id',
     'join',
     'kill',

package/dist/graph/analyze.js

@@ -1,7 +1,7 @@
 import { createGraphExplorer } from '../graph-explorer/explorer.js';
 import { getIssueType, hasStrictlyEnumReferences } from '../graph-explorer/utils.js';
 import traceReporter from '../reporters/trace.js';
-import { shouldCountRefs } from '../typescript/visitors/helpers.js';
+import { shouldCountRefs } from '../typescript/ast-nodes.js';
 import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { perfObserver } from '../util/Performance.js';
 import { findMatch } from '../util/regex.js';

package/dist/graph/build.d.ts

@@ -17,7 +17,7 @@ interface BuildOptions {
     workspaces: Workspace[];
     options: MainOptions;
 }
-export declare function build({ chief, collector, counselor, deputy, principal, isGitIgnored, streamer, workspaces, options }: BuildOptions): Promise<{
+export declare function build({ chief, collector, counselor, deputy, principal, isGitIgnored, streamer, workspaces, options, }: BuildOptions): Promise<{
     graph: ModuleGraph;
     entryPaths: Set<string>;
     analyzedFiles: Set<string>;

package/dist/graph/build.js

@@ -58,7 +58,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         const dependencies = deputy.getDependencies(name);
         const baseConfig = chief.getConfigForWorkspace(name);
         const tsConfigFilePath = join(dir, options.tsConfigFile ?? 'tsconfig.json');
-        const { isFile, compilerOptions, fileNames, include, exclude } = await loadTSConfig(tsConfigFilePath);
+        const { isFile, compilerOptions, fileNames, include, exclude, sourceMapPairs } = await loadTSConfig(tsConfigFilePath);
         const [definitionPaths, tscSourcePaths] = partition(fileNames, filePath => IS_DTS.test(filePath));
         const worker = new WorkspaceWorker({
             name,
@@ -91,7 +91,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         const config = chief.getConfigForWorkspace(name, extensions);
         worker.config = config;
         const pluginSourceMaps = await worker.resolveSourceMaps();
-        augmentWorkspace(workspace, dir, isFile ? compilerOptions : undefined, pluginSourceMaps);
+        augmentWorkspace(workspace, dir, isFile ? compilerOptions : undefined, [...pluginSourceMaps, ...sourceMapPairs]);
         const inputs = new Set();
         if (definitionPaths.length > 0) {
             debugLogArray(name, 'Definition paths', definitionPaths);

package/dist/graph-explorer/operations/is-referenced.js

@@ -15,7 +15,7 @@ const hasOnlyNsRefs = (file) => {
 };
 export const isReferenced = (graph, entryPaths, filePath, id, options) => {
     const seen = new Set();
-    const walkDown = (path, id) => {
+    const walkDown = (path, id, viaStar = false) => {
         const isEntryFile = entryPaths.has(path);
         let reExportingEntryFile = isEntryFile ? path : undefined;
         if (seen.has(path))
@@ -25,13 +25,13 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
         const identifier = restIds.shift();
         const file = graph.get(path)?.importedBy;
         if (!identifier || !file) {
-            return [false, reExportingEntryFile];
+            return [isEntryFile && viaStar && restIds.length > 0, reExportingEntryFile];
         }
-        const follow = (sources, nextId) => {
+        const follow = (sources, nextId, nextViaStar = viaStar) => {
             for (const byFilePath of sources) {
                 if (seen.has(byFilePath))
                     continue;
-                const result = walkDown(byFilePath, nextId);
+                const result = walkDown(byFilePath, nextId, nextViaStar);
                 if (result[1])
                     reExportingEntryFile = result[1];
                 if (result[0])
@@ -87,7 +87,7 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
                 return [true, reExportingEntryFile];
         }
         else if (starSources) {
-            if (follow(starSources, id))
+            if (follow(starSources, id, true))
                 return [true, reExportingEntryFile];
         }
         for (const [namespace, sources] of file.reExportNs) {

package/dist/plugins/astro/resolveFromAST.js

@@ -1,4 +1,5 @@
-import { collectPropertyValues, findProperty, getPropertyKey, getStringValue, hasImportSpecifier, resolveObjectArg, } from '../../typescript/ast-helpers.js';
+import { getStringValue } from '../../typescript/ast-nodes.js';
+import { collectPropertyValues, findProperty, getPropertyKey, hasImportSpecifier, resolveObjectArg, } from '../../typescript/ast-helpers.js';
 export const getSrcDir = (program) => {
     const values = collectPropertyValues(program, 'srcDir');
     return values.size > 0 ? Array.from(values)[0] : 'src';

package/dist/plugins/babel/helpers.d.ts

@@ -1,41 +1,4 @@
 export declare const resolveName: (identifier: string, namespace: 'preset' | 'plugin') => string;
-declare function cacheFn(): undefined;
-declare namespace cacheFn {
-    var forever: () => {
-        (): undefined;
-        forever: any;
-        never: () => any;
-        using: () => any;
-        invalidate: () => any;
-    };
-}
-declare namespace cacheFn {
-    var never: () => {
-        (): undefined;
-        forever: () => any;
-        never: any;
-        using: () => any;
-        invalidate: () => any;
-    };
-}
-declare namespace cacheFn {
-    var using: () => {
-        (): undefined;
-        forever: () => any;
-        never: () => any;
-        using: any;
-        invalidate: () => any;
-    };
-}
-declare namespace cacheFn {
-    var invalidate: () => {
-        (): undefined;
-        forever: () => any;
-        never: () => any;
-        using: () => any;
-        invalidate: any;
-    };
-}
 export declare const api: {
     assertVersion: () => boolean;
     cache: {
@@ -49,4 +12,3 @@ export declare const api: {
     env: (env?: string) => "development" | true;
     version: string;
 };
-export {};

package/dist/plugins/execa/visitors/execa.js

@@ -1,4 +1,4 @@
-import { getStringValue, isStringLiteral } from '../../../typescript/visitors/helpers.js';
+import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
 const tags = new Set(['$', '$sync']);
 const methods = new Set(['execa', 'execaSync', 'execaCommand', 'execaCommandSync', '$sync']);
 export function createExecaVisitor(ctx) {

package/dist/plugins/jest/index.js

@@ -1,3 +1,4 @@
+import { _glob, _dirGlob } from '../../util/glob.js';
 import { toDeferResolve, toEntry } from '../../util/input.js';
 import { isInternal, join, normalize, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
@@ -8,7 +9,8 @@ const isEnabled = ({ dependencies, manifest }) => hasDependency(dependencies, en
 const config = ['jest.config.{js,ts,mjs,cjs,json}', 'package.json'];
 const mocks = ['**/__mocks__/**/*.[jt]s?(x)'];
 const entry = ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).[jt]s?(x)', ...mocks];
-const resolveDependencies = async (config, options) => {
+const rootDirRe = /<rootDir>/;
+const resolveDependencies = async (config, rootDir, options) => {
     const { configFileDir } = options;
     if (config?.preset) {
         const { preset } = config;
@@ -22,10 +24,13 @@ const resolveDependencies = async (config, options) => {
     const projects = [];
     for (const project of config.projects ?? []) {
         if (typeof project === 'string') {
-            projects.push(project);
+            const patterns = [project.replace(rootDirRe, rootDir)];
+            const files = await _glob({ patterns, cwd: options.cwd });
+            const dirs = await _dirGlob({ patterns, cwd: options.cwd });
+            projects.push(...files, ...dirs);
         }
         else {
-            const dependencies = await resolveDependencies(project, options);
+            const dependencies = await resolveDependencies(project, rootDir, options);
             for (const dependency of dependencies)
                 projects.push(dependency);
         }
@@ -80,8 +85,8 @@ const resolveConfig = async (localConfig, options) => {
     if (typeof localConfig === 'function')
         localConfig = await localConfig();
     const rootDir = localConfig.rootDir ?? configFileDir;
-    const replaceRootDir = (name) => name.replace(/<rootDir>/, rootDir);
-    const inputs = await resolveDependencies(localConfig, options);
+    const replaceRootDir = (name) => name.replace(rootDirRe, rootDir);
+    const inputs = await resolveDependencies(localConfig, rootDir, options);
     const entries = localConfig.testMatch
         ? localConfig.testMatch.map(replaceRootDir).map(id => toEntry(id))
         : entry.map(id => toEntry(id));

package/dist/plugins/knex/index.js

@@ -1,6 +1,7 @@
 import { toDependency, toEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 import { clientToPackages } from './helpers.js';
+import { createKnexClientVisitor } from './visitors/clientCall.js';
 const title = 'Knex';
 const enablers = ['knex'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -27,11 +28,15 @@ const resolveConfig = config => {
     const configs = 'client' in config && config.client ? [config] : Object.values(config);
     return configs.flatMap(cfg => (typeof cfg === 'object' && cfg !== null ? processKnexConfig(cfg) : []));
 };
+const registerVisitors = ({ ctx, registerVisitor }) => {
+    registerVisitor(createKnexClientVisitor(ctx));
+};
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
     resolveConfig,
+    registerVisitors,
 };
 export default plugin;

package/dist/plugins/knex/visitors/clientCall.d.ts

@@ -0,0 +1,2 @@
+import type { PluginVisitorContext, PluginVisitorObject } from '../../../types/config.ts';
+export declare function createKnexClientVisitor(ctx: PluginVisitorContext): PluginVisitorObject;

package/dist/plugins/knex/visitors/clientCall.js

@@ -0,0 +1,83 @@
+import { IMPORT_FLAGS } from '../../../constants.js';
+import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
+import { clientToPackages } from '../helpers.js';
+const KNEX = 'knex';
+export function createKnexClientVisitor(ctx) {
+    const defaultNames = new Set();
+    const namedNames = new Set();
+    const addClientPackages = (obj, pos) => {
+        for (const prop of obj.properties) {
+            if (prop.type !== 'Property' || prop.computed || prop.key.type !== 'Identifier')
+                continue;
+            if (prop.key.name !== 'client')
+                continue;
+            if (!isStringLiteral(prop.value))
+                return;
+            const client = getStringValue(prop.value);
+            if (!client)
+                return;
+            for (const pkg of clientToPackages(client)) {
+                ctx.addImport(pkg, pos, IMPORT_FLAGS.NONE);
+            }
+            return;
+        }
+    };
+    return {
+        Program() {
+            defaultNames.clear();
+            namedNames.clear();
+        },
+        ImportDeclaration(node) {
+            if (!isStringLiteral(node.source) || getStringValue(node.source) !== KNEX)
+                return;
+            for (const spec of node.specifiers ?? []) {
+                if (spec.type === 'ImportDefaultSpecifier') {
+                    defaultNames.add(spec.local.name);
+                }
+                else if (spec.type === 'ImportSpecifier') {
+                    if (spec.imported.type === 'Identifier' && spec.imported.name === KNEX) {
+                        namedNames.add(spec.local.name);
+                    }
+                }
+            }
+        },
+        VariableDeclarator(node) {
+            if (node.init?.type !== 'CallExpression' ||
+                node.init.callee.type !== 'Identifier' ||
+                node.init.callee.name !== 'require' ||
+                !isStringLiteral(node.init.arguments[0]) ||
+                getStringValue(node.init.arguments[0]) !== KNEX)
+                return;
+            if (node.id.type === 'Identifier') {
+                defaultNames.add(node.id.name);
+            }
+            else if (node.id.type === 'ObjectPattern') {
+                for (const prop of node.id.properties) {
+                    if (prop.type === 'Property' &&
+                        prop.key.type === 'Identifier' &&
+                        prop.key.name === KNEX &&
+                        prop.value.type === 'Identifier') {
+                        namedNames.add(prop.value.name);
+                    }
+                }
+            }
+        },
+        CallExpression(node) {
+            if (defaultNames.size === 0 && namedNames.size === 0)
+                return;
+            const arg = node.arguments[0];
+            if (arg?.type !== 'ObjectExpression')
+                return;
+            const callee = node.callee;
+            const isDirectCall = callee.type === 'Identifier' && (defaultNames.has(callee.name) || namedNames.has(callee.name));
+            const isNamespaceCall = callee.type === 'MemberExpression' &&
+                !callee.computed &&
+                callee.object.type === 'Identifier' &&
+                defaultNames.has(callee.object.name) &&
+                callee.property.type === 'Identifier' &&
+                callee.property.name === KNEX;
+            if (isDirectCall || isNamespaceCall)
+                addClientPackages(arg, arg.start);
+        },
+    };
+}

package/dist/plugins/nuxt/helpers.js

@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { Visitor } from 'oxc-parser';
 import { scriptBodies } from '../../compilers/compilers.js';
-import { parseFile } from '../../typescript/visitors/helpers.js';
+import { parseFile } from '../../typescript/ast-nodes.js';
 import { basename, dirname, isInNodeModules, join } from '../../util/path.js';
 export const getVueSfc = (cwd) => {
     try {

package/dist/plugins/pino/visitors/transportCall.js

@@ -1,5 +1,5 @@
 import { IMPORT_FLAGS } from '../../../constants.js';
-import { getStringValue, isStringLiteral } from '../../../typescript/visitors/helpers.js';
+import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
 import { isInternal } from '../../../util/path.js';
 const PINO = 'pino';
 export function createPinoTransportVisitor(ctx) {

package/dist/plugins/sst/resolveFromAST.js

@@ -1,6 +1,6 @@
 import { Visitor } from 'oxc-parser';
 import { collectPropertyValues, getImportMap } from '../../typescript/ast-helpers.js';
-import { parseFile } from '../../typescript/visitors/helpers.js';
+import { parseFile } from '../../typescript/ast-nodes.js';
 import { toDeferResolveProductionEntry } from '../../util/input.js';
 import { dirname } from '../../util/path.js';
 import { _resolveSync } from '../../util/resolve.js';

package/dist/plugins/vite/visitors/importMetaGlob.js

@@ -1,7 +1,7 @@
 import { IMPORT_FLAGS } from '../../../constants.js';
 import { _syncGlob } from '../../../util/glob.js';
 import { dirname, isAbsolute, join } from '../../../util/path.js';
-import { getStringValue, isStringLiteral } from '../../../typescript/visitors/helpers.js';
+import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
 export function createImportMetaGlobVisitor(ctx) {
     return {
         CallExpression(node) {

package/dist/plugins/webpack/visitors/requireContext.js

@@ -1,7 +1,7 @@
 import { IMPORT_FLAGS } from '../../../constants.js';
 import { _syncGlob } from '../../../util/glob.js';
 import { dirname, join, toRelative } from '../../../util/path.js';
-import { getStringValue, isStringLiteral } from '../../../typescript/visitors/helpers.js';
+import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
 export function createRequireContextVisitor(ctx) {
     return {
         CallExpression(node) {

package/dist/run.js

@@ -11,7 +11,7 @@ import watchReporter from './reporters/watch.js';
 import { debugLogObject } from './util/debug.js';
 import { flushGlobCache, initGlobCache } from './util/glob-cache.js';
 import { getGitIgnoredHandler } from './util/glob-core.js';
-import { getModuleSourcePathHandler } from './util/to-source-path.js';
+import { getModuleSourcePathHandler, getWorkspaceManifestHandler } from './util/to-source-path.js';
 import { getSessionHandler } from './util/watch.js';
 export const run = async (options) => {
     debugLogObject('*', 'Unresolved configuration', options);
@@ -27,7 +27,8 @@ export const run = async (options) => {
     const workspaces = await chief.getWorkspaces();
     const isGitIgnored = await getGitIgnoredHandler(options, new Set(workspaces.map(w => w.dir)));
     const toSourceFilePath = getModuleSourcePathHandler(chief);
-    const principal = new ProjectPrincipal(options, toSourceFilePath);
+    const findWorkspaceManifestImports = getWorkspaceManifestHandler(chief);
+    const principal = new ProjectPrincipal(options, toSourceFilePath, findWorkspaceManifestImports);
     collector.setWorkspaceFilter(chief.workspaceFilePathFilter);
     collector.setIgnoreIssues(chief.config.ignoreIssues);
     debugLogObject('*', 'Included workspaces', () => workspaces.map(w => w.pkgName));

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

@@ -1,5 +1,4 @@
 import type { ParseResult, Program } from 'oxc-parser';
-export declare const getStringValue: (node: any) => string | undefined;
 export declare const getPropertyKey: (prop: any) => string | undefined;
 export declare const getImportMap: (program: Program) => Map<string, string>;
 export declare const getDefaultImportName: (importMap: Map<string, string>, specifier: string) => string | undefined;

package/dist/typescript/ast-helpers.js

@@ -1,9 +1,7 @@
 import { Visitor } from 'oxc-parser';
 import stripJsonComments from 'strip-json-comments';
 import { extname, isInternal } from '../util/path.js';
-import { parseFile } from './visitors/helpers.js';
-const isStringLiteral = (node) => node?.type === 'StringLiteral' || (node?.type === 'Literal' && typeof node.value === 'string');
-export const getStringValue = (node) => (isStringLiteral(node) ? node.value : undefined);
+import { getStringValue, isStringLiteral, parseFile } from './ast-nodes.js';
 export const getPropertyKey = (prop) => prop?.key?.type === 'Identifier' ? prop.key.name : getStringValue(prop?.key);
 export const getImportMap = (program) => {
     const importMap = new Map();

package/dist/typescript/{visitors/helpers.d.ts → ast-nodes.d.ts}

@@ -1,7 +1,7 @@
 import { type TSEnumDeclaration, type TSModuleDeclaration } from 'oxc-parser';
-import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile } from '../../types/config.ts';
-import type { SymbolType } from '../../types/issues.ts';
-import type { ExportMember } from '../../types/module-graph.ts';
+import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile } from '../types/config.ts';
+import type { SymbolType } from '../types/issues.ts';
+import type { ExportMember } from '../types/module-graph.ts';
 export declare const parseFile: (filePath: string, sourceText: string) => import("oxc-parser").ParseResult;
 export type ResolveModule = (specifier: string, containingFile: string) => ResolvedModule | undefined;
 export interface ResolvedModule {

package/dist/typescript/{visitors/helpers.js → ast-nodes.js}

@@ -1,7 +1,7 @@
 import { parseSync, rawTransferSupported, } from 'oxc-parser';
-import { DEFAULT_EXTENSIONS, FIX_FLAGS, SYMBOL_TYPE } from '../../constants.js';
-import { extname } from '../../util/path.js';
-import { EMPTY_TAGS } from './jsdoc.js';
+import { DEFAULT_EXTENSIONS, FIX_FLAGS, SYMBOL_TYPE } from '../constants.js';
+import { extname } from '../util/path.js';
+import { EMPTY_TAGS } from './visitors/jsdoc.js';
 const defaultParseOptions = {
     sourceType: 'unambiguous',
     experimentalRawTransfer: rawTransferSupported(),

package/dist/typescript/follow-imports.js

@@ -1,6 +1,6 @@
 import { Visitor } from 'oxc-parser';
 import { isInNodeModules } from '../util/path.js';
-import { getStringValue, isStringLiteral, stripQuotes } from './visitors/helpers.js';
+import { getStringValue, isStringLiteral, stripQuotes } from './ast-nodes.js';
 const _requireSpecs = [];
 const _requireVisitor = new Visitor({
     CallExpression(node) {

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

@@ -1,5 +1,5 @@
 import type { ParseResult, Visitor } from 'oxc-parser';
 import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile, PluginVisitorContext } from '../types/config.ts';
 import type { FileNode } from '../types/module-graph.ts';
-import { type ResolveModule } from './visitors/helpers.ts';
+import { type ResolveModule } from './ast-nodes.ts';
 export declare const _getImportsAndExports: (filePath: string, sourceText: string, resolveModule: ResolveModule, options: GetImportsAndExportsOptions, ignoreExportsUsedInFile: IgnoreExportsUsedInFile, skipExportsForFile: boolean, visitor: Visitor, pluginCtx: PluginVisitorContext | undefined, cachedParseResult?: ParseResult) => FileNode;

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

@@ -6,7 +6,7 @@ import { timerify } from '../util/Performance.js';
 import { dirname, isInNodeModules, resolve } from '../util/path.js';
 import { shouldIgnore } from '../util/tag.js';
 import { extractImportsFromComments } from './comments.js';
-import { buildLineStarts, getLineAndCol, parseFile, shouldCountRefs, } from './visitors/helpers.js';
+import { buildLineStarts, getLineAndCol, parseFile, shouldCountRefs, } from './ast-nodes.js';
 import { buildJSDocTagLookup } from './visitors/jsdoc.js';
 import { walkAST } from './visitors/walk.js';
 const getImportsAndExports = (filePath, sourceText, resolveModule, options, ignoreExportsUsedInFile, skipExportsForFile, visitor, pluginCtx, cachedParseResult) => {

package/dist/typescript/resolve-module-names.d.ts

@@ -1,7 +1,7 @@
-import type { ToSourceFilePath } from '../util/to-source-path.ts';
-import type { ResolveModule } from './visitors/helpers.ts';
+import type { ToSourceFilePath, WorkspaceManifestHandler } from '../util/to-source-path.ts';
+import type { ResolveModule } from './ast-nodes.ts';
 export declare function clearModuleResolutionCaches(): void;
 export declare function createCustomModuleResolver(compilerOptions: {
     paths?: Record<string, string[]>;
     rootDirs?: string[];
-}, customCompilerExtensions: string[], toSourceFilePath: ToSourceFilePath): ResolveModule;
+}, customCompilerExtensions: string[], toSourceFilePath: ToSourceFilePath, findWorkspaceManifestImports?: WorkspaceManifestHandler): ResolveModule;

package/dist/typescript/resolve-module-names.js

@@ -5,6 +5,23 @@ import { sanitizeSpecifier } from '../util/modules.js';
 import { timerify } from '../util/Performance.js';
 import { dirname, extname, isAbsolute, isInNodeModules, join } from '../util/path.js';
 import { _createSyncModuleResolver, _resolveModuleSync } from '../util/resolve.js';
+function pickStringTarget(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return;
+    const obj = value;
+    for (const key of ['default', 'node', 'import', 'require']) {
+        const v = pickStringTarget(obj[key]);
+        if (v)
+            return v;
+    }
+    for (const v of Object.values(obj)) {
+        const s = pickStringTarget(v);
+        if (s)
+            return s;
+    }
+}
 const moduleResolutionCaches = [];
 export function clearModuleResolutionCaches() {
     for (const cache of moduleResolutionCaches)
@@ -25,7 +42,7 @@ function compilePathMappings(paths) {
     }
     return mappings.length > 0 ? mappings : undefined;
 }
-export function createCustomModuleResolver(compilerOptions, customCompilerExtensions, toSourceFilePath) {
+export function createCustomModuleResolver(compilerOptions, customCompilerExtensions, toSourceFilePath, findWorkspaceManifestImports) {
     const customCompilerExtensionsSet = new Set(customCompilerExtensions);
     const hasCustomExts = customCompilerExtensionsSet.size > 0;
     const extensions = [...DEFAULT_EXTENSIONS, ...customCompilerExtensions, ...DTS_EXTENSIONS];
@@ -83,6 +100,17 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
                 }
             }
         }
+        if (specifier.startsWith('#') && findWorkspaceManifestImports) {
+            const ws = findWorkspaceManifestImports(containingFile);
+            if (ws) {
+                const target = pickStringTarget(ws.imports[specifier]);
+                if (target?.startsWith('.')) {
+                    const sourcePath = toSourceFilePath(join(ws.dir, target));
+                    if (sourcePath)
+                        return toResult(sourcePath);
+                }
+            }
+        }
         if (rootDirs && !isAbsolute(specifier)) {
             const containingDir = dirname(containingFile);
             for (const srcRoot of rootDirs) {

package/dist/typescript/visitors/calls.js

@@ -1,6 +1,6 @@
 import { IMPORT_FLAGS, OPAQUE } from '../../constants.js';
 import { addValue } from '../../util/module-graph.js';
-import { getStringValue, isStringLiteral } from './helpers.js';
+import { getStringValue, isStringLiteral } from '../ast-nodes.js';
 function extractInlineDirnamePath(node, s) {
     if (node?.type !== 'CallExpression')
         return undefined;

package/dist/typescript/visitors/exports.js

@@ -1,6 +1,6 @@
 import { ALIAS_TAG, FIX_FLAGS, IMPORT_FLAGS, IMPORT_STAR, SYMBOL_TYPE } from '../../constants.js';
 import { addNsValue, addValue } from '../../util/module-graph.js';
-import { extractEnumMembers, extractNamespaceMembers, getLineAndCol, getStringValue, isStringLiteral, } from './helpers.js';
+import { extractEnumMembers, extractNamespaceMembers, getLineAndCol, getStringValue, isStringLiteral, } from '../ast-nodes.js';
 import { EMPTY_TAGS } from './jsdoc.js';
 const getName = (n) => (n?.type === 'Identifier' ? n.name : undefined);
 const hasExplicitFunctionReturnType = (node) => !!node &&

package/dist/typescript/visitors/imports.js

@@ -1,7 +1,7 @@
 import { IMPORT_FLAGS, IMPORT_STAR, OPAQUE } from '../../constants.js';
 import { addValue } from '../../util/module-graph.js';
 import { isInNodeModules } from '../../util/path.js';
-import { getStringValue, isStringLiteral } from './helpers.js';
+import { getStringValue, isStringLiteral } from '../ast-nodes.js';
 export function handleVariableDeclarator(node, s) {
     const init = node.init;
     if (!init)

package/dist/typescript/visitors/members.js

@@ -1,6 +1,6 @@
 import { OPAQUE } from '../../constants.js';
 import { addValue } from '../../util/module-graph.js';
-import { getStringValue, isStringLiteral } from './helpers.js';
+import { getStringValue, isStringLiteral } from '../ast-nodes.js';
 import { isShadowed } from './walk.js';
 export function handleMemberExpression(node, s) {
     if (node.object.type === 'MemberExpression' && node.object.object.type === 'MemberExpression') {

package/dist/typescript/visitors/walk.d.ts

@@ -4,7 +4,7 @@ import type { GetImportsAndExportsOptions } from '../../types/config.ts';
 import type { Fix } from '../../types/exports.ts';
 import type { IssueSymbol, SymbolType } from '../../types/issues.ts';
 import type { Export, ExportMember, ImportMap, ImportMaps } from '../../types/module-graph.ts';
-import { type ResolveModule } from './helpers.ts';
+import { type ResolveModule } from '../ast-nodes.ts';
 interface WalkContext {
     lineStarts: number[];
     skipExports: boolean;

package/dist/typescript/visitors/walk.js

@@ -2,7 +2,7 @@ import { Visitor, visitorKeys, } from 'oxc-parser';
 import { FIX_FLAGS, IMPORT_FLAGS, OPAQUE, SYMBOL_TYPE } from '../../constants.js';
 import { addValue } from '../../util/module-graph.js';
 import { isInNodeModules } from '../../util/path.js';
-import { getLineAndCol, getStringValue, isStringLiteral } from './helpers.js';
+import { getLineAndCol, getStringValue, isStringLiteral } from '../ast-nodes.js';
 import { EMPTY_TAGS } from './jsdoc.js';
 import { handleCallExpression, handleNewExpression } from './calls.js';
 import { handleExportAssignment, handleExportDefault, handleExportNamed, handleExpressionStatement, } from './exports.js';

package/dist/util/load-tsconfig.d.ts

@@ -1,3 +1,4 @@
+import type { SourceMap } from '../types/config.ts';
 import type { CompilerOptions } from '../types/project.ts';
 interface TSConfigInfo {
     isFile: boolean;
@@ -5,6 +6,7 @@ interface TSConfigInfo {
     fileNames: string[];
     include: string[] | undefined;
     exclude: string[] | undefined;
+    sourceMapPairs: SourceMap[];
 }
 export declare const loadTSConfig: (tsConfigFilePath: string) => Promise<TSConfigInfo>;
 export {};

package/dist/util/load-tsconfig.js

@@ -52,12 +52,11 @@ const resolveReference = (refPath, dir) => {
     const withTsconfig = join(abs, 'tsconfig.json');
     return isFile(withTsconfig) ? withTsconfig : undefined;
 };
-const fillFromReferences = (target, references, dir, visited) => {
+const absDir = (path, dir) => toAbsolute(path, dir).replace(/\/+$/, '');
+const walkReferences = (target, references, dir, visited, pairs) => {
     if (!references?.length)
         return;
     for (const ref of references) {
-        if (target.outDir && target.rootDir)
-            return;
         const refPath = resolveReference(ref.path, dir);
         if (!refPath || visited.has(refPath))
             continue;
@@ -65,12 +64,16 @@ const fillFromReferences = (target, references, dir, visited) => {
         const refConfig = parseTsconfig(refPath);
         const refDir = dirname(refPath);
         const refOpts = refConfig.compilerOptions;
-        if (refOpts?.outDir && !target.outDir)
-            target.outDir = toAbsolute(refOpts.outDir, refDir).replace(/\/+$/, '');
-        if (refOpts?.rootDir && !target.rootDir)
-            target.rootDir = toAbsolute(refOpts.rootDir, refDir).replace(/\/+$/, '');
-        if (!refOpts?.outDir || !refOpts?.rootDir)
-            fillFromReferences(target, refConfig.references, refDir, visited);
+        const refOutDir = refOpts?.outDir ? absDir(refOpts.outDir, refDir) : undefined;
+        const refRootDir = refOpts?.rootDir ? absDir(refOpts.rootDir, refDir) : undefined;
+        if (refOutDir && refRootDir && refOutDir !== refRootDir)
+            pairs.push({ srcDir: refRootDir, outDir: refOutDir });
+        if (refOutDir && !target.outDir)
+            target.outDir = refOutDir;
+        if (refRootDir && !target.rootDir)
+            target.rootDir = refRootDir;
+        if (!refOutDir || !refRootDir)
+            walkReferences(target, refConfig.references, refDir, visited, pairs);
     }
 };
 const EMPTY = {
@@ -78,6 +81,7 @@ const EMPTY = {
     fileNames: [],
     include: undefined,
     exclude: undefined,
+    sourceMapPairs: [],
 };
 export const loadTSConfig = async (tsConfigFilePath) => {
     if (!isFile(tsConfigFilePath))
@@ -87,23 +91,24 @@ export const loadTSConfig = async (tsConfigFilePath) => {
         const dir = dirname(tsConfigFilePath);
         const compilerOptions = (config.compilerOptions ?? {});
         if (compilerOptions.outDir)
-            compilerOptions.outDir = toAbsolute(compilerOptions.outDir, dir).replace(/\/+$/, '');
+            compilerOptions.outDir = absDir(compilerOptions.outDir, dir);
         if (compilerOptions.rootDir)
-            compilerOptions.rootDir = toAbsolute(compilerOptions.rootDir, dir).replace(/\/+$/, '');
+            compilerOptions.rootDir = absDir(compilerOptions.rootDir, dir);
         if (compilerOptions.paths) {
             compilerOptions.pathsBasePath ??= dir;
         }
         if (compilerOptions.rootDirs) {
             compilerOptions.rootDirs = compilerOptions.rootDirs.map((d) => (isAbsolute(d) ? d : join(dir, d)));
         }
-        if ((!compilerOptions.outDir || !compilerOptions.rootDir) && config.references?.length) {
-            fillFromReferences(compilerOptions, config.references, dir, new Set([tsConfigFilePath]));
+        const sourceMapPairs = [];
+        if (config.references?.length) {
+            walkReferences(compilerOptions, config.references, dir, new Set([tsConfigFilePath]), sourceMapPairs);
         }
         const include = resolvePatterns(config.include, dir, true);
         const exclude = resolvePatterns(config.exclude, dir, true);
         const files = resolvePatterns(config.files, dir);
         const fileNames = expandFileNames(dir, compilerOptions, include, exclude, files);
-        return { isFile: true, compilerOptions, fileNames, include, exclude };
+        return { isFile: true, compilerOptions, fileNames, include, exclude, sourceMapPairs };
     }
     catch {
         return { isFile: true, ...EMPTY };

package/dist/util/to-source-path.d.ts

@@ -2,6 +2,11 @@ import type { SourceMap } from '../types/config.ts';
 import type { CompilerOptions } from '../types/project.ts';
 import type { ConfigurationChief, Workspace } from '../ConfigurationChief.ts';
 export declare const augmentWorkspace: (workspace: Workspace, dir: string, compilerOptions: CompilerOptions | undefined, pluginSourceMaps?: SourceMap[]) => void;
+export type WorkspaceManifestHandler = (filePath: string) => {
+    dir: string;
+    imports: unknown;
+} | undefined;
+export declare const getWorkspaceManifestHandler: (chief: ConfigurationChief) => WorkspaceManifestHandler;
 export declare const getModuleSourcePathHandler: (chief: ConfigurationChief) => (filePath: string) => string | undefined;
 export declare const getToSourcePathsHandler: (chief: ConfigurationChief) => (specifiers: Set<string>, dir: string, extensions: (string | undefined) | undefined, label: string) => Promise<string[]>;
 export declare const toSourceMappedSpecifiers: (ws: Workspace | undefined, absSpecifier: string, extensions?: string) => string[];

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

@@ -17,17 +17,41 @@ export const augmentWorkspace = (workspace, dir, compilerOptions, pluginSourceMa
     const all = compilerOptions ? [...pluginSourceMaps, tsconfigSourceMap(dir, compilerOptions)] : pluginSourceMaps;
     if (all.length === 0)
         return;
-    workspace.sourceMaps = all.sort((a, b) => b.outDir.length - a.outDir.length);
+    const seen = new Set();
+    const unique = [];
+    for (const sm of all) {
+        const key = `${sm.srcDir}\0${sm.outDir}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(sm);
+    }
+    workspace.sourceMaps = unique.sort((a, b) => b.outDir.length - a.outDir.length);
 };
 const isUnderOutDir = (absPath, outDir) => absPath === outDir || absPath.startsWith(`${outDir}/`);
-const isUnderSrcDir = (absPath, srcDir) => absPath === srcDir || absPath.startsWith(`${srcDir}/`);
+const rewriteOne = (pair, absSpecifier, extensions) => {
+    if (pair.srcDir === pair.outDir || !isUnderOutDir(absSpecifier, pair.outDir))
+        return;
+    return pair.srcDir + absSpecifier.slice(pair.outDir.length).replace(matchExt, extensions);
+};
 const rewritePattern = (sourceMaps, absSpecifier, extensions) => {
-    for (const { srcDir, outDir } of sourceMaps) {
-        if (!isUnderSrcDir(absSpecifier, srcDir) && isUnderOutDir(absSpecifier, outDir)) {
-            return srcDir + absSpecifier.slice(outDir.length).replace(matchExt, extensions);
-        }
+    for (const sm of sourceMaps) {
+        const r = rewriteOne(sm, absSpecifier, extensions);
+        if (r)
+            return r;
     }
 };
+export const getWorkspaceManifestHandler = (chief) => {
+    return (filePath) => {
+        const workspace = chief.findWorkspaceByFilePath(filePath);
+        if (!workspace)
+            return;
+        const manifest = chief.workspacePackages.get(workspace.name)?.manifest;
+        if (!manifest?.imports)
+            return;
+        return { dir: workspace.dir, imports: manifest.imports };
+    };
+};
 export const getModuleSourcePathHandler = (chief) => {
     const toSourceMapCache = new Map();
     return (filePath) => {
@@ -36,21 +60,22 @@ export const getModuleSourcePathHandler = (chief) => {
         if (toSourceMapCache.has(filePath))
             return toSourceMapCache.get(filePath);
         const workspace = chief.findWorkspaceByFilePath(filePath);
-        if (!workspace?.sourceMaps)
-            return;
-        for (const { srcDir, outDir } of workspace.sourceMaps) {
-            if (!(isUnderOutDir(filePath, outDir) || srcDir === outDir))
-                continue;
-            const basePath = (srcDir + filePath.slice(outDir.length)).replace(matchExt, '');
-            const srcFilePath = findFileWithExtensions(basePath, sourceExtensions);
-            if (srcFilePath) {
-                toSourceMapCache.set(filePath, srcFilePath);
-                if (srcFilePath !== filePath) {
+        let result;
+        if (workspace?.sourceMaps) {
+            for (const { srcDir, outDir } of workspace.sourceMaps) {
+                if (!(isUnderOutDir(filePath, outDir) || srcDir === outDir))
+                    continue;
+                const basePath = (srcDir + filePath.slice(outDir.length)).replace(matchExt, '');
+                const srcFilePath = findFileWithExtensions(basePath, sourceExtensions);
+                if (srcFilePath && srcFilePath !== filePath) {
                     debugLog('*', `Source mapping ${toRelative(filePath, chief.cwd)} → ${toRelative(srcFilePath, chief.cwd)}`);
-                    return srcFilePath;
+                    result = srcFilePath;
+                    break;
                 }
             }
         }
+        toSourceMapCache.set(filePath, result);
+        return result;
     };
 };
 export const getToSourcePathsHandler = (chief) => {
@@ -69,11 +94,11 @@ export const getToSourcePathsHandler = (chief) => {
 };
 export const toSourceMappedSpecifiers = (ws, absSpecifier, extensions = defaultExtensions) => {
     const out = [];
-    if (!ws?.sourceMaps)
-        return out;
-    for (const { srcDir, outDir } of ws.sourceMaps) {
-        if (!isUnderSrcDir(absSpecifier, srcDir) && isUnderOutDir(absSpecifier, outDir)) {
-            out.push(srcDir + absSpecifier.slice(outDir.length).replace(matchExt, extensions));
+    if (ws?.sourceMaps) {
+        for (const sm of ws.sourceMaps) {
+            const r = rewriteOne(sm, absSpecifier, extensions);
+            if (r)
+                out.push(r);
         }
     }
     return out;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.12.2";
+export declare const version = "6.13.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.12.2';
+export const version = '6.13.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.12.2",
+  "version": "6.13.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",
@@ -82,14 +82,14 @@
     "get-tsconfig": "4.14.0",
     "jiti": "^2.7.0",
     "minimist": "^1.2.8",
-    "oxc-parser": "^0.128.0",
+    "oxc-parser": "^0.130.0",
     "oxc-resolver": "^11.19.1",
     "picomatch": "^4.0.4",
     "smol-toml": "^1.6.1",
     "strip-json-comments": "5.0.3",
     "tinyglobby": "^0.2.16",
     "unbash": "^3.0.0",
-    "yaml": "^2.8.2",
+    "yaml": "^2.9.0",
     "zod": "^4.1.11"
   },
   "devDependencies": {
@@ -98,7 +98,7 @@
     "@types/minimist": "^1.2.5",
     "@types/picomatch": "^4.0.1",
     "@types/webpack": "^5.28.5",
-    "@typescript/native-preview": "7.0.0-dev.20260415.1",
+    "@typescript/native-preview": "7.0.0-dev.20260512.1",
     "@wdio/types": "^9.20.0",
     "codeclimate-types": "^0.3.1",
     "prettier": "^3.8.1",