knip 5.9.1 → 5.9.2

package/dist/cli.js

@@ -1,15 +1,15 @@
-import './util/register.js';
 import picocolors from 'picocolors';
 import prettyMilliseconds from 'pretty-ms';
+import { main } from './index.js';
+import { Performance } from './util/Performance.js';
 import parsedArgValues, { helpText } from './util/cli-arguments.js';
-import { isKnownError, getKnownError, isConfigurationError, hasCause } from './util/errors.js';
+import { getKnownError, hasCause, isConfigurationError, isKnownError } from './util/errors.js';
 import { cwd } from './util/path.js';
-import { Performance } from './util/Performance.js';
+import './util/register.js';
 import { runPreprocessors, runReporters } from './util/reporter.js';
 import { splitTags } from './util/tag.js';
 import { version } from './version.js';
-import { main } from './index.js';
-const { debug: isDebug = false, trace: isTrace = false, help: isHelp, 'max-issues': maxIssues = '0', 'no-config-hints': noConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = isDebug || isTrace || false, 'include-entry-exports': isIncludeEntryExports = false, 'include-libs': isIncludeLibs = false, 'isolate-workspaces': isIsolateWorkspaces = false, performance: isObservePerf = false, production: isProduction = false, 'reporter-options': reporterOptions = '', 'preprocessor-options': preprocessorOptions = '', strict: isStrict = false, fix: isFix = false, 'fix-type': fixTypes = [], tsConfig, version: isVersion, 'experimental-tags': experimentalTags = [], tags = [], } = parsedArgValues;
+const { debug: isDebug = false, trace: isTrace = false, help: isHelp, 'max-issues': maxIssues = '0', 'no-config-hints': noConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = isDebug || isTrace, 'include-entry-exports': isIncludeEntryExports = false, 'include-libs': isIncludeLibs = false, 'isolate-workspaces': isIsolateWorkspaces = false, performance: isObservePerf = false, production: isProduction = false, 'reporter-options': reporterOptions = '', 'preprocessor-options': preprocessorOptions = '', strict: isStrict = false, fix: isFix = false, 'fix-type': fixTypes = [], tsConfig, version: isVersion, 'experimental-tags': experimentalTags = [], tags = [], } = parsedArgValues;
 if (isHelp) {
     console.log(helpText);
     process.exit(0);
@@ -55,13 +55,14 @@ const run = async () => {
             .reduce((errorCount, reportGroup) => errorCount + finalData.counters[reportGroup], 0);
         if (isObservePerf) {
             await perfObserver.finalize();
-            console.log('\n' + perfObserver.getTable());
+            console.log(`\n${perfObserver.getTable()}`);
             const mem = Math.round((perfObserver.getMemHeapUsage() / 1024 / 1024) * 100) / 100;
             console.log('\nTotal running time:', prettyMilliseconds(perfObserver.getTotalTime()), `(mem: ${mem}MB)`);
             perfObserver.reset();
         }
         if (experimentalTags.length > 0) {
-            console.warn(`\n${picocolors.yellow('DEPRECATION WARNING:')} --experimental-tags is deprecated, please start using --tags instead`);
+            const prefix = `${picocolors.yellow('DEPRECATION WARNING:')}`;
+            console.warn(`\n${prefix} --experimental-tags is deprecated, please start using --tags instead`);
         }
         if (!noExitCode && totalErrorCount > Number(maxIssues)) {
             process.exit(1);
@@ -75,7 +76,7 @@ const run = async () => {
             if (hasCause(knownError))
                 console.error('Reason:', knownError.cause.message);
             if (isConfigurationError(knownError))
-                console.log('\n' + helpText);
+                console.log(`\n${helpText}`);
             process.exit(2);
         }
         throw error;

package/dist/compilers/index.d.ts

@@ -1,6 +1,6 @@
-import type { AsyncCompilerFn, AsyncCompilers, SyncCompilerFn, SyncCompilers } from './types.js';
 import type { RawConfiguration } from '../types/config.js';
 import type { DependencySet } from '../types/workspace.js';
+import type { AsyncCompilerFn, AsyncCompilers, SyncCompilerFn, SyncCompilers } from './types.js';
 export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     syncCompilers: Record<string, SyncCompilerFn>;
     asyncCompilers: Record<string, AsyncCompilerFn>;

package/dist/index.js

@@ -1,14 +1,14 @@
-import { _getDependenciesFromScripts } from './binaries/index.js';
-import { getCompilerExtensions, getIncludedCompilers } from './compilers/index.js';
 import { ConfigurationChief } from './ConfigurationChief.js';
 import { ConsoleStreamer } from './ConsoleStreamer.js';
 import { DependencyDeputy } from './DependencyDeputy.js';
 import { IssueCollector } from './IssueCollector.js';
 import { IssueFixer } from './IssueFixer.js';
-import { getFilteredScripts } from './manifest/helpers.js';
 import { PrincipalFactory } from './PrincipalFactory.js';
-import { ProjectPrincipal } from './ProjectPrincipal.js';
-import { debugLogObject, debugLogArray, debugLog } from './util/debug.js';
+import { WorkspaceWorker } from './WorkspaceWorker.js';
+import { _getDependenciesFromScripts } from './binaries/index.js';
+import { getCompilerExtensions, getIncludedCompilers } from './compilers/index.js';
+import { getFilteredScripts } from './manifest/helpers.js';
+import { debugLog, debugLogArray, debugLogObject } from './util/debug.js';
 import { getReExportingEntryFileHandler } from './util/get-reexporting-entry-file.js';
 import { _glob, negate } from './util/glob.js';
 import { getGitIgnoredFn } from './util/globby.js';
@@ -19,8 +19,7 @@ import { dirname, join } from './util/path.js';
 import { hasMatch } from './util/regex.js';
 import { shouldIgnore } from './util/tag.js';
 import { loadTSConfig } from './util/tsconfig-loader.js';
-import { getType, getHasStrictlyNsReferences } from './util/type.js';
-import { WorkspaceWorker } from './WorkspaceWorker.js';
+import { getHasStrictlyNsReferences, getType } from './util/type.js';
 export const main = async (unresolvedConfiguration) => {
     const { cwd, tsConfigFile, gitignore, isStrict, isProduction, isShowProgress, isIncludeEntryExports, isIncludeLibs, isIsolateWorkspaces, tags, isFix, fixTypes, } = unresolvedConfiguration;
     debugLogObject('*', 'Unresolved configuration (from CLI arguments)', unresolvedConfiguration);
@@ -41,7 +40,7 @@ export const main = async (unresolvedConfiguration) => {
     const isReportValues = report.exports || report.nsExports || report.classMembers;
     const isReportTypes = report.types || report.nsTypes || report.enumMembers;
     const isReportClassMembers = report.classMembers;
-    const isSkipLibs = !isIncludeLibs && !isReportClassMembers;
+    const isSkipLibs = !(isIncludeLibs || isReportClassMembers);
     const collector = new IssueCollector({ cwd, rules, filters });
     const enabledPluginsStore = new Map();
     deputy.setIgnored(chief.config.ignoreBinaries, chief.config.ignoreDependencies);
@@ -89,7 +88,7 @@ export const main = async (unresolvedConfiguration) => {
         });
         await worker.init();
         principal.addEntryPaths(definitionPaths);
-        debugLogArray(name, `Definition paths`, definitionPaths);
+        debugLogArray(name, 'Definition paths', definitionPaths);
         const ignore = worker.getIgnorePatterns();
         const sharedGlobOptions = { cwd, workingDir: dir, gitignore };
         collector.addIgnorePatterns(ignore.map(pattern => join(cwd, pattern)));
@@ -111,51 +110,54 @@ export const main = async (unresolvedConfiguration) => {
             {
                 const patterns = worker.getProductionEntryFilePatterns(negatedEntryPatterns);
                 const workspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
-                debugLogArray(name, `Entry paths`, workspaceEntryPaths);
+                debugLogArray(name, 'Entry paths', workspaceEntryPaths);
                 principal.addEntryPaths(workspaceEntryPaths);
             }
             {
                 const patterns = Array.from(productionEntryFilePatterns);
                 const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
-                debugLogArray(name, `Production plugin entry paths`, pluginWorkspaceEntryPaths);
+                debugLogArray(name, 'Production plugin entry paths', pluginWorkspaceEntryPaths);
                 principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
             }
             {
                 const patterns = worker.getProductionProjectFilePatterns(negatedEntryPatterns);
                 const workspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns });
-                debugLogArray(name, `Project paths`, workspaceProjectPaths);
-                workspaceProjectPaths.forEach(projectPath => principal.addProjectPath(projectPath));
+                debugLogArray(name, 'Project paths', workspaceProjectPaths);
+                for (const projectPath of workspaceProjectPaths)
+                    principal.addProjectPath(projectPath);
             }
         }
         else {
             {
                 const patterns = worker.getEntryFilePatterns();
                 const workspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
-                debugLogArray(name, `Entry paths`, workspaceEntryPaths);
+                debugLogArray(name, 'Entry paths', workspaceEntryPaths);
                 principal.addEntryPaths(workspaceEntryPaths);
             }
             {
                 const patterns = worker.getProjectFilePatterns([...productionEntryFilePatterns]);
                 const workspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns });
-                debugLogArray(name, `Project paths`, workspaceProjectPaths);
-                workspaceProjectPaths.forEach(projectPath => principal.addProjectPath(projectPath));
+                debugLogArray(name, 'Project paths', workspaceProjectPaths);
+                for (const projectPath of workspaceProjectPaths)
+                    principal.addProjectPath(projectPath);
             }
             {
                 const patterns = [...entryFilePatterns, ...productionEntryFilePatterns];
                 const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
-                debugLogArray(name, `Plugin entry paths`, pluginWorkspaceEntryPaths);
+                debugLogArray(name, 'Plugin entry paths', pluginWorkspaceEntryPaths);
                 principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
             }
             {
                 const patterns = worker.getPluginProjectFilePatterns();
                 const pluginWorkspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns });
