knip 6.32.3 → 6.34.0

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)));
@@ -67,18 +87,18 @@ const addAppEntries = (inputs, srcDir, serverDir, config, dir) => {
             inputs.push(toDeferResolveProductionEntry(resolveAlias(id, srcDir, dir)));
 };
 const findLayerConfigs = (cwd) => _syncGlob({ cwd, patterns: [`layers/*/${config.at(0)}`] });
+const definitionFiles = [
+    '.nuxt/imports.d.ts',
+    '.nuxt/components.d.ts',
+    '.nuxt/types/nitro-routes.d.ts',
+    '.nuxt/types/nitro-imports.d.ts',
+];
 const registerCompilers = async ({ cwd, hasDependency, registerCompiler }) => {
-    if (hasDependency('nuxt') || hasDependency('nuxt-nightly')) {
+    if (hasDependency('nuxt') || hasDependency('nuxt-nightly') || isDirectory(cwd, '.nuxt')) {
+        const paths = definitionFiles.map(file => join(cwd, file));
         const maps = createAutoImportMaps();
-        const definitionFiles = [
-            '.nuxt/imports.d.ts',
-            '.nuxt/components.d.ts',
-            '.nuxt/types/nitro-routes.d.ts',
-            '.nuxt/types/nitro-imports.d.ts',
-        ];
-        for (const file of definitionFiles) {
-            const path = join(cwd, file);
-            buildAutoImportMap(path, readAndParseFile(path), maps, file.endsWith('components.d.ts'));
+        for (const path of paths) {
+            buildAutoImportMap(path, readAndParseFile(path), maps, path.endsWith('components.d.ts'));
         }
         registerCompiler({ extension: '.vue', compiler: createVueCompiler(maps, cwd) });
         registerCompiler({ extension: '.ts', compiler: createTsCompiler(maps) });
@@ -101,6 +121,9 @@ const resolveConfig = async (localConfig, options) => {
             addModule(id);
     }
     addAppEntries(inputs, srcDir, serverDir, localConfig, cwd);
+    const sharedDir = toAbsolute(localConfig.dir?.shared ?? 'shared', cwd);
+    inputs.push(toAlias('#shared', sharedDir));
+    inputs.push(toAlias('#shared/*', join(sharedDir, '*'), { dir: cwd }));
     const aliases = localConfig.alias;
     if (aliases) {
         for (const key in aliases) {
@@ -111,15 +134,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/run.js

@@ -60,7 +60,7 @@ export const run = async (options) => {
     const isGitIgnored = await getGitIgnoredHandler(options, new Set(workspaces.map(w => w.dir)));
     const toSourceFilePath = getModuleSourcePathHandler(chief);
     const findWorkspacePackageTarget = getWorkspacePackageTargetHandler(chief);
-    const principal = new ProjectPrincipal(options, toSourceFilePath, findWorkspacePackageTarget);
+    const principal = new ProjectPrincipal(options, toSourceFilePath, findWorkspacePackageTarget, filePath => chief.findWorkspaceByFilePath(filePath)?.name);
     collector.setWorkspaceFilter(chief.workspaceFilePathFilter);
     collector.setSelectedWorkspaces(chief.selectedWorkspaces);
     collector.setIgnoreIssues(chief.getIgnoreIssues());

package/dist/types/config.d.ts

@@ -138,8 +138,10 @@ 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;
+        cwd?: string;
         filter?: RegExp;
     }) => void;
     markExportRegistered: (name: string) => void;

package/dist/types/module-graph.d.ts

@@ -30,6 +30,7 @@ export interface Import extends Position {
     readonly identifier: string | undefined;
     readonly isTypeOnly: boolean;
     readonly modifiers: number;
+    readonly jsDocTags: Tags | undefined;
 }
 export interface ExternalRef {
     readonly specifier: string;
@@ -76,6 +77,7 @@ export type FileNode = {
 export interface ImportGlob {
     patterns: string[];
     base?: string;
+    cwd?: string;
     filter?: RegExp;
 }
 export type ModuleGraph = Map<FilePath, FileNode>;

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);
@@ -61,6 +62,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
             col: opts.col,
             isTypeOnly: isDts || !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
             modifiers,
+            jsDocTags: undefined,
         });
         const file = internal.get(importFilePath);
         const importMaps = file ?? createImports();
@@ -145,6 +147,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
                         col,
                         isTypeOnly: isDts || !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
                         modifiers,
+                        jsDocTags,
                     });
                 }
             }
@@ -170,6 +173,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
                     col,
                     isTypeOnly: isDts || !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
                     modifiers,
+                    jsDocTags: undefined,
                 });
             }
         }
@@ -278,7 +282,8 @@ 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.addImportGlob = (patterns, opts) => importGlobs.push({ patterns, base: opts?.base, filter: opts?.filter });
+        pluginCtx.markImportExpressionHandled = (pos) => handledImportExpressions.add(pos);
+        pluginCtx.addImportGlob = (patterns, opts) => importGlobs.push({ patterns, base: opts?.base, cwd: opts?.cwd, filter: opts?.filter });
         pluginCtx.markExportRegistered = (name) => registeredCustomElements.add(name);
     }
     const localRefs = _walkAST(result.program, sourceText, filePath, result.module.hasModuleSyntax, {
@@ -311,6 +316,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         resolveModule,
         programFiles,
         entryFiles,
+        handledImportExpressions,
         visitor,
         getJSDocTags,
     });

package/dist/typescript/glob-imports.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import { _syncGlob } from '../util/glob.js';
-import { dirname, isAbsolute, join, toRelative } from '../util/path.js';
+import { dirname, isAbsolute, join, toAbsolute, toRelative } from '../util/path.js';
 function resolveBaseDir(base, dir, resolveGlobPattern) {
     if (base.startsWith('.'))
         return join(dir, base);
@@ -15,8 +15,13 @@ function resolveBaseDir(base, dir, resolveGlobPattern) {
 export function resolveImportGlobs(items, containingFile, resolveGlobPattern, workspaceRoot) {
     const filePaths = [];
     const dir = dirname(containingFile);
-    for (const { patterns, base, filter } of items) {
-        if (base !== undefined) {
+    for (const { patterns, base, cwd, filter } of items) {
+        if (cwd !== undefined) {
+            for (const filePath of _syncGlob({ patterns, cwd: toAbsolute(cwd, workspaceRoot) })) {
+                filePaths.push(filePath);
+            }
+        }
+        else if (base !== undefined) {
             const cwd = resolveBaseDir(base, dir, resolveGlobPattern);
             if (!cwd)
                 continue;

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);
                         }
                     }
                 }
@@ -256,7 +256,7 @@ export function handleNewExpression(node, s) {
         node.arguments[1].property.name === 'url') {
         const specifier = getStringValue(node.arguments[0]);
         if (specifier)
-            s.addImport(specifier, undefined, undefined, undefined, node.arguments[0].start, IMPORT_FLAGS.ENTRY | IMPORT_FLAGS.OPTIONAL);
+            s.addImport(specifier, undefined, undefined, undefined, node.arguments[0].start, IMPORT_FLAGS.ENTRY | IMPORT_FLAGS.OPTIONAL, undefined, s.getJSDocTags(node.start));
         return;
     }
     if (s.hasWorkerThreadsImport &&

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);
                 }
             }
         }