knip 6.38.0 → 6.40.0

package/dist/ConfigurationChief.d.ts

@@ -292,6 +292,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        jasmine?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         jest?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -497,6 +502,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        osls?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         oxfmt?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -592,6 +602,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        railway?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         raycast?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1072,6 +1087,7 @@ export declare class ConfigurationChief {
         hardhat?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         husky?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "i18next-parser"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        jasmine?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         jest?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         karma?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         knex?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1113,6 +1129,7 @@ export declare class ConfigurationChief {
         "openapi-ts"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         openclaw?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         orval?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        osls?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         oxfmt?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         oxlint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "panda-css"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1132,6 +1149,7 @@ export declare class ConfigurationChief {
         prisma?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         quasar?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         qwik?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        railway?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         raycast?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "react-cosmos"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "react-email"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/WorkspaceWorker.d.ts

@@ -49,7 +49,7 @@ export declare class WorkspaceWorker {
     enabledPluginsMap: Partial<Record<PluginName, boolean>>;
     enabledPlugins: PluginName[];
     enabledPluginsInAncestors: string[];
-    cache: CacheConsultant<CacheItem>;
+    cache: CacheConsultant<Partial<Record<PluginName, CacheItem>>>;
     configFilesMap: Map<string, Map<PluginName, Set<string>>>;
     constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, handleConfigLoadError, findWorkspaceByFilePath, getManifest, readRawFile, configFilesMap, options, }: WorkspaceManagerOptions);
     init(): Promise<void>;
@@ -61,14 +61,13 @@ export declare class WorkspaceWorker {
     private getPluginConfig;
     getPluginConfigPatterns(): string[];
     getPluginEntryFilePatterns(patterns: string[]): string[];
-    getProductionEntryFilePatterns(negatedTestFilePatterns: string[]): string[];
-    getProductionProjectFilePatterns(negatedTestFilePatterns: string[]): string[];
+    getProductionEntryFilePatterns(): string[];
+    getProductionProjectFilePatterns(): string[];
     private getConfigurationFilePatterns;
     registerCompilers(registerCompiler: RegisterCompiler): Promise<void>;
     resolveSourceMaps(): Promise<SourceMap[]>;
     registerVisitors(options: RegisterVisitorsOptions): void;
     runPlugins(): Promise<Input[]>;
-    private filterTransitiveDependencies;
     getConfigurationHints(type: 'entry' | 'project', patterns: string[], filePaths: string[], includedPaths: Set<string>, compilerExtensions?: Set<string>): ConfigurationHint[];
     onDispose(): void;
 }

package/dist/WorkspaceWorker.js

@@ -6,15 +6,15 @@ import { DEFAULT_EXTENSIONS, ROOT_WORKSPACE_NAME } from './constants.js';
 import { getFilteredScripts } from './manifest/helpers.js';
 import { PluginEntries, Plugins } from './plugins.js';
 import { createManifest } from './util/package-json.js';
-import { collectStringLiterals, isExternalReExportsOnly } from './typescript/ast-helpers.js';
+import { isExternalReExportsOnly } from './typescript/ast-helpers.js';
 import { _parseFile } from './typescript/ast-nodes.js';
 import { compact } from './util/array.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate } from './util/glob.js';
-import { isCatalog, isConfig, isDeferResolve, isDependency, toConfig, toDebugString, toEntry, toProductionEntry, } from './util/input.js';
-import { getPackageNameFromSpecifier } from './util/modules.js';
+import { isCatalog, isConfig, toConfig, toDebugString, toEntry, toProductionEntry, } from './util/input.js';
+import { filterTransitiveDependencies } from './util/filter-transitive-dependencies.js';
 import { timerify } from './util/Performance.js';
-import { basename, dirname, isInternal, join, toRelative } from './util/path.js';
+import { basename, dirname, join, toRelative } from './util/path.js';
 import { extractPatternExtensions } from './util/pattern-extensions.js';
 import { formatCauseMessage } from './util/errors.js';
 import { logError } from './util/log.js';
@@ -132,17 +132,17 @@ export class WorkspaceWorker {
         const negateWorkspaces = patterns.some(pattern => pattern.startsWith('**/')) ? this.negatedWorkspacePatterns : [];
         return [patterns, negateWorkspaces, this.ignoredWorkspacePatterns.map(negate)].flat();
     }
-    getProductionEntryFilePatterns(negatedTestFilePatterns) {
+    getProductionEntryFilePatterns() {
         const entry = this.config.entry.filter(hasProductionSuffix);
         if (entry.length === 0)
             return [];
         const negatedEntryFiles = this.config.entry.filter(hasNoProductionSuffix).map(negate);
-        return [entry, negatedEntryFiles, negatedTestFilePatterns, this.negatedWorkspacePatterns].flat();
+        return [entry, negatedEntryFiles, this.negatedWorkspacePatterns].flat();
     }
-    getProductionProjectFilePatterns(negatedTestFilePatterns) {
+    getProductionProjectFilePatterns() {
         const project = this.config.project;
         if (project.length === 0)
-            return this.getProductionEntryFilePatterns(negatedTestFilePatterns);
+            return this.getProductionEntryFilePatterns();
         const _project = this.config.project.map(pattern => {
             if (!(pattern.endsWith('!') || pattern.startsWith('!')))
                 return negate(pattern);
@@ -156,7 +156,6 @@ export class WorkspaceWorker {
             negatedEntryFiles,
             negatedPluginConfigPatterns,
             negatedPluginProjectFilePatterns,
-            negatedTestFilePatterns,
             this.negatedWorkspacePatterns,
         ].flat();
     }
@@ -326,8 +325,8 @@ export class WorkspaceWorker {
                 seenConfigFiles.add(configFilePath);
                 const isManifest = basename(configFilePath) === 'package.json';
                 const fd = isManifest ? undefined : this.cache.getFileDescriptor(configFilePath);
-                if (fd?.meta?.data && !fd.changed) {
-                    const data = fd.meta.data;
+                const data = fd?.changed ? undefined : fd?.meta?.data?.[pluginName];
+                if (data) {
                     if (data.resolveConfig)
                         for (const id of data.resolveConfig)
                             addInput(id, configFilePath);
@@ -370,7 +369,7 @@ export class WorkspaceWorker {
                                 if (localConfig) {
                                     const inputs = await plugin.resolveConfig(localConfig, resolveOpts);
                                     if (plugin.isFilterTransitiveDependencies && !isManifest) {
-                                        this.filterTransitiveDependencies(inputs, configFilePath);
+                                        filterTransitiveDependencies(inputs, configFilePath, this.readRawFile);
                                     }
                                     for (const input of inputs)
                                         addInput(input, configFilePath);
@@ -405,7 +404,7 @@ export class WorkspaceWorker {
                         this.cache.removeEntry(configFilePath);
                     }
                     else if (fd?.meta) {
-                        fd.meta.data = cache;
+                        fd.meta.data = { ...fd.meta.data, [pluginName]: cache };
                     }
                 }
             }
@@ -458,31 +457,6 @@ export class WorkspaceWorker {
         debugLogArray(wsName, 'Plugin dependencies', () => compact(inputs.map(input => toDebugString(input, rootCwd))));
         return inputs;
     }
-    filterTransitiveDependencies(inputs, configFilePath) {
-        const literals = new Set();
-        const visited = new Set();
-        const collect = (filePath) => {
-            if (visited.has(filePath))
-                return;
-            visited.add(filePath);
-            const sourceText = this.readRawFile(filePath);
-            if (!sourceText)
-                return;
-            for (const literal of collectStringLiterals(sourceText, filePath)) {
-                literals.add(literal);
-                if (isInternal(literal))
-                    collect(join(dirname(filePath), literal));
-            }
-        };
-        collect(configFilePath);
-        for (const input of inputs) {
-            if (!input.optional && (isDeferResolve(input) || isDependency(input))) {
-                const name = getPackageNameFromSpecifier(input.specifier);
-                if (name && !literals.has(name))
-                    input.optional = true;
-            }
-        }
-    }
     getConfigurationHints(type, patterns, filePaths, includedPaths, compilerExtensions) {
         const hints = [];
         const entries = this.config[type].filter(pattern => !pattern.startsWith('!'));

package/dist/compilers/compilers.js

@@ -1,6 +1,6 @@
 export const fencedCodeBlockMatcher = /```[\s\S]*?```/g;
 export const inlineCodeMatcher = /`[^`]+`/g;
-export const scriptExtractor = /<script\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<\/script>/gi;
+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;

package/dist/constants.js

@@ -115,6 +115,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'python',
     'python3',
     'raft',
+    'railway',
     'rm',
     'rmdir',
     'rsync',

package/dist/graph/analyze.js

@@ -6,7 +6,7 @@ import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { relative } from '../util/path.js';
 import { perfObserver, timerify } from '../util/Performance.js';
 import { findMatch } from '../util/regex.js';
-import { getShouldIgnoreHandler, getShouldIgnoreTagHandler, isAlwaysIgnored } from '../util/tag.js';
+import { getShouldIgnoreHandler, getShouldIgnoreTagHandler, hasTag, isAlwaysIgnored } from '../util/tag.js';
 import { INTERNAL_TAG } from '../constants.js';
 const toCyclePathKey = (path) => {
     const length = path.length > 1 && path[0] === path[path.length - 1] ? path.length - 1 : path.length;
@@ -123,7 +123,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                         const isInternalProd = options.isProduction && exportedItem.jsDocTags.has(INTERNAL_TAG);
                         const isIgnored = shouldIgnoreTags(exportedItem.jsDocTags) || isInternalProd;
                         if (importsForExport) {
-                            const [isReferenced, reExportingEntryFile] = explorer.isReferenced(filePath, identifier, {
+                            const [isReferenced, reExportingEntryFile, reExportedIds] = explorer.isReferenced(filePath, identifier, {
                                 traverseEntries: isIncludeEntryExports,
                             });
                             if (isIgnored) {
@@ -148,9 +148,18 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 if (!isIncludeEntryExports) {
                                     continue;
                                 }
-                                if (!isReferenced) {
-                                    const reExportedItem = graph.get(reExportingEntryFile)?.exports.get(identifier);
-                                    if (reExportedItem && shouldIgnore(reExportedItem.jsDocTags))
+                                if (!isReferenced && reExportedIds) {
+                                    const entryExports = graph.get(reExportingEntryFile)?.exports;
+                                    let isTagged = false;
+                                    for (const id of reExportedIds) {
+                                        const reExportedItem = entryExports?.get(id);
+                                        if (reExportedItem &&
+                                            (shouldIgnore(reExportedItem.jsDocTags) || hasTag(options.tags[1], reExportedItem.jsDocTags))) {
+                                            isTagged = true;
+                                            break;
+                                        }
+                                    }
+                                    if (isTagged)
                                         continue;
                                 }
                             }

package/dist/graph/build.js

@@ -9,7 +9,7 @@ import { existsSync } from 'node:fs';
 import picomatch from 'picomatch';
 import { tryRealpath } from '../util/fs.js';
 import { createManifest } from '../util/package-json.js';
-import { _glob, _syncGlob, negate, prependDirToPattern as prependDir } from '../util/glob.js';
+import { _glob, _syncGlob, prependDirToPattern as prependDir, removeProductionSuffix } from '../util/glob.js';
 import { isAlias, isCatalog, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isIgnore, isProductionEntry, isProject, toDeferResolveEntry, toDependency, toProductionEntry, } from '../util/input.js';
 import { isAmbientDeclarationFile } from '../typescript/ast-nodes.js';
 import { resolveImportGlobs } from '../typescript/glob-imports.js';
@@ -19,6 +19,7 @@ import { createFileNode, updateImportMap } from '../util/module-graph.js';
 import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
 import { perfObserver } from '../util/Performance.js';
 import { getEntrySpecifiersFromManifest, getManifestImportDependencies } from '../util/package-json.js';
+import { expandIgnorePatterns } from '../util/parse-and-convert-gitignores.js';
 import { dirname, extname, isAbsolute, isInNodeModules, isInternal, join, relative } from '../util/path.js';
 import { extensionAlias } from '../util/resolve.js';
 import { augmentWorkspace, getToSourcePathsHandler, toSourceMappedSpecifiers } from '../util/to-source-path.js';
@@ -246,16 +247,22 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 }
             }
         }
-        const negatedEntryPatterns = [];
+        const developmentMatchers = [];
         if (options.isProduction) {
+            const toPattern = (pattern) => join(isAbsolute(pattern) ? '' : dir, removeProductionSuffix(pattern));
             for (const map of [entryPatterns, entryPatternsSkipExports]) {
-                for (const patterns of map.values())
-                    for (const pattern of patterns)
-                        negatedEntryPatterns.push(negate(pattern));
+                for (const patterns of map.values()) {
+                    const [excluded, included] = partition(patterns, pattern => pattern.startsWith('!'));
+                    if (included.length === 0)
+                        continue;
+                    const ignore = expandIgnorePatterns(excluded.map(pattern => removeProductionSuffix(pattern.slice(1))));
+                    developmentMatchers.push(picomatch(included.map(toPattern), { ignore: ignore.map(toPattern), dot: true }));
+                }
             }
         }
+        const productionPaths = (paths) => developmentMatchers.length ? paths.filter(path => !developmentMatchers.some(match => match(path))) : paths;
         const userEntryPatterns = options.isProduction
-            ? worker.getProductionEntryFilePatterns(negatedEntryPatterns)
+            ? worker.getProductionEntryFilePatterns()
             : worker.getEntryFilePatterns();
         const userEntryPaths = await _glob({
             ...sharedGlobOptions,
@@ -272,7 +279,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 ]);
                 const label = `entry paths from plugins${group !== DEFAULT_GROUP ? ` - ${group}` : ''}`;
                 const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
-                principal.addEntryPaths(pluginWorkspaceEntryPaths);
+                principal.addEntryPaths(productionPaths(pluginWorkspaceEntryPaths));
             }
             {
                 const patterns = worker.getPluginEntryFilePatterns([
@@ -293,7 +300,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 collector.addConfigurationHint(hint);
         }
         const hasExplicitEntries = config.entry.some(pattern => !isDefaultPattern('entry', pattern));
-        principal.addEntryPaths(userEntryPaths, hasExplicitEntries ? { skipExportsAnalysis: false } : undefined);
+        principal.addEntryPaths(productionPaths(userEntryPaths), hasExplicitEntries ? { skipExportsAnalysis: false } : undefined);
         if (options.isUseTscFiles && isFile) {
             const isIgnoredWorkspace = chief.createIgnoredWorkspaceMatcher(name, dir);
             debugLogArray(name, 'Using tsconfig files as project files', tscSourcePaths);
@@ -320,7 +327,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         }
         else {
             const patterns = options.isProduction
-                ? worker.getProductionProjectFilePatterns(negatedEntryPatterns)
+                ? worker.getProductionProjectFilePatterns()
                 : worker.getProjectFilePatterns([
                     ...(productionPatternsSkipExports.get(DEFAULT_GROUP) ?? []),
                     ...projectFilePatterns,
@@ -332,7 +339,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 for (const hint of hints)
                     collector.addConfigurationHint(hint);
             }
-            for (const projectPath of projectPaths)
+            for (const projectPath of productionPaths(projectPaths))
                 principal.addProjectPath(projectPath);
         }
         worker.onDispose();

package/dist/graph-explorer/explorer.d.ts

@@ -3,7 +3,7 @@ export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<s
     isReferenced: (filePath: string, identifier: string, options: {
         traverseEntries: boolean;
         treatStarAtEntryAsReferenced?: boolean;
-    }) => readonly [false, string | undefined];
+    }) => readonly [false, string | undefined, Set<string> | undefined];
     hasStrictlyNsReferences: (filePath: string, identifier: string) => [boolean, (string | undefined)?];
     isEnumerated: (filePath: string, identifier: string) => boolean;
     buildExportsTree: (options: {

package/dist/graph-explorer/operations/is-referenced.d.ts

@@ -2,4 +2,4 @@ import type { Identifier, ModuleGraph } from '../../types/module-graph.ts';
 export declare const isReferenced: (graph: ModuleGraph, entryPaths: Set<string>, filePath: string, id: Identifier, options: {
     traverseEntries: boolean;
     treatStarAtEntryAsReferenced?: boolean;
-}) => readonly [false, string | undefined];
+}) => readonly [false, string | undefined, Set<string> | undefined];

package/dist/graph-explorer/operations/is-referenced.js

@@ -17,18 +17,22 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
     const seen = new Set();
     let isReferenced = false;
     let reExportingEntryFile;
+    let reExportedIds;
     const hasCompleteResult = () => isReferenced && (options.traverseEntries || reExportingEntryFile !== undefined);
     const walkDown = (path, id, viaStar = false) => {
         const isEntryFile = entryPaths.has(path);
         if (isEntryFile && !reExportingEntryFile)
             reExportingEntryFile = path;
+        if (path === reExportingEntryFile)
+            (reExportedIds ??= new Set()).add(id);
         if (hasCompleteResult())
             return true;
-        if (seen.has(path))
-            return false;
-        seen.add(path);
         const restIds = id.split('.');
         const identifier = restIds.shift();
+        const key = `${path}:${identifier}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
         if (options.treatStarAtEntryAsReferenced && isEntryFile && viaStar && restIds.length > 0) {
             isReferenced = true;
             return hasCompleteResult();
@@ -117,5 +121,5 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
         return false;
     };
     walkDown(filePath, id);
-    return [isReferenced, reExportingEntryFile];
+    return [isReferenced, reExportingEntryFile, reExportedIds];
 };

package/dist/plugins/_vue/auto-import.js

@@ -3,10 +3,12 @@ import { createRequire } from 'node:module';
 import { Visitor } from 'oxc-parser';
 import { scriptBodies } from '../../compilers/compilers.js';
 import { stylePreprocessorImports } from '../../compilers/style-preprocessors.js';
+import { DEFAULT_EXTENSIONS } from '../../constants.js';
 import { _parseFile } from '../../typescript/ast-nodes.js';
 import { isFile } from '../../util/fs.js';
 import { _syncGlob } from '../../util/glob.js';
 import { dirname, isInNodeModules, join } from '../../util/path.js';
+import { _createSyncModuleResolver } from '../../util/resolve.js';
 const getVueSfc = (cwd) => {
     try {
         const sfc = createRequire(join(cwd, 'package.json'))('vue/compiler-sfc');
@@ -124,6 +126,7 @@ const collectVue2TemplateIdentifiers = (source) => {
 };
 const toKebabCase = (s) => s.replace(/[A-Z]/g, (m, i) => (i ? '-' : '') + m.toLowerCase());
 const isLocalSpecifier = (specifier) => specifier.startsWith('.') && !isInNodeModules(specifier);
+const resolveModule = _createSyncModuleResolver([...DEFAULT_EXTENSIONS, '.vue']);
 export const collectLocalImportPaths = (filePath, result) => {
     const dir = dirname(filePath);
     const paths = new Set();
@@ -150,7 +153,7 @@ export function buildAutoImportMap(filePath, result, maps, isComponents) {
         const importType = importTypes.find(it => it.start >= start && it.end <= end);
         if (!importType || !isLocalSpecifier(importType.specifier))
             return;
-        const absSpecifier = join(dir, importType.specifier);
+        const absSpecifier = resolveModule(importType.specifier, filePath) ?? join(dir, importType.specifier);
         if (isComponents) {
             const components = maps.componentMap.get(name);
             if (components) {
@@ -184,7 +187,7 @@ export function buildAutoImportMap(filePath, result, maps, isComponents) {
             const specifier = node.source.value;
             if (!isLocalSpecifier(specifier))
                 return;
-            const absSpecifier = join(dir, specifier);
+            const absSpecifier = resolveModule(specifier, filePath) ?? join(dir, specifier);
             for (const s of node.specifiers) {
                 const name = s.exported.type === 'Identifier' ? s.exported.name : s.exported.value;
                 if (name)
@@ -210,14 +213,15 @@ const getVueAutoImportMaps = (cwd) => {
     }
     return maps;
 };
-const getSyntheticImports = (maps, identifiers, templateTags) => {
+const getSyntheticImports = (maps, identifiers, filePath, templateTags) => {
     const { importMap, componentMap } = maps;
     if (importMap.size === 0 && (!templateTags || componentMap.size === 0))
         return [];
     const syntheticImports = [];
     for (const [name, specifier] of importMap) {
-        if (identifiers.has(name))
+        if (identifiers.has(name) && specifier !== filePath) {
             syntheticImports.push(`import { ${name} } from '${specifier}';`);
+        }
     }
     if (templateTags) {
         for (const [name, specifiers] of componentMap) {
@@ -226,9 +230,12 @@ const getSyntheticImports = (maps, identifiers, templateTags) => {
                 templateTags.has(kebab) ||
                 templateTags.has(`Lazy${name}`) ||
                 templateTags.has(`lazy-${kebab}`)) {
-                syntheticImports.push(`import { default as ${name} } from '${specifiers[0]}';`);
-                for (let i = 1; i < specifiers.length; i++)
-                    syntheticImports.push(`import '${specifiers[i]}';`);
+                const targets = specifiers.filter(specifier => specifier !== filePath);
+                if (targets.length === 0)
+                    continue;
+                syntheticImports.push(`import { default as ${name} } from '${targets[0]}';`);
+                for (let i = 1; i < targets.length; i++)
+                    syntheticImports.push(`import '${targets[i]}';`);
             }
         }
     }
@@ -275,7 +282,7 @@ const compileVueSfc = (source, path, maps, root) => {
         for (const id of collectVue2TemplateIdentifiers(compiled.code))
             identifiers.add(id);
     }
-    scripts.push(...getSyntheticImports(maps, identifiers, templateTags));
+    scripts.push(...getSyntheticImports(maps, identifiers, path, templateTags));
     scripts.push(...getImportedComponentImports(maps, importedComponents));
     const styles = stylePreprocessorImports(source, path);
     if (styles)
@@ -288,7 +295,7 @@ const compileTs = (source, path, maps) => {
         path.endsWith('.config.ts'))
         return source;
     const importedComponents = new Set();
-    const syntheticImports = getSyntheticImports(maps, collectIdentifiers(source, path, importedComponents));
+    const syntheticImports = getSyntheticImports(maps, collectIdentifiers(source, path, importedComponents), path);
     syntheticImports.push(...getImportedComponentImports(maps, importedComponents));
     return syntheticImports.length === 0 ? source : `${source}\n${syntheticImports.join('\n')}`;
 };
@@ -305,7 +312,7 @@ const compileMarkdown = (source, path, maps) => {
     for (const [, tag] of code.matchAll(tagMatcher))
         tags.add(tag);
     const identifiers = scripts ? collectIdentifiers(scripts, path) : new Set();
-    return [scripts, ...getSyntheticImports(maps, identifiers, tags)].filter(Boolean).join(';\n');
+    return [scripts, ...getSyntheticImports(maps, identifiers, path, tags)].filter(Boolean).join(';\n');
 };
 export const createVueCompiler = (maps, cwd) => (source, path) => compileVueSfc(source, path, maps, cwd);
 export const createTsCompiler = (maps) => (source, path) => compileTs(source, path, maps);

package/dist/plugins/angular/index.js

@@ -13,7 +13,7 @@ const resolveConfig = async (config, options) => {
     const inputs = new Set();
     for (const project of Object.values(config.projects)) {
         if (!project.architect)
-            return [];
+            continue;
         for (const [targetName, target] of Object.entries(project.architect)) {
             const { options: opts, configurations: configs } = target;
             const [packageName] = typeof target.builder === 'string' ? target.builder.split(':') : [];

package/dist/plugins/capacitor/index.js

@@ -4,7 +4,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Capacitor';
 const enablers = [/^@capacitor\//];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['capacitor.config.{json,ts}'];
+const config = ['capacitor.config.{json,js,ts}'];
 const resolveConfig = async (config, { configFileDir }) => {
     const plugins = config.includePlugins ?? [];
     const android = isFile(configFileDir, 'android/capacitor.settings.gradle') ? ['@capacitor/android'] : [];

package/dist/plugins/commitlint/index.js

@@ -1,4 +1,5 @@
-import { toDependency } from '../../util/input.js';
+import { toConfig, toDependency } from '../../util/input.js';
+import { isInternal } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { toCosmiconfig } from '../../util/plugin-config.js';
 const title = 'commitlint';
@@ -9,13 +10,35 @@ const config = [
     'package.yaml',
     ...toCosmiconfig('commitlint', { additionalExtensions: ['cts', 'mts'] }),
 ];
-const resolveConfig = async (config) => {
-    const extendsConfigs = config.extends
-        ? [config.extends]
-            .flat()
-            .map(id => (id.startsWith('@') || id.startsWith('commitlint-config-') ? id : `commitlint-config-${id}`))
-        : [];
-    const plugins = config.plugins ? [config.plugins].flat().filter(s => typeof s === 'string') : [];
+const toExtendsSpecifier = (id) => {
+    if (id.startsWith('@'))
+        return id.includes('/') ? id : `${id}/commitlint-config`;
+    return id.startsWith('commitlint-config-') ? id : `commitlint-config-${id}`;
+};
+const toPluginSpecifier = (id) => {
+    if (!id.startsWith('@'))
+        return id.startsWith('commitlint-plugin-') ? id : `commitlint-plugin-${id}`;
+    const [scope, name] = id.split('/');
+    if (!name)
+        return `${scope}/commitlint-plugin`;
+    if (name === 'commitlint-plugin' || name.startsWith('commitlint-plugin-'))
+        return id;
+    return id.replace('/', '/commitlint-plugin-');
+};
+const resolveConfig = async (config, options) => {
+    const inputs = [];
+    const extendsConfigs = [];
+    for (const id of config.extends ? [config.extends].flat() : []) {
+        if (isInternal(id))
+            inputs.push(toConfig('commitlint', id, { containingFilePath: options.configFilePath }));
+        else
+            extendsConfigs.push(toExtendsSpecifier(id));
+    }
+    const plugins = [];
+    for (const id of config.plugins ? [config.plugins].flat() : []) {
+        if (typeof id === 'string')
+            plugins.push(toPluginSpecifier(id));
+    }
     const formatter = config.formatter ? [config.formatter] : [];
     const parserPreset = await config.parserPreset;
     const parserPresetPaths = parserPreset
@@ -25,7 +48,9 @@ const resolveConfig = async (config) => {
                 ? [parserPreset.path ?? parserPreset]
                 : []
         : [];
-    return [...extendsConfigs, ...plugins, ...formatter, ...parserPresetPaths].map(id => toDependency(id));
+    for (const id of [...extendsConfigs, ...plugins, ...formatter, ...parserPresetPaths])
+        inputs.push(toDependency(id));
+    return inputs;
 };
 const plugin = {
     title,

package/dist/plugins/cucumber/index.js

@@ -5,11 +5,43 @@ const enablers = ['@cucumber/cucumber'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['cucumber.{json,yaml,yml,js,cjs,mjs}'];
 const entry = ['features/**/*.@(js|cjs|mjs)'];
-const resolveConfig = config => {
+const builtinFormatters = new Set([
+    'html',
+    'json',
+    'junit',
+    'message',
+    'pretty',
+    'progress',
+    'progress-bar',
+    'rerun',
+    'snippets',
+    'summary',
+    'usage',
+    'usage-json',
+]);
+const toFormatterName = (format) => {
+    if (Array.isArray(format))
+        return format[0];
+    const [name, quotedName] = format.match(/^"([^"]*)"|^[^:]*/) ?? [format];
+    return quotedName ?? name;
+};
+const resolveProfile = (config) => {
     const imports = (config?.import ? config.import : entry).map(id => toEntry(id));
-    const formatters = config?.format ? config.format : [];
-    const requires = config?.require ? config.require : [];
-    return imports.concat([...formatters, ...requires].map(id => toDeferResolve(id)));
+    const requires = (config?.require ? config.require : []).map(id => toEntry(id));
+    const formatters = (config?.format ? config.format : [])
+        .map(toFormatterName)
+        .filter(name => !builtinFormatters.has(name))
+        .map(id => toDeferResolve(id));
+    return [...imports, ...requires, ...formatters];
+};
+const resolveConfig = (config, options) => {
+    if (typeof config !== 'object' || config === null)
+        return resolveProfile();
+    const isProfiles = /\.(json|ya?ml)$/.test(options.configFileName) || 'default' in config;
+    if (!isProfiles)
+        return resolveProfile(config);
+    const profiles = 'default' in config ? Object.values(config) : [undefined, ...Object.values(config)];
+    return profiles.flatMap(resolveProfile);
 };
 const plugin = {
     title,

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

@@ -2,6 +2,7 @@ export type CucumberConfig = {
     publishQuiet?: boolean;
     import?: string[];
     require?: string[];
-    format?: string[];
+    format?: Format[];
     parallel?: number;
 };
+export type Format = string | [string, string?];

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

@@ -1,4 +1,3 @@
 import type { Program } from 'oxc-parser';
 import { type Input } from '../../util/input.ts';
-export declare const getInputsFromSettingsAST: (program: Program) => Input[];
 export declare const getInputsFromFlatConfigAST: (program: Program) => Input[];

package/dist/plugins/eslint/resolveFromAST.js

@@ -4,7 +4,7 @@ import { findProperty, getPropertyKey } from '../../typescript/ast-helpers.js';
 import { getStringValue } from '../../typescript/ast-nodes.js';
 import { isInternal } from '../../util/path.js';
 import { importSettingKinds } from './helpers.js';
-export const getInputsFromSettingsAST = (program) => {
+const getInputsFromSettingsAST = (program) => {
     const inputs = [];
     const addResolver = (kind, resolver) => {
         if (!resolver || resolver === 'node' || isInternal(resolver))