-                debugLogArray(name, `Plugin project paths`, pluginWorkspaceProjectPaths);
-                pluginWorkspaceProjectPaths.forEach(projectPath => principal.addProjectPath(projectPath));
+                debugLogArray(name, 'Plugin project paths', pluginWorkspaceProjectPaths);
+                for (const projectPath of pluginWorkspaceProjectPaths)
+                    principal.addProjectPath(projectPath);
             }
             {
                 const patterns = worker.getPluginConfigPatterns();
                 const configurationEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
-                debugLogArray(name, `Plugin configuration paths`, configurationEntryPaths);
+                debugLogArray(name, 'Plugin configuration paths', configurationEntryPaths);
                 principal.addEntryPaths(configurationEntryPaths, { skipExportsAnalysis: true });
             }
         }
@@ -173,11 +175,11 @@ export const main = async (unresolvedConfiguration) => {
     for (const principal of principals) {
         principal.init();
         const handleReferencedDependency = getHandler(collector, deputy, chief);
-        principal.referencedDependencies.forEach(([containingFilePath, specifier, workspaceName]) => {
+        for (const [containingFilePath, specifier, workspaceName] of principal.referencedDependencies) {
             const workspace = chief.findWorkspaceByName(workspaceName);
             if (workspace)
                 handleReferencedDependency(specifier, containingFilePath, workspace, principal);
-        });
+        }
         const specifierFilePaths = new Set();
         const analyzeSourceFile = (filePath, _principal = principal) => {
             const workspace = chief.findWorkspaceByFilePath(filePath);
@@ -227,29 +229,29 @@ export const main = async (unresolvedConfiguration) => {
                             importedModule.isReExport = true;
                     }
                 }
-                duplicate.forEach(symbols => {
+                for (const symbols of duplicate) {
                     if (symbols.length > 1) {
                         const symbol = symbols.map(s => s.symbol).join('|');
                         collector.addIssue({ type: 'duplicates', filePath, symbol, symbols });
                     }
-                });
-                external.forEach(specifier => {
+                }
+                for (const specifier of external) {
                     const packageName = getPackageNameFromModuleSpecifier(specifier);
                     const isHandled = packageName && deputy.maybeAddReferencedExternalDependency(workspace, packageName);
                     if (!isHandled)
                         collector.addIssue({ type: 'unlisted', filePath, symbol: specifier });
-                });
-                unresolved.forEach(unresolvedImport => {
+                }
+                for (const unresolvedImport of unresolved) {
                     const { specifier, pos, line, col } = unresolvedImport;
                     collector.addIssue({ type: 'unresolved', filePath, symbol: specifier, pos, line, col });
-                });
-                _getDependenciesFromScripts(scripts, {
+                }
+                for (const specifier of _getDependenciesFromScripts(scripts, {
                     cwd: dirname(filePath),
                     manifestScriptNames: new Set(),
                     dependencies: deputy.getDependencies(workspace.name),
-                }).forEach(specifier => {
+                })) {
                     handleReferencedDependency(specifier, filePath, workspace, _principal);
-                });
+                }
             }
         };
         streamer.cast('Running async compilers...');
