rolldown 0.14.0-snapshot-ab438c3-20241121003459 → 0.14.0-snapshot-db4090b-20241123003628

package/dist/shared/{src_index-Yt-qn7mE.cjs → src_index-WgTHG2Z9.cjs}

@@ -1,6 +1,6 @@
 const { __commonJSMin, __toESM } = require("./chunk-JoMxl5V2.cjs");
-const { default: path, default: path$1 } = __toESM(require("node:path"));
 const { z, z: z$1 } = __toESM(require("zod"));
+const { default: path, default: path$1 } = __toESM(require("node:path"));
 const { Worker } = __toESM(require("node:worker_threads"));
 const { availableParallelism } = __toESM(require("node:os"));
 
@@ -45,6 +45,60 @@ function transformToRenderedModule(bindingRenderedModule) {
 	};
 }
 
+//#endregion
+//#region src/utils/error.ts
+function normalizeErrors(rawErrors) {
+	const errors = rawErrors.map((e) => e instanceof Error ? e : Object.assign(new Error(), e, {stack: undefined}));
+	let summary = `Build failed with ${errors.length} error${errors.length < 2 ? "" : "s"}:\n`;
+	for (let i = 0; i < errors.length; i++) {
+		if (i >= 5) {
+			summary += "\n...";
+			break;
+		}
+		summary += getErrorMessage(errors[i]) + "\n";
+	}
+	const wrapper = new Error(summary);
+	Object.defineProperty(wrapper, "errors", {
+		configurable: true,
+		enumerable: true,
+		get: () => errors,
+		set: (value) => Object.defineProperty(wrapper, "errors", {
+			configurable: true,
+			enumerable: true,
+			value
+		})
+	});
+	return wrapper;
+}
+function getErrorMessage(e) {
+	let s = "";
+	if (e.plugin) {
+		s += `[plugin ${e.plugin}]`;
+	}
+	const id = e.id ?? e.loc?.file;
+	if (id) {
+		s += " " + id;
+		if (e.loc) {
+			s += `:${e.loc.line}:${e.loc.column}`;
+		}
+	}
+	if (s) {
+		s += "\n";
+	}
+	const message = `${e.name ?? "Error"}: ${e.message}`;
+	s += message;
+	if (e.frame) {
+		s = joinNewLine(s, e.frame);
+	}
+	if (e.stack) {
+		s = joinNewLine(s, e.stack.replace(message, ""));
+	}
+	return s;
+}
+function joinNewLine(s1, s2) {
+	return s1.replace(/\n+$/, "") + "\n" + s2.replace(/^\n+/, "");
+}
+
 //#endregion
 //#region src/utils/transform-to-rollup-output.ts
 function transformToRollupOutputChunk(bindingChunk, changed) {
@@ -125,56 +179,8 @@ function transformToRollupOutput(output, changed) {
 function handleOutputErrors(output) {
 	const rawErrors = output.errors;
 	if (rawErrors.length > 0) {
-		const errors = rawErrors.map((e) => e instanceof Error ? e : Object.assign(new Error(), e, {stack: undefined}));
-		let summary = `Build failed with ${errors.length} error${errors.length < 2 ? "" : "s"}:\n`;
-		for (let i = 0; i < errors.length; i++) {
-			if (i >= 5) {
-				summary += "\n...";
-				break;
-			}
-			summary += getErrorMessage(errors[i]) + "\n";
-		}
-		const wrapper = new Error(summary);
-		Object.defineProperty(wrapper, "errors", {
-			configurable: true,
-			enumerable: true,
-			get: () => errors,
-			set: (value) => Object.defineProperty(wrapper, "errors", {
-				configurable: true,
-				enumerable: true,
-				value
-			})
-		});
-		throw wrapper;
-	}
-}
-function getErrorMessage(e) {
-	let s = "";
-	if (e.plugin) {
-		s += `[plugin ${e.plugin}]`;
-	}
-	const id = e.id ?? e.loc?.file;
-	if (id) {
-		s += " " + id;
-		if (e.loc) {
-			s += `:${e.loc.line}:${e.loc.column}`;
-		}
-	}
-	if (s) {
-		s += "\n";
-	}
-	const message = `${e.name ?? "Error"}: ${e.message}`;
-	s += message;
-	if (e.frame) {
-		s = joinNewLine(s, e.frame);
+		throw normalizeErrors(rawErrors);
 	}
-	if (e.stack) {
-		s = joinNewLine(s, e.stack.replace(message, ""));
-	}
-	return s;
-}
-function joinNewLine(s1, s2) {
-	return s1.replace(/\n+$/, "") + "\n" + s2.replace(/^\n+/, "");
 }
 function transformToOutputBundle(output, changed) {
 	const bundle = Object.fromEntries((transformToRollupOutput(output, changed)).output.map((item) => [item.fileName, item,]));
@@ -566,14 +572,13 @@ var require_binding = __commonJSMin((exports, module) => {
 	module.exports.BindingTransformPluginContext = nativeBinding.BindingTransformPluginContext;
 	module.exports.BindingWatcher = nativeBinding.BindingWatcher;
 	module.exports.BindingWatcherChangeData = nativeBinding.BindingWatcherChangeData;
-	module.exports.BindingWatcherEventData = nativeBinding.BindingWatcherEventData;
+	module.exports.BindingWatcherEvent = nativeBinding.BindingWatcherEvent;
 	module.exports.Bundler = nativeBinding.Bundler;
 	module.exports.ParallelJsPluginRegistry = nativeBinding.ParallelJsPluginRegistry;
 	module.exports.BindingBuiltinPluginName = nativeBinding.BindingBuiltinPluginName;
 	module.exports.BindingHookSideEffects = nativeBinding.BindingHookSideEffects;
 	module.exports.BindingLogLevel = nativeBinding.BindingLogLevel;
 	module.exports.BindingPluginOrder = nativeBinding.BindingPluginOrder;
-	module.exports.BindingWatcherEvent = nativeBinding.BindingWatcherEvent;
 	module.exports.isCallableCompatibleBuiltinPlugin = nativeBinding.isCallableCompatibleBuiltinPlugin;
 	module.exports.isolatedDeclaration = nativeBinding.isolatedDeclaration;
 	module.exports.registerPlugins = nativeBinding.registerPlugins;
@@ -607,58 +612,6 @@ function unsupported(info) {
 }
 function noop(..._args) {}
 
-//#endregion
-//#region src/utils/normalize-hook.ts
-function normalizeHook(hook) {
-	if (typeof hook === "function" || typeof hook === "string") {
-		return {
-			handler: hook,
-			options: {},
-			meta: {}
-		};
-	} else if (typeof hook === "object" && hook !== null) {
-		const { handler: handler, order: order,...options } = hook;
-		return {
-			handler,
-			options,
-			meta: {order}
-		};
-	}
-	unreachable("Invalid hook type");
-}
-
-//#endregion
-//#region src/utils/transform-sourcemap.ts
-function isEmptySourcemapFiled(array) {
-	if (!array) {
-		return true;
-	}
-	if (array.length === 0 || !array[0]) {
-		return true;
-	}
-	return false;
-}
-
-//#endregion
-//#region src/utils/transform-module-info.ts
-function transformModuleInfo(info, option) {
-	return {
-		get ast() {
-			return unsupported("ModuleInfo#ast");
-		},
-		get code() {
-			return info.code;
-		},
-		id: info.id,
-		importers: info.importers,
-		dynamicImporters: info.dynamicImporters,
-		importedIds: info.importedIds,
-		dynamicallyImportedIds: info.dynamicallyImportedIds,
-		isEntry: info.isEntry,
-		...option
-	};
-}
-
 //#endregion
 //#region src/log/logging.ts
 const LogLevelSchema = ((z$1.literal("info")).or(z$1.literal("debug"))).or(z$1.literal("warn"));
@@ -846,107 +799,248 @@ function getLogHandler(level, code, logger, pluginName, logLevel) {
 }
 
 //#endregion
-//#region src/utils/normalize-string-or-regex.ts
-function normalizedStringOrRegex(pattern) {
-	if (!pattern) {
-		return undefined;
-	}
-	if (!Array.isArray(pattern)) {
-		pattern = [pattern];
-	}
-	return pattern;
-}
-
-//#endregion
-//#region src/options/normalized-ecma-transform-plugin-config.ts
-function normalizeEcmaTransformPluginConfig(config) {
-	if (!config) {
-		return undefined;
+//#region src/utils/normalize-hook.ts
+function normalizeHook(hook) {
+	if (typeof hook === "function" || typeof hook === "string") {
+		return {
+			handler: hook,
+			options: {},
+			meta: {}
+		};
+	} else if (typeof hook === "object" && hook !== null) {
+		const { handler: handler, order: order,...options } = hook;
+		return {
+			handler,
+			options,
+			meta: {order}
+		};
 	}
-	let normalizedConfig = {
-		jsxInject: config?.jsxInject,
-		exclude: normalizedStringOrRegex(config.exclude),
-		include: normalizedStringOrRegex(config.include),
-		targets: config.targets
-	};
-	return normalizedConfig;
+	unreachable("Invalid hook type");
 }
 
 //#endregion
-//#region src/plugin/builtin-plugin.ts
-var import_binding$6 = __toESM(require_binding());
-class BuiltinPlugin {
-	constructor(name, options) {
-		this.name = name;
-		this.options = options;
-		this.name = name;
-		this.options = options;
+//#region src/log/logger.ts
+class MinimalPluginContext {
+	info;
+	warn;
+	debug;
+	meta;
+	error;
+	constructor(options, plugin) {
+		const onLog = options.onLog;
+		const pluginName = plugin.name || "unknown";
+		const logLevel = options.logLevel || LOG_LEVEL_INFO;
+		this.debug = getLogHandler(LOG_LEVEL_DEBUG, "PLUGIN_LOG", onLog, pluginName, logLevel);
+		this.info = getLogHandler(LOG_LEVEL_INFO, "PLUGIN_LOG", onLog, pluginName, logLevel);
+		this.warn = getLogHandler(LOG_LEVEL_WARN, "PLUGIN_WARNING", onLog, pluginName, logLevel);
+		this.error = (e) => {
+			return error(logPluginError(normalizeLog(e), pluginName));
+		};
+		this.meta = {
+			rollupVersion: "4.23.0",
+			rolldownVersion: VERSION,
+			watchMode: false
+		};
 	}
 }
-class ModulePreloadPolyfillPlugin extends BuiltinPlugin {
-	constructor(config) {
-		super(import_binding$6.BindingBuiltinPluginName.ModulePreloadPolyfillPlugin, config);
-	}
+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 getSortedPlugins("onLog", 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),
+					meta: {
+						rollupVersion: "4.23.0",
+						rolldownVersion: VERSION,
+						watchMode: false
+					},
+					warn: getLogHandler$1(LOG_LEVEL_WARN)
+				}, level, log) === false) {
+					return;
+				}
+			}
+		}
+		onLog(level, log);
+	};
+	return logger;
 }
-class DynamicImportVarsPlugin extends BuiltinPlugin {
-	constructor() {
-		super(import_binding$6.BindingBuiltinPluginName.DynamicImportVarsPlugin);
+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));
+			}
+		});
 	}
