rolldown 0.12.2 → 0.13.0

package/dist/shared/rolldown-KvxnG5lF.mjs

@@ -0,0 +1,1107 @@
+import __node_module__ from 'node:module';
+const require = __node_module__.createRequire(import.meta.url)
+import { LOG_LEVEL_DEBUG, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, LOG_LEVEL_WARN, PluginContextData, SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF, __toESM, arraify, bindingifyPlugin, error, getLogHandler, isNullish, logLevelPriority, logPluginError, normalizeHook, normalizeLog, require_binding, transformToRollupOutput, unimplemented } from "./plugin-context-data-nhjzqlNd.mjs";
+import { default as path } from "node:path";
+import { isRegExp, isRegExp as isRegExp$1, isRegExp as isRegExp$2 } from "node:util/types";
+import { Worker } from "node:worker_threads";
+import { availableParallelism } from "node:os";
+
+//#region src/options/normalized-ecma-transform-plugin-config.ts
+function normalizeEcmaTransformPluginConfig(config) {
+	if (!config) {
+		return undefined;
+	}
+	let normalizedConfig = {jsxInject: config?.jsxInject};
+	if (config?.exclude) {
+		let exclude = [];
+		if (isRegExp$2(config.exclude)) {
+			exclude = [config.exclude];
+		} else if (typeof config.exclude === "string") {
+			exclude = [config.exclude];
+		} else {
+			exclude = config.exclude;
+		}
+		normalizedConfig.exclude = [];
+		for (let item of exclude) {
+			if (isRegExp$2(item)) {
+				normalizedConfig.exclude.push({
+					value: item.source,
+					flag: item.flags
+				});
+			} else {
+				normalizedConfig.exclude.push({value: item});
+			}
+		}
+	}
+	if (config?.include) {
+		let include = [];
+		if (isRegExp$2(config.include)) {
+			include = [config.include];
+		} else if (typeof config.include === "string") {
+			include = [config.include];
+		} else {
+			include = config.include;
+		}
+		normalizedConfig.include = [];
+		for (let item of include) {
+			if (isRegExp$2(item)) {
+				normalizedConfig.include.push({
+					value: item.source,
+					flag: item.flags
+				});
+			} else {
+				normalizedConfig.include.push({value: item});
+			}
+		}
+	}
+	return normalizedConfig;
+}
+
+//#endregion
+//#region src/options/normalized-alias-plugin-config.ts
+function normalizeAliasPluginConfig(config) {
+	if (!config) {
+		return undefined;
+	}
+	let entries = config.entries.map((entry) => {
+		if (isRegExp$1(entry.find)) {
+			return {
+				find: {
+					value: entry.find.source,
+					flag: entry.find.flags
+				},
+				replacement: entry.replacement
+			};
+		} else {
+			return {
+				find: {value: entry.find},
+				replacement: entry.replacement
+			};
+		}
+	});
+	return {entries};
+}
+
+//#endregion
+//#region src/plugin/builtin-plugin.ts
+var import_binding$3 = __toESM(require_binding());
+class BuiltinPlugin {
+	constructor(name, options) {
+		this.name = name;
+		this.options = options;
+		this.name = name;
+		this.options = options;
+	}
+}
+class ModulePreloadPolyfillPlugin extends BuiltinPlugin {
+	constructor(config) {
+		super(import_binding$3.BindingBuiltinPluginName.ModulePreloadPolyfillPlugin, config);
+	}
+}
+class DynamicImportVarsPlugin extends BuiltinPlugin {
+	constructor() {
+		super(import_binding$3.BindingBuiltinPluginName.DynamicImportVarsPlugin);
+	}
+}
+class ImportGlobPlugin extends BuiltinPlugin {
+	constructor(config) {
+		super(import_binding$3.BindingBuiltinPluginName.ImportGlobPlugin, config);
+	}
+}
+class ManifestPlugin extends BuiltinPlugin {
+	constructor(config) {
+		super(import_binding$3.BindingBuiltinPluginName.ManifestPlugin, config);
+	}
+}
+class WasmHelperPlugin extends BuiltinPlugin {
+	constructor() {
+		super(import_binding$3.BindingBuiltinPluginName.WasmHelperPlugin);
+	}
+}
+class WasmFallbackPlugin extends BuiltinPlugin {
+	constructor() {
+		super(import_binding$3.BindingBuiltinPluginName.WasmFallbackPlugin);
+	}
+}
+class LoadFallbackPlugin extends BuiltinPlugin {
+	constructor() {
+		super(import_binding$3.BindingBuiltinPluginName.LoadFallbackPlugin);
+	}
+}
+class AliasPlugin extends BuiltinPlugin {
+	constructor(config) {
+		let normalizedAliasPluginConfig = normalizeAliasPluginConfig(config);
+		super(import_binding$3.BindingBuiltinPluginName.AliasPlugin, normalizedAliasPluginConfig);
+	}
+}
+class TransformPlugin extends BuiltinPlugin {
+	constructor(config) {
+		let normalizedConfig = normalizeEcmaTransformPluginConfig(config);
+		super(import_binding$3.BindingBuiltinPluginName.TransformPlugin, normalizedConfig);
+	}
+}
+class JsonPlugin extends BuiltinPlugin {
+	constructor(config) {
+		super(import_binding$3.BindingBuiltinPluginName.JsonPlugin, config);
+	}
+}
+class BuildImportAnalysisPlugin extends BuiltinPlugin {
+	constructor(config) {
+		super(import_binding$3.BindingBuiltinPluginName.BuildImportAnalysisPlugin, config);
+	}
+}
+class ReplacePlugin extends BuiltinPlugin {
+	constructor(config) {
+		super(import_binding$3.BindingBuiltinPluginName.ReplacePlugin, config);
+	}
+}
+function modulePreloadPolyfillPlugin(config) {
+	return new ModulePreloadPolyfillPlugin(config);
+}
+function dynamicImportVarsPlugin() {
+	return new DynamicImportVarsPlugin();
+}
+function importGlobPlugin(config) {
+	return new ImportGlobPlugin(config);
+}
+function manifestPlugin(config) {
+	return new ManifestPlugin(config);
+}
+function wasmHelperPlugin() {
+	return new WasmHelperPlugin();
+}
+function wasmFallbackPlugin() {
+	return new WasmFallbackPlugin();
+}
+function transformPlugin(config) {
+	return new TransformPlugin(config);
+}
+function loadFallbackPlugin() {
+	return new LoadFallbackPlugin();
+}
+function aliasPlugin(config) {
+	return new AliasPlugin(config);
+}
+function jsonPlugin(config) {
+	return new JsonPlugin(config);
+}
+function buildImportAnalysisPlugin(config) {
+	return new BuildImportAnalysisPlugin(config);
+}
+function replacePlugin(values = {}, options = {}) {
+	return new ReplacePlugin({
+		...options,
+		values
+	});
+}
+function bindingifyBuiltInPlugin(plugin) {
+	return {
+		__name: plugin.name,
+		options: plugin.options
+	};
+}
+
+//#endregion
+//#region src/options/bindingify-input-options.ts
+var import_binding$2 = __toESM(require_binding());
+function bindingifyInputOptions(options, outputOptions) {
+	const pluginContextData = new PluginContextData();
+	return {
+		input: bindingifyInput(options.input),
+		plugins: options.plugins.map((plugin) => {
+			if ("_parallel"in plugin) {
+				return undefined;
+			}
+			if (plugin instanceof BuiltinPlugin) {
+				return bindingifyBuiltInPlugin(plugin);
+			}
+			return bindingifyPlugin(plugin, options, outputOptions, pluginContextData);
+		}),
+		cwd: options.cwd ?? process.cwd(),
+		external: options.external ? function bindingifyExternal() {
+			const external = options.external;
+			if (typeof external === "function") {
+				return (id, importer, isResolved) => {
+					if (id.startsWith("\0")) return false;
+					return external(id, importer, isResolved) ?? false;
+				};
+			}
+			const externalArr = arraify(external);
+			return (id, _importer, _isResolved) => {
+				return externalArr.some((pat) => {
+					if (pat instanceof RegExp) {
+						return pat.test(id);
+					}
+					return id === pat;
+				});
+			};
+		}() : undefined,
+		resolve: options.resolve ? function bindingifyResolve() {
+			const { alias: alias,...rest } = options.resolve;
+			return {
+				alias: alias ? (Object.entries(alias)).map(([name, replacement]) => ({
+					find: name,
+					replacements: [replacement]
+				})) : undefined,
+				...rest
+			};
+		}() : undefined,
+		platform: options.platform,
+		shimMissingExports: options.shimMissingExports,
+		logLevel: bindingifyLogLevel(options.logLevel),
+		onLog: (level, log) => {
+			options.onLog(level, {
+				code: log.code,
+				message: log.message
+			});
+		},
+		treeshake: options.treeshake,
+		moduleTypes: options.moduleTypes,
+		define: options.define ? Object.entries(options.define) : undefined,
+		inject: options.inject ? (Object.entries(options.inject)).map(([alias, item]) => {
+			if (Array.isArray(item)) {
+				if (item[1] === "*") {
+					return {
+						tagNamespace: true,
+						alias,
+						from: item[0]
+					};
+				}
+				return {
+					tagNamed: true,
+					alias,
+					from: item[0],
+					imported: item[1]
+				};
+			} else {
+				return {
+					tagNamed: true,
+					imported: "default",
+					alias,
+					from: item
+				};
+			}
+		}) : undefined
+	};
+}
+function bindingifyLogLevel(logLevel) {
+	switch (logLevel) {
+		case "silent": return import_binding$2.BindingLogLevel.Silent;
+		case "warn": return import_binding$2.BindingLogLevel.Warn;
+		case "info": return import_binding$2.BindingLogLevel.Info;
+		case "debug": return import_binding$2.BindingLogLevel.Debug;
+		default: throw new Error(`Unexpected log level: ${logLevel}`);
+	}
+}
+function bindingifyInput(input) {
+	if (Array.isArray(input)) {
+		return input.map((src) => {
+			return {import: src};
+		});
+	} else {
+		return (Object.entries(input)).map((value) => {
+			return {
+				name: value[0],
+				import: value[1]
+			};
+		});
+	}
+}
+
+//#endregion
+//#region src/utils/initialize-parallel-plugins.ts
+var import_binding$1 = __toESM(require_binding());
+async function initializeParallelPlugins(plugins) {
+	const pluginInfos = [];
+	for (const [index, plugin] of plugins.entries()) {
+		if ("_parallel"in plugin) {
+			const { fileUrl: fileUrl, options: options } = plugin._parallel;
+			pluginInfos.push({
+				index,
+				fileUrl,
+				options
+			});
+		}
+	}
+	if (pluginInfos.length <= 0) {
+		return undefined;
+	}
+	const count = Math.min(availableParallelism(), 8);
+	const parallelJsPluginRegistry = new import_binding$1.ParallelJsPluginRegistry(count);
+	const registryId = parallelJsPluginRegistry.id;
+	const workers = await initializeWorkers(registryId, count, pluginInfos);
+	const stopWorkers = async () => {
+		await Promise.all(workers.map((worker) => worker.terminate()));
+	};
+	return {
+		registry: parallelJsPluginRegistry,
+		stopWorkers
+	};
+}
+function initializeWorkers(registryId, count, pluginInfos) {
+	return Promise.all(Array.from({length: count}, (_, i) => initializeWorker(registryId, pluginInfos, i)));
+}
+async function initializeWorker(registryId, pluginInfos, threadNumber) {
+	const urlString = import.meta.resolve("#parallel-plugin-worker");
+	const workerData = {
+		registryId,
+		pluginInfos,
+		threadNumber
+	};
+	let worker;
+	try {
+		worker = new Worker(new URL(urlString), {workerData});
+		worker.unref();
+		await new Promise((resolve, reject) => {
+			worker.once("message", async (message) => {
+				if (message.type === "error") {
+					reject(message.error);
+				} else {
+					resolve();
+				}
+			});
+		});
+		return worker;
+	} catch (e) {
+		worker?.terminate();
+		throw e;
+	}
+}
+
+//#endregion
+//#region src/log/logger.ts
+function getLogger(plugins, onLog, logLevel) {
+	const minimalPriority = logLevelPriority[logLevel];
+	const logger = (level, log, skipped = new Set()) => {
+		const logPriority = logLevelPriority[level];
+		if (logPriority < minimalPriority) {
+			return;
+		}
+		for (const plugin of plugins) {
+			if (skipped.has(plugin)) continue;
+			const { onLog: pluginOnLog } = plugin;
+			if (pluginOnLog) {
+				const getLogHandler$1 = (level$1) => {
+					if (logLevelPriority[level$1] < minimalPriority) {
+						return () => {};
+					}
+					return (log$1) => logger(level$1, normalizeLog(log$1), (new Set(skipped)).add(plugin));
+				};
+				const handler = "handler"in pluginOnLog ? pluginOnLog.handler : pluginOnLog;
+				if (handler.call({
+					debug: getLogHandler$1(LOG_LEVEL_DEBUG),
+					error: (log$1) => error(normalizeLog(log$1)),
+					info: getLogHandler$1(LOG_LEVEL_INFO),
+					warn: getLogHandler$1(LOG_LEVEL_WARN)
+				}, level, log) === false) {
+					return;
+				}
+			}
+		}
+		onLog(level, log);
+	};
+	return logger;
+}
+const getOnLog = (config, logLevel, printLog = defaultPrintLog) => {
+	const { onwarn: onwarn, onLog: onLog } = config;
+	const defaultOnLog = getDefaultOnLog(printLog, onwarn);
+	if (onLog) {
+		const minimalPriority = logLevelPriority[logLevel];
+		return (level, log) => onLog(level, addLogToString(log), (level$1, handledLog) => {
+			if (level$1 === LOG_LEVEL_ERROR) {
+				return error(normalizeLog(handledLog));
+			}
+			if (logLevelPriority[level$1] >= minimalPriority) {
+				defaultOnLog(level$1, normalizeLog(handledLog));
+			}
+		});
+	}
+	return defaultOnLog;
+};
+const getDefaultOnLog = (printLog, onwarn) => onwarn ? (level, log) => {
+	if (level === LOG_LEVEL_WARN) {
+		onwarn(addLogToString(log), (warning) => printLog(LOG_LEVEL_WARN, normalizeLog(warning)));
+	} else {
+		printLog(level, log);
+	}
+} : printLog;
+const addLogToString = (log) => {
+	Object.defineProperty(log, "toString", {
+		value: () => getExtendedLogMessage(log),
+		writable: true
+	});
+	return log;
+};
+const defaultPrintLog = (level, log) => {
+	const message = getExtendedLogMessage(log);
+	switch (level) {
+		case LOG_LEVEL_WARN: {
+			return console.warn(message);
+		}
+		case LOG_LEVEL_DEBUG: {
+			return console.debug(message);
+		}
+		default: {
+			return console.info(message);
+		}
+	}
+};
+const getExtendedLogMessage = (log) => {
+	let prefix = "";
+	if (log.plugin) {
+		prefix += `(${log.plugin} plugin) `;
+	}
+	if (log.loc) {
+		prefix += `${relativeId(log.loc.file)} (${log.loc.line}:${log.loc.column}) `;
+	}
+	return prefix + log.message;
+};
+function relativeId(id) {
+	if (!path.isAbsolute(id)) return id;
+	return path.relative(path.resolve(), id);
+}
+
+//#endregion
+//#region src/plugin/plugin-driver.ts
+class PluginDriver {
+	async callOptionsHook(inputOptions) {
+		const logLevel = inputOptions.logLevel || LOG_LEVEL_INFO;
+		const plugins = getObjectPlugins(inputOptions.plugins ?? []);
+		const logger = getLogger(plugins, getOnLog(inputOptions, logLevel), logLevel);
+		for (const plugin of plugins) {
+			const name = plugin.name || "unknown";
+			const options = plugin.options;
+			if (options) {
+				const { handler: handler } = normalizeHook(options);
+				const result = await handler.call({
+					debug: getLogHandler(LOG_LEVEL_DEBUG, "PLUGIN_LOG", logger, name, logLevel),
+					error: (e) => error(logPluginError(normalizeLog(e), name, {hook: "onLog"})),
+					info: getLogHandler(LOG_LEVEL_INFO, "PLUGIN_LOG", logger, name, logLevel),
+					warn: getLogHandler(LOG_LEVEL_WARN, "PLUGIN_WARNING", logger, name, logLevel)
+				}, inputOptions);
+				if (result) {
+					inputOptions = result;
+				}
+			}
+		}
+		return inputOptions;
+	}
+	callOutputOptionsHook(inputOptions, outputOptions) {
+		const plugins = getObjectPlugins(inputOptions.plugins);
+		for (const plugin of plugins) {
+			const options = plugin.outputOptions;
+			if (options) {
+				const { handler: handler } = normalizeHook(options);
+				const result = handler.call(null, outputOptions);
+				if (result) {
+					outputOptions = result;
+				}
+			}
+		}
+		return outputOptions;
+	}
+}
+function getObjectPlugins(plugins) {
+	return plugins.filter((plugin) => {
+		if ("_parallel"in plugin) {
+			return undefined;
+		}
+		if (plugin instanceof BuiltinPlugin) {
+			return undefined;
+		}
+		return plugin;
+	});
+}
+
+//#endregion
+//#region src/utils/async-flatten.ts
+async function asyncFlatten(array) {
+	do {
+		array = (await Promise.all(array)).flat(Infinity);
+	} while (array.some((v) => v?.then));
+	return array;
+}
+
+//#endregion
+//#region src/utils/normalize-plugin-option.ts
+const normalizePluginOption = async (plugins) => (await asyncFlatten([plugins])).filter(Boolean);
+
+//#endregion
+//#region src/utils/normalize-tree-shake.ts
+function normalizeTreeshakeOptions(config) {
+	if (config === false) {
+		return undefined;
+	}
+	if (config === true || config === undefined) {
+		return {moduleSideEffects: "true"};
+	}
+	let normalizedConfig = {moduleSideEffects: ""};
+	if (config.moduleSideEffects === undefined) {
+		normalizedConfig.moduleSideEffects = "true";
+	} else if (isRegExp(config.moduleSideEffects)) {
+		normalizedConfig.moduleSideEffects = config.moduleSideEffects.source;
+	} else {
+		normalizedConfig.moduleSideEffects = config.moduleSideEffects.toString();
+	}
+	return normalizedConfig;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.11.0/node_modules/remeda/dist/chunk-K26VP6CL.js
+function u$1(t$1, n, a) {
+	let o = (r) => t$1(r, ...n);
+	return a === void 0 ? o : Object.assign(o, {
+		lazy: a,
+		lazyArgs: n
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.11.0/node_modules/remeda/dist/chunk-RAAYCPUM.js
+function u(r, n, a) {
+	let o = r.length - n.length;
+	if (o === 0) return r(...n);
+	if (o === 1) return u$1(r, n, a);
+	throw new Error("Wrong number of arguments");
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.11.0/node_modules/remeda/dist/chunk-NMJS7ULY.js
+function t(...n) {
+	return u(Object.keys, n);
+}
+
+//#endregion
+//#region src/constants/plugin.ts
+const ENUMERATED_PLUGIN_HOOK_NAMES = ["options", "buildStart", "resolveId", "load", "transform", "moduleParsed", "augmentChunkHash", "buildEnd", "onLog", "resolveDynamicImport", "generateBundle", "outputOptions", "renderChunk", "renderStart", "renderError", "writeBundle", "footer", "banner", "intro", "outro",];
+const DEFINED_HOOK_NAMES = {
+	[ENUMERATED_PLUGIN_HOOK_NAMES[0]]: ENUMERATED_PLUGIN_HOOK_NAMES[0],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[1]]: ENUMERATED_PLUGIN_HOOK_NAMES[1],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[2]]: ENUMERATED_PLUGIN_HOOK_NAMES[2],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[3]]: ENUMERATED_PLUGIN_HOOK_NAMES[3],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[4]]: ENUMERATED_PLUGIN_HOOK_NAMES[4],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[5]]: ENUMERATED_PLUGIN_HOOK_NAMES[5],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[6]]: ENUMERATED_PLUGIN_HOOK_NAMES[6],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[7]]: ENUMERATED_PLUGIN_HOOK_NAMES[7],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[8]]: ENUMERATED_PLUGIN_HOOK_NAMES[8],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[9]]: ENUMERATED_PLUGIN_HOOK_NAMES[9],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[10]]: ENUMERATED_PLUGIN_HOOK_NAMES[10],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[11]]: ENUMERATED_PLUGIN_HOOK_NAMES[11],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[12]]: ENUMERATED_PLUGIN_HOOK_NAMES[12],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[13]]: ENUMERATED_PLUGIN_HOOK_NAMES[13],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[14]]: ENUMERATED_PLUGIN_HOOK_NAMES[14],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[15]]: ENUMERATED_PLUGIN_HOOK_NAMES[15],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[16]]: ENUMERATED_PLUGIN_HOOK_NAMES[16],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[17]]: ENUMERATED_PLUGIN_HOOK_NAMES[17],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[18]]: ENUMERATED_PLUGIN_HOOK_NAMES[18],
+	[ENUMERATED_PLUGIN_HOOK_NAMES[19]]: ENUMERATED_PLUGIN_HOOK_NAMES[19]
+};
+
+//#endregion
+//#region src/utils/plugin/index.ts
+const isPluginHookName = function() {
+	const PLUGIN_HOOK_NAMES_SET = new Set(ENUMERATED_PLUGIN_HOOK_NAMES);
+	return function isPluginHookName$1(hookName) {
+		return PLUGIN_HOOK_NAMES_SET.has(hookName);
+	};
+}();
+
+//#endregion
+//#region src/utils/compose-js-plugins.ts
+const unsupportedHookName = ["augmentChunkHash", "generateBundle", "moduleParsed", "onLog", "options", "outputOptions", "renderError", "renderStart", "resolveDynamicImport", "writeBundle",];
+const unsupportedHooks = new Set(unsupportedHookName);
+function isUnsupportedHooks(hookName) {
+	return unsupportedHooks.has(hookName);
+}
+function createComposedPlugin(plugins) {
+	const names = [];
+	const batchedHooks = {};
+	plugins.forEach((plugin, index) => {
+		const pluginName = plugin.name || `Anonymous(index: ${index})`;
+		names.push(pluginName);
+		(t(plugin)).forEach((pluginProp) => {
+			if (isUnsupportedHooks(pluginProp)) {
+				throw new Error(`Failed to compose js plugins. Plugin ${pluginName} has an unsupported hook: ${pluginProp}`);
+			}
+			if (!isPluginHookName(pluginProp)) {
+				return;
+			}
+			switch (pluginProp) {
+				case "buildStart": {
+					const handlers = batchedHooks.buildStart ?? [];
+					batchedHooks.buildStart = handlers;
+					if (plugin.buildStart) {
+						handlers.push([plugin.buildStart, plugin]);
+					}
+					break;
+				}
+				case "load": {
+					const handlers = batchedHooks.load ?? [];
+					batchedHooks.load = handlers;
+					if (plugin.load) {
+						handlers.push([plugin.load, plugin]);
+					}
+					break;
+				}
+				case "transform": {
+					const handlers = batchedHooks.transform ?? [];
+					batchedHooks.transform = handlers;
+					if (plugin.transform) {
+						handlers.push([plugin.transform, plugin]);
+					}
+					break;
+				}
+				case "resolveId": {
+					const handlers = batchedHooks.resolveId ?? [];
+					batchedHooks.resolveId = handlers;
+					if (plugin.resolveId) {
+						handlers.push([plugin.resolveId, plugin]);
+					}
+					break;
+				}
+				case "buildEnd": {
+					const handlers = batchedHooks.buildEnd ?? [];
+					batchedHooks.buildEnd = handlers;
+					if (plugin.buildEnd) {
+						handlers.push([plugin.buildEnd, plugin]);
+					}
+					break;
+				}
+				case "renderChunk": {
+					const handlers = batchedHooks.renderChunk ?? [];
+					batchedHooks.renderChunk = handlers;
+					if (plugin.renderChunk) {
+						handlers.push([plugin.renderChunk, plugin]);
+					}
+					break;
+				}
+				case "banner":
+				case "footer":
+				case "intro":
+				case "outro": {
+					const hook = plugin[pluginProp];
+					if (hook) {
+						;
+						(batchedHooks[pluginProp] ??= []).push([hook, plugin]);
+					}
+					break;
+				}
+				default: {}
+			}
+		});
+	});
+	const composed = {name: `Composed(${names.join(", ")})`};
+	const createFixedPluginResolveFnMap = new Map();
+	function applyFixedPluginResolveFn(ctx, plugin) {
+		const createFixedPluginResolveFn = createFixedPluginResolveFnMap.get(plugin);
+		if (createFixedPluginResolveFn) {
+			return {
+				...ctx,
+				resolve: createFixedPluginResolveFn(ctx)
+			};
+		}
+		return ctx;
+	}
+	if (batchedHooks.resolveId) {
+		const batchedHandlers = batchedHooks.resolveId;
+		const handlerSymbols = batchedHandlers.map(([_handler, plugin]) => Symbol(plugin.name ?? `Anonymous`));
+		for (let handlerIdx = 0; handlerIdx < batchedHandlers.length; handlerIdx++) {
+			const [_handler, plugin] = batchedHandlers[handlerIdx];
+			const handlerSymbol = handlerSymbols[handlerIdx];
+			const createFixedPluginResolveFn = (ctx) => {
+				return (source, importer, rawContextResolveOptions) => {
+					const contextResolveOptions = rawContextResolveOptions ?? {};
+					if (contextResolveOptions.skipSelf) {
+						contextResolveOptions[SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF] = handlerSymbol;
+						contextResolveOptions.skipSelf = false;
+					}
+					return ctx.resolve(source, importer, contextResolveOptions);
+				};
+			};
+			createFixedPluginResolveFnMap.set(plugin, createFixedPluginResolveFn);
+		}
+		composed.resolveId = async function(source, importer, rawHookResolveIdOptions) {
+			const hookResolveIdOptions = rawHookResolveIdOptions;
+			const symbolForCallerThatSkipSelf = hookResolveIdOptions?.[SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF];
+			for (let handlerIdx = 0; handlerIdx < batchedHandlers.length; handlerIdx++) {
+				const [handler, plugin] = batchedHandlers[handlerIdx];
+				const handlerSymbol = handlerSymbols[handlerIdx];
+				if (symbolForCallerThatSkipSelf === handlerSymbol) {
+					continue;
+				}
+				const { handler: handlerFn } = normalizeHook(handler);
+				const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), source, importer, rawHookResolveIdOptions);
+				if (!isNullish(result)) {
+					return result;
+				}
+			}
+		};
+	}
+	(t(batchedHooks)).forEach((hookName) => {
+		switch (hookName) {
+			case "resolveId": {
+				break;
+			}
+			case "buildStart": {
+				if (batchedHooks.buildStart) {
+					const batchedHandlers = batchedHooks.buildStart;
+					composed.buildStart = async function(options) {
+						await Promise.all(batchedHandlers.map(([handler, plugin]) => {
+							const { handler: handlerFn } = normalizeHook(handler);
+							return handlerFn.call(applyFixedPluginResolveFn(this, plugin), options);
+						}));
+					};
+				}
+				break;
+			}
+			case "load": {
+				if (batchedHooks.load) {
+					const batchedHandlers = batchedHooks.load;
+					composed.load = async function(id) {
+						for (const [handler, plugin] of batchedHandlers) {
+							const { handler: handlerFn } = normalizeHook(handler);
+							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), id);
+							if (!isNullish(result)) {
+								return result;
+							}
+						}
+					};
+				}
+				break;
+			}
+			case "transform": {
+				if (batchedHooks.transform) {
+					const batchedHandlers = batchedHooks.transform;
+					composed.transform = async function(initialCode, id, moduleType) {
+						let code = initialCode;
+						let moduleSideEffects = undefined;
+						function updateOutput(newCode, newModuleSideEffects) {
+							code = newCode;
+							moduleSideEffects = newModuleSideEffects ?? undefined;
+						}
+						for (const [handler, plugin] of batchedHandlers) {
+							const { handler: handlerFn } = normalizeHook(handler);
+							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), code, id, moduleType);
+							if (!isNullish(result)) {
+								if (typeof result === "string") {
+									updateOutput(result);
+								} else {
+									if (result.code) {
+										updateOutput(result.code, result.moduleSideEffects);
+									}
+								}
+							}
+						}
+						return {
+							code,
+							moduleSideEffects
+						};
+					};
+				}
+				break;
+			}
+			case "buildEnd": {
+				if (batchedHooks.buildEnd) {
+					const batchedHandlers = batchedHooks.buildEnd;
+					composed.buildEnd = async function(err) {
+						await Promise.all(batchedHandlers.map(([handler, plugin]) => {
+							const { handler: handlerFn } = normalizeHook(handler);
+							return handlerFn.call(applyFixedPluginResolveFn(this, plugin), err);
+						}));
+					};
+				}
+				break;
+			}
+			case "renderChunk": {
+				if (batchedHooks.renderChunk) {
+					const batchedHandlers = batchedHooks.renderChunk;
+					composed.renderChunk = async function(code, chunk, options) {
+						for (const [handler, plugin] of batchedHandlers) {
+							const { handler: handlerFn } = normalizeHook(handler);
+							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), code, chunk, options);
+							if (!isNullish(result)) {
+								return result;
+							}
+						}
+					};
+				}
+				break;
+			}
+			case "banner":
+			case "footer":
+			case "intro":
+			case "outro": {
+				const hooks = batchedHooks[hookName];
+				if (hooks?.length) {
+					composed[hookName] = async function(chunk) {
+						const ret = [];
+						for (const [hook, plugin] of hooks) {
+							{
+								const { handler: handler } = normalizeHook(hook);
+								ret.push(typeof handler === "string" ? handler : await handler.call(applyFixedPluginResolveFn(this, plugin), chunk));
+							}
+						}
+						return ret.join("\n");
+					};
+				}
+				break;
+			}
+			default: {}
+		}
+	});
+	return composed;
+}
+function isComposablePlugin(plugin) {
+	if (plugin instanceof BuiltinPlugin) {
+		return false;
+	}
+	if ("_parallel"in plugin) {
+		return false;
+	}
+	const hasNotComposablePattern = (t(plugin)).some((hookName) => {
+		if (!isPluginHookName(hookName)) {
+			return false;
+		}
+		const OK_TO_COMPOSE = false;
+		if (isUnsupportedHooks(hookName)) {
+			return !OK_TO_COMPOSE;
+		}
+		if (plugin[hookName]) {
+			const { meta: meta } = normalizeHook(plugin[hookName]);
+			if (meta.order === "pre" || meta.order === "post") {
+				return !OK_TO_COMPOSE;
+			}
+		}
+		return OK_TO_COMPOSE;
+	});
+	if (hasNotComposablePattern) {
+		return false;
+	}
+	return true;
+}
+function composeJsPlugins(plugins) {
+	const newPlugins = [];
+	const toBeComposed = [];
+	plugins.forEach((plugin) => {
+		if (isComposablePlugin(plugin)) {
+			toBeComposed.push(plugin);
+		} else {
+			if (toBeComposed.length > 0) {
+				if (toBeComposed.length > 1) {
+					newPlugins.push(createComposedPlugin(toBeComposed));
+				} else {
+					newPlugins.push(toBeComposed[0]);
+				}
+				toBeComposed.length = 0;
+			}
+			newPlugins.push(plugin);
+		}
+	});
+	if (toBeComposed.length > 0) {
+		if (toBeComposed.length > 1) {
+			newPlugins.push(createComposedPlugin(toBeComposed));
+		} else {
+			newPlugins.push(toBeComposed[0]);
+		}
+		toBeComposed.length = 0;
+	}
+	return newPlugins;
+}
+
+//#endregion
+//#region src/utils/normalize-input-options.ts
+async function normalizeInputOptions(config) {
+	const { input: input,...rest } = config;
+	let plugins = await normalizePluginOption(config.plugins);
+	if (rest.experimental?.enableComposingJsPlugins ?? false) {
+		plugins = composeJsPlugins(plugins);
+	}
+	const treeshake = normalizeTreeshakeOptions(config.treeshake);
+	const logLevel = config.logLevel || LOG_LEVEL_INFO;
+	const onLog = getLogger(getObjectPlugins(plugins), getOnLog(config, logLevel), logLevel);
+	return {
+		...rest,
+		input: input ? typeof input === "string" ? [input] : input : [],
+		plugins,
+		logLevel,
+		onLog,
+		treeshake
+	};
+}
+
+//#endregion
+//#region src/utils/normalize-output-options.ts
+function normalizeOutputOptions(opts) {
+	const { dir: dir, format: format, exports: exports, sourcemap: sourcemap, sourcemapIgnoreList: sourcemapIgnoreList, sourcemapPathTransform: sourcemapPathTransform, globals: globals, entryFileNames: entryFileNames, chunkFileNames: chunkFileNames, assetFileNames: assetFileNames, name: name, esModule: esModule } = opts;
+	return {
+		dir: dir,
+		format: getFormat(format),
+		exports: exports ?? "auto",
+		sourcemap: sourcemap ?? false,
+		sourcemapIgnoreList: typeof sourcemapIgnoreList === "function" ? sourcemapIgnoreList : sourcemapIgnoreList === false ? () => false : (relativeSourcePath, _sourcemapPath) => relativeSourcePath.includes("node_modules"),
+		sourcemapPathTransform,
+		banner: getAddon(opts, "banner"),
+		footer: getAddon(opts, "footer"),
+		intro: getAddon(opts, "intro"),
+		outro: getAddon(opts, "outro"),
+		esModule: esModule ?? "if-default-prop",
+		globals: globals ?? {},
+		entryFileNames: entryFileNames ?? "[name].js",
+		chunkFileNames: chunkFileNames ?? "[name]-[hash].js",
+		assetFileNames: assetFileNames ?? "assets/[name]-[hash][extname]",
+		plugins: [],
+		minify: opts.minify,
+		extend: opts.extend,
+		name,
+		externalLiveBindings: opts.externalLiveBindings ?? true,
+		inlineDynamicImports: opts.inlineDynamicImports ?? false
+	};
+}
+function getFormat(format) {
+	switch (format) {
+		case undefined:
+		case "es":
+		case "esm":
+		case "module": {
+			return "es";
+		}
+		case "cjs":
+		case "commonjs": {
+			return "cjs";
+		}
+		case "iife": {
+			return "iife";
+		}
+		default: unimplemented(`output.format: ${format}`);
+	}
+}
+const getAddon = (config, name) => {
+	return async (chunk) => {
+		const configAddon = config[name];
+		if (typeof configAddon === "function") {
+			return configAddon(chunk);
+		}
+		return configAddon || "";
+	};
+};
+
+//#endregion
+//#region src/options/bindingify-output-options.ts
+function bindingifyOutputOptions(outputOptions) {
+	const { dir: dir, format: format, exports: exports, sourcemap: sourcemap, sourcemapIgnoreList: sourcemapIgnoreList, sourcemapPathTransform: sourcemapPathTransform, name: name, entryFileNames: entryFileNames, chunkFileNames: chunkFileNames, assetFileNames: assetFileNames, banner: banner, footer: footer, intro: intro, outro: outro, esModule: esModule, globals: globals } = outputOptions;
+	return {
+		dir,
+		format: function() {
+			switch (format) {
+				case "es": return "es";
+				case "cjs": return "cjs";
+				case "iife": return "iife";
+			}
+		}(),
+		exports,
+		sourcemap: bindingifySourcemap(sourcemap),
+		sourcemapIgnoreList,
+		sourcemapPathTransform,
+		banner,
+		footer,
+		intro,
+		outro,
+		extend: outputOptions.extend,
+		globals,
+		esModule: bindingifyEsModule(esModule),
+		name,
+		entryFileNames,
+		chunkFileNames,
+		assetFileNames,
+		plugins: [],
+		minify: outputOptions.minify,
+		externalLiveBindings: outputOptions.externalLiveBindings,
+		inlineDynamicImports: outputOptions.inlineDynamicImports
+	};
+}
+function bindingifySourcemap(sourcemap) {
+	switch (sourcemap) {
+		case true: return "file";
+		case "inline": return "inline";
+		case false:
+		case undefined:
+		case "hidden": return "hidden";
+		default: throw new Error(`unknown sourcemap: ${sourcemap}`);
+	}
+}
+function bindingifyEsModule(esModule) {
+	switch (esModule) {
+		case true:
+		case false:
+		case "if-default-prop": return esModule;
+		default: throw new Error(`unknown esModule: ${esModule}`);
+	}
+}
+
+//#endregion
+//#region src/utils/create-bundler.ts
+var import_binding = __toESM(require_binding());
+async function createBundler(inputOptions, outputOptions) {
+	const pluginDriver = new PluginDriver();
+	inputOptions = await pluginDriver.callOptionsHook(inputOptions);
+	const normalizedInputOptions = await normalizeInputOptions(inputOptions);
+	const parallelPluginInitResult = await initializeParallelPlugins(normalizedInputOptions.plugins);
+	try {
+		outputOptions = pluginDriver.callOutputOptionsHook(normalizedInputOptions, outputOptions);
+		const normalizedOutputOptions = normalizeOutputOptions(outputOptions);
+		const bindingInputOptions = bindingifyInputOptions(normalizedInputOptions, normalizedOutputOptions);
+		return {
+			bundler: new import_binding.Bundler(bindingInputOptions, bindingifyOutputOptions(normalizedOutputOptions), parallelPluginInitResult?.registry),
+			stopWorkers: parallelPluginInitResult?.stopWorkers
+		};
+	} catch (e) {
+		await parallelPluginInitResult?.stopWorkers();
+		throw e;
+	}
+}
+
+//#endregion
+//#region src/rolldown-build.ts
+class RolldownBuild {
+	#inputOptions;
+	#bundler;
+	#stopWorkers;
+	constructor(inputOptions) {
+		this.#inputOptions = inputOptions;
+	}
+	async #getBundler(outputOptions) {
+		if (typeof this.#bundler === "undefined") {
+			const { bundler: bundler, stopWorkers: stopWorkers } = await createBundler(this.#inputOptions, outputOptions);
+			this.#bundler = bundler;
+			this.#stopWorkers = stopWorkers;
+		}
+		return this.#bundler;
+	}
+	async generate(outputOptions = {}) {
+		const bundler = await this.#getBundler(outputOptions);
+		const output = await bundler.generate();
+		return transformToRollupOutput(output);
+	}
+	async write(outputOptions = {}) {
+		const bundler = await this.#getBundler(outputOptions);
+		const output = await bundler.write();
+		return transformToRollupOutput(output);
+	}
+	async destroy() {
+		await this.#stopWorkers?.();
+	}
+}
+
+//#endregion
+//#region src/rolldown.ts
+const rolldown = async (input) => {
+	return new RolldownBuild(input);
+};
+const experimental_scan = async (input) => {
+	const { bundler: bundler, stopWorkers: stopWorkers } = await createBundler(input, {});
+	await bundler.scan();
+	await stopWorkers?.();
+};
+
+//#endregion
+export { aliasPlugin, buildImportAnalysisPlugin, composeJsPlugins, dynamicImportVarsPlugin, experimental_scan, importGlobPlugin, jsonPlugin, loadFallbackPlugin, manifestPlugin, modulePreloadPolyfillPlugin, replacePlugin, rolldown, transformPlugin, wasmFallbackPlugin, wasmHelperPlugin };