@@ -262,30 +264,30 @@ export const main = async (unresolvedConfiguration) => {
             const resolvedFiles = principal.getUsedResolvedFiles();
             const files = resolvedFiles.filter(filePath => !analyzedFiles.has(filePath));
             debugLogArray('*', `Analyzing used resolved files [P${principals.indexOf(principal) + 1}/${++round}]`, files);
-            files.forEach(filePath => {
+            for (const filePath of files) {
                 analyzeSourceFile(filePath);
                 analyzedFiles.add(filePath);
-            });
+            }
         } while (size !== principal.entryPaths.size);
-        specifierFilePaths.forEach(specifierFilePath => {
+        for (const specifierFilePath of specifierFilePaths) {
             if (!analyzedFiles.has(specifierFilePath)) {
                 analyzedFiles.add(specifierFilePath);
                 analyzeSourceFile(specifierFilePath, principal);
             }
-        });
-        principal.getUnreferencedFiles().forEach(filePath => unreferencedFiles.add(filePath));
-        principal.entryPaths.forEach(filePath => entryPaths.add(filePath));
+        }
+        for (const filePath of principal.getUnreferencedFiles())
+            unreferencedFiles.add(filePath);
+        for (const filePath of principal.entryPaths)
+            entryPaths.add(filePath);
         if (isSkipLibs)
             factory.deletePrincipal(principal);
     }
     const isIdentifierReferenced = getIsIdentifierReferencedHandler(importedSymbols);
     const getReExportingEntryFile = getReExportingEntryFileHandler(entryPaths, exportedSymbols, importedSymbols);
