knip 6.42.1 → 6.44.0

package/dist/binaries/resolvers/pnpm.js

@@ -89,6 +89,7 @@ const commands = [
     'with',
 ];
 const recursiveCommands = ['recursive', 'multi', 'm'];
+const testAliases = new Set(['t', 'tst']);
 export const resolve = (_binary, words, options) => {
     const parseOptions = {
         isStorePositions: true,
@@ -120,16 +121,17 @@ export const resolve = (_binary, words, options) => {
     if (parsed.filter && !parsed.recursive)
         return [];
     const childInputs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(argsAfter(words, '--'), { isForwardedArgs: true }) : [];
-    if (command === 'run') {
+    if (command === 'run' || command === 'run-script') {
         const script = parsed._[1];
         if (script && manifest.scriptNames.has(script)) {
             return expandScript(script, argsAfter(words, script), manifest.scripts, options) ?? childInputs;
         }
         return childInputs;
     }
-    const isScript = manifest.scriptNames.has(command);
+    const name = testAliases.has(command) ? 'test' : command;
+    const isScript = manifest.scriptNames.has(name);
     if (isScript)
-        return expandScript(command, argsAfter(words, command), manifest.scripts, options) ?? childInputs;
+        return expandScript(name, argsAfter(words, command), manifest.scripts, options) ?? childInputs;
     if (commands.includes(command))
         return childInputs;
     return command && isValidBinary(command) ? [toBinary(command)] : [];

package/dist/binaries/util.js

@@ -48,7 +48,8 @@ export const expandScript = (name, forwardedArgs, scripts, options, opts = {}) =
     if (expandedScripts.has(name))
         return;
     expandedScripts.add(name);
-    return options.fromArgs([source, ...forwardedArgs], { ...opts, expandedScripts });
+    const cwd = options.manifestDir ?? options.cwd;
+    return options.fromArgs([source, ...forwardedArgs], { cwd, manifestDir: undefined, ...opts, expandedScripts });
 };
 export const parseNodeArgs = (args) => parseArgs(args, {
     string: ['r'],

package/dist/cli.js

@@ -9,6 +9,7 @@ import { createPreprocessor, toReporterOptions } from './util/preprocessor.js';
 import { runReporters } from './util/reporter.js';
 import { prettyMilliseconds } from './util/string.js';
 import { version } from './version.js';
+import { watchSession } from './session/watch.js';
 let args = {};
 try {
     args = parseArgs();
@@ -32,6 +33,10 @@ const main = async () => {
             process.exit(0);
         }
         const options = await createOptions({ args });
+        if (options.isWatch) {
+            await watchSession(options);
+            return;
+        }
         const { results } = await run(options);
         if (options.isWatch || options.isTrace)
             return;
@@ -39,7 +44,7 @@ const main = async () => {
         const finalData = await preprocess(toReporterOptions(options, results, args));
         if (options.isFix)
             await fix(finalData.issues, finalData.counters, options);
-        await runReporters(args.reporter ?? ['symbols'], finalData);
+        await runReporters(args.reporter ?? ['symbols'], args['output-file'] ?? [], finalData);
         const totalErrorCount = Object.keys(finalData.report)
             .filter(reportGroup => finalData.report[reportGroup] && options.rules[reportGroup] === 'error')
             .reduce((errorCount, reportGroup) => errorCount + finalData.counters[reportGroup], 0);

package/dist/compilers/compilers.js

@@ -1,7 +1,7 @@
 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;
+export const scriptExtractor = /<script(?=[\s/>])((?:[^>"']|"[^"]*"|'[^']*')*)(?<!\/)>([\s\S]*?)<\/script>/gi;
+export const styleExtractor = /<style(?![\w-])((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<\/style>/gi;
 const langAttrMatcher = /\blang\s*=\s*["']([^"']+)["']/i;
 export const blockCommentMatcher = /\/\*[\s\S]*?\*\//g;
 export const lineCommentMatcher = /^[ \t]*\/\/.*$/gm;

package/dist/compilers/index.d.ts

@@ -3,4 +3,9 @@ import type { DependencySet } from '../types/workspace.ts';
 import type { Compilers, RawCompilers } from './types.ts';
 export declare const normalizeCompilerExtension: (ext: string) => string;
 export declare const normalizeCompilers: (rawLocalConfig: RawConfiguration) => RawCompilers;
+export declare const builtInCompilers: {
+    dependencies: string[];
+    compiler: import("./types.ts").CompilerSync;
+    extensions: string[];
+}[];
 export declare const getIncludedCompilers: (rawCompilers: RawCompilers, dependencies: DependencySet, onReferencedDependency?: (packageName: string) => void) => Compilers;

package/dist/compilers/index.js

@@ -18,7 +18,7 @@ export const normalizeCompilers = (rawLocalConfig) => {
     }
     return compilers;
 };
-const builtInCompilers = [
+export const builtInCompilers = [
     { extensions: ['.mdx'], ...MDX },
     { extensions: ['.sass', '.scss'], ...SCSS },
     { extensions: ['.less'], ...LESS },

package/dist/constants.d.ts

@@ -69,4 +69,5 @@ export declare const IMPORT_FLAGS: {
     readonly AUGMENT: number;
     readonly DYNAMIC: number;
     readonly LOADER: number;
+    readonly CAUGHT: number;
 };

package/dist/constants.js

@@ -101,6 +101,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'nub',
     'nubx',
     'open',
+    'osascript',
     'paste',
     'pnpm',
     'pnpx',
@@ -277,4 +278,5 @@ export const IMPORT_FLAGS = {
     AUGMENT: 1 << 7,
     DYNAMIC: 1 << 8,
     LOADER: 1 << 9,
+    CAUGHT: 1 << 10,
 };

package/dist/graph/analyze.js

@@ -7,7 +7,7 @@ import { relative } from '../util/path.js';
 import { perfObserver, timerify } from '../util/Performance.js';
 import { findMatch } from '../util/regex.js';
 import { getShouldIgnoreHandler, getShouldIgnoreTagHandler, hasTag, isAlwaysIgnored } from '../util/tag.js';
-import { INTERNAL_TAG } from '../constants.js';
+import { IMPORT_FLAGS, INTERNAL_TAG } from '../constants.js';
 const toCyclePathKey = (path) => {
     const length = path.length > 1 && path[0] === path[path.length - 1] ? path.length - 1 : path.length;
     return path.slice(0, length).join('\0');
@@ -25,7 +25,7 @@ const isAllowedCycle = (symbols, paths) => paths?.has(toCyclePathKey(symbols.map
 export const analyze = async ({ analyzedFiles, counselor, chief, collector, deputy, entryPaths, graph, streamer, unreferencedFiles, options, }) => {
     const shouldIgnore = getShouldIgnoreHandler(options.isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(options.tags);
-    const explorer = createGraphExplorer(graph, entryPaths);
+    const explorer = createGraphExplorer(graph, entryPaths, options.isSession);
     const isReferencedInUsedExport = (exportedItem, filePath, includeEntryExports, ignoreExportsUsedInFile, visited) => {
         if (!exportedItem.referencedIn)
             return false;
@@ -230,6 +230,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 specifier: extImport.specifier,
                                 isTypeOnly: extImport.isTypeOnly,
                                 isResolved: extImport.filePath !== undefined,
+                                isCaught: !!(extImport.modifiers & IMPORT_FLAGS.CAUGHT),
                             });
                         if (!isHandled && !(extImport.jsDocTags?.size && shouldIgnoreTags(extImport.jsDocTags)))
                             collector.addIssue({

package/dist/graph/build.d.ts

@@ -7,6 +7,7 @@ import type { IssueCollector } from '../IssueCollector.ts';
 import type { ProjectPrincipal } from '../ProjectPrincipal.ts';
 import type { ModuleGraph } from '../types/module-graph.ts';
 import type { MainOptions } from '../util/create-options.ts';
+import { ConfigurationFiles } from '../session/configuration.ts';
 interface BuildOptions {
     chief: ConfigurationChief;
     collector: IssueCollector;
@@ -21,6 +22,7 @@ interface BuildOptions {
 }
 export declare function build({ chief, collector, counselor, deputy, principal, isGitIgnored, scriptParserContext, streamer, workspaces, options, }: BuildOptions): Promise<{
     graph: ModuleGraph;
+    configurationFiles: ConfigurationFiles | undefined;
     entryPaths: Set<string>;
     analyzedFiles: Set<string>;
     unreferencedFiles: Set<string>;

package/dist/graph/build.js

@@ -4,12 +4,13 @@ import { getIncludedCompilers, normalizeCompilerExtension } from '../compilers/i
 import { DEFAULT_EXTENSIONS, FOREIGN_FILE_EXTENSIONS, IS_DTS, ROOT_WORKSPACE_NAME } from '../constants.js';
 import { partition } from '../util/array.js';
 import { createInputHandler } from '../util/create-input-handler.js';
+import { ConfigurationFiles } from '../session/configuration.js';
 import { debugLog, debugLogArray } from '../util/debug.js';
 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, prependDirToPattern as prependDir, removeProductionSuffix } from '../util/glob.js';
+import { _glob, _syncGlob, prependDirToPattern as prependDir, rebasePattern, 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';
@@ -26,10 +27,11 @@ import { augmentWorkspace, getToSourcePathsHandler, toSourceMappedSpecifiers } f
 import { WorkspaceWorker } from '../WorkspaceWorker.js';
 export async function build({ chief, collector, counselor, deputy, principal, isGitIgnored, scriptParserContext, streamer, workspaces, options, }) {
     const configFilesMap = new Map();
+    const configurationFiles = options.isSession ? new ConfigurationFiles(options) : undefined;
     const enabledPluginsStore = new Map();
     const registeredVisitorPlugins = new Set();
     const toSourceFilePaths = getToSourcePathsHandler(chief);
-    const addIssue = (issue) => collector.addIssue(issue) && options.isWatch && collector.retainIssue(issue);
+    const addIssue = (issue) => collector.addIssue(issue) && options.isSession && collector.retainIssue(issue);
     const externalRefsFromInputs = options.isSession ? new Map() : undefined;
     const handleInput = createInputHandler(deputy, chief, isGitIgnored, addIssue, externalRefsFromInputs, options);
     const getPublishedTypeDependencies = options.isReportDependencies
@@ -79,6 +81,8 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             continue;
         const dependencies = deputy.getDependencies(name);
         const tsConfigFilePath = join(dir, options.tsConfigFile ?? 'tsconfig.json');
+        configurationFiles?.paths.add(filePath);
+        configurationFiles?.paths.add(tsConfigFilePath);
         const { isFile, compilerOptions, fileNames, include, exclude, sourceMapPairs, paths: tsConfigPaths, } = await loadTSConfig(tsConfigFilePath, options.isUseTscFiles);
         const [definitionPaths, tscSourcePaths] = partition(fileNames, filePath => IS_DTS.test(filePath));
         const worker = new WorkspaceWorker({
@@ -97,6 +101,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             enabledPluginsInAncestors: ancestors.flatMap(ancestor => enabledPluginsStore.get(ancestor) ?? []),
             readRawFile: (filePath) => principal.fileManager.readRawFile(filePath) ?? '',
             configFilesMap,
+            configurationFiles,
             options,
         });
         await worker.init();
@@ -189,32 +194,42 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         });
         const DEFAULT_GROUP = 'default';
         const createPatternMap = () => new Map([[DEFAULT_GROUP, new Set()]]);
-        const groups = new Set([DEFAULT_GROUP]);
+        const groups = new Map([[DEFAULT_GROUP, undefined]]);
         const entryPatterns = createPatternMap();
         const entryPatternsSkipExports = createPatternMap();
         const productionPatterns = createPatternMap();
         const productionPatternsSkipExports = createPatternMap();
         const projectFilePatterns = new Set();
-        const addPattern = (map, input, pattern) => {
-            if (input.group && !map.has(input.group))
-                map.set(input.group, new Set());
-            map.get(input.group ?? DEFAULT_GROUP).add(pattern);
+        const addPattern = (map, group, pattern) => {
+            let patterns = map.get(group);
+            if (!patterns)
+                map.set(group, (patterns = new Set()));
+            patterns.add(pattern);
         };
         const toWorkspaceRelative = (path) => (isAbsolute(path) ? relative(dir, path) : path);
+        const addEntryPattern = (map, input) => {
+            const base = input.dir;
+            if (base && base !== dir) {
+                const group = `${input.group ?? DEFAULT_GROUP}:${base}`;
+                groups.set(group, base);
+                addPattern(map, group, rebasePattern(input.specifier, base, dir));
+            }
+            else {
+                addPattern(map, input.group ?? DEFAULT_GROUP, toWorkspaceRelative(input.specifier));
+            }
+        };
         for (const input of inputs) {
             if (input.group)
-                groups.add(input.group);
+                groups.set(input.group, undefined);
             const specifier = input.specifier;
             if (isCatalog(input)) {
                 counselor.addReference({ catalogName: input.catalogName, packageName: specifier });
             }
             else if (isEntry(input)) {
-                const targetMap = input.skipExportsAnalysis ? entryPatternsSkipExports : entryPatterns;
-                addPattern(targetMap, input, toWorkspaceRelative(specifier));
+                addEntryPattern(input.skipExportsAnalysis ? entryPatternsSkipExports : entryPatterns, input);
             }
             else if (isProductionEntry(input)) {
-                const targetMap = input.skipExportsAnalysis ? productionPatternsSkipExports : productionPatterns;
-                addPattern(targetMap, input, toWorkspaceRelative(specifier));
+                addEntryPattern(input.skipExportsAnalysis ? productionPatternsSkipExports : productionPatterns, input);
             }
             else if (isProject(input)) {
                 projectFilePatterns.add(toWorkspaceRelative(specifier));
@@ -239,7 +254,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 if (resolvedFilePath) {
                     if (isDeferResolveEntry(input) && options.isProduction && !isDeferResolveProductionEntry(input)) {
                         if (!input.optional)
-                            addPattern(entryPatternsSkipExports, input, resolvedFilePath);
+                            addPattern(entryPatternsSkipExports, input.group ?? DEFAULT_GROUP, resolvedFilePath);
                     }
                     else {
                         principal.addEntryPath(resolvedFilePath, { skipExportsAnalysis: true });
@@ -278,13 +293,9 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             gitignore: false,
             label: 'entry paths',
         });
-        for (const group of groups) {
+        for (const [group, base] of groups) {
             {
-                const patterns = worker.getPluginEntryFilePatterns([
-                    ...((!options.isProduction && entryPatterns.get(group)) || []),
-                    ...((!options.isProduction && group === DEFAULT_GROUP && worker.getPluginConfigPatterns()) || []),
-                    ...(productionPatterns.get(group) ?? []),
-                ]);
+                const patterns = worker.getPluginEntryFilePatterns([...((!options.isProduction && entryPatterns.get(group)) || []), ...(productionPatterns.get(group) ?? [])], base);
                 const label = `entry paths from plugins${group !== DEFAULT_GROUP ? ` - ${group}` : ''}`;
                 const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
                 principal.addEntryPaths(productionPaths(pluginWorkspaceEntryPaths));
@@ -293,7 +304,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 const patterns = worker.getPluginEntryFilePatterns([
                     ...((!options.isProduction && entryPatternsSkipExports.get(group)) || []),
                     ...(productionPatternsSkipExports.get(group) ?? []),
-                ]);
+                ], base);
                 const label = `entry paths from plugins (ignore exports)${group !== DEFAULT_GROUP ? ` - ${group}` : ''}`;
                 const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
                 principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
@@ -368,7 +379,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         tags: options.tags,
     };
     const analyzeSourceFile = (filePath, sourceText, parseResult, cachedFile) => {
-        if (!options.isWatch && !options.isSession && analyzedFiles.has(filePath))
+        if (!options.isSession && analyzedFiles.has(filePath))
             return;
         analyzedFiles.add(filePath);
         const workspace = chief.findWorkspaceByFilePath(filePath);
@@ -433,6 +444,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 const dir = dirname(filePath);
                 const opts = {
                     cwd: dir,
+                    manifestDir: workspace.dir,
                     rootCwd: options.cwd,
                     containingFilePath: filePath,
                     dependencies,
@@ -448,6 +460,8 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                     }
                     input.containingFilePath ??= filePath;
                     input.dir ??= dir;
+                    if (options.isProduction)
+                        input.production = true;
                     const specifierFilePath = handleInput(input, workspace);
                     if (specifierFilePath)
                         principal.addEntryPath(specifierFilePath, { skipExportsAnalysis: true });
@@ -515,7 +529,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
     }
     for (const filePath of principal.entryPaths)
         entryPaths.add(filePath);
-    principal.reconcileCache(graph);
+    principal.reconcileCache();
     perfObserver.addMemoryMark('build');
     if (externalRefsFromInputs) {
         for (const [filePath, refs] of externalRefsFromInputs) {
@@ -527,6 +541,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
     }
     return {
         graph,
+        configurationFiles,
         entryPaths,
         analyzedFiles,
         unreferencedFiles,

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

@@ -2,7 +2,8 @@ import type { ModuleGraph } from '../types/module-graph.ts';
 import type { UsageResult } from './operations/get-usage.ts';
 import type { DefinitionResult } from './operations/resolve-definition.ts';
 import type { ExportTableCache } from './operations/resolve-export-origins.ts';
-export declare const invalidateCache: (graph: ModuleGraph) => void;
+export declare const getTopologyGeneration: (graph: ModuleGraph) => number;
+export declare const invalidateCache: (graph: ModuleGraph, topologyUnchanged?: boolean) => void;
 export declare const getCachedDefinition: (graph: ModuleGraph, filePath: string, identifier: string) => DefinitionResult | null | undefined;
 export declare const setCachedDefinition: (graph: ModuleGraph, filePath: string, identifier: string, result: DefinitionResult | null) => void;
 export declare const getCachedUsage: (graph: ModuleGraph, filePath: string, identifier: string) => UsageResult | undefined;

package/dist/graph-explorer/cache.js

@@ -6,6 +6,7 @@ const createEmptyCache = () => ({
     exportedIdentifiers: new Map(),
     exportTables: new Map(),
     generation: 0,
+    topologyGeneration: 0,
 });
 const getCache = (graph) => {
     let cache = caches.get(graph);
@@ -15,7 +16,8 @@ const getCache = (graph) => {
     }
     return cache;
 };
-export const invalidateCache = (graph) => {
+export const getTopologyGeneration = (graph) => getCache(graph).topologyGeneration;
+export const invalidateCache = (graph, topologyUnchanged = false) => {
     const cache = caches.get(graph);
     if (cache) {
         cache.definitions.clear();
@@ -24,6 +26,8 @@ export const invalidateCache = (graph) => {
         cache.exportedIdentifiers.clear();
         cache.exportTables.clear();
         cache.generation++;
+        if (!topologyUnchanged)
+            cache.topologyGeneration++;
     }
 };
 export const getCachedDefinition = (graph, filePath, identifier) => {

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

@@ -1,9 +1,7 @@
 import type { ModuleGraph } from '../types/module-graph.ts';
-export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<string>) => {
-    isReferenced: (filePath: string, identifier: string, options: {
-        traverseEntries: boolean;
-        treatStarAtEntryAsReferenced?: boolean;
-    }) => readonly [false, string | undefined, Set<string> | undefined];
+import { isReferenced } from './operations/is-referenced.ts';
+export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<string>, cacheUsage?: boolean) => {
+    isReferenced: (filePath: string, identifier: string, options: Parameters<typeof isReferenced>[4]) => 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/explorer.js

@@ -1,4 +1,4 @@
-import { invalidateCache as invalidateCacheInternal } from './cache.js';
+import { getTopologyGeneration, invalidateCache as invalidateCacheInternal } from './cache.js';
 import { buildExportsTree } from './operations/build-exports-tree.js';
 import { findAllCycles } from './operations/find-all-cycles.js';
 import { findCycles } from './operations/find-cycles.js';
@@ -10,9 +10,30 @@ import { isEnumerated } from './operations/is-enumerated.js';
 import { isReferenced } from './operations/is-referenced.js';
 import { resolveDefinition } from './operations/resolve-definition.js';
 import { resolveExportOrigins } from './operations/resolve-export-origins.js';
-export const createGraphExplorer = (graph, entryPaths) => {
+export const createGraphExplorer = (graph, entryPaths, cacheUsage = false) => {
+    const references = new Map();
+    let generation = getTopologyGeneration(graph);
+    const reference = (filePath, identifier, options) => {
+        if (!cacheUsage)
+            return isReferenced(graph, entryPaths, filePath, identifier, options);
+        const current = getTopologyGeneration(graph);
+        if (current !== generation) {
+            references.clear();
+            generation = current;
+        }
+        let file = references.get(filePath);
+        if (!file)
+            references.set(filePath, (file = new Map()));
+        const key = `${options.traverseEntries ? 1 : 0}${options.treatStarAtEntryAsReferenced ? 1 : 0}:${identifier}`;
+        const cached = file.get(key);
+        if (cached)
+            return cached;
+        const result = isReferenced(graph, entryPaths, filePath, identifier, options);
+        file.set(key, result);
+        return result;
+    };
     return {
-        isReferenced: (filePath, identifier, options) => isReferenced(graph, entryPaths, filePath, identifier, options),
+        isReferenced: reference,
         hasStrictlyNsReferences: (filePath, identifier) => hasStrictlyNsReferences(graph, filePath, graph.get(filePath)?.importedBy, identifier),
         isEnumerated: (filePath, identifier) => isEnumerated(graph, filePath, graph.get(filePath)?.importedBy, identifier),
         buildExportsTree: (options) => buildExportsTree(graph, entryPaths, options),

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

@@ -250,9 +250,36 @@ const getImportedComponentImports = (maps, names) => {
     }
     return imports;
 };
+const srcBlockMatcher = /<!--[\s\S]*?-->|<(script|style)(?=[\s/>])((?:[^>"']|"[^"]*"|'[^']*')*?)(?:\/>|>[\s\S]*?<\/\1\s*>)/g;
+const attributeMatcher = /([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g;
+const getSrc = (attrs) => {
+    for (const [, name, double, single, unquoted] of attrs.matchAll(attributeMatcher)) {
+        if (name === 'src')
+            return double ?? single ?? unquoted;
+    }
+};
+const getSrcImports = (source) => {
+    if (!source.includes('src'))
+        return '';
+    const imports = [];
+    for (const [, tag, attrs] of source.matchAll(srcBlockMatcher)) {
+        const src = tag && getSrc(attrs);
+        if (!src)
+            continue;
+        const specifier = JSON.stringify(src);
+        if (tag === 'script') {
+            imports.push(`import _sfc_main from ${specifier};\nexport * from ${specifier};\nexport default _sfc_main;`);
+        }
+        else
+            imports.push(`import ${specifier};`);
+    }
+    return imports.join('\n');
+};
 const compileVueSfc = (source, path, maps, root) => {
     if (maps.importMap.size === 0 && maps.componentMap.size === 0) {
-        return [scriptBodies(source, path), stylePreprocessorImports(source, path)].filter(Boolean).join(';\n');
+        return [scriptBodies(source, path), getSrcImports(source), stylePreprocessorImports(source, path)]
+            .filter(Boolean)
+            .join(';\n');
     }
     const sfc = sfcForRoot(root);
     const { descriptor } = sfc.parse(source, path);
@@ -284,6 +311,9 @@ const compileVueSfc = (source, path, maps, root) => {
     }
     scripts.push(...getSyntheticImports(maps, identifiers, path, templateTags));
     scripts.push(...getImportedComponentImports(maps, importedComponents));
+    const srcImports = getSrcImports(source);
+    if (srcImports)
+        scripts.push(srcImports);
     const styles = stylePreprocessorImports(source, path);
     if (styles)
         scripts.push(styles);

package/dist/plugins/biome/index.js

@@ -5,7 +5,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Biome';
 const enablers = ['@biomejs/biome'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['biome.json', 'biome.jsonc'];
+const config = ['biome.json', 'biome.jsonc', '.biome.json', '.biome.jsonc'];
 const isRootConfigReference = (specifier) => specifier === '//';
 const resolveExtends = (extendsArray, options) => {
     return extendsArray.map(specifier => {

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

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/buf/index.js

@@ -0,0 +1,33 @@
+import { hasDependency } from '../../util/plugin.js';
+import { toShellCommand } from '../../util/scripts.js';
+const title = 'Buf';
+const enablers = ['@bufbuild/buf', '@bufbuild/protoc-gen-es'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['buf.gen.yaml'];
+const args = {
+    config: ['template'],
+};
+const resolveConfig = (config, options) => {
+    const inputs = [];
+    for (const plugin of config.plugins ?? []) {
+        const name = plugin.plugin ?? plugin.name;
+        const command = plugin.local ?? plugin.path ?? (name && !name.includes('/') ? `protoc-gen-${name}` : undefined);
+        if (!command)
+            continue;
+        const script = toShellCommand(typeof command === 'string' ? [command] : command);
+        for (const input of options.getInputsFromScripts(script, { optionalBinaries: true })) {
+            input.dir ??= options.cwd;
+            inputs.push(input);
+        }
+    }
+    return inputs;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    args,
+    resolveConfig,
+};
+export default plugin;

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

@@ -0,0 +1,8 @@
+export interface BufGenConfig {
+    plugins?: Array<{
+        local?: string | string[];
+        path?: string | string[];
+        plugin?: string;
+        name?: string;
+    }>;
+}

package/dist/plugins/buf/types.js

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

package/dist/plugins/cspell/index.js

@@ -4,6 +4,7 @@ const title = 'CSpell';
 const enablers = ['cspell'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = [
+    'package.json',
     'cspell.config.{js,cjs,mjs,ts,mts,json,yaml,yml}',
     'cspell.{json,yaml,yml}',
     '.c{s,S}pell.json',

package/dist/plugins/dependency-cruiser/index.js

@@ -2,7 +2,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'dependency-cruiser';
 const enablers = ['dependency-cruiser'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.dependency-cruiser.{js,cjs,mjs,json}'];
+const entry = ['.dependency-cruiser.{js,cjs,mjs,json}'];
 const args = {
     binaries: ['depcruise', 'dependency-cruise', 'dependency-cruiser', 'depcruise-baseline'],
     config: true,
@@ -11,7 +11,7 @@ const plugin = {
     title,
     enablers,
     isEnabled,
-    config,
+    entry,
     args,
 };
 export default plugin;

package/dist/plugins/docusaurus/helpers.js

@@ -1,7 +1,7 @@
 import { toDeferResolve, toProductionEntry } from '../../util/input.js';
-import { join } from '../../util/path.js';
+import { isAbsolute, toAbsolute } from '../../util/path.js';
 import { findWebpackDependenciesFromConfig } from '../webpack/index.js';
-const isLocalPath = (name) => name.startsWith('.') || name.startsWith('/');
+const isLocalPath = (name) => name.startsWith('.') || isAbsolute(name);
 const FIRST_PARTY_MODULES = new Set([
     'content-docs',
     'content-blog',
@@ -63,7 +63,7 @@ const resolveArrayConfig = ([name, config], type, cwd) => {
     const sidebarPath = type !== 'theme' ? resolveSidebarPath(config) : undefined;
     const sidebar = sidebarPath ? [toProductionEntry(sidebarPath)] : [];
     if (isLocalPath(name))
-        return [toProductionEntry(join(cwd, name)), ...sidebar];
+        return [toProductionEntry(toAbsolute(name, cwd)), ...sidebar];
     return [toDeferResolve(resolveModuleName(name, type)), ...sidebar];
 };
 export const resolveConfigItems = async (items, type, options) => {
@@ -75,7 +75,7 @@ export const resolveConfigItems = async (items, type, options) => {
             continue;
         if (typeof item === 'string') {
             if (isLocalPath(item))
-                inputs.add(toProductionEntry(join(options.cwd, item)));
+                inputs.add(toProductionEntry(toAbsolute(item, options.cwd)));
             else
                 inputs.add(toDeferResolve(resolveModuleName(item, type)));
         }

package/dist/plugins/electron-forge/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;