knip 6.32.2 → 6.33.0

package/README.md

@@ -51,7 +51,7 @@ following projects:
 [3]: https://img.shields.io/npm/dm/knip?color=f56e0f
 [4]: https://github.com/webpro-nl/knip
 [5]:
-  https://img.shields.io/github/stars/webpro-nl/knip?style=flat-square&color=f56e0f
+  https://img.shields.io/github/stars/webpro-nl/knip?style=flat&color=f56e0f
 [6]: https://knip.dev
 [7]: https://www.npmx.dev/package/@knip/create-config
 [8]: https://www.npmx.dev/package/@knip/language-server

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/binaries/resolvers/bun.js

@@ -15,6 +15,7 @@ const commands = new Set([
     'completions',
     'config',
     'create',
+    'dedupe',
     'deploy',
     'discord',
     'exec',

package/dist/binaries/resolvers/pnpm.js

@@ -15,6 +15,7 @@ const commands = [
     'clean-install',
     'clean',
     'config',
+    'create',
     'dedupe',
     'deploy',
     'dlx',
@@ -28,6 +29,7 @@ const commands = [
     'ic',
     'ignored-builds',
     'import',
+    'info',
     'init',
     'install-clean',
     'install-test',
@@ -39,6 +41,8 @@ const commands = [
     'list',
     'll',
     'ln',
+    'login',
+    'logout',
     'ls',
     'outdated',
     'pack-app',
@@ -70,6 +74,7 @@ const commands = [
     'store',
     't',
     'test',
+    'token',
     'tst',
     'un',
     'uninstall',
@@ -78,9 +83,11 @@ const commands = [
     'update',
     'upgrade',
     'version',
+    'view',
     'why',
     'with',
 ];
+const recursiveCommands = ['recursive', 'multi', 'm'];
 export const resolve = (_binary, words, options) => {
     const parsed = parseArgs(words, {
         boolean: ['aggregate-output', 'if-present', 'parallel', 'recursive', 'reverse', 'shell-mode', 'silent', 'stream'],
@@ -92,6 +99,9 @@ export const resolve = (_binary, words, options) => {
         const wordsForDlx = words.filter(word => word.value !== 'dlx');
         return resolveDlx(wordsForDlx, options);
     }
+    if (recursiveCommands.includes(command)) {
+        return resolve(_binary, argsAfter(words, command), options);
+    }
     const { manifest, fromArgs } = options;
     if (parsed.filter && !parsed.recursive)
         return [];

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/constants.js

@@ -108,6 +108,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'powershell.exe',
     'pr',
     'printenv',
+    'printf',
     'ps',
     'pulumi',
     'pwd',

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/lefthook/index.js

@@ -6,12 +6,20 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Lefthook';
 const enablers = ['lefthook', '@arkweid/lefthook', '@evilmartians/lefthook'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const configFiles = [
+    'lefthook.{yml,yaml,json,jsonc,toml}',
+    '.lefthook.{yml,yaml,json,jsonc,toml}',
+    '.config/lefthook.{yml,yaml,json,jsonc,toml}',
+    'lefthook-local.{yml,yaml,json,jsonc,toml}',
+    '.lefthook-local.{yml,yaml,json,jsonc,toml}',
+    '.config/lefthook-local.{yml,yaml,json,jsonc,toml}',
+];
 const resolveConfig = async (localConfig, options) => {
     if (options.isProduction)
         return [];
     const { manifest, configFileName, cwd, getInputsFromScripts } = options;
     const inputs = manifest.devDependencies ? Object.keys(manifest.devDependencies).map(id => toDependency(id)) : [];
-    if (extname(configFileName) === '.yml') {
+    if (extname(configFileName) !== '') {
         const scripts = findByKeyDeep(localConfig, 'run').flatMap(command => {
             const deps = getInputsFromScripts([command.run], { ...options, knownBinsOnly: true });
             const dir = command.root ?? cwd;
@@ -33,7 +41,7 @@ const plugin = {
     title,
     enablers,
     isEnabled,
-    config: options => ['lefthook.yml', ...getGitHookPaths('.git/hooks', true, options.cwd)],
+    config: options => [...configFiles, ...getGitHookPaths('.git/hooks', true, options.cwd)],
     resolveConfig,
 };
 export default plugin;

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/tsup/index.js

@@ -4,7 +4,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'tsup';
 const enablers = ['tsup'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['tsup.config.{js,ts,cjs,mjs,json}', 'package.json'];
+const config = ['tsup.config.{js,ts,cjs,mjs,cts,mts,json}', 'package.json'];
 const isLoadConfig = ({ configFileName }) => configFileName === 'package.json' || configFileName.endsWith('.json');
 const resolveConfig = async (config) => {
     if (typeof config === 'function')

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