knip 6.32.3 → 6.33.0

package/dist/DependencyDeputy.d.ts

@@ -22,9 +22,8 @@ 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, dir, manifestPath, manifestStr, manifest, ignoreDependencies: id, ignoreBinaries: ib, ignoreUnresolved: iu, }: {
         name: string;
-        cwd: string;
         dir: string;
         manifestPath: string;
         manifestStr: string;

package/dist/DependencyDeputy.js

@@ -26,7 +26,7 @@ export class DependencyDeputy {
         this.installedBinaries = new Map();
         this.hasTypesIncluded = new Map();
     }
-    addWorkspace({ name, cwd, dir, manifestPath, manifestStr, manifest, ignoreDependencies: id, ignoreBinaries: ib, ignoreUnresolved: iu, }) {
+    addWorkspace({ name, dir, manifestPath, manifestStr, manifest, ignoreDependencies: id, ignoreBinaries: ib, ignoreUnresolved: iu, }) {
         const dependencies = Object.keys(manifest.dependencies ?? {});
         const peerDependencies = Object.keys(manifest.peerDependencies ?? {});
         const optionalDependencies = Object.keys(manifest.optionalDependencies ?? {});
@@ -45,7 +45,6 @@ export class DependencyDeputy {
             const { hostDependencies, installedBinaries, hasTypesIncluded } = getDependencyMetaData({
                 packageNames,
                 dir,
-                cwd,
             });
             this.setHostDependencies(name, hostDependencies);
             this.installedBinaries.set(name, installedBinaries);

package/dist/ProjectPrincipal.js

@@ -21,6 +21,7 @@ export class ProjectPrincipal {
         sourceText: '',
         addScript: () => { },
         addImport: () => { },
+        markImportExpressionHandled: () => { },
         addImportGlob: () => { },
         markExportRegistered: () => { },
     };

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+import type { KnipConfig } from './types.ts';
+export declare const defineConfig: (config: KnipConfig) => KnipConfig;

package/dist/config.js

@@ -0,0 +1 @@
+export const defineConfig = (config) => config;

package/dist/graph/analyze.js

@@ -106,7 +106,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                     exportedItem.members.length > 0 &&
                                     exportedItem.type !== 'enum';
                                 if ((isEnumMembers || isNsMembers) && exportedItem.members.length > 0) {
-                                    if (importsForExport.enumerated?.has(identifier))
+                                    if (explorer.isEnumerated(filePath, identifier))
                                         continue;
                                     if (!options.includedIssueTypes.nsTypes && importsForExport.refs.has(identifier))
                                         continue;

package/dist/graph/build.js

@@ -41,7 +41,6 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             continue;
         deputy.addWorkspace({
             name,
-            cwd: options.cwd,
             dir,
             manifestPath,
             manifestStr,

package/dist/graph-explorer/explorer.d.ts

@@ -5,6 +5,7 @@ export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<s
         treatStarAtEntryAsReferenced?: boolean;
     }) => readonly [false, string | undefined];
     hasStrictlyNsReferences: (filePath: string, identifier: string) => [boolean, (string | undefined)?];
+    isEnumerated: (filePath: string, identifier: string) => boolean;
     buildExportsTree: (options: {
         filePath?: string;
         identifier?: string;

package/dist/graph-explorer/explorer.js

@@ -6,12 +6,14 @@ import { getContention } from './operations/get-contention.js';
 import { getDependencyUsage } from './operations/get-dependency-usage.js';
 import { getUsage } from './operations/get-usage.js';
 import { hasStrictlyNsReferences } from './operations/has-strictly-ns-references.js';
+import { isEnumerated } from './operations/is-enumerated.js';
 import { isReferenced } from './operations/is-referenced.js';
 import { resolveDefinition } from './operations/resolve-definition.js';
 export const createGraphExplorer = (graph, entryPaths) => {
     return {
         isReferenced: (filePath, identifier, options) => isReferenced(graph, entryPaths, filePath, identifier, options),
         hasStrictlyNsReferences: (filePath, identifier) => hasStrictlyNsReferences(graph, filePath, graph.get(filePath)?.importedBy, identifier),
+        isEnumerated: (filePath, identifier) => isEnumerated(graph, filePath, graph.get(filePath)?.importedBy, identifier),
         buildExportsTree: (options) => buildExportsTree(graph, entryPaths, options),
         getDependencyUsage: (pattern) => getDependencyUsage(graph, pattern),
         resolveDefinition: (filePath, identifier) => resolveDefinition(graph, filePath, identifier),

package/dist/graph-explorer/operations/is-enumerated.d.ts

@@ -0,0 +1,2 @@
+import type { ImportMaps, ModuleGraph } from '../../types/module-graph.ts';
+export declare const isEnumerated: (graph: ModuleGraph, filePath: string, importsForExport: ImportMaps | undefined, identifier: string) => boolean;

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

@@ -0,0 +1,33 @@
+import { getAliasReExportMap, getPassThroughReExportSources, getStarReExportSources } from '../visitors.js';
+export const isEnumerated = (graph, filePath, importsForExport, identifier) => {
+    const seen = new Set();
+    const walkDown = (path, importMaps, id) => {
+        if (!importMaps || seen.has(path))
+            return false;
+        seen.add(path);
+        if (importMaps.enumerated?.has(id))
+            return true;
+        const follow = (sources, nextId) => {
+            for (const source of sources) {
+                if (walkDown(source, graph.get(source)?.importedBy, nextId))
+                    return true;
+            }
+            return false;
+        };
+        const directSources = getPassThroughReExportSources(importMaps, id);
+        if (directSources && follow(directSources, id))
+            return true;
+        const starSources = getStarReExportSources(importMaps);
+        if (starSources && follow(starSources, id))
+            return true;
+        const aliasMap = getAliasReExportMap(importMaps, id);
+        if (aliasMap) {
+            for (const [alias, sources] of aliasMap) {
+                if (follow(sources, alias))
+                    return true;
+            }
+        }
+        return false;
+    };
+    return walkDown(filePath, importsForExport, identifier);
+};

package/dist/manifest/helpers.d.ts

@@ -1,9 +1,8 @@
-import type { Scripts } from '../types/package-json.ts';
+import type { PackageJson, Scripts } from '../types/package-json.ts';
 type LoadPackageManifestOptions = {
     dir: string;
     packageName: string;
-    cwd: string;
 };
-export declare const loadPackageManifest: ({ dir, packageName, cwd }: LoadPackageManifestOptions) => any;
+export declare const loadPackageManifest: ({ dir, packageName }: LoadPackageManifestOptions) => PackageJson | undefined;
 export declare const getFilteredScripts: (scripts: Scripts) => Scripts[];
 export {};

package/dist/manifest/helpers.js

@@ -1,49 +1,13 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join } from '../util/path.js';
+import { resolvePackageManifestPath } from '../util/resolve.js';
 import { _require } from '../util/require.js';
-const monorepoRootCache = new Map();
-const findMonorepoRootAbove = (startDir) => {
-    if (monorepoRootCache.has(startDir))
-        return monorepoRootCache.get(startDir);
-    let current = dirname(startDir);
-    let result;
-    while (current !== dirname(current)) {
-        if (existsSync(join(current, 'pnpm-workspace.yaml'))) {
-            result = current;
-            break;
-        }
-        try {
-            const pkg = JSON.parse(readFileSync(join(current, 'package.json'), 'utf8'));
-            if (pkg.workspaces) {
-                result = current;
-                break;
-            }
-        }
-        catch { }
-        current = dirname(current);
-    }
-    monorepoRootCache.set(startDir, result);
-    return result;
-};
-export const loadPackageManifest = ({ dir, packageName, cwd }) => {
+export const loadPackageManifest = ({ dir, packageName }) => {
+    const manifestPath = resolvePackageManifestPath(packageName, dir);
+    if (!manifestPath)
+        return;
     try {
-        return _require(join(dir, 'node_modules', packageName, 'package.json'));
+        return _require(manifestPath);
     }
     catch { }
-    if (dir !== cwd) {
-        try {
-            return _require(join(cwd, 'node_modules', packageName, 'package.json'));
-        }
-        catch { }
-        return;
-    }
-    const root = findMonorepoRootAbove(cwd);
-    if (root) {
-        try {
-            return _require(join(root, 'node_modules', packageName, 'package.json'));
-        }
-        catch { }
-    }
 };
 export const getFilteredScripts = (scripts) => {
     if (!scripts)

package/dist/manifest/index.d.ts

@@ -2,9 +2,8 @@ import type { HostDependencies, InstalledBinaries } from '../types/workspace.ts'
 type Options = {
     packageNames: string[];
     dir: string;
-    cwd: string;
 };
-declare const getMetaDataFromPackageJson: ({ cwd, dir, packageNames }: Options) => {
+declare const getMetaDataFromPackageJson: ({ dir, packageNames }: Options) => {
     hostDependencies: HostDependencies;
     installedBinaries: InstalledBinaries;
     hasTypesIncluded: Set<string>;

package/dist/manifest/index.js

@@ -1,7 +1,7 @@
 import { isDefinitelyTyped } from '../util/modules.js';
 import { timerify } from '../util/Performance.js';
 import { loadPackageManifest } from './helpers.js';
-const getMetaDataFromPackageJson = ({ cwd, dir, packageNames }) => {
+const getMetaDataFromPackageJson = ({ dir, packageNames }) => {
     const hostDependencies = new Map();
     const installedBinaries = new Map();
     const hasTypesIncluded = new Set();
@@ -13,7 +13,7 @@ const getMetaDataFromPackageJson = ({ cwd, dir, packageNames }) => {
             installedBinaries.set(key, new Set([value]));
     };
     for (const packageName of packageNames) {
-        const manifest = loadPackageManifest({ cwd, dir, packageName });
+        const manifest = loadPackageManifest({ dir, packageName });
         if (manifest) {
             const defaultBinaryName = packageName.replace(/^@[^/]+\//, '');
             const binaries = typeof manifest.bin === 'string' ? [defaultBinaryName] : Object.keys(manifest.bin ?? {});

package/dist/plugins/dotenv/index.js

@@ -1,14 +1,7 @@
 import { argsFrom } from '../../binaries/util.js';
 const title = 'dotenv';
 const args = {
-    fromArgs: (parsed, args) => {
-        if (parsed._[0])
-            return argsFrom(args, parsed._[0]);
-        if (!parsed['--'] || parsed['--'].length === 0)
-            return [];
-        const script = parsed['--'].map(arg => (arg.includes(' ') ? `"${arg}"` : arg)).join(' ');
-        return [script];
-    },
+    fromArgs: (parsed, args) => (parsed._[0] ? argsFrom(args, parsed._[0]) : (parsed['--'] ?? [])),
 };
 const plugin = {
     title,

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

@@ -1,6 +1,7 @@
 import type { PluginOptions } from '../../types/config.ts';
 import { type ConfigInput, type Input } from '../../util/input.ts';
-import type { ESLintConfig, ESLintConfigDeprecated, OverrideConfigDeprecated } from './types.ts';
+import type { ESLintConfig, ESLintConfigDeprecated, OverrideConfigDeprecated, Settings } from './types.ts';
 export declare const isFlatConfig: (fileName: string) => boolean;
 export declare const getInputs: (config: ESLintConfigDeprecated | OverrideConfigDeprecated | ESLintConfig, options: PluginOptions) => (Input | ConfigInput)[];
+export declare const getInputsFromSettings: (settings?: Settings) => Input[];
 export declare const resolveFormatters: (formatters: string | string[]) => Set<Input>;

package/dist/plugins/eslint/helpers.js

@@ -80,6 +80,7 @@ const getDependenciesFromSettings = (settings = {}) => {
         }
     });
 };
+export const getInputsFromSettings = (settings) => compact(getDependenciesFromSettings(settings)).map(id => toDeferResolve(id, { optional: true }));
 const builtinFormatters = new Set(['html', 'json-with-metadata', 'json', 'stylish']);
 export const resolveFormatters = (formatters) => {
     const inputs = new Set();

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

@@ -1,3 +1,4 @@
 import type { Program } from 'oxc-parser';
 import { type Input } from '../../util/input.ts';
+export declare const getInputsFromSettingsAST: (program: Program) => Input[];
 export declare const getInputsFromFlatConfigAST: (program: Program) => Input[];

package/dist/plugins/eslint/resolveFromAST.js

@@ -3,7 +3,7 @@ import { toDeferResolve } from '../../util/input.js';
 import { findProperty, getPropertyKey } from '../../typescript/ast-helpers.js';
 import { getStringValue } from '../../typescript/ast-nodes.js';
 import { isInternal } from '../../util/path.js';
-export const getInputsFromFlatConfigAST = (program) => {
+export const getInputsFromSettingsAST = (program) => {
     const inputs = [];
     const addResolver = (key, resolver) => {
         if (!resolver || resolver === 'node' || isInternal(resolver))
@@ -35,6 +35,9 @@ export const getInputsFromFlatConfigAST = (program) => {
         },
     });
     visitor.visit(program);
-    inputs.push(toDeferResolve('eslint-import-resolver-typescript', { optional: true }));
     return inputs;
 };
+export const getInputsFromFlatConfigAST = (program) => [
+    ...getInputsFromSettingsAST(program),
+    toDeferResolve('eslint-import-resolver-typescript', { optional: true }),
+];

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

@@ -6,7 +6,7 @@ type ParserOptions = {
         presets: string[];
     };
 };
-type Settings = Record<string, Record<string, unknown> | string>;
+export type Settings = Record<string, Record<string, unknown> | string>;
 type Rules = Record<string, string | number>;
 type BaseConfig = {
     extends?: string | string[];

package/dist/plugins/moonrepo/index.js

@@ -1,4 +1,5 @@
 import { hasDependency } from '../../util/plugin.js';
+import { toShellCommand } from '../../util/scripts.js';
 const title = 'moonrepo';
 const enablers = ['@moonrepo/cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -6,12 +7,11 @@ const isRootOnly = true;
 const config = ['moon.yml', '.moon/tasks.yml', '.moon/tasks/*.yml'];
 const resolveConfig = async (config, options) => {
     const tasks = config.tasks ? Object.values(config.tasks) : [];
+    const expand = (value) => value.replace('$workspaceRoot', options.rootCwd).replace('$projectRoot', options.cwd);
     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))
+        .map(command => (Array.isArray(command) ? toShellCommand(command.map(expand)) : expand(command)))
         .flatMap(command => options.getInputsFromScripts(command));
     return [...inputs];
 };

package/dist/plugins/nuxt/index.js

@@ -49,6 +49,26 @@ const resolveAlias = (specifier, srcDir, rootDir) => {
         return join(srcDir, specifier.slice(2));
     return specifier;
 };
+const remoteSourcePrefixes = ['gh:', 'github:', 'gitlab:', 'bitbucket:', 'https://', 'http://'];
+const toLayerSource = (layer) => {
+    if (typeof layer === 'string')
+        return layer;
+    if (Array.isArray(layer))
+        return layer[0];
+    if (layer && typeof layer === 'object' && 'source' in layer)
+        return layer.source;
+};
+const toLayerSources = (extend) => {
+    const sources = [];
+    if (!extend)
+        return sources;
+    for (const layer of Array.isArray(extend) ? extend : [extend]) {
+        const source = toLayerSource(layer);
+        if (typeof source === 'string')
+            sources.push(source);
+    }
+    return sources;
+};
 const addAppEntries = (inputs, srcDir, serverDir, config, dir) => {
     for (const id of entry)
         inputs.push(toEntry(join(srcDir, id)));
@@ -111,15 +131,17 @@ const resolveConfig = async (localConfig, options) => {
             }
         }
     }
-    for (const ext of localConfig.extends ?? []) {
-        const target = resolveAlias(ext, srcDir, cwd);
+    for (const source of toLayerSources(localConfig.extends)) {
+        if (remoteSourcePrefixes.some(prefix => source.startsWith(prefix)))
+            continue;
+        const target = resolveAlias(source, srcDir, cwd);
         const resolved = isInternal(target) ? toAbsolute(target, cwd) : target;
         const configs = _syncGlob({ cwd: resolved, patterns: config });
         if (configs.length > 0)
             for (const cfg of configs)
                 inputs.push(toConfig('nuxt', cfg));
         else
-            inputs.push(toDependency(ext));
+            inputs.push(toDependency(source));
     }
     for (const layerConfig of findLayerConfigs(cwd)) {
         inputs.push(toConfig('nuxt', layerConfig));

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

@@ -1,3 +1,6 @@
+type NuxtLayer = string | [string, unknown?] | {
+    source: string;
+};
 export interface NuxtConfig {
     srcDir?: string;
     buildDir?: string;
@@ -14,7 +17,7 @@ export interface NuxtConfig {
         autoImport?: boolean;
         dirs?: string[];
     };
-    extends?: string[];
+    extends?: NuxtLayer | NuxtLayer[];
     components?: Array<string | {
         path: string;
     }> | {
@@ -25,3 +28,4 @@ export interface NuxtConfig {
     css?: string[];
     alias?: Record<string, string>;
 }
+export {};

package/dist/plugins/oxlint/index.js

@@ -3,10 +3,12 @@ import { findProperty, getPropertyValues } from '../../typescript/ast-helpers.js
 import { toDependency, toEntry } from '../../util/input.js';
 import { isInternal } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
+import { getInputsFromSettings } from '../eslint/helpers.js';
+import { getInputsFromSettingsAST } from '../eslint/resolveFromAST.js';
 const title = 'Oxlint';
 const enablers = ['oxlint', 'vite-plus'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.oxlintrc.json', 'oxlint.config.{ts,mts}', 'vite.config.{js,mjs,ts,cjs,mts,cts}'];
+const config = ['.oxlintrc.{json,jsonc}', 'oxlint.config.{ts,mts}', 'vite.config.{js,mjs,ts,cjs,mts,cts}'];
 const isViteConfig = (configFileName) => configFileName.startsWith('vite.config.');
 const args = {
     config: true,
@@ -29,6 +31,8 @@ const resolveConfig = config => {
         for (const input of resolveJsPlugins(override.jsPlugins))
             inputs.push(input);
     }
+    for (const input of getInputsFromSettings(config.settings))
+        inputs.push(input);
     return inputs;
 };
 const resolveFromAST = (program, options) => {
@@ -51,7 +55,7 @@ const resolveFromAST = (program, options) => {
         },
     });
     visitor.visit(program);
-    return resolveJsPlugins([...jsPlugins]);
+    return [...resolveJsPlugins([...jsPlugins]), ...getInputsFromSettingsAST(program)];
 };
 const plugin = {
     title,

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

@@ -1,3 +1,4 @@
+import type { Settings } from '../eslint/types.ts';
 type JsPlugin = string | {
     name: string;
     specifier: string;
@@ -8,5 +9,6 @@ type Override = {
 export type OxlintConfig = {
     jsPlugins?: JsPlugin[];
     overrides?: Override[];
+    settings?: Settings;
 };
 export {};

package/dist/plugins/typescript/index.js

@@ -1,12 +1,21 @@
 import { compact } from '../../util/array.js';
-import { toConfig, toDeferResolve, toProductionDependency } from '../../util/input.js';
+import { toConfig, toDeferResolve, toDependency, toProductionDependency } from '../../util/input.js';
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
+import { toShellCommand } from '../../util/scripts.js';
 const title = 'TypeScript';
 const enablers = ['typescript', '@typescript/native', '@typescript/native-preview'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['tsconfig.json'];
-const resolveConfig = async (localConfig, options) => {
+const config = ['tsconfig.json', 'package.json'];
+const packageJsonPath = 'typescript.contentMapper';
+const resolveContentMapper = ({ exec }, options) => {
+    if (!Array.isArray(exec) || exec.some(arg => typeof arg !== 'string'))
+        return [];
+    return options
+        .getInputsFromScripts(toShellCommand(exec))
+        .map(input => input.type === 'entry' || input.type === 'deferResolveEntry' ? { ...input, production: true } : input);
+};
+const resolveTsConfig = (localConfig, options) => {
     const { compilerOptions } = localConfig;
     const extend = localConfig.extends
         ? [localConfig.extends]
@@ -16,8 +25,9 @@ const resolveConfig = async (localConfig, options) => {
     const references = localConfig.references
         ?.filter(reference => reference.path.endsWith('.json'))
         .map(reference => toConfig('typescript', reference.path, { containingFilePath: options.configFilePath })) ?? [];
+    const contentMappers = localConfig.contentMappers?.map(contentMapper => toDependency(contentMapper.package)) ?? [];
     if (!(compilerOptions && localConfig))
-        return compact([...extend, ...references]);
+        return compact([...contentMappers, ...extend, ...references]);
     const jsx = (compilerOptions?.jsxImportSource ? [compilerOptions.jsxImportSource] : []).map(toProductionDependency);
     const types = compilerOptions.types ?? [];
     const plugins = Array.isArray(compilerOptions?.plugins)
@@ -25,6 +35,7 @@ const resolveConfig = async (localConfig, options) => {
         : [];
     const importHelpers = compilerOptions?.importHelpers ? ['tslib'] : [];
     return compact([
+        ...contentMappers,
         ...extend,
         ...references,
         ...types.map(id => toDeferResolve(id, { isTypeOnly: true, dir: options.cwd })),
@@ -32,19 +43,25 @@ const resolveConfig = async (localConfig, options) => {
         ...jsx,
     ]);
 };
+const resolveConfig = (localConfig, options) => options.configFileName === 'package.json'
+    ? resolveContentMapper(localConfig, options)
+    : resolveTsConfig(localConfig, options);
 const args = {
     binaries: ['tsc', 'tsgo'],
     string: ['project'],
     alias: { project: ['p'] },
     config: [['project', (p) => (p.endsWith('.json') ? p : join(p, 'tsconfig.json'))]],
 };
-const note = "[What's up with that configurable tsconfig.json location?](/reference/faq#whats-up-with-that-configurable-tsconfigjson-location)";
+const note = `[What's up with that configurable tsconfig.json location?](/reference/faq#whats-up-with-that-configurable-tsconfigjson-location)
+
+In a content mapper package, the command in \`package.json#typescript.contentMapper.exec\` is resolved to a production entry.`;
 export const docs = { note };
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
+    packageJsonPath,
     resolveConfig,
     args,
 };

package/dist/plugins/vitest/index.js

@@ -6,6 +6,7 @@ import { isAbsolute, isInternal, join, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getIndexHtmlEntries } from '../vite/helpers.js';
 import { getAliasInputs, getEnvSpecifier, getExternalReporters } from './helpers.js';
+import { createVitestMockVisitor } from './visitors/mock.js';
 const title = 'Vitest';
 const enablers = ['vitest', 'vite-plus'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -15,7 +16,6 @@ const testEntry = ['**/*.{bench,test,test-d,spec,spec-d}.?(c|m)[jt]s?(x)'];
 const entry = [...testEntry, ...mocks];
 const benchmark = ['**/*.bench.?(c|m)[jt]s?(x)'];
 const findConfigDependencies = (localConfig, options, vitestRoot) => {
-    const { configFileDir: dir } = options;
     const testConfig = localConfig.test;
     if (!testConfig)
         return [];
@@ -37,7 +37,9 @@ const findConfigDependencies = (localConfig, options, vitestRoot) => {
         ...toDeferResolve(specifier),
         dir: vitestRoot,
     }));
-    const globalSetup = [testConfig.globalSetup ?? []].flat().map(specifier => ({ ...toDeferResolve(specifier), dir }));
+    const globalSetup = [testConfig.globalSetup ?? []]
+        .flat()
+        .map(specifier => ({ ...toDeferResolve(specifier), dir: vitestRoot }));
     const workspaceDependencies = [];
     if (testConfig.workspace !== undefined) {
         for (const workspaceConfig of testConfig.workspace) {
@@ -75,12 +77,14 @@ const getConfigs = async (localConfig) => {
             if (typeof config === 'function') {
                 for (const command of ['serve', 'build']) {
                     for (const mode of ['development', 'production']) {
-                        const cfg = await config({ command, mode, ssrBuild: undefined });
-                        configs.push(cfg);
-                        if (cfg.test?.projects) {
-                            for (const project of cfg.test.projects) {
-                                if (typeof project !== 'string') {
-                                    configs.push(project);
+                        for (const ssrBuild of command === 'build' ? [undefined, false, true] : [undefined]) {
+                            const cfg = await config({ command, mode, ssrBuild });
+                            configs.push(cfg);
+                            if (cfg.test?.projects) {
+                                for (const project of cfg.test.projects) {
+                                    if (typeof project !== 'string') {
+                                        configs.push(project);
+                                    }
                                 }
                             }
                         }
@@ -181,9 +185,8 @@ export const resolveConfig = async (localConfig, options) => {
         for (const dependency of findConfigDependencies(cfg, options, vitestRoot))
             inputs.add(dependency);
         const _entry = cfg.build?.lib?.entry ?? [];
-        const deps = (typeof _entry === 'string' ? [_entry] : Object.values(_entry))
-            .map(specifier => join(vitestRoot, specifier))
-            .map(id => toEntry(id));
+        const entries = typeof _entry === 'string' ? [_entry] : Array.isArray(_entry) ? _entry : Object.values(_entry).flat();
+        const deps = entries.map(specifier => join(vitestRoot, specifier)).map(id => toEntry(id));
         for (const dependency of deps)
             inputs.add(dependency);
     }
@@ -215,6 +218,9 @@ const args = {
         return inputs;
     },
 };
+const registerVisitors = ({ ctx, registerVisitor }) => {
+    registerVisitor(createVitestMockVisitor(ctx));
+};
 const plugin = {
     title,
     enablers,
@@ -223,5 +229,6 @@ const plugin = {
     entry,
     resolveConfig,
     args,
+    registerVisitors,
 };
 export default plugin;

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

@@ -43,7 +43,7 @@ export interface ViteConfig extends VitestConfig {
     build?: {
         lib?: {
             entry: string | string[] | {
-                [entryAlias: string]: string;
+                [entryAlias: string]: string | string[];
             };
         };
     };

package/dist/plugins/vitest/visitors/mock.d.ts

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

package/dist/plugins/vitest/visitors/mock.js

@@ -0,0 +1,50 @@
+import { IMPORT_FLAGS } from '../../../constants.js';
+import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
+import { isShadowed } from '../../../typescript/visitors/walk.js';
+export function createVitestMockVisitor(ctx) {
+    const viNames = new Set();
+    return {
+        Program(node) {
+            viNames.clear();
+            for (const statement of node.body) {
+                if (statement.type !== 'ImportDeclaration' ||
+                    !isStringLiteral(statement.source) ||
+                    getStringValue(statement.source) !== 'vitest')
+                    continue;
+                for (const specifier of statement.specifiers ?? []) {
+                    if (specifier.type === 'ImportSpecifier' &&
+                        specifier.imported.type === 'Identifier' &&
+                        specifier.imported.name === 'vi') {
+                        viNames.add(specifier.local.name);
+                    }
+                }
+            }
+        },
+        CallExpression(node) {
+            const argument = node.arguments[0];
+            const factory = node.arguments[1];
+            const factoryBody = factory?.type === 'ArrowFunctionExpression' &&
+                factory.body.type === 'ParenthesizedExpression' &&
+                factory.body.expression.type === 'ObjectExpression'
+                ? factory.body.expression
+                : undefined;
+            if (argument?.type !== 'ImportExpression' ||
+                !isStringLiteral(argument.source) ||
+                factory?.type !== 'ArrowFunctionExpression' ||
+                !factoryBody ||
+                factory.async ||
+                factory.params.length > 0 ||
+                factoryBody.properties.some(property => property.type === 'SpreadElement') ||
+                node.callee.type !== 'MemberExpression' ||
+                node.callee.computed ||
+                node.callee.object.type !== 'Identifier' ||
+                !viNames.has(node.callee.object.name) ||
+                isShadowed(node.callee.object.name, node.callee.object.start) ||
+                node.callee.property.type !== 'Identifier' ||
+                node.callee.property.name !== 'mock')
+                return;
+            ctx.markImportExpressionHandled(argument.start);
+            ctx.addImport(getStringValue(argument.source), argument.source.start, IMPORT_FLAGS.SIDE_EFFECTS);
+        },
+    };
+}

package/dist/plugins/webpack/index.js

@@ -105,20 +105,21 @@ export const findWebpackDependenciesFromConfig = async (config, options) => {
                     }
                 }
             }
-            if (typeof opts.entry === 'string')
-                entries.push(opts.entry);
-            else if (Array.isArray(opts.entry))
-                entries.push(...opts.entry);
-            else if (typeof opts.entry === 'object') {
-                for (const entry of Object.values(opts.entry)) {
-                    if (typeof entry === 'string')
-                        entries.push(entry);
-                    else if (Array.isArray(entry))
-                        entries.push(...entry);
-                    else if (typeof entry === 'function')
-                        entries.push(entry());
-                    else if (entry && typeof entry === 'object' && 'filename' in entry)
-                        entries.push(entry['filename']);
+            const entry = typeof opts.entry === 'function' ? await opts.entry() : opts.entry;
+            if (typeof entry === 'string')
+                entries.push(entry);
+            else if (Array.isArray(entry))
+                entries.push(...entry);
+            else if (typeof entry === 'object') {
+                for (const item of Object.values(entry)) {
+                    if (typeof item === 'string')
+                        entries.push(item);
+                    else if (Array.isArray(item))
+                        entries.push(...item);
+                    else if (typeof item === 'function')
+                        entries.push(item());
+                    else if (item && typeof item === 'object' && 'import' in item)
+                        entries.push(...[item.import].flat());
                 }
             }
             if (entries.length === 0 && opts.context)

package/dist/types/config.d.ts

@@ -138,6 +138,7 @@ export type PluginVisitorContext = {
     sourceText: string;
     addScript: (script: string) => void;
     addImport: (specifier: string, pos: number, modifiers: number) => void;
+    markImportExpressionHandled: (pos: number) => void;
     addImportGlob: (patterns: string[], options?: {
         base?: string;
         filter?: RegExp;

package/dist/types/tsconfig-json.d.ts

@@ -8,7 +8,13 @@ export interface TsConfigJson {
         }>;
         [key: string]: unknown;
     };
+    contentMappers?: {
+        package: string;
+    }[];
     references?: Array<{
         path: string;
     }>;
 }
+export interface ContentMapperManifest {
+    exec?: string[];
+}

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

@@ -25,6 +25,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
     const specifierExportNames = new Set();
     const scripts = new Set();
     const importGlobs = [];
+    const handledImportExpressions = new Set();
     const importAliases = new Map();
     const addImportAlias = (aliasName, id, importFilePath) => {
         const aliases = importAliases.get(aliasName);
@@ -278,6 +279,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         pluginCtx.sourceText = sourceText;
         pluginCtx.addScript = (s) => scripts.add(s);
         pluginCtx.addImport = (spec, pos, mod) => addImport(spec, undefined, undefined, undefined, pos, mod);
+        pluginCtx.markImportExpressionHandled = (pos) => handledImportExpressions.add(pos);
         pluginCtx.addImportGlob = (patterns, opts) => importGlobs.push({ patterns, base: opts?.base, filter: opts?.filter });
         pluginCtx.markExportRegistered = (name) => registeredCustomElements.add(name);
     }
@@ -311,6 +313,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         resolveModule,
         programFiles,
         entryFiles,
+        handledImportExpressions,
         visitor,
         getJSDocTags,
     });

package/dist/typescript/visitors/calls.js

@@ -202,7 +202,7 @@ export function handleCallExpression(node, s) {
                             addValue(internalImport.import, OPAQUE, s.filePath);
                         else {
                             internalImport.refs.add(arg.name);
-                            (internalImport.enumerated ??= new Set()).add(arg.name);
+                            (internalImport.enumerated ??= new Set()).add(_import.importedName);
                         }
                     }
                 }

package/dist/typescript/visitors/members.js

@@ -2,6 +2,12 @@ import { OPAQUE } from '../../constants.js';
 import { addValue } from '../../util/module-graph.js';
 import { getStringValue, isStringLiteral } from '../ast-nodes.js';
 import { isShadowed } from './walk.js';
+function markWholeObjectRead(internalImport, id) {
+    (internalImport.enumerated ??= new Set()).add(id);
+}
+function isNumericKey(value) {
+    return value != null && Number.isFinite(Number(value)) && String(Number(value)) === value;
+}
 export function handleMemberExpression(node, s) {
     if (node.object.type === 'MemberExpression' && node.object.object.type === 'MemberExpression') {
         s.chainedMemberExprs.add(node.object);
@@ -18,12 +24,21 @@ export function handleMemberExpression(node, s) {
                     memberName = node.property.name;
                 }
                 else if (node.computed && isStringLiteral(node.property)) {
-                    memberName = getStringValue(node.property);
+                    const value = getStringValue(node.property);
+                    if (!_import.isNamespace && isNumericKey(value)) {
+                        markWholeObjectRead(internalImport, _import.importedName);
+                        return;
+                    }
+                    memberName = value;
                 }
                 else if (node.computed && _import.isNamespace) {
                     addValue(internalImport.import, OPAQUE, s.filePath);
                     return;
                 }
+                else if (node.computed) {
+                    markWholeObjectRead(internalImport, _import.importedName);
+                    return;
+                }
                 if (memberName) {
                     if (_import.isDynamicImport) {
                         addValue(internalImport.import, memberName, s.filePath);
@@ -44,18 +59,51 @@ export function handleMemberExpression(node, s) {
         if (aliases) {
             s.accessedAliases.add(localName);
             let memberName;
+            let isWholeRead = false;
             if (node.computed === false && node.property.type === 'Identifier') {
                 memberName = node.property.name;
             }
             else if (node.computed && isStringLiteral(node.property)) {
-                memberName = getStringValue(node.property);
+                const value = getStringValue(node.property);
+                if (isNumericKey(value))
+                    isWholeRead = true;
+                else
+                    memberName = value;
             }
-            if (memberName) {
-                for (const alias of aliases) {
-                    const internalImport = s.internal.get(alias.filePath);
-                    if (internalImport) {
-                        s.addNsMemberRefs(internalImport, alias.id, memberName);
-                    }
+            else if (node.computed) {
+                isWholeRead = true;
+            }
+            for (const alias of aliases) {
+                const internalImport = s.internal.get(alias.filePath);
+                if (!internalImport)
+                    continue;
+                if (isWholeRead) {
+                    const origin = s.localImportMap.get(alias.id);
+                    markWholeObjectRead(internalImport, origin?.importedName ?? alias.id);
+                }
+                else if (memberName) {
+                    s.addNsMemberRefs(internalImport, alias.id, memberName);
+                }
+            }
+        }
+    }
+    if (node.computed &&
+        node.object.type === 'MemberExpression' &&
+        !node.object.computed &&
+        node.object.object.type === 'Identifier' &&
+        node.object.property.type === 'Identifier') {
+        const rootName = node.object.object.name;
+        if (!isShadowed(rootName, node.object.object.start)) {
+            const _import = s.localImportMap.get(rootName);
+            if (_import?.isNamespace) {
+                const internalImport = s.internal.get(_import.filePath);
+                if (internalImport) {
+                    const mid = node.object.property.name;
+                    const value = isStringLiteral(node.property) ? getStringValue(node.property) : undefined;
+                    if (value !== undefined && !isNumericKey(value))
+                        s.addNsMemberRefs(internalImport, rootName, `${mid}.${value}`);
+                    else
+                        markWholeObjectRead(internalImport, mid);
                 }
             }
         }

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

@@ -43,6 +43,7 @@ interface WalkContext {
     resolveModule: ResolveModule;
     programFiles: Set<string>;
     entryFiles: Set<string>;
+    handledImportExpressions: Set<number>;
     visitor: Visitor;
     getJSDocTags: (nodeStart: number) => Set<string>;
 }

package/dist/typescript/visitors/walk.js

@@ -726,7 +726,6 @@ function walkAST(program, sourceText, filePath, hasModuleSyntax, ctx) {
         sourceText,
         isJS,
         isModuleFile: isExternalModule(program, hasModuleSyntax),
-        handledImportExpressions: new Set(),
         bareExprRefs: new Set(),
         accessedAliases: new Set(),
         nsContainers: new Map(),

package/dist/util/load-config.js

@@ -13,12 +13,17 @@ const unwrapFunction = async (maybeFunction, options) => {
     }
     return maybeFunction;
 };
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 export async function loadResolvedConfigFile(configPath, options) {
     const loadedValue = await _load(configPath);
+    let config;
     try {
-        return await unwrapFunction(loadedValue, options);
+        config = await unwrapFunction(loadedValue, options);
     }
     catch (_error) {
         throw new ConfigurationError(`Error running the function from ${configPath}`);
     }
+    if (!isObject(config))
+        throw new ConfigurationError(`Expected an object as configuration from ${configPath}`);
+    return config;
 }

package/dist/util/resolve.d.ts

@@ -1,4 +1,5 @@
 export declare const extensionAlias: Record<string, string[]>;
+export declare const resolvePackageManifestPath: (packageName: string, baseDir: string) => string | undefined;
 export declare const _resolveModuleSync: (specifier: string, basePath: string) => string | undefined;
 declare const resolveDeclarationSync: (specifier: string, containingFile: string) => {
     path: string;

package/dist/util/resolve.js

@@ -23,6 +23,17 @@ const declarationResolver = new ResolverFactory({
     nodePath: false,
 });
 resolverInstances.push(declarationResolver);
+const packageManifestResolver = new ResolverFactory({
+    extensions: ['.json'],
+    exportsFields: [],
+    nodePath: false,
+});
+resolverInstances.push(packageManifestResolver);
+export const resolvePackageManifestPath = (packageName, baseDir) => {
+    const resolved = packageManifestResolver.sync(baseDir, `${packageName}/package.json`);
+    if (resolved.path)
+        return toPosix(resolved.path);
+};
 const createSyncModuleResolver = (extensions, tsConfigFile) => {
     const baseOptions = {
         extensions,

package/dist/util/scripts.d.ts

@@ -3,5 +3,6 @@ export interface ScriptCommand {
     binary: string;
     args: string[];
 }
+export declare const toShellCommand: (argv: string[]) => string;
 export declare function walkCommands(node: Node): Generator<Command>;
 export declare const getScriptCommands: (script: string) => ScriptCommand[];

package/dist/util/scripts.js

@@ -1,6 +1,7 @@
 import { parse } from 'unbash';
 import { extractBinary } from './modules.js';
 const spawningBinaries = new Set(['c8', 'cross-env', 'retry-cli']);
+export const toShellCommand = (argv) => argv.map(arg => `'${arg.replaceAll("'", `'\\''`)}'`).join(' ');
 export function* walkCommands(node) {
     switch (node.type) {
         case 'Command':

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.32.3";
+export declare const version = "6.33.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.32.3';
+export const version = '6.33.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.32.3",
+  "version": "6.33.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",
@@ -71,6 +71,10 @@
       "types": "./dist/types.d.ts",
       "default": "./dist/index.js"
     },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "default": "./dist/config.js"
+    },
     "./session": {
       "types": "./dist/session/index.d.ts",
       "default": "./dist/session/index.js"
@@ -78,27 +82,27 @@
   },
   "dependencies": {
     "fdir": "^6.5.0",
-    "formatly": "^0.3.0",
-    "get-tsconfig": "4.14.1",
+    "formatly": "^0.7.0",
+    "get-tsconfig": "4.14.3",
     "jiti": "^2.7.0",
-    "oxc-parser": "^0.143.0",
+    "oxc-parser": "^0.147.0",
     "oxc-resolver": "11.24.2",
-    "picomatch": "^4.0.5",
-    "smol-toml": "^1.7.1",
+    "picomatch": "^4.0.7",
+    "smol-toml": "^1.8.0",
     "strip-json-comments": "5.0.3",
     "tinyglobby": "^0.2.17",
-    "unbash": "^4.0.9",
+    "unbash": "^4.0.10",
     "yaml": "^2.9.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@jest/types": "^30.4.1",
-    "@types/bun": "^1.3.14",
+    "@types/bun": "^1.4.0",
     "@types/picomatch": "^4.0.3",
     "@types/webpack": "^5.28.5",
     "codeclimate-types": "^0.3.1",
     "prettier": "^3.9.6",
-    "tsx": "^4.23.11",
+    "tsx": "^4.23.12",
     "typescript": "7.0.2"
   },
   "engines": {