knip 6.23.0 → 6.25.0

package/LICENSE

@@ -1,6 +1,6 @@
 ISC License (ISC)
 
-Copyright 2022-2025 Lars Kappert
+Copyright 2022-2026 Lars Kappert
 
 Permission to use, copy, modify, and/or distribute this software for any purpose
 with or without fee is hereby granted, provided that the above copyright notice

package/dist/ConfigurationChief.d.ts

@@ -207,6 +207,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        eve?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         execa?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -227,6 +232,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        fumadocs?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         gatsby?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -852,7 +862,7 @@ export declare class ConfigurationChief {
         ignoreMembers?: (string | RegExp)[] | undefined;
         ignoreUnresolved?: (string | RegExp)[] | undefined;
         ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
-        ignoreIssues?: Record<string, ("binaries" | "catalog" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
+        ignoreIssues?: Record<string, ("binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
         includeEntryExports?: boolean | undefined;
     };
     getIgnores(workspaceName: string): {
@@ -899,10 +909,12 @@ export declare class ConfigurationChief {
         drizzle?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         eleventy?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         eslint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        eve?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         execa?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         expo?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "expressive-code"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         fast?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        fumadocs?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         gatsby?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "github-action"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "github-actions"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/ConfigurationChief.js

@@ -34,6 +34,7 @@ const defaultConfig = {
     ignoreBinaries: [],
     ignoreDependencies: [],
     ignoreFiles: [],
+    cycles: {},
     ignoreIssues: {},
     ignoreMembers: [],
     ignoreUnresolved: [],
@@ -103,6 +104,7 @@ export class ConfigurationChief {
         const ignoreMembers = rawConfig.ignoreMembers ?? [];
         const ignoreUnresolved = rawConfig.ignoreUnresolved ?? [];
         const ignoreExportsUsedInFile = rawConfig.ignoreExportsUsedInFile ?? false;
+        const cycles = rawConfig.cycles ?? {};
         const ignoreIssues = rawConfig.ignoreIssues ?? {};
         const ignoreWorkspaces = rawConfig.ignoreWorkspaces ?? defaultConfig.ignoreWorkspaces;
         const isIncludeEntryExports = rawConfig.includeEntryExports ?? this.isIncludeEntryExports;
@@ -116,6 +118,7 @@ export class ConfigurationChief {
         return {
             ignore,
             ignoreFiles,
+            cycles,
             ignoreBinaries,
             ignoreDependencies,
             ignoreMembers,

package/dist/ProjectPrincipal.d.ts

@@ -4,6 +4,7 @@ import type { AsyncCompilers, SyncCompilers } from './compilers/types.ts';
 import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile, PluginVisitorContext, PluginVisitorObject } from './types/config.ts';
 import type { FileNode, ModuleGraph } from './types/module-graph.ts';
 import type { Paths } from './types/project.ts';
+import type { ResolveGlobPattern } from './typescript/resolve-module-names.ts';
 import { SourceFileManager } from './typescript/SourceFileManager.ts';
 import type { MainOptions } from './util/create-options.ts';
 import type { ToSourceFilePath, WorkspaceManifestHandler } from './util/to-source-path.ts';
@@ -27,6 +28,7 @@ export declare class ProjectPrincipal {
     private findWorkspaceManifestImports;
     fileManager: SourceFileManager;
     private resolveModule;
+    resolveGlobPattern: ResolveGlobPattern;
     resolvedFiles: Set<string>;
     deletedFiles: Set<string>;
     private onPathAdded;

package/dist/ProjectPrincipal.js

@@ -6,7 +6,7 @@ import { DEFAULT_EXTENSIONS } from './constants.js';
 import { _getImportsAndExports } from './typescript/get-imports-and-exports.js';
 import { createBunShellVisitor } from './typescript/visitors/script-visitors.js';
 import { buildVisitor } from './typescript/visitors/walk.js';
-import { createCustomModuleResolver } from './typescript/resolve-module-names.js';
+import { createCustomModuleResolver, createGlobAliasResolver } from './typescript/resolve-module-names.js';
 import { SourceFileManager } from './typescript/SourceFileManager.js';
 import { compact } from './util/array.js';
 import { timerify } from './util/Performance.js';
@@ -21,6 +21,7 @@ export class ProjectPrincipal {
         sourceText: '',
         addScript: () => { },
         addImport: () => { },
+        addImportGlob: () => { },
         markExportRegistered: () => { },
     };
     pluginVisitorObjects = [];
@@ -37,6 +38,7 @@ export class ProjectPrincipal {
     findWorkspaceManifestImports;
     fileManager;
     resolveModule = () => undefined;
+    resolveGlobPattern = pattern => [pattern];
     resolvedFiles = new Set();
     deletedFiles = new Set();
     onPathAdded;
@@ -90,6 +92,7 @@ export class ProjectPrincipal {
         const scopedPaths = this.paths.size > 0 ? Array.from(this.paths, ([scope, paths]) => ({ scope, paths })) : undefined;
         const scopedRootDirs = this.rootDirs.size > 0 ? Array.from(this.rootDirs, ([scope, rootDirs]) => ({ scope, rootDirs })) : undefined;
         this.resolveModule = createCustomModuleResolver({ scopedPaths, scopedRootDirs }, customCompilerExtensions, this.toSourceFilePath, this.findWorkspaceManifestImports, this.tsConfigFile);
+        this.resolveGlobPattern = createGlobAliasResolver(scopedPaths);
     }
     readFile(filePath) {
         return this.fileManager.readFile(filePath);
@@ -130,11 +133,9 @@ export class ProjectPrincipal {
     }
     async runAsyncCompilers() {
         const add = timerify(this.fileManager.compileAndAddSourceFile.bind(this.fileManager));
-        const extensions = Array.from(this.asyncCompilers.keys());
-        const files = Array.from(this.projectPaths).filter(filePath => extensions.includes(extname(filePath)));
-        for (const filePath of files) {
-            await add(filePath);
-        }
+        for (const filePath of this.projectPaths)
+            if (this.asyncCompilers.has(extname(filePath)))
+                await add(filePath);
     }
     walkAndAnalyze(analyzeFile) {
         this.resolvedFiles.clear();

package/dist/WorkspaceWorker.d.ts

@@ -17,6 +17,7 @@ type WorkspaceManagerOptions = {
     rootManifest: Manifest | undefined;
     handleInput: HandleInput;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
+    getManifest: (dir: string) => Manifest | undefined;
     readFile: (filePath: string) => string;
     negatedWorkspacePatterns: string[];
     ignoredWorkspacePatterns: string[];
@@ -38,6 +39,7 @@ export declare class WorkspaceWorker {
     dependencies: DependencySet;
     handleInput: HandleInput;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
+    getManifest: (dir: string) => Manifest | undefined;
     readFile: (filePath: string) => string;
     negatedWorkspacePatterns: string[];
     ignoredWorkspacePatterns: string[];
@@ -47,7 +49,7 @@ export declare class WorkspaceWorker {
     enabledPluginsInAncestors: string[];
     cache: CacheConsultant<CacheItem>;
     configFilesMap: Map<string, Map<PluginName, Set<string>>>;
-    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, readFile, configFilesMap, options, }: WorkspaceManagerOptions);
+    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getManifest, readFile, configFilesMap, options, }: WorkspaceManagerOptions);
     init(): Promise<void>;
     private determineEnabledPlugins;
     private getConfigForPlugin;

package/dist/WorkspaceWorker.js

@@ -32,6 +32,7 @@ export class WorkspaceWorker {
     dependencies;
     handleInput;
     findWorkspaceByFilePath;
+    getManifest;
     readFile;
     negatedWorkspacePatterns = [];
     ignoredWorkspacePatterns = [];
@@ -41,7 +42,7 @@ export class WorkspaceWorker {
     enabledPluginsInAncestors;
     cache;
     configFilesMap;
-    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, readFile, configFilesMap, options, }) {
+    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getManifest, readFile, configFilesMap, options, }) {
         this.name = name;
         this.dir = dir;
         this.config = config;
@@ -54,6 +55,7 @@ export class WorkspaceWorker {
         this.configFilesMap = configFilesMap;
         this.handleInput = handleInput;
         this.findWorkspaceByFilePath = findWorkspaceByFilePath;
+        this.getManifest = getManifest;
         this.readFile = readFile;
         this.options = options;
         this.cache = new CacheConsultant(`plugins-${name}`, options);
@@ -211,7 +213,8 @@ export class WorkspaceWorker {
         const isProduction = this.options.isProduction;
         const knownBinsOnly = false;
         const rootManifest = this.rootManifest;
-        const baseOptions = { manifest, rootManifest, cwd, rootCwd, containingFilePath, knownBinsOnly };
+        const getManifest = this.getManifest;
+        const baseOptions = { manifest, rootManifest, cwd, rootCwd, containingFilePath, knownBinsOnly, getManifest };
         const baseScriptOptions = { ...baseOptions, isProduction, enabledPlugins: this.enabledPlugins };
         const [productionScripts, developmentScripts] = getFilteredScripts(manifest.scripts ?? {});
         const inputsFromManifest = _getInputsFromScripts(Object.values(developmentScripts), baseOptions);

package/dist/binaries/bash-parser.js

@@ -5,6 +5,7 @@ import { toBinary, toDeferResolve } from '../util/input.js';
 import { extractBinary, isValidBinary } from '../util/modules.js';
 import { relative } from '../util/path.js';
 import { truncate } from '../util/string.js';
+import { walkCommands } from '../util/scripts.js';
 import { resolve as fallbackResolve } from './fallback.js';
 import KnownResolvers from './resolvers/index.js';
 import { resolve as resolverFromPlugins } from './plugins.js';
@@ -46,93 +47,64 @@ export const getDependenciesFromScript = (script, options) => {
     const processScript = (s) => {
         collectFunctionNames(s.commands);
         const pending = [];
-        const mainDeps = getDependenciesFromStatements(s.commands, pending);
+        const mainDeps = [];
+        for (const statement of s.commands) {
+            for (const command of walkCommands(statement.command))
+                mainDeps.push(...processCommand(command, pending));
+        }
         const expansionDeps = pending.flatMap(inner => processScript(inner));
         return [...mainDeps, ...expansionDeps];
     };
-    const getDependenciesFromStatements = (statements, pending) => statements.flatMap(stmt => getDependenciesFromNode(stmt.command, pending));
-    const getDependenciesFromNode = (node, pending) => {
-        switch (node.type) {
-            case 'Command': {
-                const text = node.name?.value;
-                const binary = text ? extractBinary(text) : text;
-                if (node.name)
-                    collectExpansionScripts(node.name, pending);
-                for (const prefix of node.prefix)
-                    if (prefix.value)
-                        collectExpansionScripts(prefix.value, pending);
-                for (const suffix of node.suffix)
-                    collectExpansionScripts(suffix, pending);
-                if (!binary || binary === '.' || binary === 'source' || binary === '[')
-                    return [];
-                if (binary.startsWith('-') || binary.startsWith('..'))
-                    return [];
-                if (definedFunctions.has(binary))
-                    return [];
-                const args = node.suffix.map(w => w.value);
-                if (['!', 'test'].includes(binary))
-                    return fromArgs(args);
-                const fromNodeOptions = node.prefix
-                    .filter(a => a.name === 'NODE_OPTIONS' && a.value)
-                    .map(a => a.value.value)
-                    .map(arg => parseNodeArgs(arg.split(' ')))
-                    .filter(args => args.require)
-                    .flatMap(arg => arg.require)
-                    .map(id => toDeferResolve(id));
-                if (binary in KnownResolvers) {
-                    const resolver = KnownResolvers[binary];
-                    return resolver(binary, args, { ...options, fromArgs });
-                }
-                if (pluginArgsMap.has(binary)) {
-                    return [...resolverFromPlugins(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
-                }
-                if (spawningBinaries.includes(binary)) {
-                    const rest = node.suffix
-                        .filter(w => w.text !== '--')
-                        .map(w => w.text)
-                        .join(' ');
-                    return [toBinary(binary), ...getDependenciesFromScript(rest, options)];
-                }
-                if (binary in Plugins) {
-                    const inputs = fallbackResolve(binary, args, { ...options, fromArgs });
-                    if (options.knownBinsOnly)
-                        for (const input of inputs)
-                            input.optional = true;
-                    return [...inputs, ...fromNodeOptions];
-                }
-                if (options.knownBinsOnly && !text?.startsWith('.'))
-                    return [];
-                return [...fallbackResolve(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
-            }
-            case 'AndOr':
-            case 'Pipeline':
-                return node.commands.flatMap(n => getDependenciesFromNode(n, pending));
-            case 'If':
-                return [
-                    ...getDependenciesFromStatements(node.clause.commands, pending),
-                    ...getDependenciesFromStatements(node.then.commands, pending),
-                    ...(node.else ? getDependenciesFromNode(node.else, pending) : []),
-                ];
-            case 'While':
-                return [
-                    ...getDependenciesFromStatements(node.clause.commands, pending),
-                    ...getDependenciesFromStatements(node.body.commands, pending),
-                ];
-            case 'For':
-            case 'Select':
-            case 'Subshell':
-            case 'BraceGroup':
-                return getDependenciesFromStatements(node.body.commands, pending);
-            case 'CompoundList':
-                return getDependenciesFromStatements(node.commands, pending);
-            case 'Function':
-            case 'Coproc':
-                return getDependenciesFromNode(node.body, pending);
-            case 'Statement':
-                return getDependenciesFromNode(node.command, pending);
-            default:
-                return [];
+    const processCommand = (node, pending) => {
+        const text = node.name?.value;
+        const binary = text ? extractBinary(text) : text;
+        if (node.name)
+            collectExpansionScripts(node.name, pending);
+        for (const prefix of node.prefix)
+            if (prefix.value)
+                collectExpansionScripts(prefix.value, pending);
+        for (const suffix of node.suffix)
+            collectExpansionScripts(suffix, pending);
+        if (!binary || binary === '.' || binary === 'source' || binary === '[')
+            return [];
+        if (binary.startsWith('-') || binary.startsWith('..'))
+            return [];
+        if (definedFunctions.has(binary))
+            return [];
+        const args = node.suffix.map(w => w.value);
+        if (['!', 'test'].includes(binary))
+            return fromArgs(args);
+        const fromNodeOptions = node.prefix
+            .filter(a => a.name === 'NODE_OPTIONS' && a.value)
+            .map(a => a.value.value)
+            .map(arg => parseNodeArgs(arg.split(' ')))
+            .filter(args => args.require)
+            .flatMap(arg => arg.require)
+            .map(id => toDeferResolve(id));
+        if (binary in KnownResolvers) {
+            const resolver = KnownResolvers[binary];
+            return resolver(binary, args, { ...options, fromArgs });
         }
+        if (pluginArgsMap.has(binary)) {
+            return [...resolverFromPlugins(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
+        }
+        if (spawningBinaries.includes(binary)) {
+            const rest = node.suffix
+                .filter(w => w.text !== '--')
+                .map(w => w.text)
+                .join(' ');
+            return [toBinary(binary), ...getDependenciesFromScript(rest, options)];
+        }
+        if (binary in Plugins) {
+            const inputs = fallbackResolve(binary, args, { ...options, fromArgs });
+            if (options.knownBinsOnly)
+                for (const input of inputs)
+                    input.optional = true;
+            return [...inputs, ...fromNodeOptions];
+        }
+        if (options.knownBinsOnly && !text?.startsWith('.'))
+            return [];
+        return [...fallbackResolve(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
     };
     try {
         const parsed = parse(script);

package/dist/binaries/index.js

@@ -1,3 +1,4 @@
+import { SCRIPT_INTERPOLATION } from '../constants.js';
 import { fromBinary, isBinary, isDependency } from '../util/input.js';
 import { timerify } from '../util/Performance.js';
 import { getDependenciesFromScript } from './bash-parser.js';
@@ -8,6 +9,8 @@ const getInputsFromScripts = (npmScripts, options) => {
     for (const input of results) {
         if (!input.specifier)
             continue;
+        if (input.specifier.includes(SCRIPT_INTERPOLATION))
+            continue;
         if (isDependency(input) && input.specifier.startsWith('http'))
             continue;
         if (isBinary(input) && !/^\b/.test(fromBinary(input)))

package/dist/binaries/resolvers/yarn.js

@@ -49,15 +49,16 @@ const resolveDlx = (args, options) => {
     return [...packages.map(id => toDependency(id)), ...command].map(id => isDependency(id) || isBinary(id) ? Object.assign(id, { optional: true }) : id);
 };
 export const resolve = (_binary, args, options) => {
-    const { manifest, fromArgs, cwd, rootCwd } = options;
+    const { manifest, fromArgs, cwd, rootCwd, getManifest } = options;
     const parsed = parseArgs(args, { boolean: ['top-level'], string: ['cwd'], '--': true });
     const dir = parsed['top-level'] ? rootCwd : parsed.cwd ? join(cwd, parsed.cwd) : undefined;
     const [command, binary] = parsed._;
     if (!command && !binary)
         return [];
+    const dirManifest = (dir && getManifest(dir)) || manifest;
     const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
     if (command === 'run') {
-        if (manifest.scriptNames.has(binary))
+        if (dirManifest.scriptNames.has(binary))
             return _childArgs;
         const bin = toBinary(binary, { optional: true });
         if (dir)
@@ -70,7 +71,7 @@ export const resolve = (_binary, args, options) => {
         const argsForDlx = args.filter(arg => arg !== 'dlx');
         return resolveDlx(argsForDlx, options);
     }
-    if ((!dir && manifest.scriptNames.has(command)) || commands.includes(command))
+    if (dirManifest.scriptNames.has(command) || commands.includes(command))
         return _childArgs;
     const opts = dir ? { cwd: dir } : {};
     return fromArgs(argsFrom(args, command === 'exec' ? binary : command), opts);

package/dist/compilers/compilers.d.ts

@@ -2,10 +2,12 @@ import type { CompilerSync } from './types.ts';
 export declare const fencedCodeBlockMatcher: RegExp;
 export declare const inlineCodeMatcher: RegExp;
 export declare const scriptExtractor: RegExp;
+export declare const styleExtractor: RegExp;
 export declare const blockCommentMatcher: RegExp;
 export declare const lineCommentMatcher: RegExp;
 export declare const importMatcher: RegExp;
 export declare const importsWithinScripts: CompilerSync;
 export declare const scriptBodies: CompilerSync;
+export declare const getStyleLang: (attrs: string) => string | undefined;
 export declare const frontmatterMatcher: RegExp;
 export declare const importsWithinFrontmatter: (text: string, keys?: string[]) => string;

package/dist/compilers/compilers.js

@@ -1,26 +1,37 @@
 export const fencedCodeBlockMatcher = /```[\s\S]*?```/g;
 export const inlineCodeMatcher = /`[^`]+`/g;
 export const scriptExtractor = /<script\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<\/script>/gi;
+export const styleExtractor = /<style\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<\/style>/gi;
+const langAttrMatcher = /\blang\s*=\s*["']([^"']+)["']/i;
 export const blockCommentMatcher = /\/\*[\s\S]*?\*\//g;
 export const lineCommentMatcher = /^[ \t]*\/\/.*$/gm;
 export const importMatcher = /import(?:\s*\(\s*['"][^'"]+['"][^)]*\)|(?!\s*\()[^'"]+['"][^'"]+['"])/g;
 export const importsWithinScripts = (text) => {
     const scripts = [];
-    for (const [, , scriptBody] of text.matchAll(scriptExtractor)) {
+    scriptExtractor.lastIndex = 0;
+    let scriptMatch;
+    while ((scriptMatch = scriptExtractor.exec(text))) {
+        const scriptBody = scriptMatch[2];
         const body = scriptBody.replace(blockCommentMatcher, '').replace(lineCommentMatcher, '');
-        for (const importMatch of body.matchAll(importMatcher))
-            scripts.push(importMatch);
+        let importMatch;
+        importMatcher.lastIndex = 0;
+        while ((importMatch = importMatcher.exec(body)))
+            scripts.push(importMatch[0]);
     }
     return scripts.join(';\n');
 };
 export const scriptBodies = (text) => {
     const scripts = [];
-    for (const [, , body] of text.matchAll(scriptExtractor)) {
+    scriptExtractor.lastIndex = 0;
+    let match;
+    while ((match = scriptExtractor.exec(text))) {
+        const body = match[2];
         if (body)
             scripts.push(body);
     }
     return scripts.join(';\n');
 };
+export const getStyleLang = (attrs) => attrs.match(langAttrMatcher)?.[1]?.toLowerCase();
 export const frontmatterMatcher = /^---\r?\n([\s\S]*?)\r?\n---/;
 export const importsWithinFrontmatter = (text, keys = []) => {
     const frontmatter = text.match(frontmatterMatcher)?.[1];

package/dist/compilers/index.d.ts

@@ -153,6 +153,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    eve?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     execa?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -173,6 +178,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    fumadocs?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     gatsby?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -789,7 +799,7 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         project?: string | string[] | undefined;
     } | undefined;
     $schema?: string | undefined;
-    rules?: Partial<Record<"binaries" | "catalog" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved", "error" | "off" | "warn">> | undefined;
+    rules?: Partial<Record<"binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved", "error" | "off" | "warn">> | undefined;
     entry?: string | string[] | undefined;
     project?: string | string[] | undefined;
     paths?: Record<string, string[]> | undefined;
@@ -800,15 +810,19 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     ignoreMembers?: (string | RegExp)[] | undefined;
     ignoreUnresolved?: (string | RegExp)[] | undefined;
     ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
-    ignoreIssues?: Record<string, ("binaries" | "catalog" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
+    ignoreIssues?: Record<string, ("binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
+    cycles?: {
+        allow?: string[][] | undefined;
+        dynamicImports?: boolean | undefined;
+    } | undefined;
     ignoreWorkspaces?: string[] | undefined;
     includeEntryExports?: boolean | undefined;
     compilers?: Record<string, true | CompilerAsync | CompilerSync> | undefined;
     tags?: string[] | undefined;
     treatConfigHintsAsErrors?: boolean | undefined;
     treatTagHintsAsErrors?: boolean | undefined;
-    include?: ("binaries" | "catalog" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[] | undefined;
-    exclude?: ("binaries" | "catalog" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[] | undefined;
+    include?: ("binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[] | undefined;
+    exclude?: ("binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[] | undefined;
     workspaces?: Record<string, {
         angular?: string | boolean | string[] | {
             config?: string | string[] | undefined;
@@ -960,6 +974,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        eve?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         execa?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -980,6 +999,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        fumadocs?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         gatsby?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1605,11 +1629,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         ignoreMembers?: (string | RegExp)[] | undefined;
         ignoreUnresolved?: (string | RegExp)[] | undefined;
         ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
-        ignoreIssues?: Record<string, ("binaries" | "catalog" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
+        ignoreIssues?: Record<string, ("binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
         includeEntryExports?: boolean | undefined;
     }> | undefined;
     syncCompilers: Record<string, true | CompilerSync>;
     asyncCompilers: Record<string, CompilerAsync>;
 };
-export declare const getIncludedCompilers: (syncCompilers: RawSyncCompilers, asyncCompilers: AsyncCompilers, dependencies: DependencySet) => Compilers;
+export declare const getIncludedCompilers: (syncCompilers: RawSyncCompilers, asyncCompilers: AsyncCompilers, dependencies: DependencySet, onReferencedDependency?: (packageName: string) => void) => Compilers;
 export declare const getCompilerExtensions: (compilers: [SyncCompilers, AsyncCompilers]) => string[];

package/dist/compilers/index.js

@@ -1,5 +1,7 @@
+import LESS from './less.js';
 import MDX from './mdx.js';
 import SCSS from './scss.js';
+import STYLUS from './stylus.js';
 const isAsyncCompiler = (fn) => (fn ? fn.constructor.name === 'AsyncFunction' : false);
 export const normalizeCompilerExtension = (ext) => ext.replace(/^\.*/, '.');
 export const partitionCompilers = (rawLocalConfig) => {
@@ -26,16 +28,29 @@ export const partitionCompilers = (rawLocalConfig) => {
     }
     return { ...rawLocalConfig, syncCompilers, asyncCompilers };
 };
-const compilers = new Map([
-    ['.mdx', MDX],
-    ['.sass', SCSS],
-    ['.scss', SCSS],
-]);
-export const getIncludedCompilers = (syncCompilers, asyncCompilers, dependencies) => {
-    const hasDependency = (packageName) => dependencies.has(packageName);
-    for (const [extension, { condition, compiler }] of compilers) {
-        if ((!syncCompilers.has(extension) && condition(hasDependency)) || syncCompilers.get(extension) === true) {
-            syncCompilers.set(extension, compiler);
+const compilers = [
+    { extensions: ['.mdx'], ...MDX },
+    { extensions: ['.sass', '.scss'], ...SCSS },
+    { extensions: ['.less'], ...LESS },
+    { extensions: ['.styl', '.stylus'], ...STYLUS },
+];
+export const getIncludedCompilers = (syncCompilers, asyncCompilers, dependencies, onReferencedDependency) => {
+    for (const { extensions, dependencies: compilerDependencies, compiler } of compilers) {
+        let hasCompilerDependency = false;
+        for (const dependency of compilerDependencies) {
+            if (dependencies.has(dependency)) {
+                hasCompilerDependency = true;
+                if (onReferencedDependency)
+                    onReferencedDependency(dependency);
+                else
+                    break;
+            }
+        }
+        for (const extension of extensions) {
+            const existingCompiler = syncCompilers.get(extension);
+            if (existingCompiler === true || (existingCompiler === undefined && hasCompilerDependency)) {
+                syncCompilers.set(extension, compiler);
+            }
         }
     }
     return [syncCompilers, asyncCompilers];

package/dist/compilers/less.d.ts

@@ -0,0 +1,7 @@
+import type { CompilerSync } from './types.ts';
+export declare const compiler: CompilerSync;
+declare const _default: {
+    dependencies: string[];
+    compiler: CompilerSync;
+};
+export default _default;