rolldown 0.13.2 → 0.14.0

package/dist/shared/rolldown-Hf7txSlh.mjs

@@ -1,1071 +0,0 @@
-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, normalizedStringOrRegex, require_binding, transformToRollupOutput, unimplemented } from "./plugin-context-data-iKSAvmTX.mjs";
-import { default as path } from "node:path";
-import { isRegExp, isRegExp as isRegExp$1 } 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,
-		exclude: normalizedStringOrRegex(config.exclude),
-		include: normalizedStringOrRegex(config.include)
-	};
-	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,
-		advancedChunks: opts.advancedChunks
-	};
-}
-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,
-		advancedChunks: outputOptions.advancedChunks
-	};
-}
-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 };