knip 5.61.3 → 5.63.0

package/dist/plugins/index.js

@@ -48,6 +48,7 @@ import { default as nanoStaged } from './nano-staged/index.js';
 import { default as nest } from './nest/index.js';
 import { default as netlify } from './netlify/index.js';
 import { default as next } from './next/index.js';
+import { default as nodeModulesInspector } from './node-modules-inspector/index.js';
 import { default as node } from './node/index.js';
 import { default as nodemon } from './nodemon/index.js';
 import { default as npmPackageJsonLint } from './npm-package-json-lint/index.js';
@@ -72,6 +73,7 @@ import { default as remark } from './remark/index.js';
 import { default as remix } from './remix/index.js';
 import { default as rollup } from './rollup/index.js';
 import { default as rsbuild } from './rsbuild/index.js';
+import { default as rslib } from './rslib/index.js';
 import { default as rspack } from './rspack/index.js';
 import { default as semanticRelease } from './semantic-release/index.js';
 import { default as sentry } from './sentry/index.js';
@@ -159,6 +161,7 @@ export const Plugins = {
     netlify,
     next,
     node,
+    'node-modules-inspector': nodeModulesInspector,
     nodemon,
     'npm-package-json-lint': npmPackageJsonLint,
     nuxt,
@@ -182,6 +185,7 @@ export const Plugins = {
     remix,
     rollup,
     rsbuild,
+    rslib,
     rspack,
     'semantic-release': semanticRelease,
     sentry,

package/dist/plugins/lefthook/index.js

@@ -9,6 +9,8 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const gitHookPaths = getGitHookPaths();
 const config = ['lefthook.yml', ...gitHookPaths];
 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') {

package/dist/plugins/node-modules-inspector/index.d.ts

@@ -0,0 +1,12 @@
+import type { IsPluginEnabled } from '../../types/config.js';
+declare const _default: {
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    args: {
+        binaries: string[];
+        config: boolean;
+    };
+};
+export default _default;

package/dist/plugins/node-modules-inspector/index.js

@@ -0,0 +1,17 @@
+import { toUnconfig } from '../../util/plugin-config.js';
+import { hasDependency } from '../../util/plugin.js';
+const title = 'node-modules-inspector';
+const enablers = ['node-modules-inspector'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = [...toUnconfig('node-modules-inspector.config')];
+const args = {
+    binaries: ['node-modules-inspector'],
+    config: true,
+};
+export default {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    args,
+};

package/dist/plugins/playwright/index.js

@@ -1,3 +1,4 @@
+import { arrayify } from '../../util/array.js';
 import { toDeferResolve, toEntry } from '../../util/input.js';
 import { join, relative } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
@@ -15,6 +16,11 @@ const toEntryPatterns = (testMatch, cwd, configDir, localConfig, rootConfig) =>
 const builtinReporters = ['dot', 'line', 'list', 'junit', 'html', 'blob', 'json', 'github'];
 export const resolveConfig = async (localConfig, options) => {
     const { cwd, configFileDir } = options;
+    const inputs = [];
+    for (const id of arrayify(localConfig.globalSetup))
+        inputs.push(toEntry(id));
+    for (const id of arrayify(localConfig.globalTeardown))
+        inputs.push(toEntry(id));
     const projects = localConfig.projects ? [localConfig, ...localConfig.projects] : [localConfig];
     const reporters = [localConfig.reporter].flat().flatMap(reporter => {
         const name = typeof reporter === 'string' ? reporter : reporter?.[0];
@@ -24,7 +30,8 @@ export const resolveConfig = async (localConfig, options) => {
     });
     return projects
         .flatMap(config => toEntryPatterns(config.testMatch ?? entry, cwd, configFileDir, config, localConfig))
-        .concat(reporters.map(id => toDeferResolve(id)));
+        .concat(reporters.map(id => toDeferResolve(id)))
+        .concat(inputs);
 };
 const args = {
     binaries: ['playwright'],

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

@@ -1,27 +1,31 @@
 type LiteralUnion<T extends U, U = string> = T | (U & {
     zz_IGNORE_ME?: never;
 });
-type ReporterDescription = Readonly<['blob'] | ['blob', {
+type BlobReporterOptions = {
     outputDir?: string;
     fileName?: string;
-}] | ['dot'] | ['line'] | ['list'] | ['list', {
+};
+type ListReporterOptions = {
     printSteps?: boolean;
-}] | ['github'] | ['junit'] | ['junit', {
+};
+type JUnitReporterOptions = {
     outputFile?: string;
     stripANSIControlSequences?: boolean;
     includeProjectInTestName?: boolean;
-}] | ['json'] | ['json', {
+};
+type JsonReporterOptions = {
     outputFile?: string;
-}] | ['html'] | [
-    'html',
-    {
-        outputFolder?: string;
-        open?: 'always' | 'never' | 'on-failure';
-        host?: string;
-        port?: number;
-        attachmentsBaseURL?: string;
-    }
-] | ['null'] | [string] | [string, any]>;
+};
+type HtmlReporterOptions = {
+    outputFolder?: string;
+    open?: 'always' | 'never' | 'on-failure';
+    host?: string;
+    port?: number;
+    attachmentsBaseURL?: string;
+    title?: string;
+    noSnippets?: boolean;
+};
+type ReporterDescription = Readonly<['blob'] | ['blob', BlobReporterOptions] | ['dot'] | ['line'] | ['list'] | ['list', ListReporterOptions] | ['github'] | ['junit'] | ['junit', JUnitReporterOptions] | ['json'] | ['json', JsonReporterOptions] | ['html'] | ['html', HtmlReporterOptions] | ['null'] | [string] | [string, any]>;
 type Project = {
     name: string;
     use: string;
@@ -32,5 +36,7 @@ export type PlaywrightTestConfig = {
     testMatch?: string | RegExp | (string | RegExp)[];
     testDir?: string;
     reporter?: LiteralUnion<'dot' | 'line' | 'list' | 'junit' | 'html' | 'json' | 'github' | 'null', string> | ReporterDescription[];
+    globalSetup?: string | Array<string>;
+    globalTeardown?: string | Array<string>;
 };
 export {};

package/dist/plugins/postcss/index.js

@@ -7,7 +7,7 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = [
     'package.json',
     'postcss.config.json',
-    ...toLilconfig('postcss', { configDir: false, additionalExtensions: ['ts', 'mts', 'cts', 'yaml', 'yml'] }),
+    ...toLilconfig('postcss', { configDir: false, additionalExtensions: ['mts', 'cts', 'yaml', 'yml'] }),
 ];
 const resolveConfig = config => {
     const plugins = config.plugins

package/dist/plugins/preconstruct/index.js

@@ -1,11 +1,12 @@
 import { toProductionEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Preconstruct';
 const enablers = ['@preconstruct/cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['package.json'];
 const resolveConfig = async (config) => {
-    return (config.entrypoints ?? []).map(id => toProductionEntry(id, { allowIncludeExports: true }));
+    return (config.entrypoints ?? []).map(id => toProductionEntry(join('src', id), { allowIncludeExports: true }));
 };
 export default {
     title,

package/dist/plugins/react-router/index.js

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs';
 import os from 'node:os';
-import { toEntry } from '../../util/input.js';
+import { _glob } from '../../util/glob.js';
+import { toEntry, toProductionDependency, toProductionEntry } from '../../util/input.js';
 import { join } from '../../util/path.js';
 import { hasDependency, load } from '../../util/plugin.js';
 import vite from '../vite/index.js';
@@ -28,13 +29,22 @@ const resolveConfig = async (localConfig, options) => {
     };
     const routes = routeConfig
         .flatMap(mapRoute)
-        .map(route => (isWindows ? route : route.replace(/[$^*+?()\[\]]/g, '\\$&')));
-    return [
-        join(appDir, 'routes.{js,ts}'),
-        join(appDir, 'root.{jsx,tsx}'),
-        join(appDir, 'entry.{client,server}.{js,jsx,ts,tsx}'),
-        ...routes,
-    ].map(id => toEntry(id));
+        .map(route => (isWindows ? route : route.replace(/[\^*+?()\[\]]/g, '\\$&')));
+    const resolved = [
+        toEntry(join(appDir, 'routes.{js,ts}')),
+        toProductionEntry(join(appDir, 'root.{jsx,tsx}')),
+        toProductionEntry(join(appDir, 'entry.{client,server}.{js,jsx,ts,tsx}')),
+        ...routes.map(id => toProductionEntry(id)),
+    ];
+    const serverEntries = await _glob({
+        cwd: appDir,
+        patterns: ['entry.server.{js,ts,jsx,tsx}'],
+    });
+    if (serverEntries.length === 0) {
+        resolved.push(toProductionDependency('@react-router/node'));
+        resolved.push(toProductionDependency('isbot'));
+    }
+    return resolved;
 };
 export default {
     title,

package/dist/plugins/rsbuild/index.js

@@ -1,10 +1,19 @@
+import { toEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Rsbuild';
 const enablers = ['@rsbuild/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['rsbuild*.config.{mjs,ts,js,cjs,mts,cts}'];
-const resolveConfig = async () => {
-    return [];
+const resolveConfig = async (config) => {
+    const inputs = new Set();
+    if (config.source?.entry) {
+        if (Array.isArray(config.source.entry))
+            for (const entry of config.source.entry)
+                inputs.add(toEntry(entry));
+        if (typeof config.source.entry === 'string')
+            inputs.add(toEntry(config.source.entry));
+    }
+    return Array.from(inputs);
 };
 export default {
     title,

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

@@ -1,3 +1,11 @@
+type EntryDescription = Record<string, unknown>;
+type Entry = Record<string, string | string[] | (EntryDescription & {
+    html?: boolean;
+})>;
 export type RsbuildConfig = {
     plugins?: unknown[];
+    source?: {
+        entry?: Entry;
+    };
 };
+export {};

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

@@ -0,0 +1,10 @@
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
+import type { RslibConfig } from './types.js';
+declare const _default: {
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    entry: string[];
+    resolveConfig: ResolveConfig<RslibConfig>;
+};
+export default _default;

package/dist/plugins/rslib/index.js

@@ -0,0 +1,15 @@
+import { hasDependency } from '../../util/plugin.js';
+const title = 'Rslib';
+const enablers = ['rslib'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const entry = ['rslib*.config.{mjs,ts,js,cjs,mts,cts}'];
+const resolveConfig = () => {
+    return [];
+};
+export default {
+    title,
+    enablers,
+    isEnabled,
+    entry,
+    resolveConfig,
+};

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

@@ -0,0 +1 @@
+export type RslibConfig = {};

package/dist/plugins/rslib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/rspack/index.js

@@ -3,7 +3,7 @@ import { findWebpackDependenciesFromConfig } from '../webpack/index.js';
 const title = 'Rspack';
 const enablers = ['@rspack/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['rspack.config*.{js,ts,mjs,cjs}'];
+const config = ['rspack.config*.{js,ts,mjs,mts,cjs,cts}'];
 const resolveConfig = async (localConfig, options) => {
     const inputs = await findWebpackDependenciesFromConfig(localConfig, options);
     return inputs.filter(input => !input.specifier.startsWith('builtin:'));

package/dist/plugins/size-limit/index.js

@@ -6,7 +6,7 @@ const enablers = ['size-limit'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = [
     'package.json',
-    ...toLilconfig('size-limit', { configDir: false, additionalExtensions: ['ts', 'mts', 'cts'], rcSuffix: '' }),
+    ...toLilconfig('size-limit', { configDir: false, additionalExtensions: ['mts', 'cts'], rcSuffix: '' }),
 ];
 const resolve = options => {
     const allDeps = [

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

@@ -1,5 +1,5 @@
-import type { TsConfigJson } from 'type-fest';
 import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
+import type { TsConfigJson } from '../../types/tsconfig-json.js';
 export declare const docs: {
     note: string;
 };

package/dist/plugins/vitest/index.js

@@ -1,5 +1,6 @@
 import { DEFAULT_EXTENSIONS } from '../../constants.js';
-import { toAlias, toDeferResolve, toDependency, toEntry } from '../../util/input.js';
+import { _glob } from '../../util/glob.js';
+import { toAlias, toConfig, toDeferResolve, toDependency, toEntry } from '../../util/input.js';
 import { join, toPosix } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getEnvPackageName, getExternalReporters } from './helpers.js';
@@ -28,11 +29,20 @@ const findConfigDependencies = (localConfig, options) => {
             workspaceDependencies.push(...findConfigDependencies(workspaceConfig, options));
         }
     }
+    const projectsDependencies = [];
+    if (testConfig.projects !== undefined) {
+        for (const projectConfig of testConfig.projects) {
+            if (typeof projectConfig !== 'string') {
+                projectsDependencies.push(...findConfigDependencies(projectConfig, options));
+            }
+        }
+    }
     return [
         ...[...environments, ...reporters, ...coverage].map(id => toDependency(id)),
         ...setupFiles,
         ...globalSetup,
         ...workspaceDependencies,
+        ...projectsDependencies,
     ];
 };
 const getConfigs = async (localConfig) => {
@@ -44,11 +54,25 @@ const getConfigs = async (localConfig) => {
                     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);
+                                }
+                            }
+                        }
                     }
                 }
             }
             else {
                 configs.push(config);
+                if (config.test?.projects) {
+                    for (const project of config.test.projects) {
+                        if (typeof project !== 'string') {
+                            configs.push(project);
+                        }
+                    }
+                }
             }
         }
     }
@@ -58,6 +82,22 @@ export const resolveConfig = async (localConfig, options) => {
     const inputs = new Set();
     inputs.add(toEntry(join(options.cwd, 'src/vite-env.d.ts')));
     const configs = await getConfigs(localConfig);
+    for (const cfg of configs) {
+        if (cfg.test?.projects) {
+            for (const project of cfg.test.projects) {
+                if (typeof project === 'string') {
+                    const projectFiles = await _glob({
+                        cwd: options.cwd,
+                        patterns: [project],
+                        gitignore: false,
+                    });
+                    for (const projectFile of projectFiles) {
+                        inputs.add(toConfig('vitest', projectFile, { containingFilePath: options.configFilePath }));
+                    }
+                }
+            }
+        }
+    }
     const addStar = (value) => (value.endsWith('*') ? value : join(value, '*').replace(/\/\*\*$/, '/*'));
     const addAliases = (aliasOptions) => {
         for (const [alias, value] of Object.entries(aliasOptions)) {

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

@@ -23,6 +23,11 @@ interface VitestConfig {
                 workspace: never;
             };
         })[];
+        projects?: (string | (ViteConfig & {
+            test: VitestConfig['test'] & {
+                projects: never;
+            };
+        }))[];
         alias?: AliasOptions;
     };
 }

package/dist/reporters/symbols.js

@@ -20,7 +20,9 @@ export default (options) => {
     if (!isDisableConfigHints) {
         printConfigurationHints(options);
     }
-    if (totalIssues === 0 && isShowProgress) {
+    if (totalIssues === 0 &&
+        isShowProgress &&
+        (!options.isTreatConfigHintsAsErrors || options.configurationHints.size === 0)) {
         console.log('✂️  Excellent, Knip found no issues.');
     }
 };

package/dist/reporters/util/configuration-hints.d.ts

@@ -1,2 +1,2 @@
 import type { ReporterOptions } from '../../types/issues.js';
-export declare const printConfigurationHints: ({ counters, issues, tagHints, configurationHints, isTreatConfigHintsAsErrors, includedWorkspaces, }: ReporterOptions) => void;
+export declare const printConfigurationHints: ({ counters, issues, tagHints, configurationHints, isTreatConfigHintsAsErrors, includedWorkspaces, configFilePath, }: ReporterOptions) => void;

package/dist/reporters/util/configuration-hints.js

@@ -1,14 +1,33 @@
-import { toRelative } from '../../util/path.js';
+import { relative, toRelative } from '../../util/path.js';
+import { Table } from '../../util/table.js';
 import { byPathDepth } from '../../util/workspace.js';
-import { bright, dim, getColoredTitle, getDimmedTitle, plain, yellow } from './util.js';
-const id = (id) => bright(id.toString() + (id === '.' ? ' (root)' : ''));
-const type = (id) => yellow(id.split('-').at(0));
-const workspace = ({ isRootOnly, workspaceName: id }) => isRootOnly ? '' : id === '.' ? ` in root ${yellow('"."')} workspace` : ` in ${yellow(id ?? '.')}`;
-const unused = (options) => `Remove from ${type(options.type)}${options.workspaceName === '.' ? '' : `${workspace(options)}`}: ${id(options.identifier)}`;
-const empty = (options) => `Refine ${type(options.type)}${workspace(options)}: ${id(options.identifier)} (no files found)`;
-const remove = (options) => `Remove ${type(options.type)}${workspace(options)}: ${id(options.identifier)}`;
-const add = (options) => `Add to or refine in ${yellow('workspaces')}: ${id(options.identifier)} (${options.size} unused files)`;
-const topLevel = (options) => `Remove or move unused top-level ${type(options.type)} to one of ${yellow('workspaces')}: ${id(options.identifier)}`;
+import { bright, dim, getColoredTitle, getDimmedTitle } from './util.js';
+const getWorkspaceName = (hint) => hint.workspaceName &&
+    hint.workspaceName !== '.' &&
+    hint.type !== 'workspace-unconfigured' &&
+    hint.type !== 'package-entry'
+    ? hint.workspaceName
+    : '';
+const getTableForHints = (hints) => {
+    const table = new Table({ truncateStart: ['identifier', 'workspace', 'filePath'] });
+    for (const hint of hints) {
+        table.row();
+        table.cell('identifier', hint.identifier.toString());
+        table.cell('workspace', getWorkspaceName(hint));
+        table.cell('filePath', hint.filePath ? relative(hint.filePath) : '');
+        table.cell('description', dim(hint.message));
+    }
+    return table;
+};
+const type = (id) => bright(id.split('-').at(0));
+const unused = (options) => `Remove from ${type(options.type)}`;
+const empty = (options) => `Refine ${type(options.type)} pattern (no matches)`;
+const remove = (options) => `Remove redundant ${type(options.type)} pattern`;
+const topLevel = (options) => `Remove, or move unused top-level ${type(options.type)} to one of ${bright('"workspaces"')}`;
+const add = (options) => options.configFilePath
+    ? `Add ${bright('entry')} and/or refine ${bright('project')} files in ${bright(`workspaces["${options.workspaceName}"]`)} (${options.size} unused files)`
+    : `Create ${bright('knip.json')} configuration file with ${bright(`workspaces["${options.workspaceName}"]`)} object (${options.size} unused files)`;
+const packageEntry = () => 'Package entry file not found';
 const hintPrinters = new Map([
     ['ignoreBinaries', { print: unused }],
     ['ignoreDependencies', { print: unused }],
@@ -21,8 +40,19 @@ const hintPrinters = new Map([
     ['workspace-unconfigured', { print: add }],
     ['entry-top-level', { print: topLevel }],
     ['project-top-level', { print: topLevel }],
+    ['package-entry', { print: packageEntry }],
 ]);
-export const printConfigurationHints = ({ counters, issues, tagHints, configurationHints, isTreatConfigHintsAsErrors, includedWorkspaces, }) => {
+const hintTypesOrder = [
+    ['workspace-unconfigured'],
+    ['entry-top-level', 'project-top-level'],
+    ['ignoreWorkspaces'],
+    ['ignoreDependencies'],
+    ['ignoreBinaries'],
+    ['ignoreUnresolved'],
+    ['entry-empty', 'project-empty', 'entry-redundant', 'project-redundant'],
+    ['package-entry'],
+];
+export const printConfigurationHints = ({ counters, issues, tagHints, configurationHints, isTreatConfigHintsAsErrors, includedWorkspaces, configFilePath, }) => {
     if (counters.files > 20) {
         const workspaces = includedWorkspaces
             .map(workspace => workspace.dir)
@@ -41,17 +71,23 @@ export const printConfigurationHints = ({ counters, issues, tagHints, configurat
         }
     }
     if (configurationHints.size > 0) {
-        const isTopLevel = (type) => type.includes('top-level');
-        const hintOrderer = (a, b) => isTopLevel(a.type) && !isTopLevel(b.type) ? -1 : !isTopLevel(a.type) && isTopLevel(b.type) ? 1 : 0;
         const getTitle = isTreatConfigHintsAsErrors ? getColoredTitle : getDimmedTitle;
-        const style = isTreatConfigHintsAsErrors ? plain : dim;
         console.log(getTitle('Configuration hints', configurationHints.size));
-        const isRootOnly = includedWorkspaces.length === 1 && includedWorkspaces[0].name === '.';
-        for (const hint of Array.from(configurationHints).sort(hintOrderer)) {
-            const hintPrinter = hintPrinters.get(hint.type);
-            if (hintPrinter)
-                console.warn(style(hintPrinter.print({ ...hint, isRootOnly })));
+        const hintsByType = new Map();
+        for (const hint of configurationHints) {
+            const hints = hintsByType.get(hint.type) ?? [];
+            hintsByType.set(hint.type, [...hints, hint]);
         }
+        const rows = hintTypesOrder.flatMap(hintTypes => hintTypes.flatMap(hintType => {
+            const hints = hintsByType.get(hintType) ?? [];
+            return hints.map(hint => {
+                hint.filePath ??= configFilePath;
+                const hintPrinter = hintPrinters.get(hint.type);
+                const message = hintPrinter ? hintPrinter.print({ ...hint, configFilePath }) : '';
+                return { ...hint, message };
+            });
+        }));
+        console.warn(getTableForHints(rows).toString());
     }
     if (tagHints.size > 0) {
         console.log(getColoredTitle('Tag issues', tagHints.size));

package/dist/reporters/util/util.d.ts

@@ -1,10 +1,8 @@
 import { ISSUE_TYPE_TITLE } from '../../constants.js';
 import { type Issue, type IssueSeverity, type IssueSymbol } from '../../types/issues.js';
 import { Table } from '../../util/table.js';
-export declare const plain: (text: string) => string;
 export declare const dim: import("picocolors/types.js").Formatter;
 export declare const bright: import("picocolors/types.js").Formatter;
-export declare const yellow: import("picocolors/types.js").Formatter;
 export declare const getIssueTypeTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => string;
 export declare const getColoredTitle: (title: string, count: number) => string;
 export declare const getDimmedTitle: (title: string, count: number) => string;

package/dist/reporters/util/util.js

@@ -3,10 +3,10 @@ import { ISSUE_TYPE_TITLE } from '../../constants.js';
 import { SymbolType } from '../../types/issues.js';
 import { relative } from '../../util/path.js';
 import { Table } from '../../util/table.js';
-export const plain = (text) => text;
+const plain = (text) => text;
 export const dim = picocolors.gray;
 export const bright = picocolors.whiteBright;
-export const yellow = picocolors.yellow;
+const yellow = picocolors.yellow;
 export const getIssueTypeTitle = (reportType) => ISSUE_TYPE_TITLE[reportType];
 export const getColoredTitle = (title, count) => `${picocolors.yellowBright(picocolors.underline(title))} (${count})`;
 export const getDimmedTitle = (title, count) => `${yellow(`${picocolors.underline(title)} (${count})`)}`;