-}
-class ImportGlobPlugin extends BuiltinPlugin {
-	constructor(config) {
-		super(import_binding$6.BindingBuiltinPluginName.ImportGlobPlugin, config);
+	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$1.isAbsolute(id)) return id;
+	return path$1.relative(path$1.resolve(), id);
+}
+
+//#endregion
+//#region src/utils/normalize-string-or-regex.ts
+function normalizedStringOrRegex(pattern) {
+	if (!pattern) {
+		return undefined;
+	}
+	if (!Array.isArray(pattern)) {
+		pattern = [pattern];
+	}
+	return pattern;
+}
+
+//#endregion
+//#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),
+		targets: config.targets
+	};
+	return normalizedConfig;
+}
+
+//#endregion
+//#region src/plugin/builtin-plugin.ts
+var import_binding$5 = __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$5.BindingBuiltinPluginName.ModulePreloadPolyfillPlugin, config);
+	}
+}
+class DynamicImportVarsPlugin extends BuiltinPlugin {
+	constructor() {
+		super(import_binding$5.BindingBuiltinPluginName.DynamicImportVarsPlugin);
+	}
+}
+class ImportGlobPlugin extends BuiltinPlugin {
+	constructor(config) {
+		super(import_binding$5.BindingBuiltinPluginName.ImportGlobPlugin, config);
 	}
 }
 class ManifestPlugin extends BuiltinPlugin {
 	constructor(config) {
-		super(import_binding$6.BindingBuiltinPluginName.ManifestPlugin, config);
+		super(import_binding$5.BindingBuiltinPluginName.ManifestPlugin, config);
 	}
 }
 class WasmHelperPlugin extends BuiltinPlugin {
 	constructor() {
-		super(import_binding$6.BindingBuiltinPluginName.WasmHelperPlugin);
+		super(import_binding$5.BindingBuiltinPluginName.WasmHelperPlugin);
 	}
 }
 class WasmFallbackPlugin extends BuiltinPlugin {
 	constructor() {
-		super(import_binding$6.BindingBuiltinPluginName.WasmFallbackPlugin);
+		super(import_binding$5.BindingBuiltinPluginName.WasmFallbackPlugin);
 	}
 }
 class LoadFallbackPlugin extends BuiltinPlugin {
 	constructor() {
-		super(import_binding$6.BindingBuiltinPluginName.LoadFallbackPlugin);
+		super(import_binding$5.BindingBuiltinPluginName.LoadFallbackPlugin);
 	}
 }
 class AliasPlugin extends BuiltinPlugin {
 	constructor(config) {
-		super(import_binding$6.BindingBuiltinPluginName.AliasPlugin, config);
+		super(import_binding$5.BindingBuiltinPluginName.AliasPlugin, config);
 	}
 }
 class TransformPlugin extends BuiltinPlugin {
 	constructor(config) {
 		let normalizedConfig = normalizeEcmaTransformPluginConfig(config);
-		super(import_binding$6.BindingBuiltinPluginName.TransformPlugin, normalizedConfig);
+		super(import_binding$5.BindingBuiltinPluginName.TransformPlugin, normalizedConfig);
 	}
 }
 class JsonPlugin extends BuiltinPlugin {
 	constructor(config) {
-		super(import_binding$6.BindingBuiltinPluginName.JsonPlugin, config);
+		super(import_binding$5.BindingBuiltinPluginName.JsonPlugin, config);
 	}
 }
 class BuildImportAnalysisPlugin extends BuiltinPlugin {
 	constructor(config) {
-		super(import_binding$6.BindingBuiltinPluginName.BuildImportAnalysisPlugin, config);
+		super(import_binding$5.BindingBuiltinPluginName.BuildImportAnalysisPlugin, config);
 	}
 }
 class ReplacePlugin extends BuiltinPlugin {
 	constructor(config) {
-		super(import_binding$6.BindingBuiltinPluginName.ReplacePlugin, config);
+		super(import_binding$5.BindingBuiltinPluginName.ReplacePlugin, config);
 	}
 }
 class ViteResolvePlugin extends BuiltinPlugin {
 	constructor(config) {
-		super(import_binding$6.BindingBuiltinPluginName.ViteResolvePlugin, config);
+		super(import_binding$5.BindingBuiltinPluginName.ViteResolvePlugin, config);
 	}
 }
 function modulePreloadPolyfillPlugin(config) {
@@ -995,10 +1089,10 @@ function replacePlugin(values = {}, options = {}) {
 	});
 }
 function isCallableCompatibleBuiltinPlugin(plugin) {
-	return plugin instanceof BuiltinPlugin && (0, import_binding$6.isCallableCompatibleBuiltinPlugin)(bindingifyBuiltInPlugin(plugin));
+	return plugin instanceof BuiltinPlugin && (0, import_binding$5.isCallableCompatibleBuiltinPlugin)(bindingifyBuiltInPlugin(plugin));
 }
 function makeBuiltinPluginCallable(plugin) {
-	let callablePlugin = new import_binding$6.BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
+	let callablePlugin = new import_binding$5.BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
 	const wrappedPlugin = {_original: callablePlugin};
 	for (const key in callablePlugin) {
 		if (key === "name") {
@@ -1012,7 +1106,7 @@ function makeBuiltinPluginCallable(plugin) {
 	return wrappedPlugin;
 }
 function isCallableBuiltinPlugin(plugin) {
-	return "_original"in plugin && plugin._original instanceof import_binding$6.BindingCallableBuiltinPlugin;
+	return "_original"in plugin && plugin._original instanceof import_binding$5.BindingCallableBuiltinPlugin;
 }
 function bindingifyBuiltInPlugin(plugin) {
 	return {
@@ -1051,9 +1145,9 @@ class PluginDriver {
 		}
 		return inputOptions;
 	}
-	callOutputOptionsHook(inputOptions, outputOptions) {
-		const plugins = getSortedPlugins("outputOptions", getObjectPlugins(inputOptions.plugins));
-		for (const plugin of plugins) {
+	callOutputOptionsHook(rawPlugins, outputOptions) {
+		const sortedPlugins = getSortedPlugins("outputOptions", getObjectPlugins(rawPlugins));
+		for (const plugin of sortedPlugins) {
 			const options = plugin.outputOptions;
 			if (options) {
 				const { handler: handler } = normalizeHook(options);
@@ -1104,134 +1198,60 @@ function getSortedPlugins(hookName, plugins) {
 }
 
 //#endregion
-//#region src/log/logger.ts
-class MinimalPluginContext {
-	debug;
-	info;
-	meta;
-	warn;
-	error;
-	constructor(options, plugin) {
-		const onLog = options.onLog;
-		const pluginName = plugin.name || "unknown";
-		const logLevel = options.logLevel;
-		this.debug = getLogHandler(LOG_LEVEL_DEBUG, "PLUGIN_LOG", onLog, pluginName, logLevel);
-		this.info = getLogHandler(LOG_LEVEL_INFO, "PLUGIN_LOG", onLog, pluginName, logLevel);
-		this.warn = getLogHandler(LOG_LEVEL_WARN, "PLUGIN_WARNING", onLog, pluginName, logLevel);
-		this.error = (e) => {
-			return error(logPluginError(normalizeLog(e), pluginName));
-		};
-		this.meta = {
-			rollupVersion: "4.23.0",
-			rolldownVersion: VERSION,
-			watchMode: false
-		};
+//#region src/treeshake/module-side-effects.ts
+const ModuleSideEffectsRuleSchema = (z.object({
+	test: (z.instanceof(RegExp)).optional(),
+	external: (z.boolean()).optional(),
+	sideEffects: z.boolean()
+})).refine((data) => {
+	return data.test !== undefined || data.external !== undefined;
+}, "Either `test` or `external` should be set.");
+const ModuleSideEffectsOptionSchema = ((z.boolean()).or(z.array(ModuleSideEffectsRuleSchema))).or(z.literal("no-external"));
+const TreeshakingOptionsSchema = ((z.object({
+	moduleSideEffects: ModuleSideEffectsOptionSchema.optional(),
+	annotations: (z.boolean()).optional()
+})).passthrough()).or(z.boolean());
+
+//#endregion
+//#region src/utils/transform-sourcemap.ts
+function isEmptySourcemapFiled(array) {
+	if (!array) {
+		return true;
+	}
+	if (array.length === 0 || !array[0]) {
+		return true;
 	}
+	return false;
 }
-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 getSortedPlugins("onLog", 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),
-					meta: {
-						rollupVersion: "4.23.0",
-						rolldownVersion: VERSION,
-						watchMode: false
-					},
-					warn: getLogHandler$1(LOG_LEVEL_WARN)
-				}, level, log) === false) {
-					return;
-				}
-			}
-		}
-		onLog(level, log);
+
+//#endregion
+//#region src/utils/transform-module-info.ts
+function transformModuleInfo(info, option) {
+	return {
+		get ast() {
+			return unsupported("ModuleInfo#ast");
+		},
+		get code() {
+			return info.code;
+		},
+		id: info.id,
+		importers: info.importers,
+		dynamicImporters: info.dynamicImporters,
+		importedIds: info.importedIds,
+		dynamicallyImportedIds: info.dynamicallyImportedIds,
+		isEntry: info.isEntry,
+		...option
 	};
-	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$1.isAbsolute(id)) return id;
-	return path$1.relative(path$1.resolve(), id);
 }
 
 //#endregion
 //#region src/utils/transform-side-effects.ts
-var import_binding$5 = __toESM(require_binding());
+var import_binding$4 = __toESM(require_binding());
 function bindingifySideEffects(sideEffects) {
 	switch (sideEffects) {
-		case true: return import_binding$5.BindingHookSideEffects.True;
-		case false: return import_binding$5.BindingHookSideEffects.False;
-		case "no-treeshake": return import_binding$5.BindingHookSideEffects.NoTreeshake;
+		case true: return import_binding$4.BindingHookSideEffects.True;
+		case false: return import_binding$4.BindingHookSideEffects.False;
+		case "no-treeshake": return import_binding$4.BindingHookSideEffects.NoTreeshake;
 		case null:
 		case undefined: return undefined;
 		default: throw new Error(`Unexpected side effects: ${sideEffects}`);
@@ -1346,14 +1366,14 @@ class TransformPluginContext extends PluginContext {
 
 //#endregion
 //#region src/plugin/bindingify-plugin-hook-meta.ts
-var import_binding$4 = __toESM(require_binding());
+var import_binding$3 = __toESM(require_binding());
 function bindingifyPluginHookMeta(options) {
 	return {order: bindingPluginOrder(options.order)};
 }
 function bindingPluginOrder(order) {
 	switch (order) {
-		case "post": return import_binding$4.BindingPluginOrder.Post;
-		case "pre": return import_binding$4.BindingPluginOrder.Pre;
+		case "post": return import_binding$3.BindingPluginOrder.Post;
+		case "pre": return import_binding$3.BindingPluginOrder.Pre;
 		case null:
 		case undefined: return undefined;
 		default: throw new Error(`Unknown plugin order: ${order}`);
@@ -1558,21 +1578,10 @@ function bindingifyLoad(plugin, normalized_options, pluginContextData) {
 			if (typeof ret === "string") {
 				return {code: ret};
 			}
-			if (!ret.map) {
-				return {
-					code: ret.code,
-					moduleType: ret.moduleType
-				};
-			}
-			let map = typeof ret.map === "object" ? ret.map : JSON.parse(ret.map);
-			if (!isEmptySourcemapFiled(map.sources)) {
-				const directory = path.dirname(id) || ".";
-				const sourceRoot = map.sourceRoot || ".";
-				map.sources = map.sources.map((source) => path.resolve(directory, sourceRoot, source));
-			}
+			let map = preProcessSourceMap(ret, id);
 			const result = {
 				code: ret.code,
-				map: bindingifySourcemap$1(map),
+				map: map !== undefined ? bindingifySourcemap$1(map) : undefined,
 				moduleType: ret.moduleType
 			};
 			if (ret.moduleSideEffects !== null) {
@@ -1588,6 +1597,18 @@ function bindingifyLoad(plugin, normalized_options, pluginContextData) {
 		filter: bindingifyLoadFilter(options.filter)
 	};
 }
+function preProcessSourceMap(ret, id) {
+	if (!ret.map) {
+		return;
+	}
+	let map = typeof ret.map === "object" ? ret.map : JSON.parse(ret.map);
+	if (!isEmptySourcemapFiled(map.sources)) {
+		const directory = path.dirname(id) || ".";
+		const sourceRoot = map.sourceRoot || ".";
+		map.sources = map.sources.map((source) => path.resolve(directory, sourceRoot, source));
+	}
+	return map;
+}
 function bindingifyModuleParsed(plugin, options, pluginContextData) {
 	const hook = plugin.moduleParsed;
 	if (!hook) {
@@ -1957,66 +1978,83 @@ class PluginContextData {
 
 //#endregion
 //#region src/options/bindingify-input-options.ts
-var import_binding$3 = __toESM(require_binding());
-function bindingifyInputOptions(options, outputOptions) {
+var import_binding$2 = __toESM(require_binding());
+function bindingifyInputOptions(rawPlugins, inputOptions, 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, extensionAlias: extensionAlias,...rest } = options.resolve;
-			return {
-				alias: alias ? (Object.entries(alias)).map(([name, replacement]) => ({
-					find: name,
-					replacements: [replacement]
-				})) : undefined,
-				extensionAlias: extensionAlias ? (Object.entries(extensionAlias)).map(([name, value]) => ({
-					target: name,
-					replacements: value
-				})) : undefined,
-				...rest
+	const logLevel = inputOptions.logLevel || LOG_LEVEL_INFO;
+	const onLog = inputOptions.onLog = getLogger(getObjectPlugins(rawPlugins), getOnLog(inputOptions, logLevel), logLevel);
+	const plugins = rawPlugins.map((plugin) => {
+		if ("_parallel"in plugin) {
+			return undefined;
+		}
+		if (plugin instanceof BuiltinPlugin) {
+			return bindingifyBuiltInPlugin(plugin);
+		}
+		return bindingifyPlugin(plugin, inputOptions, outputOptions, pluginContextData);
+	});
+	return {
+		input: bindingifyInput(inputOptions.input),
+		plugins,
+		cwd: inputOptions.cwd ?? process.cwd(),
+		external: bindingifyExternal(inputOptions.external),
+		resolve: bindingifyResolve(inputOptions.resolve),
+		platform: inputOptions.platform,
+		shimMissingExports: inputOptions.shimMissingExports,
+		logLevel: bindingifyLogLevel(logLevel),
+		onLog,
+		treeshake: bindingifyTreeshakeOptions(inputOptions.treeshake),
+		moduleTypes: inputOptions.moduleTypes,
+		define: inputOptions.define ? Object.entries(inputOptions.define) : undefined,
+		inject: bindingifyInject(inputOptions.inject),
+		experimental: {
+			strictExecutionOrder: inputOptions.experimental?.strictExecutionOrder,
+			disableLiveBindings: inputOptions.experimental?.disableLiveBindings,
+			viteMode: inputOptions.experimental?.viteMode
+		},
+		profilerNames: inputOptions?.profilerNames,
+		jsx: bindingifyJsx(inputOptions.jsx),
+		watch: bindingifyWatch(inputOptions.watch),
+		dropLabels: inputOptions.dropLabels
+	};
+}
+function bindingifyExternal(external) {
+	if (external) {
+		if (typeof external === "function") {
+			return (id, importer, isResolved) => {
+				if (id.startsWith("\0")) return false;
+				return external(id, importer, isResolved) ?? false;
 			};
-		}() : undefined,
-		platform: options.platform,
-		shimMissingExports: options.shimMissingExports,
-		logLevel: bindingifyLogLevel(options.logLevel),
-		onLog: (level, log) => {
-			options.onLog(level, {
-				code: log.code,
-				message: log.message
+		}
+		const externalArr = arraify(external);
+		return (id, _importer, _isResolved) => {
+			return externalArr.some((pat) => {
+				if (pat instanceof RegExp) {
+					return pat.test(id);
+				}
+				return id === pat;
 			});
-		},
-		treeshake: options.treeshake,
-		moduleTypes: options.moduleTypes,
-		define: options.define ? Object.entries(options.define) : undefined,
-		inject: options.inject ? (Object.entries(options.inject)).map(([alias, item]) => {
+		};
+	}
+}
+function bindingifyResolve(resolve) {
+	if (resolve) {
+		const { alias: alias, extensionAlias: extensionAlias,...rest } = resolve;
+		return {
+			alias: alias ? (Object.entries(alias)).map(([name, replacement]) => ({
+				find: name,
+				replacements: [replacement]
+			})) : undefined,
+			extensionAlias: extensionAlias ? (Object.entries(extensionAlias)).map(([name, value]) => ({
+				target: name,
+				replacements: value
+			})) : undefined,
+			...rest
+		};
+	}
+}
+function bindingifyInject(inject) {
+	if (inject) {
+		return (Object.entries(inject)).map(([alias, item]) => {
 			if (Array.isArray(item)) {
 				if (item[1] === "*") {
 					return {
@@ -2039,39 +2077,34 @@ function bindingifyInputOptions(options, outputOptions) {
 					from: item
 				};
 			}
-		}) : undefined,
-		experimental: {
-			strictExecutionOrder: options.experimental?.strictExecutionOrder,
-			disableLiveBindings: options.experimental?.disableLiveBindings
-		},
-		profilerNames: options?.profilerNames,
-		jsx: bindingifyJsx(options.jsx),
-		watch: bindingifyWatch(options.watch),
-		dropLabels: options.dropLabels
-	};
+		});
+	}
 }
 function bindingifyLogLevel(logLevel) {
 	switch (logLevel) {
-		case "silent": return import_binding$3.BindingLogLevel.Silent;
-		case "warn": return import_binding$3.BindingLogLevel.Warn;
-		case "info": return import_binding$3.BindingLogLevel.Info;
-		case "debug": return import_binding$3.BindingLogLevel.Debug;
+		case "silent": return import_binding$2.BindingLogLevel.Silent;
+		case "debug": return import_binding$2.BindingLogLevel.Debug;
+		case "warn": return import_binding$2.BindingLogLevel.Warn;
+		case "info": return import_binding$2.BindingLogLevel.Info;
 		default: throw new Error(`Unexpected log level: ${logLevel}`);
 	}
 }
 function bindingifyInput(input) {
+	if (input === undefined) {
+		return [];
+	}
+	if (typeof input === "string") {
+		return [{import: 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]
-			};
-		});
+		return input.map((src) => ({import: src}));
 	}
+	return (Object.entries(input)).map((value) => {
+		return {
+			name: value[0],
+			import: value[1]
+		};
+	});
 }
 function bindingifyJsx(input) {
 	if (input) {
@@ -2105,88 +2138,15 @@ function bindingifyWatch(watch$1) {
 		return value;
 	}
 }
-
-//#endregion
-//#region src/utils/initialize-parallel-plugins.ts
-var import_binding$2 = __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$2.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 = undefined("#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/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) {
+function bindingifyTreeshakeOptions(config) {
 	if (config === false) {
 		return undefined;
 	}
 	if (config === true || config === undefined) {
-		return {moduleSideEffects: true};
+		return {
+			moduleSideEffects: true,
+			annotations: true
+		};
 	}
 	let normalizedConfig = {moduleSideEffects: true};
 	if (config.moduleSideEffects === undefined) {
@@ -2202,9 +2162,86 @@ function normalizeTreeshakeOptions(config) {
 	} else {
 		normalizedConfig.moduleSideEffects = config.moduleSideEffects;
 	}
+	normalizedConfig.annotations = config.annotations ?? true;
 	return normalizedConfig;
 }
 
+//#endregion
+//#region src/options/bindingify-output-options.ts
+function bindingifyOutputOptions(outputOptions) {
+	const { dir: dir, format: format, exports: exports, hashCharacters: hashCharacters, sourcemap: sourcemap, sourcemapIgnoreList: sourcemapIgnoreList, sourcemapPathTransform: sourcemapPathTransform, name: name, assetFileNames: assetFileNames, entryFileNames: entryFileNames, chunkFileNames: chunkFileNames, cssEntryFileNames: cssEntryFileNames, cssChunkFileNames: cssChunkFileNames, banner: banner, footer: footer, intro: intro, outro: outro, esModule: esModule, globals: globals, file: file } = outputOptions;
+	return {
+		dir,
+		file: file == null ? undefined : file,
+		format: bindingifyFormat(format),
+		exports,
+		hashCharacters,
+		sourcemap: bindingifySourcemap(sourcemap),
+		sourcemapIgnoreList: bindingifySourcemapIgnoreList(sourcemapIgnoreList),
+		sourcemapPathTransform,
+		banner: bindingifyAddon(banner),
+		footer: bindingifyAddon(footer),
+		intro: bindingifyAddon(intro),
+		outro: bindingifyAddon(outro),
+		extend: outputOptions.extend,
+		globals,
+		esModule,
+		name,
+		assetFileNames,
+		entryFileNames,
+		chunkFileNames,
+		cssEntryFileNames,
+		cssChunkFileNames,
+		plugins: [],
+		minify: outputOptions.minify,
+		externalLiveBindings: outputOptions.externalLiveBindings,
+		inlineDynamicImports: outputOptions.inlineDynamicImports,
+		advancedChunks: outputOptions.advancedChunks
+	};
+}
+function bindingifyAddon(configAddon) {
+	return async (chunk) => {
+		if (typeof configAddon === "function") {
+			return configAddon(chunk);
+		}
+		return configAddon || "";
+	};
+}
+function bindingifyFormat(format) {
+	switch (format) {
+		case undefined:
+		case "es":
+		case "esm":
+		case "module": {
+			return "es";
+		}
+		case "cjs":
+		case "commonjs": {
+			return "cjs";
+		}
+		case "iife": {
+			return "iife";
+		}
+		case "umd": {
+			return "umd";
+		}
+		default: unimplemented(`output.format: ${format}`);
+	}
+}
+function bindingifySourcemap(sourcemap) {
+	switch (sourcemap) {
+		case true: return "file";
+		case "inline": return "inline";
+		case false:
+		case undefined: return undefined;
+		case "hidden": return "hidden";
+		default: throw new Error(`unknown sourcemap: ${sourcemap}`);
+	}
+}
+function bindingifySourcemapIgnoreList(sourcemapIgnoreList) {
+	return typeof sourcemapIgnoreList === "function" ? sourcemapIgnoreList : sourcemapIgnoreList === false ? () => false : (relativeSourcePath, _sourcemapPath) => relativeSourcePath.includes("node_modules");
+}
+
 //#endregion
 //#region ../../node_modules/.pnpm/remeda@2.16.0/node_modules/remeda/dist/chunk-K26VP6CL.js
 function u$1(t$1, n, a) {
@@ -2631,178 +2668,98 @@ function composeJsPlugins(plugins) {
 }
 
 //#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
-	};
+//#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-output-options.ts
-function normalizeOutputOptions(opts) {
-	const { dir: dir, format: format, exports: exports, hashCharacters: hashCharacters, sourcemap: sourcemap, sourcemapIgnoreList: sourcemapIgnoreList, sourcemapPathTransform: sourcemapPathTransform, globals: globals, assetFileNames: assetFileNames, entryFileNames: entryFileNames, chunkFileNames: chunkFileNames, cssEntryFileNames: cssEntryFileNames, cssChunkFileNames: cssChunkFileNames, name: name, esModule: esModule, file: file } = opts;
-	return {
-		dir: dir,
-		file,
-		format: getFormat(format),
-		exports: exports ?? "auto",
-		hashCharacters: hashCharacters ?? "base64",
-		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",
-		cssEntryFileNames: cssEntryFileNames ?? "[name].css",
-		cssChunkFileNames: cssChunkFileNames ?? "[name]-[hash].css",
-		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";
-		}
-		case "umd": {
-			return "umd";
+//#region src/utils/normalize-plugin-option.ts
+const normalizePluginOption = async (plugins) => (await asyncFlatten([plugins])).filter(Boolean);
+
+//#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
+			});
 		}
-		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 || "";
+	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()));
 	};
-};
-
-//#endregion
-//#region src/options/bindingify-output-options.ts
-function bindingifyOutputOptions(outputOptions) {
-	const { dir: dir, format: format, exports: exports, hashCharacters: hashCharacters, sourcemap: sourcemap, sourcemapIgnoreList: sourcemapIgnoreList, sourcemapPathTransform: sourcemapPathTransform, name: name, assetFileNames: assetFileNames, entryFileNames: entryFileNames, chunkFileNames: chunkFileNames, cssEntryFileNames: cssEntryFileNames, cssChunkFileNames: cssChunkFileNames, banner: banner, footer: footer, intro: intro, outro: outro, esModule: esModule, globals: globals, file: file } = outputOptions;
 	return {
-		dir,
-		file: file == null ? undefined : file,
-		format: function() {
-			switch (format) {
-				case "es": return "es";
-				case "cjs": return "cjs";
-				case "iife": return "iife";
-				case "umd": return "umd";
-			}
-		}(),
-		exports,
-		hashCharacters,
-		sourcemap: bindingifySourcemap(sourcemap),
-		sourcemapIgnoreList,
-		sourcemapPathTransform,
-		banner,
-		footer,
-		intro,
-		outro,
-		extend: outputOptions.extend,
-		globals,
-		esModule: bindingifyEsModule(esModule),
-		name,
-		assetFileNames,
-		entryFileNames,
-		chunkFileNames,
-		cssEntryFileNames,
-		cssChunkFileNames,
-		plugins: [],
-		minify: outputOptions.minify,
-		externalLiveBindings: outputOptions.externalLiveBindings,
-		inlineDynamicImports: outputOptions.inlineDynamicImports,
-		advancedChunks: outputOptions.advancedChunks
+		registry: parallelJsPluginRegistry,
+		stopWorkers
 	};
 }
-function bindingifySourcemap(sourcemap) {
-	switch (sourcemap) {
-		case true: return "file";
-		case "inline": return "inline";
-		case false:
-		case undefined: return undefined;
-		case "hidden": return "hidden";
-		default: throw new Error(`unknown sourcemap: ${sourcemap}`);
-	}
+function initializeWorkers(registryId, count, pluginInfos) {
+	return Promise.all(Array.from({length: count}, (_, i) => initializeWorker(registryId, pluginInfos, i)));
 }
-function bindingifyEsModule(esModule) {
-	switch (esModule) {
-		case true:
-		case false:
-		case "if-default-prop": return esModule;
-		default: throw new Error(`unknown esModule: ${esModule}`);
+async function initializeWorker(registryId, pluginInfos, threadNumber) {
+	const urlString = undefined("#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/treeshake/module-side-effects.ts
-const ModuleSideEffectsRuleSchema = (z.object({
-	test: (z.instanceof(RegExp)).optional(),
-	external: (z.boolean()).optional(),
-	sideEffects: z.boolean()
-})).refine((data) => {
-	return data.test !== undefined || data.external !== undefined;
-}, "Either `test` or `external` should be set.");
-const ModuleSideEffectsOptionSchema = ((z.boolean()).or(z.array(ModuleSideEffectsRuleSchema))).or(z.literal("no-external"));
-const TreeshakingOptionsSchema = ((z.object({moduleSideEffects: ModuleSideEffectsOptionSchema.optional()})).passthrough()).or(z.boolean());
-
 //#endregion
 //#region src/utils/create-bundler.ts
-var import_binding$1 = __toESM(require_binding());
+var import_binding = __toESM(require_binding());
 async function createBundler(inputOptions, outputOptions) {
 	const pluginDriver = new PluginDriver();
 	inputOptions = await pluginDriver.callOptionsHook(inputOptions);
 	if (inputOptions.treeshake !== undefined) {
 		TreeshakingOptionsSchema.parse(inputOptions.treeshake);
 	}
-	const normalizedInputOptions = await normalizeInputOptions(inputOptions);
-	const parallelPluginInitResult = await initializeParallelPlugins(normalizedInputOptions.plugins);
+	let plugins = await normalizePluginOption(inputOptions.plugins);
+	if (inputOptions.experimental?.enableComposingJsPlugins ?? false) {
+		plugins = composeJsPlugins(plugins);
+	}
+	const parallelPluginInitResult = await initializeParallelPlugins(plugins);
 	try {
-		outputOptions = pluginDriver.callOutputOptionsHook(normalizedInputOptions, outputOptions);
-		const normalizedOutputOptions = normalizeOutputOptions(outputOptions);
-		const bindingInputOptions = bindingifyInputOptions(normalizedInputOptions, normalizedOutputOptions);
+		outputOptions = pluginDriver.callOutputOptionsHook(plugins, outputOptions);
+		const bindingInputOptions = bindingifyInputOptions(plugins, inputOptions, outputOptions);
+		const bindingOutputOptions = bindingifyOutputOptions(outputOptions);
 		return {
-			bundler: new import_binding$1.Bundler(bindingInputOptions, bindingifyOutputOptions(normalizedOutputOptions), parallelPluginInitResult?.registry),
+			bundler: new import_binding.Bundler(bindingInputOptions, bindingOutputOptions, parallelPluginInitResult?.registry),
 			stopWorkers: parallelPluginInitResult?.stopWorkers
 		};
 	} catch (e) {
@@ -2851,12 +2808,12 @@ class RolldownBuild {
 
 //#endregion
 //#region src/watcher.ts
-var import_binding = __toESM(require_binding());
 class Watcher {
 	closed;
 	controller;
 	inner;
 	stopWorkers;
+	listeners = new Map();
 	constructor(inner, stopWorkers) {
 		this.closed = false;
 		this.controller = new AbortController();
@@ -2870,48 +2827,11 @@ class Watcher {
 		this.controller.abort();
 	}
 	on(event, listener) {
-		switch (event) {
-			case "close":
-				this.inner.on(import_binding.BindingWatcherEvent.Close, async () => {
-					await listener();
-				});
-				break;
-			case "event":
-				this.inner.on(import_binding.BindingWatcherEvent.Event, async (data) => {
-					const code = data.bundleEventKind();
-					switch (code) {
-						case "BUNDLE_END":
-							const { duration: duration, output: output } = data.bundleEndData();
-							await listener({
-								code: "BUNDLE_END",
-								duration,
-								output: [output]
-							});
-							break;
-						case "ERROR":
-							await listener({
-								code: "ERROR",
-								error: {message: data.error()}
-							});
-							break;
-						default:
-							await listener({code});
-							break;
-					}
-				});
-				break;
-			case "restart":
-				this.inner.on(import_binding.BindingWatcherEvent.ReStart, async () => {
-					await listener();
-				});
-				break;
-			case "change":
-				this.inner.on(import_binding.BindingWatcherEvent.Change, async (data) => {
-					const { path: path$2, kind: kind } = data.watchChangeData();
-					await listener(path$2, {event: kind});
-				});
-				break;
-			default: throw new Error(`Unknown event: ${event}`);
+		const listeners = this.listeners.get(event);
+		if (listeners) {
+			listeners.push(listener);
+		} else {
+			this.listeners.set(event, [listener]);
 		}
 		return this;
 	}
@@ -2920,7 +2840,51 @@ class Watcher {
 		this.controller.signal.addEventListener("abort", () => {
 			clearInterval(timer);
 		});
-		process.nextTick(() => this.inner.start());
+		process.nextTick(() => this.inner.start(async (event) => {
+			const listeners = this.listeners.get(event.eventKind());
+			if (listeners) {
+				switch (event.eventKind()) {
+					case "close":
+					case "restart":
+						for (const listener of listeners) {
+							await listener();
+						}
+						break;
+					case "event":
+						for (const listener of listeners) {
+							const code = event.bundleEventKind();
+							switch (code) {
+								case "BUNDLE_END":
+									const { duration: duration, output: output } = event.bundleEndData();
+									await listener({
+										code: "BUNDLE_END",
+										duration,
+										output: [output]
+									});
+									break;
+								case "ERROR":
+									const errors = event.errors();
+									await listener({
+										code: "ERROR",
+										error: normalizeErrors(errors)
+									});
+									break;
+								default:
+									await listener({code});
+									break;
+							}
+						}
+						break;
+					case "change":
+						for (const listener of listeners) {
+							const { path: path$2, kind: kind } = event.watchChangeData();
+							await listener(path$2, {event: kind});
+						}
+						break;
+					default: throw new Error(`Unknown event: ${event}`);
+				}
+			}
+		}));
 	}
 }