knip 5.1.2 → 5.1.3

package/dist/plugins/vue/index.js

@@ -1,22 +1,13 @@
-import { timerify } from '../../util/Performance.js';
-import { hasDependency, load } from '../../util/plugin.js';
-import { toEntryPattern, toProductionEntryPattern } from '../../util/protocols.js';
+import { hasDependency } from '#p/util/plugin.js';
 import { findWebpackDependenciesFromConfig } from '../webpack/index.js';
-const NAME = 'Vue';
-const ENABLERS = ['vue'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const CONFIG_FILE_PATTERNS = ['vue.config.{js,ts}'];
-const ENTRY_FILE_PATTERNS = [];
-const PRODUCTION_ENTRY_FILE_PATTERNS = [];
-const findPluginDependencies = async (configFilePath, options) => {
-    const { config, isProduction, cwd, manifest } = options;
-    const localConfig = await load(configFilePath);
-    const deps = config.entry
-        ? config.entry.map(toProductionEntryPattern)
-        : [...ENTRY_FILE_PATTERNS.map(toEntryPattern), ...PRODUCTION_ENTRY_FILE_PATTERNS.map(toProductionEntryPattern)];
-    if (isProduction || !localConfig)
-        return deps;
-    if (localConfig.configureWebpack) {
+const title = 'Vue';
+const enablers = ['vue'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['vue.config.{js,ts}'];
+const resolveConfig = async (config, options) => {
+    const { cwd, isProduction, manifest } = options;
+    const deps = [];
+    if (config.configureWebpack) {
         const baseConfig = {
             mode: 'development',
             entry: {},
@@ -24,9 +15,7 @@ const findPluginDependencies = async (configFilePath, options) => {
             plugins: [],
             module: { rules: [] },
         };
-        const modifiedConfig = typeof localConfig.configureWebpack === 'function'
-            ? localConfig.configureWebpack(baseConfig)
-            : localConfig.configureWebpack;
+        const modifiedConfig = typeof config.configureWebpack === 'function' ? config.configureWebpack(baseConfig) : config.configureWebpack;
         const { dependencies } = await findWebpackDependenciesFromConfig({
             config: modifiedConfig ?? baseConfig,
             cwd,
@@ -40,11 +29,10 @@ const findPluginDependencies = async (configFilePath, options) => {
     }
     return deps;
 };
-const findDependencies = timerify(findPluginDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    CONFIG_FILE_PATTERNS,
-    findDependencies,
+    config,
+    resolveConfig,
 };

package/dist/plugins/webpack/index.d.ts

@@ -1,5 +1,5 @@
+import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
 import type { WebpackConfig } from './types.js';
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
 export declare const findWebpackDependenciesFromConfig: ({ config, cwd }: {
     config: WebpackConfig;
     cwd: string;
@@ -8,10 +8,11 @@ export declare const findWebpackDependenciesFromConfig: ({ config, cwd }: {
     entryPatterns: Set<string>;
 }>;
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    CONFIG_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    production: string[];
+    resolveConfig: ResolveConfig<WebpackConfig>;
 };
 export default _default;

package/dist/plugins/webpack/index.js

@@ -1,13 +1,13 @@
-import { compact } from '../../util/array.js';
-import { isInternal, join, relative } from '../../util/path.js';
-import { timerify } from '../../util/Performance.js';
-import { hasDependency, load } from '../../util/plugin.js';
-import { toEntryPattern, toProductionEntryPattern } from '../../util/protocols.js';
+import { compact } from '#p/util/array.js';
+import { isInternal, join, relative } from '#p/util/path.js';
+import { hasDependency } from '#p/util/plugin.js';
+import { toEntryPattern, toProductionEntryPattern } from '#p/util/protocols.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
-const NAME = 'Webpack';
-const ENABLERS = ['webpack', 'webpack-cli'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const CONFIG_FILE_PATTERNS = ['webpack.config*.{js,ts,mjs,cjs,mts,cts}'];
+const title = 'Webpack';
+const enablers = ['webpack', 'webpack-cli'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['webpack.config*.{js,ts,mjs,cjs,mts,cts}'];
+const production = [];
 const hasBabelOptions = (use) => Boolean(use) &&
     typeof use !== 'string' &&
     'loader' in use &&
@@ -87,12 +87,9 @@ export const findWebpackDependenciesFromConfig = async ({ config, cwd }) => {
     }
     return { dependencies, entryPatterns };
 };
-const findWebpackDependencies = async (configFilePath, options) => {
-    const { manifest, isProduction, cwd } = options;
-    const localConfig = await load(configFilePath);
-    if (!localConfig)
-        return [];
-    const { dependencies, entryPatterns } = await findWebpackDependenciesFromConfig({ config: localConfig, cwd });
+const resolveConfig = async (localConfig, options) => {
+    const { cwd, isProduction, manifest } = options;
+    const { entryPatterns, dependencies } = await findWebpackDependenciesFromConfig({ config: localConfig, cwd });
     if (isProduction)
         return [...entryPatterns];
     const scripts = Object.values(manifest.scripts ?? {});
@@ -100,11 +97,11 @@ const findWebpackDependencies = async (configFilePath, options) => {
     const webpackDevServer = scripts.some(script => script?.includes('webpack serve')) ? ['webpack-dev-server'] : [];
     return compact([...entryPatterns, ...dependencies, ...webpackCLI, ...webpackDevServer]);
 };
-const findDependencies = timerify(findWebpackDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    CONFIG_FILE_PATTERNS,
-    findDependencies,
+    config,
+    production,
+    resolveConfig,
 };

package/dist/plugins/wireit/index.d.ts

@@ -1,10 +1,11 @@
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+import type { ResolveConfig, IsPluginEnabled } from '#p/types/plugins.js';
+import type { WireitConfig } from './types.js';
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    PACKAGE_JSON_PATH: string;
-    CONFIG_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    readonly title: "Wireit";
+    readonly enablers: string[];
+    readonly isEnabled: IsPluginEnabled;
+    readonly packageJsonPath: "wireit";
+    readonly config: string[];
+    readonly resolveConfig: ResolveConfig<WireitConfig>;
 };
 export default _default;

package/dist/plugins/wireit/index.js

@@ -1,27 +1,19 @@
-import { timerify } from '../../util/Performance.js';
-import { getDependenciesFromScripts, hasDependency } from '../../util/plugin.js';
-const NAME = 'Wireit';
-const ENABLERS = ['wireit'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const PACKAGE_JSON_PATH = 'wireit';
-const CONFIG_FILE_PATTERNS = ['package.json'];
-const findWireItDependencies = async (_configFilePath, options) => {
-    const { manifest, isProduction } = options;
-    if (isProduction)
-        return [];
-    const localConfig = manifest[PACKAGE_JSON_PATH];
-    if (!localConfig)
-        return [];
+import { getDependenciesFromScripts, hasDependency } from '#p/util/plugin.js';
+const title = 'Wireit';
+const enablers = ['wireit'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const packageJsonPath = 'wireit';
+const config = ['package.json'];
+const resolveConfig = (localConfig, options) => {
     const scripts = Object.values(localConfig).flatMap(({ command: script }) => (script ? [script] : []));
     const scriptDependencies = getDependenciesFromScripts(scripts, options);
     return scriptDependencies;
 };
-const findDependencies = timerify(findWireItDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    PACKAGE_JSON_PATH,
-    CONFIG_FILE_PATTERNS,
-    findDependencies,
+    packageJsonPath,
+    config,
+    resolveConfig,
 };

package/dist/plugins/yorkie/index.d.ts

@@ -1,10 +1,11 @@
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+import type { ResolveConfig, IsPluginEnabled } from '#p/types/plugins.js';
+import type { LintStagedConfig } from '../lint-staged/types.js';
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    PACKAGE_JSON_PATH: string;
-    CONFIG_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    readonly title: "yorkie";
+    readonly enablers: string[];
+    readonly isEnabled: IsPluginEnabled;
+    readonly packageJsonPath: "gitHooks";
+    readonly config: string[];
+    readonly resolveConfig: ResolveConfig<LintStagedConfig>;
 };
 export default _default;

package/dist/plugins/yorkie/index.js

@@ -1,30 +1,22 @@
-import { timerify } from '../../util/Performance.js';
-import { getDependenciesFromScripts, hasDependency } from '../../util/plugin.js';
-const NAME = 'yorkie';
-const ENABLERS = ['yorkie'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const PACKAGE_JSON_PATH = 'gitHooks';
-const CONFIG_FILE_PATTERNS = ['package.json'];
-const findPluginDependencies = async (configFilePath, options) => {
-    const { manifest, isProduction } = options;
-    if (isProduction)
-        return [];
-    const localConfig = manifest[PACKAGE_JSON_PATH];
-    if (!localConfig)
-        return [];
+import { getDependenciesFromScripts, hasDependency } from '#p/util/plugin.js';
+const title = 'yorkie';
+const enablers = ['yorkie'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const packageJsonPath = 'gitHooks';
+const config = ['package.json'];
+const resolveConfig = (config, options) => {
     const dependencies = new Set();
-    for (const script of Object.values(localConfig).flat()) {
+    for (const script of Object.values(config).flat()) {
         const scripts = [script].flat();
         getDependenciesFromScripts(scripts, options).forEach(identifier => dependencies.add(identifier));
     }
     return ['yorkie', ...dependencies];
 };
-const findDependencies = timerify(findPluginDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    PACKAGE_JSON_PATH,
-    CONFIG_FILE_PATTERNS,
-    findDependencies,
+    packageJsonPath,
+    config,
+    resolveConfig,
 };

package/dist/plugins.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from './types/plugins.js';
+declare const plugins: Record<"astro" | "svelte" | "vue" | "angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eleventy" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "linthtml" | "markdownlint" | "mocha" | "msw" | "netlify" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "tailwind" | "tsup" | "typedoc" | "typescript" | "unbuild" | "vite" | "vitest" | "webpack" | "wireit" | "yorkie" | "drizzle" | "githubActions" | "graphqlCodegen" | "lintStaged" | "nodeTestRunner" | "npmPackageJsonLint" | "playwrightCt" | "releaseIt" | "semanticRelease" | "vercelOg", Plugin>;
+export { plugins };

package/dist/plugins.js

@@ -0,0 +1,14 @@
+import * as originalPlugins from './plugins/index.js';
+import parsedArgValues from './util/cli-arguments.js';
+import { timerify } from './util/Performance.js';
+const { performance: isEnabled = false } = parsedArgValues;
+const plugins = (isEnabled ? {} : originalPlugins);
+const methods = ['resolve', 'resolveConfig', 'resolveEntryPaths'];
+if (isEnabled) {
+    for (const [name, plugin] of Object.entries(originalPlugins)) {
+        plugins[name] = plugin;
+        methods.forEach(method => method in plugin &&
+            (plugins[name][method] = timerify(plugin[method], `${method} (${plugin.title})`)));
+    }
+}
+export { plugins };

package/dist/reporters/index.d.ts

@@ -1,8 +1,8 @@
 declare const _default: {
-    symbols: ({ report, issues, configurationHints, noConfigHints, isShowProgress }: import("src/index.js").ReporterOptions) => void;
-    compact: ({ report, issues, isShowProgress }: import("src/index.js").ReporterOptions) => void;
-    codeowners: ({ report, issues, isShowProgress, options }: import("src/index.js").ReporterOptions) => void;
-    json: ({ report, issues, options }: import("src/index.js").ReporterOptions) => Promise<void>;
-    markdown: ({ report, issues }: import("src/index.js").ReporterOptions) => void;
+    symbols: ({ report, issues, configurationHints, noConfigHints, isShowProgress }: import("#p/index.ts").ReporterOptions) => void;
+    compact: ({ report, issues, isShowProgress }: import("#p/index.ts").ReporterOptions) => void;
+    codeowners: ({ report, issues, isShowProgress, options }: import("#p/index.ts").ReporterOptions) => void;
+    json: ({ report, issues, options }: import("#p/index.ts").ReporterOptions) => Promise<void>;
+    markdown: ({ report, issues }: import("#p/index.ts").ReporterOptions) => void;
 };
 export default _default;

package/dist/types/config.d.ts

@@ -6,7 +6,7 @@ import type { SyncCompilers, AsyncCompilers } from '../compilers/types.js';
 export type RawConfiguration = z.infer<typeof ConfigurationValidator>;
 export type RawPluginConfiguration = z.infer<typeof pluginSchema>;
 type NormalizedGlob = string[];
-type IgnorePatterns = (string | RegExp)[];
+export type IgnorePatterns = (string | RegExp)[];
 export type PluginName = keyof typeof Plugins;
 export type PluginMap = typeof Plugins;
 export type EnsuredPluginConfiguration = {

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

@@ -1,5 +1,5 @@
 import type { PluginMap } from './config.js';
-import type { LiteralUnion, MergeUnion } from './util.js';
+import type { LiteralUnion } from './util.js';
 type Dependency = Record<string, string>;
 type ExportCondition = LiteralUnion<'import' | 'require' | 'node' | 'node-addons' | 'deno' | 'browser' | 'electron' | 'react-native' | 'default', string>;
 type Exports = null | string | string[] | {
@@ -7,19 +7,18 @@ type Exports = null | string | string[] | {
 } | {
     [key: string]: Exports;
 };
-type ExtractKeys<T, K extends string> = T extends {
-    PACKAGE_JSON_PATH: infer P;
-} ? P extends `${infer First}.${infer Second}` ? {
-    [K1 in First]?: {
-        [K2 in Second]?: unknown;
-    };
-} : {
-    [P in T['PACKAGE_JSON_PATH'] & string]?: unknown;
-} : Record<K, unknown>;
-type PluginKeys = {
-    [K in keyof PluginMap]: ExtractKeys<PluginMap[K], K>;
+type PackageJsonPath<T> = T extends {
+    packageJsonPath: infer P;
+} ? (P extends string ? P : never) : never;
+type WithPackageJsonPathAsKey<T> = {
+    [K in keyof T]: PackageJsonPath<T[K]> extends never ? K : PackageJsonPath<T[K]>;
+};
+type PluginConfigs<P> = {
+    [K in keyof P as WithPackageJsonPathAsKey<P>[K]]: unknown;
+};
+type Plugins = PluginConfigs<PluginMap> & {
+    plugin: unknown;
 };
-type Plugins = MergeUnion<PluginKeys[keyof PluginMap]>;
 export type Scripts = Record<string, string>;
 export type PackageJson = {
     name?: string;

package/dist/types/plugins.d.ts

@@ -1,4 +1,4 @@
-import type { EnsuredPluginConfiguration, WorkspaceConfiguration } from './config.js';
+import type { EnsuredPluginConfiguration, IgnorePatterns, WorkspaceConfiguration } from './config.js';
 import type { PackageJson } from './package-json.js';
 import type { DependencySet } from './workspace.js';
 export interface BaseOptions {
@@ -6,29 +6,35 @@ export interface BaseOptions {
     manifestScriptNames: Set<string>;
     dependencies: DependencySet;
 }
-type IsPluginEnabledCallbackOptions = {
+type IsPluginEnabledOptions = {
     cwd: string;
     manifest: PackageJson;
     dependencies: Set<string>;
     config: WorkspaceConfiguration;
 };
-export type IsPluginEnabledCallback = (options: IsPluginEnabledCallbackOptions) => boolean | Promise<boolean>;
-export interface GenericPluginCallbackOptions extends BaseOptions {
+export type IsPluginEnabled = (options: IsPluginEnabledOptions) => boolean | Promise<boolean>;
+export interface PluginOptions extends BaseOptions {
     manifest: PackageJson;
     config: EnsuredPluginConfiguration;
+    configFileDir: string;
+    configFileName: string;
     isProduction: boolean;
     enabledPlugins: string[];
 }
-export type GenericPluginCallback = (configFilePath: string, options: GenericPluginCallbackOptions) => Promise<string[]> | string[];
+export type ResolveEntryPaths<T = any> = (config: T, options: PluginOptions) => Promise<string[]> | string[];
+export type ResolveConfig<T = any> = (config: T, options: PluginOptions) => Promise<string[]> | string[];
+export type Resolve = (options: PluginOptions) => Promise<string[]> | string[];
 export interface Plugin {
-    NAME: string;
-    ENABLERS: string[];
-    PACKAGE_JSON_PATH?: string;
-    isEnabled: IsPluginEnabledCallback;
-    CONFIG_FILE_PATTERNS?: string[];
-    ENTRY_FILE_PATTERNS?: string[];
-    PRODUCTION_ENTRY_FILE_PATTERNS?: string[];
-    PROJECT_FILE_PATTERNS?: string[];
-    findDependencies: GenericPluginCallback;
+    title: string;
+    enablers: IgnorePatterns | string;
+    packageJsonPath?: string;
+    isEnabled: IsPluginEnabled;
+    config?: string[];
+    entry?: string[];
+    production?: string[];
+    project?: string[];
+    resolveEntryPaths?: ResolveEntryPaths;
+    resolveConfig?: ResolveConfig;
+    resolve?: Resolve;
 }
 export {};

package/dist/types/util.d.ts

@@ -1,16 +1,3 @@
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 export type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
-type CommonKeys<T extends object> = keyof T;
-type AllKeys<T> = T extends unknown ? keyof T : never;
-type Subtract<A, C> = A extends C ? never : A;
-type NonCommonKeys<T extends object> = Subtract<AllKeys<T>, CommonKeys<T>>;
-type PickType<T, K extends AllKeys<T>> = T extends {
-    [k in K]?: unknown;
-} ? T[K] : undefined;
-type PickTypeOf<T, K extends string | number | symbol> = K extends AllKeys<T> ? PickType<T, K> : never;
-export type MergeUnion<T extends object> = {
-    [k in CommonKeys<T>]: PickTypeOf<T, k>;
-} & {
-    [k in NonCommonKeys<T>]?: PickTypeOf<T, k>;
-};
 export {};

package/dist/typescript/SourceFileManager.js

@@ -1,4 +1,5 @@
 import ts from 'typescript';
+import { FOREIGN_FILE_EXTENSIONS } from '../constants.js';
 import { debugLog } from '../util/debug.js';
 import { extname, isInNodeModules, isInternal } from '../util/path.js';
 export class SourceFileManager {
@@ -19,6 +20,8 @@ export class SourceFileManager {
         return sourceFile;
     }
     getSourceFile(filePath) {
+        if (FOREIGN_FILE_EXTENSIONS.has(extname(filePath)))
+            return undefined;
         if (this.isSkipLibs && isInNodeModules(filePath))
             return undefined;
         if (this.sourceFileCache.has(filePath))

package/dist/typescript/createHosts.js

@@ -2,15 +2,16 @@ import { EOL } from 'node:os';
 import path from 'node:path';
 import ts from 'typescript';
 import { getCompilerExtensions } from '../compilers/index.js';
+import { FOREIGN_FILE_EXTENSIONS } from '../constants.js';
 import { createCustomModuleResolver } from './resolveModuleNames.js';
 import { SourceFileManager } from './SourceFileManager.js';
 import { createCustomSys } from './sys.js';
 const libLocation = path.dirname(ts.getDefaultLibFilePath({}));
 export const createHosts = ({ cwd, compilerOptions, entryPaths, compilers, isSkipLibs }) => {
     const fileManager = new SourceFileManager({ compilers, isSkipLibs });
-    const virtualFileExtensions = getCompilerExtensions(compilers);
-    const sys = createCustomSys(cwd, virtualFileExtensions);
-    const resolveModuleNames = createCustomModuleResolver(sys, compilerOptions, virtualFileExtensions);
+    const compilerExtensions = [...getCompilerExtensions(compilers), ...FOREIGN_FILE_EXTENSIONS];
+    const sys = createCustomSys(cwd, compilerExtensions);
+    const resolveModuleNames = createCustomModuleResolver(sys, compilerOptions, compilerExtensions);
     const languageServiceHost = {
         getCompilationSettings: () => compilerOptions,
         getScriptFileNames: () => Array.from(entryPaths),

package/dist/typescript/resolveModuleNames.js

@@ -2,7 +2,7 @@ import { existsSync } from 'node:fs';
 import { isBuiltin } from 'node:module';
 import ts from 'typescript';
 import { sanitizeSpecifier } from '../util/modules.js';
-import { basename, dirname, extname, format, isAbsolute, isInNodeModules, isInternal, join } from '../util/path.js';
+import { dirname, extname, isAbsolute, isInNodeModules, isInternal, join } from '../util/path.js';
 import { isDeclarationFileExtension } from './ast-helpers.js';
 import { ensureRealFilePath, isVirtualFilePath } from './utils.js';
 const resolutionCache = new Map();
@@ -17,27 +17,6 @@ const fileExists = (name, containingFile) => {
         };
     }
 };
-const DTS_EXTENSIONS_MAP = {
-    [ts.Extension.Dts]: ts.Extension.Js,
-    [ts.Extension.Dmts]: ts.Extension.Mjs,
-    [ts.Extension.Dcts]: ts.Extension.Cjs,
-};
-const jsMatchingDeclarationFileExists = (resolveDtsFileName, dtsExtension) => {
-    const extension = DTS_EXTENSIONS_MAP[dtsExtension];
-    const resolvedFileName = format({
-        ext: extension,
-        dir: dirname(resolveDtsFileName),
-        name: basename(resolveDtsFileName, dtsExtension),
-    });
-    if (existsSync(resolvedFileName)) {
-        return {
-            resolvedFileName,
-            extension,
-            isExternalLibraryImport: false,
-            resolvedUsingTsExtension: false,
-        };
-    }
-};
 export function createCustomModuleResolver(customSys, compilerOptions, virtualFileExtensions) {
     function resolveModuleNames(moduleNames, containingFile) {
         return moduleNames.map(moduleName => {
@@ -53,40 +32,46 @@ export function createCustomModuleResolver(customSys, compilerOptions, virtualFi
     }
     function resolveModuleName(name, containingFile) {
         const sanitizedSpecifier = sanitizeSpecifier(name);
-        if (isBuiltin(sanitizedSpecifier))
-            return undefined;
-        if (isInNodeModules(name))
+        if (isBuiltin(sanitizedSpecifier) || isInNodeModules(name))
             return undefined;
         const tsResolvedModule = ts.resolveModuleName(sanitizedSpecifier, containingFile, compilerOptions, ts.sys).resolvedModule;
-        if (!tsResolvedModule) {
-            const extension = extname(sanitizedSpecifier);
-            if (extension && !virtualFileExtensions.includes(extension)) {
-                const module = fileExists(sanitizedSpecifier, containingFile);
-                if (module)
-                    return module;
-            }
-        }
         if (tsResolvedModule &&
             isDeclarationFileExtension(tsResolvedModule.extension) &&
             isInternal(tsResolvedModule.resolvedFileName)) {
-            {
-                const module = jsMatchingDeclarationFileExists(tsResolvedModule.resolvedFileName, tsResolvedModule.extension);
-                if (module)
-                    return module;
+            if (tsResolvedModule.extension === '.d.mts') {
+                const resolvedFileName = tsResolvedModule.resolvedFileName.replace(/\.d\.mts$/, '.mjs');
+                return { resolvedFileName, extension: '.mjs', isExternalLibraryImport: false, resolvedUsingTsExtension: false };
+            }
+            if (tsResolvedModule.extension === '.d.cts') {
+                const resolvedFileName = tsResolvedModule.resolvedFileName.replace(/\.d\.cts$/, '.cjs');
+                return { resolvedFileName, extension: '.cjs', isExternalLibraryImport: false, resolvedUsingTsExtension: false };
+            }
+            const base = tsResolvedModule.resolvedFileName.replace(/\.d\.ts$/, '');
+            const baseExt = extname(base);
+            if (baseExt && virtualFileExtensions.includes(baseExt)) {
+                const resolvedFileName = ensureRealFilePath(base, virtualFileExtensions);
+                return {
+                    resolvedFileName,
+                    extension: ts.Extension.Js,
+                    isExternalLibraryImport: false,
+                    resolvedUsingTsExtension: false,
+                };
             }
-            {
-                const module = fileExists(sanitizedSpecifier, containingFile);
+            for (const ext of ['.js', '.jsx']) {
+                const module = fileExists(base + ext, containingFile);
                 if (module)
                     return module;
             }
-        }
-        if (virtualFileExtensions.length === 0)
             return tsResolvedModule;
+        }
         if (tsResolvedModule && !isVirtualFilePath(tsResolvedModule.resolvedFileName, virtualFileExtensions)) {
             return tsResolvedModule;
         }
         const customResolvedModule = ts.resolveModuleName(sanitizedSpecifier, containingFile, compilerOptions, customSys).resolvedModule;
         if (!customResolvedModule || !isVirtualFilePath(customResolvedModule.resolvedFileName, virtualFileExtensions)) {
+            const module = fileExists(sanitizedSpecifier, containingFile);
+            if (module)
+                return module;
             return customResolvedModule;
         }
         const resolvedFileName = ensureRealFilePath(customResolvedModule.resolvedFileName, virtualFileExtensions);

package/dist/typescript/visitors/dynamic-imports/importCall.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("src/typescript/getImportsAndExports.js").GetImportsAndExportsOptions) => import("src/types/imports.js").ImportNode | import("src/types/imports.js").ImportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("#p/typescript/getImportsAndExports.ts").GetImportsAndExportsOptions) => import("#p/types/imports.ts").ImportNode | import("#p/types/imports.ts").ImportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/dynamic-imports/importType.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("src/typescript/getImportsAndExports.js").GetImportsAndExportsOptions) => import("src/types/imports.js").ImportNode | import("src/types/imports.js").ImportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("#p/typescript/getImportsAndExports.ts").GetImportsAndExportsOptions) => import("#p/types/imports.ts").ImportNode | import("#p/types/imports.ts").ImportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/dynamic-imports/index.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("src/typescript/getImportsAndExports.js").GetImportsAndExportsOptions) => import("src/types/imports.js").ImportNode | import("src/types/imports.js").ImportNode[] | undefined)[];
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("#p/typescript/getImportsAndExports.ts").GetImportsAndExportsOptions) => import("#p/types/imports.ts").ImportNode | import("#p/types/imports.ts").ImportNode[] | undefined)[];
 export default _default;

package/dist/typescript/visitors/dynamic-imports/jsDocType.d.ts

@@ -1,4 +1,4 @@
 import ts from 'typescript';
 import type { ImportNode } from '../../../types/imports.js';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("src/typescript/getImportsAndExports.js").GetImportsAndExportsOptions) => ImportNode | ImportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("#p/typescript/getImportsAndExports.ts").GetImportsAndExportsOptions) => ImportNode | ImportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/dynamic-imports/propertyAccessCall.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("src/typescript/getImportsAndExports.js").GetImportsAndExportsOptions) => import("src/types/imports.js").ImportNode | import("src/types/imports.js").ImportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("#p/typescript/getImportsAndExports.ts").GetImportsAndExportsOptions) => import("#p/types/imports.ts").ImportNode | import("#p/types/imports.ts").ImportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/dynamic-imports/requireCall.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("src/typescript/getImportsAndExports.js").GetImportsAndExportsOptions) => import("src/types/imports.js").ImportNode | import("src/types/imports.js").ImportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("#p/typescript/getImportsAndExports.ts").GetImportsAndExportsOptions) => import("#p/types/imports.ts").ImportNode | import("#p/types/imports.ts").ImportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/exports/exportAssignment.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("src/typescript/getImportsAndExports.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("#p/typescript/getImportsAndExports.ts").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/exports/exportDeclaration.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("src/typescript/getImportsAndExports.js").GetImportsAndExportsOptions) => import("src/types/exports.js").ExportNode | import("src/types/exports.js").ExportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("#p/typescript/getImportsAndExports.ts").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/exports/exportKeyword.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("src/typescript/getImportsAndExports.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("#p/typescript/getImportsAndExports.ts").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
 export default _default;