-    const isExportedItemReferenced = (exportedItem) => {
-        return (exportedItem.refs > 0 &&
-            (typeof chief.config.ignoreExportsUsedInFile === 'object'
-                ? exportedItem.type !== 'unknown' && !!chief.config.ignoreExportsUsedInFile[exportedItem.type]
-                : chief.config.ignoreExportsUsedInFile));
-    };
+    const isExportedItemReferenced = (exportedItem) => exportedItem.refs > 0 &&
+        (typeof chief.config.ignoreExportsUsedInFile === 'object'
+            ? exportedItem.type !== 'unknown' && !!chief.config.ignoreExportsUsedInFile[exportedItem.type]
+            : chief.config.ignoreExportsUsedInFile);
     if (isReportValues || isReportTypes) {
         streamer.cast('Analyzing source files...');
         for (const [filePath, exportItems] of Object.entries(exportedSymbols)) {
@@ -312,11 +314,11 @@ export const main = async (unresolvedConfiguration) => {
                         }
                         if (isIdentifierReferenced(filePath, identifier, importsForExport)) {
                             if (report.enumMembers && exportedItem.type === 'enum') {
-                                exportedItem.members?.forEach(member => {
+                                for (const member of exportedItem.members) {
                                     if (hasMatch(workspace.ignoreMembers, member.identifier))
-                                        return;
+                                        continue;
                                     if (shouldIgnore(member.jsDocTags, tags))
-                                        return;
+                                        continue;
                                     if (member.refs === 0) {
                                         if (!isIdentifierReferenced(filePath, `${identifier}.${member.identifier}`, importsForExport)) {
                                             collector.addIssue({
@@ -330,11 +332,11 @@ export const main = async (unresolvedConfiguration) => {
                                             });
                                         }
                                     }
-                                });
+                                }
                             }
-                            if (isReportClassMembers && exportedItem.type === 'class') {
-                                const members = exportedItem.members.filter(member => !hasMatch(workspace.ignoreMembers, member.identifier) && !shouldIgnore(member.jsDocTags, tags));
-                                principal?.findUnusedMembers(filePath, members).forEach(member => {
+                            if (principal && isReportClassMembers && exportedItem.type === 'class') {
+                                const members = exportedItem.members.filter(member => !(hasMatch(workspace.ignoreMembers, member.identifier) || shouldIgnore(member.jsDocTags, tags)));
+                                for (const member of principal.findUnusedMembers(filePath, members)) {
                                     collector.addIssue({
                                         type: 'classMembers',
                                         filePath,
@@ -344,14 +346,14 @@ export const main = async (unresolvedConfiguration) => {
                                         line: member.line,
                                         col: member.col,
                                     });
-                                });
+                                }
                             }
                             continue;
                         }
                     }
                     const [hasStrictlyNsReferences, namespace] = getHasStrictlyNsReferences(importsForExport);
                     const isType = ['enum', 'type', 'interface'].includes(exportedItem.type);
-                    if (hasStrictlyNsReferences && ((!report.nsTypes && isType) || (!report.nsExports && !isType)))
+                    if (hasStrictlyNsReferences && ((!report.nsTypes && isType) || !(report.nsExports || isType)))
                         continue;
                     if (!isExportedItemReferenced(exportedItem)) {
                         if (!isSkipLibs && principal?.hasReferences(filePath, exportedItem))
@@ -382,14 +384,20 @@ export const main = async (unresolvedConfiguration) => {
     if (isReportDependencies) {
         const { dependencyIssues, devDependencyIssues, optionalPeerDependencyIssues } = deputy.settleDependencyIssues();
         const { configurationHints } = deputy.getConfigurationHints();
-        dependencyIssues.forEach(issue => collector.addIssue(issue));
+        for (const issue of dependencyIssues)
+            collector.addIssue(issue);
         if (!isProduction)
-            devDependencyIssues.forEach(issue => collector.addIssue(issue));
-        optionalPeerDependencyIssues.forEach(issue => collector.addIssue(issue));
-        configurationHints.forEach(hint => collector.addConfigurationHint(hint));
+            for (const issue of devDependencyIssues)
+                collector.addIssue(issue);
+        for (const issue of optionalPeerDependencyIssues)
+            collector.addIssue(issue);
+        for (const hint of configurationHints)
+            collector.addConfigurationHint(hint);
     }
     const unusedIgnoredWorkspaces = chief.getUnusedIgnoredWorkspaces();
-    unusedIgnoredWorkspaces.forEach(identifier => collector.addConfigurationHint({ type: 'ignoreWorkspaces', identifier }));
+    for (const identifier of unusedIgnoredWorkspaces) {
+        collector.addConfigurationHint({ type: 'ignoreWorkspaces', identifier });
+    }
     const { issues, counters, configurationHints } = collector.getIssues();
     if (isFix) {
         await fixer.fixIssues(issues);

package/dist/issues/initializers.d.ts

@@ -1,4 +1,4 @@
-import type { Issues, Counters, Rules } from '../types/issues.js';
+import type { Counters, Issues, Rules } from '../types/issues.js';
 export declare const initIssues: () => Issues;
 export declare const initCounters: () => Counters;
 export declare const defaultRules: Rules;

package/dist/manifest/helpers.js

@@ -21,7 +21,7 @@ export const getFilteredScripts = ({ isProduction, scripts }) => {
         return scripts;
     const scriptFilter = new Set(['start', 'postinstall']);
     const filteredScripts = {};
-    for (let scriptName in scripts) {
+    for (const scriptName in scripts) {
         if (scriptFilter.has(scriptName))
             filteredScripts[scriptName] = scripts[scriptName];
     }

package/dist/manifest/index.d.ts

@@ -1,4 +1,4 @@
-import type { InstalledBinaries, HostDependencies } from '../types/workspace.js';
+import type { HostDependencies, InstalledBinaries } from '../types/workspace.js';
 type Options = {
     packageNames: string[];
     dir: string;

package/dist/manifest/index.js

@@ -1,5 +1,5 @@
-import { isDefinitelyTyped } from '../util/modules.js';
 import { timerify } from '../util/Performance.js';
+import { isDefinitelyTyped } from '../util/modules.js';
 import { loadPackageManifest } from './helpers.js';
 const getMetaDataFromPackageJson = ({ cwd, dir, packageNames }) => {
     const hostDependencies = new Map();
@@ -10,7 +10,7 @@ const getMetaDataFromPackageJson = ({ cwd, dir, packageNames }) => {
         if (manifest) {
             const binaryName = packageName.replace(/^@[^/]+\//, '');
             const binaries = typeof manifest.bin === 'string' ? [binaryName] : Object.keys(manifest.bin ?? {});
-            binaries.forEach(binaryName => {
+            for (const binaryName of binaries) {
                 if (installedBinaries.has(binaryName)) {
                     installedBinaries.get(binaryName)?.add(packageName);
                 }
@@ -23,7 +23,7 @@ const getMetaDataFromPackageJson = ({ cwd, dir, packageNames }) => {
                 else {
                     installedBinaries.set(packageName, new Set([binaryName]));
                 }
-            });
+            }
             const packagePeerDependencies = Object.keys(manifest.peerDependencies ?? {});
             for (const packagePeerDependency of packagePeerDependencies) {
                 const hostDependency = {
@@ -31,7 +31,7 @@ const getMetaDataFromPackageJson = ({ cwd, dir, packageNames }) => {
                     isPeerOptional: manifest.peerDependenciesMeta?.[packagePeerDependency]?.optional ?? false,
                 };
                 if (hostDependencies.has(packagePeerDependency)) {
-                    hostDependencies.get(packagePeerDependency).push(hostDependency);
+                    hostDependencies.get(packagePeerDependency)?.push(hostDependency);
                 }
                 else {
                     hostDependencies.set(packagePeerDependency, [hostDependency]);

package/dist/plugins/ava/index.js

@@ -5,14 +5,14 @@ const enablers = ['ava'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['ava.config.{js,cjs,mjs}', 'package.json'];
 const entry = [
-    `test.{js,cjs,mjs,ts}`,
-    `{src,source}/test.{js,cjs,mjs,ts}`,
-    `**/__tests__/**/*.{js,cjs,mjs,ts}`,
-    `**/*.spec.{js,cjs,mjs,ts}`,
-    `**/*.test.{js,cjs,mjs,ts}`,
-    `**/test-*.{js,cjs,mjs,ts}`,
-    `**/test/**/*.{js,cjs,mjs,ts}`,
-    `**/tests/**/*.{js,cjs,mjs,ts}`,
+    'test.{js,cjs,mjs,ts}',
+    '{src,source}/test.{js,cjs,mjs,ts}',
+    '**/__tests__/**/*.{js,cjs,mjs,ts}',
+    '**/*.spec.{js,cjs,mjs,ts}',
+    '**/*.test.{js,cjs,mjs,ts}',
+    '**/test-*.{js,cjs,mjs,ts}',
+    '**/test/**/*.{js,cjs,mjs,ts}',
+    '**/tests/**/*.{js,cjs,mjs,ts}',
     '!**/__tests__/**/__{helper,fixture}?(s)__/**/*',
     '!**/test?(s)/**/{helper,fixture}?(s)/**/*',
 ];

package/dist/plugins/babel/index.js

@@ -1,11 +1,11 @@
 import { compact } from '#p/util/array.js';
 import { hasDependency } from '#p/util/plugin.js';
-import { resolveName, api } from './helpers.js';
+import { api, resolveName } from './helpers.js';
 const title = 'Babel';
 const enablers = [/^@babel\//];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['babel.config.{json,js,cjs,mjs,cts}', '.babelrc.{json,js,cjs,mjs,cts}', '.babelrc', 'package.json'];
-const getName = (value) => typeof value === 'string' ? [value] : Array.isArray(value) ? [value[0]] : [];
+const getName = (value) => [Array.isArray(value) ? value[0] : value].filter(name => typeof name === 'string');
 export const getDependenciesFromConfig = (config) => {
     const presets = config.presets?.flatMap(getName).map(name => resolveName(name, 'preset')) ?? [];
     const plugins = config.plugins?.flatMap(getName).map(name => resolveName(name, 'plugin')) ?? [];

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

@@ -1,4 +1,4 @@
-import { api } from './helpers.js';
+import type { api } from './helpers.js';
 type BabelConfigFn = (options: typeof api) => BabelConfigObj;
 export type BabelConfigObj = {
     plugins?: (string | [string, unknown])[];

package/dist/plugins/babel/types.js

@@ -1 +1 @@
-import { api } from './helpers.js';
+export {};

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

@@ -1,4 +1,4 @@
-import type { ResolveConfig, IsPluginEnabled } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
 type CommitLintConfig = {
     extends: string[];
     plugins: string[];

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

@@ -1,4 +1,4 @@
-import type { ResolveConfig, IsPluginEnabled } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
 import type { CSpellConfig } from './types.js';
 declare const _default: {
     title: string;

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

@@ -1,4 +1,4 @@
-import type { ResolveConfig, IsPluginEnabled } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
 import type { DrizzleConfig } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/eleventy/helpers.d.ts

@@ -1,6 +1,5 @@
 import type { EleventyConfig } from './types.js';
 export declare class DummyEleventyConfig {
-    constructor();
     _getUniqueId(): void;
     reset(): void;
     versionCheck(): void;

package/dist/plugins/eleventy/helpers.js

@@ -1,5 +1,4 @@
 export class DummyEleventyConfig {
-    constructor() { }
     _getUniqueId() { }
     reset() { }
     versionCheck() { }
@@ -35,7 +34,7 @@ export class DummyEleventyConfig {
             this.passthroughCopies[input] = {};
         }
         else {
-            for (let [inputPath] of Object.entries(input)) {
+            for (const [inputPath] of Object.entries(input)) {
                 this.passthroughCopies[inputPath] = {};
             }
         }

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

@@ -1,5 +1,5 @@
-import { DummyEleventyConfig } from './helpers.js';
 import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types/plugins.js';
+import { DummyEleventyConfig } from './helpers.js';
 import type { EleventyConfig } from './types.js';
 type T = Partial<EleventyConfig> | ((arg: DummyEleventyConfig) => Promise<Partial<EleventyConfig>>);
 declare const _default: {

package/dist/plugins/eslint/helpers.d.ts

@@ -1,5 +1,5 @@
-import type { ESLintConfig } from './types.js';
 import type { PluginOptions } from '../../types/plugins.js';
+import type { ESLintConfig } from './types.js';
 type GetDependenciesDeep = (localConfig: ESLintConfig, options: PluginOptions, dependencies?: Set<string>) => Promise<Set<string>>;
 export declare const getDependenciesDeep: GetDependenciesDeep;
 export {};

package/dist/plugins/eslint/helpers.js

@@ -1,6 +1,6 @@
 import { compact } from '#p/util/array.js';
 import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from '#p/util/modules.js';
-import { isInternal, toAbsolute, isAbsolute } from '#p/util/path.js';
+import { isAbsolute, isInternal, toAbsolute } from '#p/util/path.js';
 import { load } from '#p/util/plugin.js';
 import { _resolve } from '#p/util/require.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
@@ -19,7 +19,10 @@ const getDependencies = (config) => {
 };
 export const getDependenciesDeep = async (localConfig, options, dependencies = new Set()) => {
     const { configFileDir } = options;
-    const addAll = (deps) => deps.forEach(dependency => dependencies.add(dependency));
+    const addAll = (deps) => {
+        for (const dependency of deps)
+            dependencies.add(dependency);
+    };
     if (localConfig) {
         if (localConfig.extends) {
             for (const extend of [localConfig.extends].flat()) {

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

@@ -1,6 +1,5 @@
 import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
 import type { ESLintConfig } from './types.js';
-export declare const packageJsonPath = "eslintConfig";
 declare const _default: {
     title: string;
     enablers: string[];

package/dist/plugins/eslint/index.js

@@ -5,7 +5,7 @@ const enablers = ['eslint'];
 const isEnabled = ({ dependencies, manifest, config }) => hasDependency(dependencies, enablers) ||
     'eslint' in config ||
     Boolean(manifest.name && /(^eslint-config|\/eslint-config)/.test(manifest.name));
-export const packageJsonPath = 'eslintConfig';
+const packageJsonPath = 'eslintConfig';
 const entry = ['eslint.config.{js,cjs,mjs}'];
 const config = ['.eslintrc', '.eslintrc.{js,json,cjs}', '.eslintrc.{yml,yaml}', 'package.json'];
 const resolveConfig = async (localConfig, options) => {

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

@@ -12,7 +12,7 @@ const resolveConfig = async (config, options) => {
     const scripts = getValuesByKeyDeep(config, 'run').filter(isString);
     const getActionDependencies = () => {
         const isActionManifest = configFileName === 'action.yml' || configFileName === 'action.yaml';
-        if (!isActionManifest || !config?.runs?.using?.startsWith('node'))
+        if (!(isActionManifest && config?.runs?.using?.startsWith('node')))
             return [];
         const scripts = [config.runs.pre, config.runs.main, config.runs.post].filter(isString);
         return scripts.map(script => join(configFileDir, script));

package/dist/plugins/graphql-codegen/index.d.ts

@@ -1,4 +1,4 @@
-import type { ResolveConfig, IsPluginEnabled } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
 import type { GraphqlCodegenTypes } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/jest/index.js

@@ -1,4 +1,4 @@
-import { join, isInternal, toAbsolute, dirname } from '#p/util/path.js';
+import { dirname, isInternal, join, toAbsolute } from '#p/util/path.js';
 import { hasDependency, load } from '#p/util/plugin.js';
 import { toEntryPattern } from '#p/util/protocols.js';
 const title = 'Jest';
@@ -36,7 +36,8 @@ const resolveDependencies = async (config, options) => {
         }
         else {
             const dependencies = await resolveDependencies(project, options);
-            dependencies.forEach(dependency => projects.push(dependency));
+            for (const dependency of dependencies)
+                projects.push(dependency);
         }
     }
     const runner = config.runner ? [config.runner] : [];
@@ -84,7 +85,7 @@ const resolveEntryPaths = async (localConfig, options) => {
         localConfig = await localConfig();
     const rootDir = localConfig.rootDir ? join(configFileDir, localConfig.rootDir) : configFileDir;
     const replaceRootDir = (name) => (name.includes('<rootDir>') ? name.replace(/<rootDir>/, rootDir) : name);
-    const matchCwd = new RegExp('^' + toEntryPattern(cwd) + '/');
+    const matchCwd = new RegExp(`^${toEntryPattern(cwd)}/`);
     return (localConfig.testMatch ?? [])
         .map(replaceRootDir)
         .map(dependency => dependency.replace(matchCwd, toEntryPattern('')))
@@ -97,7 +98,7 @@ const resolveConfig = async (localConfig, options) => {
     const rootDir = localConfig.rootDir ? join(configFileDir, localConfig.rootDir) : configFileDir;
     const replaceRootDir = (name) => (name.includes('<rootDir>') ? name.replace(/<rootDir>/, rootDir) : name);
     const dependencies = await resolveDependencies(localConfig, options);
-    const matchCwd = new RegExp('^' + toEntryPattern(cwd) + '/');
+    const matchCwd = new RegExp(`^${toEntryPattern(cwd)}/`);
     return dependencies.map(replaceRootDir).map(dependency => dependency.replace(matchCwd, toEntryPattern('')));
 };
 export default {

package/dist/plugins/lint-staged/index.d.ts

@@ -1,4 +1,4 @@
-import type { ResolveConfig, IsPluginEnabled } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
 import type { LintStagedConfig } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/lint-staged/index.js

@@ -19,7 +19,8 @@ const resolveConfig = async (config, options) => {
     const dependencies = new Set();
     for (const entry of Object.values(config).flat()) {
         const scripts = [typeof entry === 'function' ? await entry([]) : entry].flat();
-        getDependenciesFromScripts(scripts, options).forEach(identifier => dependencies.add(identifier));
+        for (const id of getDependenciesFromScripts(scripts, options))
+            dependencies.add(id);
     }
     return Array.from(dependencies);
 };