knip 6.41.0 → 6.42.0

package/README.md

@@ -48,7 +48,7 @@ following projects:
 
 [1]: https://www.npmx.dev/package/knip
 [2]: https://img.shields.io/npm/v/knip?color=f56e0f
-[3]: https://img.shields.io/npm/dm/knip?color=f56e0f
+[3]: https://img.shields.io/badge/dynamic/json?url=https://npm-gapless.webpro.nl/downloads/range/last-month/knip&query=$.totalCompact&label=downloads&suffix=/month&color=f56e0f
 [4]: https://github.com/webpro-nl/knip
 [5]:
   https://img.shields.io/github/stars/webpro-nl/knip?style=flat&color=f56e0f

package/dist/ConfigurationChief.d.ts

@@ -252,6 +252,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'filesystem-routing'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         flue?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -722,6 +727,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'solidjs-vite-plugin'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         sst?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -837,6 +847,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        tsrs?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         tsup?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1089,6 +1104,7 @@ export declare class ConfigurationChief {
         "expo-router"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "expressive-code"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         fast?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        "filesystem-routing"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         flue?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         fumadocs?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         gatsby?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1183,6 +1199,7 @@ export declare class ConfigurationChief {
         "serverless-framework"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "simple-git-hooks"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "size-limit"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        "solidjs-vite-plugin"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         sst?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         starlight?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         stencil?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1206,6 +1223,7 @@ export declare class ConfigurationChief {
         "ts-node"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsd?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsdown?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        tsrs?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsup?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsx?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         turbo?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/WorkspaceWorker.js

@@ -294,6 +294,7 @@ export class WorkspaceWorker {
             }
             const options = {
                 ...baseScriptOptions,
+                pluginName,
                 config,
                 configFilePath: containingFilePath,
                 configFileDir: cwd,

package/dist/binaries/bash-parser.js

@@ -1,31 +1,11 @@
-import { parse } from 'unbash';
+import { forEachChild, parse } from 'unbash';
 import { debugLogObject } from '../util/debug.js';
 import { extractBinary, isValidBinary } from '../util/modules.js';
 import { relative } from '../util/path.js';
 import { substringBefore, truncate } from '../util/string.js';
-import { walkCommands } from '../util/scripts.js';
+import { isScriptExpansion } from '../util/scripts.js';
 import { getDependenciesFromCommand } from './command.js';
 import { toScript } from './util.js';
-const collectExpansionScripts = (word, out) => {
-    if (word.type === 'ArrayValue') {
-        for (const element of word.elements)
-            collectExpansionScripts(element, out);
-        return;
-    }
-    if (!word.parts)
-        return;
-    for (const part of word.parts) {
-        if ((part.type === 'CommandExpansion' || part.type === 'ProcessSubstitution') && part.script) {
-            out.push(part.script);
-        }
-        else if (part.type === 'DoubleQuoted' || part.type === 'LocaleString') {
-            for (const child of part.parts) {
-                if (child.type === 'CommandExpansion' && child.script)
-                    out.push(child.script);
-            }
-        }
-    }
-};
 export const getDependenciesFromScript = (script, options) => {
     if (!script)
         return [];
@@ -56,24 +36,21 @@ export const getDependenciesFromScript = (script, options) => {
     };
     const processScript = (s) => {
         collectFunctionNames(s.commands);
-        const pending = [];
-        const mainDeps = [];
-        for (const statement of s.commands) {
-            for (const command of walkCommands(statement.command))
-                mainDeps.push(...processCommand(command, pending));
-        }
-        const expansionDeps = pending.flatMap(inner => processScript(inner));
-        return [...mainDeps, ...expansionDeps];
+        const inputs = [];
+        const visit = (node) => {
+            if (node.type === 'Command')
+                inputs.push(...processCommand(node));
+            if (isScriptExpansion(node)) {
+                if (node.script)
+                    inputs.push(...processScript(node.script));
+            }
+            else
+                forEachChild(node, visit);
+        };
+        visit(s);
+        return inputs;
     };
-    const processCommand = (node, pending) => {
-        if (node.name)
-            collectExpansionScripts(node.name, pending);
-        for (const prefix of node.prefix) {
-            if (prefix.type === 'Assignment')
-                collectExpansionScripts(prefix.value, pending);
-        }
-        for (const arg of node.args)
-            collectExpansionScripts(arg.type === 'Assignment' ? arg.value : arg, pending);
+    const processCommand = (node) => {
         if (definedFunctions.size && node.name && definedFunctions.has(extractBinary(node.name.value)))
             return [];
         return getDependenciesFromCommand(node, { ...options, fromArgs }, fromWords);

package/dist/binaries/resolvers/bun.js

@@ -10,6 +10,7 @@ const commands = new Set([
     'auth',
     'build',
     'c',
+    'check',
     'ci',
     'cloud',
     'completions',

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

@@ -38,10 +38,16 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
             return hasCompleteResult();
         }
         const node = graph.get(path);
-        const file = node?.importedBy;
-        if (!identifier || !node || !file) {
+        if (!identifier || !node) {
             return false;
         }
+        if (isEntryFile && node.skipExports) {
+            isReferenced = true;
+            return hasCompleteResult();
+        }
+        const file = node.importedBy;
+        if (!file)
+            return false;
         const follow = (sources, nextId, nextViaStar = viaStar) => {
             for (const byFilePath of sources) {
                 if (walkDown(byFilePath, nextId, nextViaStar))

package/dist/manifest/index.js

@@ -16,10 +16,9 @@ const getMetaDataFromPackageJson = ({ dir, packageNames }) => {
     for (const packageName of packageNames) {
         const manifest = loadPackageManifest({ dir, packageName });
         if (manifest) {
-            const defaultBinaryName = packageName.replace(/^@[^/]+\//, '');
-            const binaries = typeof manifest.bin === 'string' ? [defaultBinaryName] : Object.keys(manifest.bin ?? {});
+            const binaries = typeof manifest.bin === 'string' ? [packageName] : Object.keys(manifest.bin ?? {});
             for (const binaryName of binaries)
-                addBinary(binaryName, packageName);
+                addBinary(binaryName.replace(/^@[^/]+\//, ''), packageName);
             const packagePeerDependencies = Object.keys(manifest.peerDependencies ?? {});
             for (const packagePeerDependency of packagePeerDependencies) {
                 const hostDependency = {

package/dist/plugins/_component-style-urls/component-style-urls-visitor.d.ts

@@ -0,0 +1,2 @@
+import type { PluginVisitorContext, PluginVisitorObject } from '../../types/config.ts';
+export declare function createComponentStyleUrlsVisitor(ctx: PluginVisitorContext, isSpecifier: (specifier: string) => boolean): PluginVisitorObject;

package/dist/plugins/_component-style-urls/component-style-urls-visitor.js

@@ -0,0 +1,40 @@
+import { IMPORT_FLAGS } from '../../constants.js';
+import { getPropertyValues } from '../../typescript/ast-helpers.js';
+import { dirname, join } from '../../util/path.js';
+export function createComponentStyleUrlsVisitor(ctx, isSpecifier) {
+    const componentNames = new Set();
+    return {
+        Program() {
+            componentNames.clear();
+        },
+        ImportDeclaration(node) {
+            if (!isSpecifier(node.source?.value))
+                return;
+            for (const spec of node.specifiers ?? []) {
+                if (spec.type === 'ImportSpecifier' &&
+                    spec.imported.type === 'Identifier' &&
+                    spec.imported.name === 'Component')
+                    componentNames.add(spec.local.name);
+            }
+        },
+        ClassDeclaration(node) {
+            if (componentNames.size === 0)
+                return;
+            const dir = dirname(ctx.filePath);
+            for (const decorator of node.decorators ?? []) {
+                const expr = decorator.expression;
+                if (expr?.type !== 'CallExpression')
+                    continue;
+                if (expr.callee?.type !== 'Identifier' || !componentNames.has(expr.callee.name))
+                    continue;
+                const arg = expr.arguments?.[0];
+                if (arg?.type !== 'ObjectExpression')
+                    continue;
+                for (const url of getPropertyValues(arg, 'styleUrl'))
+                    ctx.addImport(join(dir, url), arg.start, IMPORT_FLAGS.NONE);
+                for (const url of getPropertyValues(arg, 'styleUrls'))
+                    ctx.addImport(join(dir, url), arg.start, IMPORT_FLAGS.NONE);
+            }
+        },
+    };
+}

package/dist/plugins/angular/index.js

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs';
 import { toConfig, toDeferResolve, toDependency, toEntry, toProductionEntry } from '../../util/input.js';
 import { isInternal, join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
+import { createComponentStyleUrlsVisitor } from '../_component-style-urls/component-style-urls-visitor.js';
 import * as karma from '../karma/helpers.js';
 const title = 'Angular';
 const enablers = ['@angular/cli'];
@@ -72,7 +73,7 @@ const resolveConfig = async (config, options) => {
                     karma.inputsFromFrameworks(['jasmine']).forEach(inputs.add, inputs);
                 }
                 if (karmaConfig && !karma.configFiles.includes(karmaConfig)) {
-                    inputs.add(toConfig('karma', karmaConfig, { containingFilePath: options.configFilePath }));
+                    inputs.add(toConfig('karma', karmaConfig));
                 }
             }
         }
@@ -111,11 +112,16 @@ const isAngularBuilderRefWithName = ({ builderRef, name }) => {
 };
 const PRODUCTION_CONFIG_NAME = 'production';
 const BUILD_TARGET_NAME = 'build';
+const isAngularSpecifier = (specifier) => specifier === '@angular/core';
+const registerVisitors = ({ ctx, registerVisitor }) => {
+    registerVisitor(createComponentStyleUrlsVisitor(ctx, isAngularSpecifier));
+};
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
     resolveConfig,
+    registerVisitors,
 };
 export default plugin;

package/dist/plugins/biome/index.js

@@ -10,9 +10,9 @@ const isRootConfigReference = (specifier) => specifier === '//';
 const resolveExtends = (extendsArray, options) => {
     return extendsArray.map(specifier => {
         if (isRootConfigReference(specifier)) {
-            return toConfig('biome', join(options.rootCwd, 'biome'), { containingFilePath: options.configFilePath });
+            return toConfig('biome', join(options.rootCwd, 'biome'));
         }
-        return toConfig('biome', specifier, { containingFilePath: options.configFilePath });
+        return toConfig('biome', specifier);
     });
 };
 const resolveConfig = (config, options) => {

package/dist/plugins/commitlint/index.js

@@ -25,12 +25,12 @@ const toPluginSpecifier = (id) => {
         return id;
     return id.replace('/', '/commitlint-plugin-');
 };
-const resolveConfig = async (config, options) => {
+const resolveConfig = async (config) => {
     const inputs = [];
     const extendsConfigs = [];
     for (const id of config.extends ? [config.extends].flat() : []) {
         if (isInternal(id))
-            inputs.push(toConfig('commitlint', id, { containingFilePath: options.configFilePath }));
+            inputs.push(toConfig('commitlint', id));
         else
             extendsConfigs.push(toExtendsSpecifier(id));
     }

package/dist/plugins/eslint/helpers.js

@@ -20,7 +20,7 @@ const getInputsDeprecated = (config, options) => {
     const extendsSpecifiers = compact(extendsList.map(resolveExtendSpecifier));
     if (extendsSpecifiers.some(specifier => specifier?.startsWith('eslint-plugin-prettier')))
         extendsSpecifiers.push('eslint-config-prettier');
-    const extendConfigs = [...extendsList.filter(isInternal), ...extendsSpecifiers].map(specifier => toConfig('eslint', specifier, { containingFilePath: options.configFilePath }));
+    const extendConfigs = [...extendsList.filter(isInternal), ...extendsSpecifiers].map(specifier => toConfig('eslint', specifier));
     const plugins = config.plugins ? config.plugins.map(resolvePluginSpecifier) : [];
     const parsers = getParsers(config);
     const babelDependencies = config.parserOptions?.babelOptions

package/dist/plugins/filesystem-routing/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/filesystem-routing/index.js

@@ -0,0 +1,57 @@
+import { escapePath } from 'tinyglobby';
+import { findImportedCalls, findProperty } from '../../typescript/ast-helpers.js';
+import { getStringValue } from '../../typescript/ast-nodes.js';
+import { toProductionEntry } from '../../util/input.js';
+import { join, relative, toAbsolute } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+import { getViteRoot } from '../vite/helpers.js';
+const title = 'filesystem-routing';
+const enablers = ['filesystem-routing'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['vite.config.{js,mjs,ts,cjs,mts,cts}'];
+const defaultDir = 'src/routes';
+const defaultExtensions = ['js', 'jsx', 'ts', 'tsx', 'tsrx'];
+const production = [`${defaultDir}/**/*.{${defaultExtensions.join(',')}}`];
+const resolveFromAST = (program, { config, cwd }) => {
+    if (config.entry)
+        return [];
+    const root = getViteRoot(program, cwd);
+    const toEntry = (dir, pattern) => toProductionEntry(join(cwd, escapePath(relative(cwd, dir)), pattern));
+    const calls = findImportedCalls(program, 'filesystem-routing/vite');
+    if (calls.length === 0)
+        return production.map(pattern => toEntry(root, pattern));
+    const inputs = [];
+    for (const call of calls) {
+        const options = call.arguments[0];
+        const dir = getStringValue(findProperty(options, 'dir')) ?? defaultDir;
+        const value = findProperty(options, 'extensions');
+        const extensions = new Set();
+        let useDefaults = value?.type !== 'ArrayExpression';
+        if (value?.type === 'ArrayExpression') {
+            for (const element of value.elements) {
+                const extension = getStringValue(element);
+                if (extension === undefined)
+                    useDefaults = true;
+                else
+                    extensions.add(extension);
+            }
+        }
+        if (useDefaults)
+            for (const extension of defaultExtensions)
+                extensions.add(extension);
+        if (extensions.size === 0)
+            continue;
+        const suffix = extensions.size === 1 ? [...extensions][0] : `{${[...extensions].join(',')}}`;
+        inputs.push(toEntry(toAbsolute(dir, root), `**/*.${suffix}`));
+    }
+    return inputs;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    production,
+    resolveFromAST,
+};
+export default plugin;

package/dist/plugins/github-actions/index.js

@@ -29,7 +29,7 @@ const resolveConfig = async (config, options) => {
         const path = action?.with?.path;
         for (const step of steps.steps) {
             const workingDir = step['working-directory'];
-            const dir = join(rootCwd, path && workingDir ? relative(workingDir, path) : workingDir ? workingDir : '.');
+            const dir = join(rootCwd, path && workingDir ? relative(path, workingDir) : workingDir ? workingDir : '.');
             if (step.run) {
                 const manifest = getManifest(dir) ?? options.manifest;
                 const actionPath = relative(dir, configFileDir);

package/dist/plugins/index.d.ts

@@ -43,6 +43,7 @@ export declare const Plugins: {
         config: string[];
     };
     fast: import("../types/config.ts").Plugin;
+    'filesystem-routing': import("../types/config.ts").Plugin;
     flue: import("../types/config.ts").Plugin;
     fumadocs: import("../types/config.ts").Plugin;
     gatsby: import("../types/config.ts").Plugin;
@@ -137,6 +138,7 @@ export declare const Plugins: {
     'serverless-framework': import("../types/config.ts").Plugin;
     'simple-git-hooks': import("../types/config.ts").Plugin;
     'size-limit': import("../types/config.ts").Plugin;
+    'solidjs-vite-plugin': import("../types/config.ts").Plugin;
     sst: import("../types/config.ts").Plugin;
     starlight: import("../types/config.ts").Plugin;
     stencil: import("../types/config.ts").Plugin;
@@ -160,6 +162,7 @@ export declare const Plugins: {
     'ts-node': import("../types/config.ts").Plugin;
     tsd: import("../types/config.ts").Plugin;
     tsdown: import("../types/config.ts").Plugin;
+    tsrs: import("../types/config.ts").Plugin;
     tsup: import("../types/config.ts").Plugin;
     tsx: import("../types/config.ts").Plugin;
     turbo: import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -37,6 +37,7 @@ import { default as expo } from './expo/index.js';
 import { default as expoRouter } from './expo-router/index.js';
 import { default as expressiveCode } from './expressive-code/index.js';
 import { default as fast } from './fast/index.js';
+import { default as filesystemRouting } from './filesystem-routing/index.js';
 import { default as flue } from './flue/index.js';
 import { default as fumadocs } from './fumadocs/index.js';
 import { default as gatsby } from './gatsby/index.js';
@@ -131,6 +132,7 @@ import { default as sentry } from './sentry/index.js';
 import { default as serverlessFramework } from './serverless-framework/index.js';
 import { default as simpleGitHooks } from './simple-git-hooks/index.js';
 import { default as sizeLimit } from './size-limit/index.js';
+import { default as solidjsVitePlugin } from './solidjs-vite-plugin/index.js';
 import { default as sst } from './sst/index.js';
 import { default as starlight } from './starlight/index.js';
 import { default as stencil } from './stencil/index.js';
@@ -154,6 +156,7 @@ import { default as travis } from './travis/index.js';
 import { default as tsNode } from './ts-node/index.js';
 import { default as tsd } from './tsd/index.js';
 import { default as tsdown } from './tsdown/index.js';
+import { default as tsrs } from './tsrs/index.js';
 import { default as tsup } from './tsup/index.js';
 import { default as tsx } from './tsx/index.js';
 import { default as turbo } from './turbo/index.js';
@@ -230,6 +233,7 @@ export const Plugins = {
     'expo-router': expoRouter,
     'expressive-code': expressiveCode,
     fast,
+    'filesystem-routing': filesystemRouting,
     flue,
     fumadocs,
     gatsby,
@@ -324,6 +328,7 @@ export const Plugins = {
     'serverless-framework': serverlessFramework,
     'simple-git-hooks': simpleGitHooks,
     'size-limit': sizeLimit,
+    'solidjs-vite-plugin': solidjsVitePlugin,
     sst,
     starlight,
     stencil,
@@ -347,6 +352,7 @@ export const Plugins = {
     'ts-node': tsNode,
     tsd,
     tsdown,
+    tsrs,
     tsup,
     tsx,
     turbo,

package/dist/plugins/jest/index.js

@@ -5,6 +5,7 @@ import { isInternal, join, normalize, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
 import { getReportersDependencies, resolveExtensibleConfig, resolveWithPrefix } from './helpers.js';
+import { createJestMockVisitor } from './visitors/mock.js';
 const title = 'Jest';
 const enablers = ['jest'];
 const isEnabled = ({ dependencies, manifest }) => hasDependency(dependencies, enablers) || Boolean(manifest.name?.startsWith('jest-presets'));
@@ -127,6 +128,9 @@ const resolveConfig = async (localConfig, options) => {
 const args = {
     config: true,
 };
+const registerVisitors = ({ ctx, registerVisitor }) => {
+    registerVisitor(createJestMockVisitor(ctx));
+};
 const plugin = {
     title,
     enablers,
@@ -135,5 +139,6 @@ const plugin = {
     entry,
     resolveConfig,
     args,
+    registerVisitors,
 };
 export default plugin;

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

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

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

@@ -0,0 +1,91 @@
+import { IMPORT_FLAGS } from '../../../constants.js';
+import { getPropertyKey } from '../../../typescript/ast-helpers.js';
+import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
+import { isShadowed } from '../../../typescript/visitors/walk.js';
+const mockMethods = new Set([
+    'mock',
+    'doMock',
+    'requireActual',
+    'requireMock',
+    'createMockFromModule',
+    'unmock',
+    'dontMock',
+    'deepUnmock',
+    'setMock',
+    'unstable_mockModule',
+    'unstable_unmockModule',
+]);
+export function createJestMockVisitor(ctx) {
+    const jestNames = new Set();
+    const virtualMocks = new Set();
+    const virtualEsmMocks = new Set();
+    const mockLookups = [];
+    return {
+        Program(node) {
+            jestNames.clear();
+            virtualMocks.clear();
+            virtualEsmMocks.clear();
+            mockLookups.length = 0;
+            jestNames.add('jest');
+            for (const statement of node.body) {
+                if (statement.type !== 'ImportDeclaration' ||
+                    !isStringLiteral(statement.source) ||
+                    getStringValue(statement.source) !== '@jest/globals')
+                    continue;
+                for (const specifier of statement.specifiers ?? []) {
+                    if (specifier.type === 'ImportSpecifier' &&
+                        specifier.imported.type === 'Identifier' &&
+                        specifier.imported.name === 'jest') {
+                        jestNames.add(specifier.local.name);
+                    }
+                }
+            }
+        },
+        CallExpression(node) {
+            const argument = node.arguments[0];
+            const callee = node.callee;
+            if (!isStringLiteral(argument) ||
+                callee.type !== 'MemberExpression' ||
+                callee.computed ||
+                callee.object.type !== 'Identifier' ||
+                !jestNames.has(callee.object.name) ||
+                isShadowed(callee.object.name, callee.object.start) ||
+                callee.property.type !== 'Identifier' ||
+                !mockMethods.has(callee.property.name))
+                return;
+            const specifier = getStringValue(argument);
+            const method = callee.property.name;
+            const options = node.arguments[2];
+            if ((method === 'mock' || method === 'doMock' || method === 'unstable_mockModule') &&
+                options?.type === 'ObjectExpression') {
+                for (const property of options.properties) {
+                    if (property.type === 'Property' &&
+                        !property.computed &&
+                        getPropertyKey(property) === 'virtual' &&
+                        property.value.type === 'Literal' &&
+                        property.value.value === true) {
+                        (method === 'unstable_mockModule' ? virtualEsmMocks : virtualMocks).add(specifier);
+                        return;
+                    }
+                }
+            }
+            if (method === 'requireActual' || method === 'createMockFromModule') {
+                const flags = method === 'requireActual' ? IMPORT_FLAGS.OPAQUE : IMPORT_FLAGS.SIDE_EFFECTS;
+                ctx.addImport(specifier, argument.start, flags);
+                return;
+            }
+            mockLookups.push({
+                specifier,
+                pos: argument.start,
+                isEsm: method === 'unstable_mockModule' || method === 'unstable_unmockModule',
+            });
+        },
+        'Program:exit'() {
+            for (const { specifier, pos, isEsm } of mockLookups) {
+                if ((isEsm ? virtualEsmMocks : virtualMocks).has(specifier))
+                    continue;
+                ctx.addImport(specifier, pos, IMPORT_FLAGS.SIDE_EFFECTS);
+            }
+        },
+    };
+}