@vigla/vite-plugin 0.0.0-stage → 0.1.1

package/src/plugins/optimizer.ts

@@ -0,0 +1,262 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import {
+	createIdResolver,
+	type Environment,
+	type Plugin,
+	type ResolvedConfig,
+	type Rolldown,
+	type UserConfig
+} from 'vite';
+import { isDepExcluded } from 'vitefu';
+import type { PluginAPI } from '../api.ts';
+import type { CompileError, CompileOptions } from '../compiler.ts';
+import { dynamicOptions } from '../compile.ts';
+import { toRollupError } from '../error.ts';
+import type { FrontEnd } from '../front-end.ts';
+import type { Identity, Names } from '../identity.ts';
+import type { Log } from '../log.ts';
+import { arraify, type ResolvedOptions } from '../options.ts';
+import { preprocessWith } from './preprocess.ts';
+import { clientImports } from '../vite-config.ts';
+import { runtimeScanPlugin, type RuntimeResolver } from './runtime-scan.ts';
+import { scanning, scanPlugin } from './scan.ts';
+
+const sensitive = [
+	'compilerOptions',
+	'configFile',
+	'experimental',
+	'extensions',
+	'preprocess'
+] as const;
+
+function escape(text: string): string {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function bare(extension: string): string {
+	return escape(extension.startsWith('.') ? extension.slice(1) : extension);
+}
+
+function componentFilter(frontEnds: readonly FrontEnd[]): RegExp {
+	const extensions = frontEnds.flatMap((frontEnd) => frontEnd.components).map(bare);
+	return new RegExp(`^[^?#]+\\.(?:${extensions.join('|')})(?:[?#]|$)`);
+}
+
+function moduleFilter(frontEnds: readonly FrontEnd[]): RegExp {
+	const alternatives = frontEnds.map(
+		(frontEnd) =>
+			`(?:${frontEnd.modules.infixes.map(escape).join('|')})(?:${frontEnd.modules.extensions.map(bare).join('|')})`
+	);
+	return new RegExp(`^[^?#]+(?:${alternatives.join('|')})(?:[?#]|$)`);
+}
+
+function claiming(frontEnds: readonly FrontEnd[], filename: string, modules: boolean): FrontEnd {
+	const found = frontEnds.find((frontEnd) =>
+		modules
+			? frontEnd.modules.infixes.some((infix) => filename.includes(infix))
+			: frontEnd.components.some((extension) => filename.endsWith(extension))
+	);
+	return found ?? (frontEnds[0] as FrontEnd);
+}
+
+async function compileComponent(
+	options: ResolvedOptions,
+	frontEnd: FrontEnd,
+	filename: string,
+	code: string,
+	generate: 'client' | 'server',
+	environment: Environment,
+	log: Log
+) {
+	const compileOptions: CompileOptions = {
+		dev: true,
+		...options.compilerOptions,
+		css: 'injected',
+		filename,
+		generate
+	};
+	const groups = arraify(options.preprocess);
+	let source = code;
+	if (options.preprocess) {
+		const processed = await preprocessWith({ filename, frontEnd }, code, groups);
+		if (processed.map) compileOptions.sourcemap = processed.map as object;
+		source = processed.code;
+	}
+	const dynamic = await dynamicOptions(
+		options,
+		filename,
+		source,
+		compileOptions,
+		environment,
+		log,
+		'compile'
+	);
+	const compiled = frontEnd.compiler.compile(
+		source,
+		dynamic ? { ...compileOptions, ...dynamic } : compileOptions
+	);
+	return { code: compiled.js.code, map: compiled.js.map as never, moduleType: 'js' as const };
+}
+
+function compileLibraryModule(
+	options: CompileOptions,
+	frontEnd: FrontEnd,
+	filename: string,
+	code: string,
+	generate: 'client' | 'server'
+) {
+	const compiled = frontEnd.compiler.compileModule(code, {
+		...options,
+		dev: options.dev ?? true,
+		filename,
+		generate
+	});
+	return { code: compiled.js.code, map: compiled.js.map as never, moduleType: 'js' as const };
+}
+
+function optimizerPlugin(
+	api: PluginAPI,
+	{ name, log }: Identity,
+	environmentName: string,
+	consumer: 'client' | 'server',
+	components: boolean
+): Rolldown.Plugin {
+	const generate = consumer === 'server' ? 'server' : 'client';
+	const plugin: Rolldown.Plugin = {
+		name: components ? `${name}:optimize` : `${name}:optimize-module`
+	};
+	plugin.options = (input) => {
+		if (scanning(input)) {
+			delete plugin.transform;
+			return;
+		}
+		plugin.transform = {
+			filter: { id: components ? componentFilter(api.frontEnds) : moduleFilter(api.frontEnds) },
+			async handler(code: string, filename: string) {
+				const frontEnd = claiming(api.frontEnds, filename, !components);
+				try {
+					if (!components)
+						return compileLibraryModule(api.moduleOptions, frontEnd, filename, code, generate);
+					const environment = api.options.server?.environments[environmentName] as Environment;
+					return await compileComponent(
+						api.options,
+						frontEnd,
+						filename,
+						code,
+						generate,
+						environment,
+						log
+					);
+				} catch (error) {
+					throw toRollupError(error as CompileError, api.options);
+				}
+			}
+		} as Rolldown.Plugin['transform'];
+	};
+	return plugin;
+}
+
+async function metadataChanged(
+	cacheDir: string,
+	options: ResolvedOptions,
+	{ metadataFile }: Names
+): Promise<boolean> {
+	const metadata: Record<string, unknown> = {};
+	for (const key of sensitive) metadata[key] = options[key];
+	const current = JSON.stringify(metadata, (_, value) =>
+		typeof value === 'function' ? value.toString() : value
+	);
+	const file = path.resolve(cacheDir, metadataFile);
+	let existing: string | undefined;
+	try {
+		existing = await fs.readFile(file, 'utf8');
+	} catch {}
+	await fs.mkdir(cacheDir, { recursive: true });
+	await fs.writeFile(file, current);
+	return current !== existing;
+}
+
+export function setupOptimizer(api: PluginAPI, identity: Identity): Plugin {
+	let viteConfig: ResolvedConfig;
+	return {
+		name: `${identity.name}:setup-optimizer`,
+		apply: 'serve',
+		configEnvironment(name, config) {
+			const consumer = config.consumer ?? (name === 'client' ? 'client' : 'server');
+			let resolve: ReturnType<typeof createIdResolver> | undefined;
+			let legacy: ReturnType<ResolvedConfig['createResolver']> | undefined;
+			const resolveRuntime: RuntimeResolver = async (source, importer) => {
+				const environment = api.options.server?.environments[name];
+				return environment
+					? await (resolve ??= createIdResolver(viteConfig, { scan: true }))(
+							environment,
+							source,
+							importer
+						)
+					: await (legacy ??= viteConfig.createResolver({ scan: true }))(
+							source,
+							importer,
+							false,
+							consumer === 'server'
+						);
+			};
+			const plugins: Rolldown.Plugin[] = [
+				{
+					name: `${identity.name}:shared-core`,
+					resolveId: {
+						order: 'pre',
+						filter: { id: /^vigla(?:\/[^?#]+)?$/ },
+						async handler(source, importer) {
+							const resolved = await resolveRuntime(source, importer);
+							if (resolved === undefined)
+								return this.error(
+									`Cannot resolve core runtime ${source} from ${importer ?? viteConfig.root}`
+								);
+							return {
+								id: resolved.startsWith('file://') ? resolved : pathToFileURL(resolved).href,
+								external: 'absolute'
+							};
+						}
+					}
+				}
+			];
+			const optimizeDeps: UserConfig['optimizeDeps'] = {
+				exclude: ['vigla'],
+				rolldownOptions: { plugins }
+			};
+			if (api.frontEnds.length === 0) return { optimizeDeps };
+			optimizeDeps.extensions = [
+				...new Set(api.frontEnds.flatMap((frontEnd) => frontEnd.components))
+			];
+			const exclude = config.optimizeDeps?.exclude ?? [];
+			const runtime = api.frontEnds.filter((frontEnd) => !isDepExcluded(frontEnd.name, exclude));
+			plugins.unshift(
+				runtimeScanPlugin(
+					identity.name,
+					runtime.flatMap(clientImports),
+					['vigla', ...runtime.map((frontEnd) => frontEnd.name)],
+					resolveRuntime
+				)
+			);
+			plugins.push(
+				scanPlugin(identity.name, api.frontEnds),
+				optimizerPlugin(api, identity, name, consumer, true),
+				optimizerPlugin(api, identity, name, consumer, false)
+			);
+			if (consumer === 'server') {
+				optimizeDeps.include = runtime.flatMap((frontEnd) => frontEnd.imports);
+			}
+			return { optimizeDeps };
+		},
+		configResolved(config) {
+			viteConfig = config;
+		},
+		async buildStart() {
+			if (api.frontEnds.length === 0 || !api.options.prebundleLibraries) return;
+			if (await metadataChanged(viteConfig.cacheDir, api.options, identity.names))
+				viteConfig.optimizeDeps.force = true;
+		}
+	};
+}

package/src/plugins/preprocess.ts

@@ -0,0 +1,163 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { Plugin, ResolvedConfig, Rollup, ViteDevServer } from 'vite';
+import type { PluginAPI } from '../api.ts';
+import type { CompileError, PreprocessorGroup, Processed } from '../compiler.ts';
+import { toRollupError } from '../error.ts';
+import type { ComponentRequest } from '../id.ts';
+import type { Identity } from '../identity.ts';
+import type { Log } from '../log.ts';
+import { mapToRelative } from '../maps.ts';
+import { arraify } from '../options.ts';
+
+type Preprocess = (request: ComponentRequest, code: string) => Promise<Processed | undefined>;
+
+interface Tagged {
+	__resolvedConfig?: ResolvedConfig | null;
+}
+
+export async function preprocessWith(
+	request: { filename: string; frontEnd: ComponentRequest['frontEnd'] },
+	code: string,
+	groups: PreprocessorGroup[]
+): Promise<Processed> {
+	const { filename } = request;
+	try {
+		return await request.frontEnd.compiler.preprocess(code, groups, { filename });
+	} catch (error) {
+		const failure = error as Error;
+		failure.message = `Error while preprocessing ${filename}${failure.message ? ` - ${failure.message}` : ''}`;
+		throw failure;
+	}
+}
+
+function createPreprocess(groups: PreprocessorGroup[], config: ResolvedConfig): Preprocess {
+	for (const group of groups) {
+		const style = group.style as (PreprocessorGroup['style'] & Tagged) | undefined;
+		if (style && '__resolvedConfig' in style) style.__resolvedConfig = config;
+	}
+	return async (request, code) => {
+		const processed = await preprocessWith(request, code, groups);
+		if (typeof processed?.map === 'object') mapToRelative(processed.map, request.filename);
+		return processed;
+	};
+}
+
+function dependencyKey(file: string): string {
+	if (!/^[a-z]:/i.test(file) && !file.startsWith(path.win32.sep.repeat(2))) return file;
+	return file.replaceAll(path.win32.sep, path.posix.sep);
+}
+
+class Dependencies {
+	readonly #dependencies = new Map<string, Set<string>>();
+	readonly #dependants = new Map<string, Set<string>>();
+	readonly #server: ViteDevServer;
+
+	constructor(server: ViteDevServer, log: Log) {
+		this.#server = server;
+		const changed = (filename: string) => {
+			for (const dependant of this.#dependants.get(dependencyKey(filename)) ?? []) {
+				if (!fs.existsSync(dependant)) continue;
+				log.debug(
+					`emitting virtual change event for "${dependant}" because dependency "${filename}" changed`,
+					undefined,
+					'hmr'
+				);
+				server.watcher.emit('change', dependant);
+			}
+		};
+		server.watcher.on('change', changed);
+		server.watcher.on('unlink', changed);
+	}
+
+	#watch(file: string): void {
+		const root = this.#server.config.root;
+		if (file && !file.startsWith(`${root}/`) && !file.includes('\0') && fs.existsSync(file)) {
+			this.#server.watcher.add(path.resolve(file));
+		}
+	}
+
+	clear(): void {
+		this.#dependencies.clear();
+		this.#dependants.clear();
+	}
+
+	update(request: ComponentRequest, dependencies: string[]): void {
+		const id = request.normalizedFilename;
+		const previous = this.#dependencies.get(id) ?? new Set<string>();
+		const next = new Set<string>();
+		for (const dependency of dependencies) {
+			const key = dependencyKey(dependency);
+			if (next.has(key)) continue;
+			next.add(key);
+			if (previous.has(key)) continue;
+			this.#watch(dependency);
+			let dependants = this.#dependants.get(key);
+			if (dependants === undefined) {
+				dependants = new Set();
+				this.#dependants.set(key, dependants);
+			}
+			dependants.add(request.filename);
+		}
+		this.#dependencies.set(id, next);
+		for (const dependency of previous) {
+			if (!next.has(dependency)) {
+				this.#dependants.get(dependency)?.delete(request.filename);
+			}
+		}
+	}
+}
+
+export function preprocess(api: PluginAPI, { name, log }: Identity): Plugin {
+	let run: Preprocess | undefined;
+	let dependencies: Dependencies | undefined;
+	const plugin: Plugin = {
+		name: `${name}:preprocess`,
+		enforce: 'pre',
+		configResolved(config) {
+			const groups = arraify(api.options.preprocess);
+			if (groups.length > 0) {
+				run = createPreprocess(groups, config);
+				Object.assign(plugin.transform as object, { filter: api.filter });
+			} else {
+				log.debug(
+					`disabling ${plugin.name} because no preprocessor is configured`,
+					undefined,
+					'preprocess'
+				);
+				run = undefined;
+				Object.assign(plugin.transform as object, { filter: { id: /$./ } });
+			}
+		},
+		configureServer(server) {
+			dependencies = new Dependencies(server, log);
+		},
+		buildStart() {
+			dependencies?.clear();
+		},
+		transform: {
+			async handler(code, id) {
+				const request = api.idParser(id, this.environment.config.consumer === 'server');
+				if (!request || run === undefined) return undefined;
+				try {
+					const processed = await run(request, code);
+					dependencies?.update(request, processed?.dependencies ?? []);
+					if (!processed) return undefined;
+					if (
+						api.options.isBuild &&
+						this.environment.config.build.watch &&
+						processed.dependencies
+					) {
+						for (const dependency of processed.dependencies) this.addWatchFile(dependency);
+					}
+					const result: Rollup.SourceDescription = { code: processed.code };
+					if (processed.map) result.map = processed.map as never;
+					return result;
+				} catch (error) {
+					throw toRollupError(error as CompileError, api.options);
+				}
+			}
+		}
+	};
+	return plugin;
+}

package/src/plugins/runtime-scan.ts

@@ -0,0 +1,75 @@
+import type { Rolldown } from 'vite';
+import { scanning } from './scan.ts';
+
+export type RuntimeResolver = (
+	source: string,
+	importer: string | undefined
+) => Promise<string | undefined>;
+
+function escape(text: string): string {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function withEntry(
+	input: Rolldown.InputOption | undefined,
+	runtimeId: string
+): Rolldown.InputOption {
+	if (input === undefined) return [runtimeId];
+	if (typeof input === 'string') return [input, runtimeId];
+	if (Array.isArray(input)) return [...input, runtimeId];
+	return { ...input, [runtimeId]: runtimeId };
+}
+
+function crawler(
+	name: string,
+	runtimeId: string,
+	entries: readonly string[],
+	owned: RegExp,
+	resolve: RuntimeResolver
+): Rolldown.Plugin {
+	return {
+		name,
+		resolveId: {
+			order: 'pre',
+			async handler(source, importer) {
+				if (source === runtimeId) return { id: source };
+				if (importer === undefined || !owned.test(source)) return null;
+				const file = await resolve(source, importer === runtimeId ? undefined : importer);
+				return file === undefined || /[\\/]node_modules[\\/]/.test(file) ? null : { id: file };
+			}
+		},
+		load: {
+			filter: { id: new RegExp(`^${escape(runtimeId)}$`) },
+			handler: () => ({
+				code: entries.map((entry) => `import ${JSON.stringify(entry)};\n`).join(''),
+				moduleType: 'js'
+			})
+		}
+	};
+}
+
+export function runtimeScanPlugin(
+	prefix: string,
+	entries: readonly string[],
+	packages: readonly string[],
+	resolve: RuntimeResolver
+): Rolldown.Plugin {
+	const owned = new RegExp(`^(?:${packages.map(escape).join('|')})(?:/[^?#]+)?$`);
+	const name = `${prefix}:runtime-scan`;
+	const runtimeId = `\0${name}`;
+	const plugin: Rolldown.Plugin = {
+		name,
+		options(input) {
+			if (entries.length === 0 || !scanning(input)) return;
+			const plugins = (input.plugins ?? []) as Rolldown.Plugin[];
+			return {
+				...input,
+				input: withEntry(input.input, runtimeId),
+				plugins: plugins.map((entry) =>
+					entry === plugin ? crawler(name, runtimeId, entries, owned, resolve) : entry
+				)
+			};
+		}
+	};
+	return plugin;
+}

package/src/plugins/scan.ts

@@ -0,0 +1,206 @@
+import fs from 'node:fs/promises';
+import type { Rolldown } from 'vite';
+import type { Compiler, Parse, ParsedComponent, Script } from '../compiler.ts';
+import type { FrontEnd } from '../front-end.ts';
+
+interface Node {
+	readonly type: string;
+	readonly [key: string]: unknown;
+}
+
+interface Part {
+	module: boolean;
+	lang: 'js' | 'ts';
+	code: string;
+}
+
+const partId = /\?scan=(\d+)&lang\.[jt]s$/;
+
+export function scanning(input: Rolldown.InputOptions): boolean {
+	const plugins = (input.plugins ?? []) as { name?: string }[];
+	return plugins.some((entry) => entry?.name === 'vite:dep-scan:resolve');
+}
+
+function node(value: unknown): Node | undefined {
+	return value !== null && typeof value === 'object' && typeof (value as Node).type === 'string'
+		? (value as Node)
+		: undefined;
+}
+
+function nodes(value: unknown): Node[] {
+	return Array.isArray(value) ? value.flatMap((item) => node(item) ?? []) : [];
+}
+
+function identifier(value: unknown): string | undefined {
+	const found = node(value);
+	return found?.type === 'Identifier' ? (found.name as string) : undefined;
+}
+
+function bind(pattern: Node | undefined, names: Set<string>): void {
+	if (pattern === undefined) return;
+	if (pattern.type === 'Identifier') names.add(pattern.name as string);
+	else if (pattern.type === 'ObjectPattern') {
+		for (const property of nodes(pattern.properties))
+			bind(node(property.type === 'RestElement' ? property.argument : property.value), names);
+	} else if (pattern.type === 'ArrayPattern') {
+		for (const element of nodes(pattern.elements)) bind(element, names);
+	} else if (pattern.type === 'RestElement') bind(node(pattern.argument), names);
+	else if (pattern.type === 'AssignmentPattern') bind(node(pattern.left), names);
+}
+
+function declared(body: readonly Node[]): Set<string> {
+	const names = new Set<string>();
+	for (const statement of body) {
+		const declaration = statement.type.startsWith('Export')
+			? node(statement.declaration)
+			: statement;
+		if (declaration === undefined) continue;
+		if (declaration.type === 'ImportDeclaration') {
+			for (const specifier of nodes(declaration.specifiers)) bind(node(specifier.local), names);
+		} else if (declaration.type === 'VariableDeclaration') {
+			for (const declarator of nodes(declaration.declarations)) bind(node(declarator.id), names);
+		} else {
+			const name = identifier(declaration.id);
+			if (name !== undefined) names.add(name);
+		}
+	}
+	return names;
+}
+
+function undeclaredExports(body: readonly Node[]): Set<string> {
+	const names = declared(body);
+	const missing = new Set<string>();
+	for (const statement of body) {
+		if (statement.type !== 'ExportNamedDeclaration' || statement.source) continue;
+		if (statement.exportKind === 'type') continue;
+		for (const specifier of nodes(statement.specifiers)) {
+			const local = identifier(specifier.local);
+			if (local !== undefined && specifier.exportKind !== 'type' && !names.has(local))
+				missing.add(local);
+		}
+	}
+	return missing;
+}
+
+function importedSources(body: readonly Node[]): string[] {
+	return body.flatMap((statement) =>
+		statement.type === 'ImportDeclaration' && statement.importKind !== 'type'
+			? [String(node(statement.source)?.value)]
+			: []
+	);
+}
+
+function language(script: Script): 'js' | 'ts' | undefined {
+	let lang = 'js';
+	for (const attribute of script.attributes) {
+		if (attribute.name === 'src') return undefined;
+		if (attribute.name !== 'lang') continue;
+		if (!Array.isArray(attribute.value)) return undefined;
+		lang = (attribute.value as readonly { data?: string }[])
+			.map((part) => part.data ?? '')
+			.join('');
+	}
+	if (lang === 'js' || lang === 'javascript') return 'js';
+	if (lang === 'ts' || lang === 'typescript') return 'ts';
+	return undefined;
+}
+
+async function parse(
+	compiler: Compiler,
+	parser: Parse,
+	filename: string
+): Promise<{ source: string; parsed: ParsedComponent }> {
+	const source = (await fs.readFile(filename, 'utf8')).replace(/^/, '');
+	try {
+		return { source, parsed: parser(source, { modern: true, filename }) };
+	} catch {
+		const blank = await compiler.preprocess(source, { style: () => ({ code: '' }) }, { filename });
+		return { source: blank.code, parsed: parser(blank.code, { modern: true, filename }) };
+	}
+}
+
+async function split(compiler: Compiler, filename: string): Promise<Part[] | undefined> {
+	if (compiler.parse === undefined) return undefined;
+	try {
+		const { source, parsed } = await parse(compiler, compiler.parse, filename);
+		const parts: Part[] = [];
+		for (const [script, module] of [
+			[parsed.module, true],
+			[parsed.instance, false]
+		] as const) {
+			if (!script) continue;
+			const lang = language(script);
+			if (lang === undefined) return undefined;
+			const body = nodes(script.content.body);
+			let code = source.slice(script.content.start, script.content.end);
+			for (const local of undeclaredExports(body)) code += `\nvar ${local};`;
+			if (lang === 'ts') {
+				for (const imported of importedSources(body))
+					code += `\nimport ${JSON.stringify(imported)};`;
+			}
+			parts.push({ module, lang, code });
+		}
+		return parts;
+	} catch {
+		return undefined;
+	}
+}
+
+function facade(filename: string, parts: readonly Part[]): string {
+	let code = '';
+	for (const [index, part] of parts.entries()) {
+		const specifier = JSON.stringify(`${filename}?scan=${index}&lang.${part.lang}`);
+		code += part.module ? `export * from ${specifier};\n` : `import ${specifier};\n`;
+	}
+	return `${code}export default {};\n`;
+}
+
+function escape(text: string): string {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function scanner(name: string, parsing: readonly FrontEnd[]): Rolldown.Plugin {
+	const extensions = parsing.flatMap((frontEnd) => frontEnd.components).map(escape);
+	const component = new RegExp(`^[^?#]+(?:${extensions.join('|')})$`);
+	const pending = new Map<string, Promise<Part[] | undefined>>();
+	return {
+		name,
+		resolveId: { filter: { id: partId }, handler: (source) => ({ id: source }) },
+		load: {
+			filter: { id: { include: [component, partId] } },
+			async handler(id) {
+				const part = partId.exec(id);
+				const filename = part === null ? id : id.slice(0, part.index);
+				let parts = pending.get(filename);
+				if (parts === undefined) {
+					const frontEnd = parsing.find((candidate) =>
+						candidate.components.some((extension) => filename.endsWith(extension))
+					) as FrontEnd;
+					parts = split(frontEnd.compiler, filename);
+					pending.set(filename, parts);
+				}
+				const found = await parts;
+				if (found === undefined) return null;
+				if (part === null) return { code: facade(filename, found), moduleType: 'js' };
+				const chosen = found[Number(part[1])] as Part;
+				return { code: chosen.code, moduleType: chosen.lang };
+			}
+		}
+	};
+}
+
+export function scanPlugin(prefix: string, frontEnds: readonly FrontEnd[]): Rolldown.Plugin {
+	const parsing = frontEnds.filter((frontEnd) => frontEnd.compiler.parse !== undefined);
+	const plugin: Rolldown.Plugin = {
+		name: `${prefix}:scan`,
+		options(input) {
+			if (parsing.length === 0 || !scanning(input)) return;
+			const plugins = (input.plugins ?? []) as Rolldown.Plugin[];
+			return {
+				...input,
+				plugins: plugins.map((entry) => (entry === plugin ? scanner(plugin.name, parsing) : entry))
+			};
+		}
+	};
+	return plugin;
+}