rolldown 0.15.0 → 0.15.1-commit.cc6f557

package/dist/shared/{src-COU7qQBJ.cjs → src-DKykz7Lg.cjs}

@@ -1,4 +1,5 @@
-const require_chunk = require('./chunk-BK2Ye-xa.cjs');
+const require_chunk = require('./chunk-BFvIen8E.cjs');
+const node_buffer = require_chunk.__toESM(require("node:buffer"));
 const zod = require_chunk.__toESM(require("zod"));
 const node_path = require_chunk.__toESM(require("node:path"));
 const node_worker_threads = require_chunk.__toESM(require("node:worker_threads"));
@@ -35,7 +36,11 @@ function bindingifySourcemap$1(map) {
 //#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 }));
+	const errors = rawErrors.map((e) => e instanceof Error ? e : Object.assign(new Error(), {
+		kind: e.kind,
+		message: e.message,
+		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) {
@@ -107,6 +112,19 @@ function transformChunkModules(modules) {
 
 //#endregion
 //#region src/utils/transform-to-rollup-output.ts
+function transformToRollupSourceMap(map) {
+	const parsed = JSON.parse(map);
+	const obj = {
+		...parsed,
+		toString() {
+			return JSON.stringify(obj);
+		},
+		toUrl() {
+			return `data:application/json;charset=utf-8;base64,${node_buffer.Buffer.from(obj.toString(), "utf-8").toString("base64")}`;
+		}
+	};
+	return obj;
+}
 function transformToRollupOutputChunk(bindingChunk, changed) {
 	const chunk = {
 		type: "chunk",
@@ -132,7 +150,7 @@ function transformToRollupOutputChunk(bindingChunk, changed) {
 			return bindingChunk.moduleIds;
 		},
 		get map() {
-			return bindingChunk.map ? JSON.parse(bindingChunk.map) : null;
+			return bindingChunk.map ? transformToRollupSourceMap(bindingChunk.map) : null;
 		},
 		sourcemapFileName: bindingChunk.sourcemapFileName || null,
 		preliminaryFileName: bindingChunk.preliminaryFileName
@@ -155,10 +173,12 @@ function transformToRollupOutputAsset(bindingAsset, changed) {
 		type: "asset",
 		fileName: bindingAsset.fileName,
 		originalFileName: bindingAsset.originalFileName || null,
+		originalFileNames: bindingAsset.originalFileNames,
 		get source() {
 			return transformAssetSource(bindingAsset.source);
 		},
-		name: bindingAsset.name ?? undefined
+		name: bindingAsset.name ?? undefined,
+		names: bindingAsset.names
 	};
 	const cache = {};
 	return new Proxy(asset, {
@@ -197,9 +217,9 @@ function collectChangedBundle(changed, bundle) {
 		const item = bundle[key];
 		if (item.type === "asset") assets.push({
 			filename: item.fileName,
-			originalFileName: item.originalFileName || undefined,
+			originalFileNames: item.originalFileNames,
 			source: bindingAssetSource(item.source),
-			name: item.name
+			names: item.names
 		});
 else chunks.push({
 			code: item.code,
@@ -517,7 +537,7 @@ else loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architectur
 	}
 	module.exports.BindingBundleEndEventData = nativeBinding.BindingBundleEndEventData;
 	module.exports.BindingCallableBuiltinPlugin = nativeBinding.BindingCallableBuiltinPlugin;
-	module.exports.BindingHookError = nativeBinding.BindingHookError;
+	module.exports.BindingError = nativeBinding.BindingError;
 	module.exports.BindingLog = nativeBinding.BindingLog;
 	module.exports.BindingModuleInfo = nativeBinding.BindingModuleInfo;
 	module.exports.BindingNormalizedOptions = nativeBinding.BindingNormalizedOptions;
@@ -536,8 +556,10 @@ else loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architectur
 	module.exports.BindingHookSideEffects = nativeBinding.BindingHookSideEffects;
 	module.exports.BindingLogLevel = nativeBinding.BindingLogLevel;
 	module.exports.BindingPluginOrder = nativeBinding.BindingPluginOrder;
+	module.exports.HelperMode = nativeBinding.HelperMode;
 	module.exports.isolatedDeclaration = nativeBinding.isolatedDeclaration;
 	module.exports.registerPlugins = nativeBinding.registerPlugins;
+	module.exports.Severity = nativeBinding.Severity;
 	module.exports.transform = nativeBinding.transform;
 } });
 
@@ -558,9 +580,7 @@ function unreachable(info) {
 	throw new Error("unreachable");
 }
 function unsupported(info) {
-	return () => {
-		throw new Error(`UNSUPPORTED: ${info}`);
-	};
+	throw new Error(`UNSUPPORTED: ${info}`);
 }
 function noop(..._args) {}
 
@@ -675,7 +695,13 @@ function locate(source, search, options) {
 
 //#endregion
 //#region src/log/logs.ts
-const INVALID_LOG_POSITION = "INVALID_LOG_POSITION", PLUGIN_ERROR = "PLUGIN_ERROR", INPUT_HOOK_IN_OUTPUT_PLUGIN = "INPUT_HOOK_IN_OUTPUT_PLUGIN", CYCLE_LOADING = "CYCLE_LOADING";
+const INVALID_LOG_POSITION = "INVALID_LOG_POSITION", PLUGIN_ERROR = "PLUGIN_ERROR", INPUT_HOOK_IN_OUTPUT_PLUGIN = "INPUT_HOOK_IN_OUTPUT_PLUGIN", CYCLE_LOADING = "CYCLE_LOADING", MULTIPLY_NOTIFY_OPTION = "MULTIPLY_NOTIFY_OPTION", MINIFY_WARNING = "MINIFY_WARNING";
+function logMinifyWarning() {
+	return {
+		code: MINIFY_WARNING,
+		message: "The built-in minifier is still under development. Setting \"minify: true\" is not recommended for production use."
+	};
+}
 function logInvalidLogPosition(pluginName) {
 	return {
 		code: INVALID_LOG_POSITION,
@@ -694,6 +720,12 @@ function logCycleLoading(pluginName, moduleId) {
 		message: `Found the module "${moduleId}" cycle loading at ${pluginName} plugin, it maybe blocking fetching modules.`
 	};
 }
+function logMultiplyNotifyOption() {
+	return {
+		code: MULTIPLY_NOTIFY_OPTION,
+		message: `Found multiply notify option at watch options, using first one to start notify watcher.`
+	};
+}
 function logPluginError(error$1, plugin, { hook, id } = {}) {
 	const code = error$1.code;
 	if (!error$1.pluginCode && code != null && (typeof code !== "string" || !code.startsWith("PLUGIN_"))) error$1.pluginCode = code;
@@ -797,7 +829,8 @@ function getLogger(plugins, onLog, logLevel) {
 						rolldownVersion: VERSION,
 						watchMode: false
 					},
-					warn: getLogHandler$1(LOG_LEVEL_WARN)
+					warn: getLogHandler$1(LOG_LEVEL_WARN),
+					pluginName: plugin.name || "unknown"
 				}, level, log) === false) return;
 			}
 		}
@@ -849,9 +882,9 @@ function relativeId(id) {
 
 //#endregion
 //#region src/builtin-plugin/utils.ts
-var import_binding$5 = require_chunk.__toESM(require_binding());
+var import_binding$6 = require_chunk.__toESM(require_binding());
 function makeBuiltinPluginCallable(plugin) {
-	let callablePlugin = new import_binding$5.BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
+	let callablePlugin = new import_binding$6.BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
 	const wrappedPlugin = plugin;
 	for (const key in callablePlugin) wrappedPlugin[key] = function(...args) {
 		return callablePlugin[key](...args);
@@ -1020,7 +1053,8 @@ var PluginDriver = class {
 						rolldownVersion: VERSION,
 						watchMode: false
 					},
-					warn: getLogHandler(LOG_LEVEL_WARN, "PLUGIN_WARNING", logger, name, logLevel)
+					warn: getLogHandler(LOG_LEVEL_WARN, "PLUGIN_WARNING", logger, name, logLevel),
+					pluginName: name
 				}, inputOptions);
 				if (result) inputOptions = result;
 			}
@@ -1084,7 +1118,7 @@ const ModuleSideEffectsRuleSchema = zod.z.object({
 }).refine((data) => {
 	return data.test !== undefined || data.external !== undefined;
 }, "Either `test` or `external` should be set.");
-const ModuleSideEffectsOptionSchema = zod.z.boolean().or(zod.z.array(ModuleSideEffectsRuleSchema)).or(zod.z.literal("no-external"));
+const ModuleSideEffectsOptionSchema = zod.z.boolean().or(zod.z.array(ModuleSideEffectsRuleSchema)).or(zod.z.function().args(zod.z.string(), zod.z.boolean()).returns(zod.z.boolean().optional())).or(zod.z.literal("no-external"));
 const TreeshakingOptionsSchema = zod.z.object({
 	moduleSideEffects: ModuleSideEffectsOptionSchema.optional(),
 	annotations: zod.z.boolean().optional()
@@ -1120,6 +1154,7 @@ function transformModuleInfo(info, option) {
 		dynamicImporters: info.dynamicImporters,
 		importedIds: info.importedIds,
 		dynamicallyImportedIds: info.dynamicallyImportedIds,
+		exports: info.exports,
 		isEntry: info.isEntry,
 		...option
 	};
@@ -1132,31 +1167,30 @@ var MinimalPluginContext = class {
 	warn;
 	debug;
 	meta;
-	error;
-	constructor(onLog, logLevel, plugin) {
-		const pluginName = plugin.name || "unknown";
+	constructor(onLog, logLevel, pluginName) {
+		this.pluginName = pluginName;
 		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
 		};
 	}
+	error(e) {
+		return error(logPluginError(normalizeLog(e), this.pluginName));
+	}
 };
 
 //#endregion
 //#region src/utils/transform-side-effects.ts
-var import_binding$4 = require_chunk.__toESM(require_binding());
+var import_binding$5 = require_chunk.__toESM(require_binding());
 function bindingifySideEffects(sideEffects) {
 	switch (sideEffects) {
-		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 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 null:
 		case undefined: return undefined;
 		default: throw new Error(`Unexpected side effects: ${sideEffects}`);
@@ -1166,84 +1200,92 @@ function bindingifySideEffects(sideEffects) {
 //#endregion
 //#region src/plugin/plugin-context.ts
 var PluginContext = class extends MinimalPluginContext {
-	load;
-	resolve;
-	emitFile;
-	getFileName;
-	getModuleInfo;
-	getModuleIds;
-	addWatchFile;
-	/**
-	* @deprecated This rollup API won't be supported by rolldown. Using this API will cause runtime error.
-	*/
-	parse;
 	constructor(context, plugin, data, onLog, logLevel, currentLoadingModule) {
-		super(onLog, logLevel, plugin);
-		this.load = async ({ id,...options }) => {
-			if (id === currentLoadingModule) onLog(LOG_LEVEL_WARN, logCycleLoading(plugin.name, currentLoadingModule));
-			const moduleInfo = data.getModuleInfo(id, context);
-			if (moduleInfo && moduleInfo.code !== null) return moduleInfo;
-			const rawOptions = {
-				meta: options.meta || {},
-				moduleSideEffects: options.moduleSideEffects || null
-			};
-			data.updateModuleOption(id, rawOptions);
-			async function createLoadModulePromise() {
-				const loadPromise = data.loadModulePromiseMap.get(id);
-				if (loadPromise) return loadPromise;
-				let resolveFn;
-				const promise = new Promise((resolve, _) => {
-					resolveFn = resolve;
-				});
-				data.loadModulePromiseMap.set(id, promise);
-				try {
-					await context.load(id, bindingifySideEffects(options.moduleSideEffects), resolveFn);
-				} finally {
-					data.loadModulePromiseMap.delete(id);
-				}
-				return promise;
-			}
-			await createLoadModulePromise();
-			return data.getModuleInfo(id, context);
-		};
-		this.resolve = async (source, importer, options) => {
-			let receipt = undefined;
-			if (options != null) receipt = data.saveResolveOptions(options);
-			const res = await context.resolve(source, importer, {
-				custom: receipt,
-				skipSelf: options?.skipSelf
-			});
-			if (receipt != null) data.removeSavedResolveOptions(receipt);
-			if (res == null) return null;
-			const info = data.getModuleOption(res.id) || {};
-			return {
-				...res,
-				...info
-			};
+		super(onLog, logLevel, plugin.name);
+		this.context = context;
+		this.data = data;
+		this.onLog = onLog;
+		this.currentLoadingModule = currentLoadingModule;
+	}
+	async load(options) {
+		const id = options.id;
+		if (id === this.currentLoadingModule) this.onLog(LOG_LEVEL_WARN, logCycleLoading(this.pluginName, this.currentLoadingModule));
+		const moduleInfo = this.data.getModuleInfo(id, this.context);
+		if (moduleInfo && moduleInfo.code !== null) return moduleInfo;
+		const rawOptions = {
+			meta: options.meta || {},
+			moduleSideEffects: options.moduleSideEffects || null
 		};
-		this.emitFile = (file) => {
-			if (file.type !== "asset") return unimplemented("PluginContext.emitFile: only asset type is supported");
-			return context.emitFile({
-				...file,
-				originalFileName: file.originalFileName || undefined,
-				source: bindingAssetSource(file.source)
+		this.data.updateModuleOption(id, rawOptions);
+		async function createLoadModulePromise(context, data) {
+			const loadPromise = data.loadModulePromiseMap.get(id);
+			if (loadPromise) return loadPromise;
+			let resolveFn;
+			const promise = new Promise((resolve, _) => {
+				resolveFn = resolve;
 			});
+			data.loadModulePromiseMap.set(id, promise);
+			try {
+				await context.load(id, bindingifySideEffects(options.moduleSideEffects), resolveFn);
+			} finally {
+				data.loadModulePromiseMap.delete(id);
+			}
+			return promise;
+		}
+		await createLoadModulePromise(this.context, this.data);
+		return this.data.getModuleInfo(id, this.context);
+	}
+	async resolve(source, importer, options) {
+		let receipt = undefined;
+		if (options != null) receipt = this.data.saveResolveOptions(options);
+		const res = await this.context.resolve(source, importer, {
+			custom: receipt,
+			skipSelf: options?.skipSelf
+		});
+		if (receipt != null) this.data.removeSavedResolveOptions(receipt);
+		if (res == null) return null;
+		const info = this.data.getModuleOption(res.id) || {};
+		return {
+			...res,
+			...info
 		};
-		this.getFileName = context.getFileName.bind(context);
-		this.getModuleInfo = (id) => data.getModuleInfo(id, context);
-		this.getModuleIds = () => data.getModuleIds(context);
-		this.parse = unsupported("`PluginContext#parse` is not supported by rolldown.");
-		this.addWatchFile = context.addWatchFile.bind(context);
+	}
+	emitFile(file) {
+		if (file.type !== "asset") return unimplemented("PluginContext.emitFile: only asset type is supported");
+		return this.context.emitFile({
+			...file,
+			originalFileName: file.originalFileName || undefined,
+			source: bindingAssetSource(file.source)
+		});
+	}
+	getFileName(referenceId) {
+		return this.context.getFileName(referenceId);
+	}
+	getModuleInfo(id) {
+		return this.data.getModuleInfo(id, this.context);
+	}
+	getModuleIds() {
+		return this.data.getModuleIds(this.context);
+	}
+	addWatchFile(id) {
+		this.context.addWatchFile(id);
+	}
+	/**
+	* @deprecated This rollup API won't be supported by rolldown. Using this API will cause runtime error.
+	*/
+	parse(_input, _options) {
+		unsupported("`PluginContext#parse` is not supported by rolldown.");
 	}
 };
 
 //#endregion
 //#region src/plugin/transform-plugin-context.ts
 var TransformPluginContext = class extends PluginContext {
-	error;
-	getCombinedSourcemap;
 	constructor(context, plugin, data, inner, moduleId, moduleSource, onLog, LogLevelOption) {
 		super(context, plugin, data, onLog, LogLevelOption, moduleId);
+		this.inner = inner;
+		this.moduleId = moduleId;
+		this.moduleSource = moduleSource;
 		const getLogHandler$1 = (handler) => (log, pos) => {
 			log = normalizeLog(log);
 			if (pos) augmentCodeLocation(log, pos, moduleSource, moduleId);
@@ -1254,27 +1296,29 @@ var TransformPluginContext = class extends PluginContext {
 		this.debug = getLogHandler$1(this.debug);
 		this.warn = getLogHandler$1(this.warn);
 		this.info = getLogHandler$1(this.info);
-		this.error = (e, pos) => {
-			if (typeof e === "string") e = { message: e };
-			if (pos) augmentCodeLocation(e, pos, moduleSource, moduleId);
-			e.id = moduleId;
-			e.hook = "transform";
-			return error(logPluginError(normalizeLog(e), plugin.name || "unknown"));
-		};
-		this.getCombinedSourcemap = () => JSON.parse(inner.getCombinedSourcemap());
+	}
+	error(e, pos) {
+		if (typeof e === "string") e = { message: e };
+		if (pos) augmentCodeLocation(e, pos, this.moduleSource, this.moduleId);
+		e.id = this.moduleId;
+		e.hook = "transform";
+		return error(logPluginError(normalizeLog(e), this.pluginName));
+	}
+	getCombinedSourcemap() {
+		return JSON.parse(this.inner.getCombinedSourcemap());
 	}
 };
 
 //#endregion
 //#region src/plugin/bindingify-plugin-hook-meta.ts
-var import_binding$3 = require_chunk.__toESM(require_binding());
+var import_binding$4 = require_chunk.__toESM(require_binding());
 function bindingifyPluginHookMeta(options) {
 	return { order: bindingPluginOrder(options.order) };
 }
 function bindingPluginOrder(order) {
 	switch (order) {
-		case "post": return import_binding$3.BindingPluginOrder.Post;
-		case "pre": return import_binding$3.BindingPluginOrder.Pre;
+		case "post": return import_binding$4.BindingPluginOrder.Post;
+		case "pre": return import_binding$4.BindingPluginOrder.Pre;
 		case null:
 		case undefined: return undefined;
 		default: throw new Error(`Unknown plugin order: ${order}`);
@@ -1355,7 +1399,7 @@ function bindingifyBuildEnd(args) {
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, err) => {
-			await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), err ? normalizeErrors(err.errors) : undefined);
+			await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), err ? normalizeErrors(err) : undefined);
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
@@ -1494,7 +1538,9 @@ function bindingifyModuleParsed(args) {
 //#endregion
 //#region src/options/normalized-output-options.ts
 function mapFunctionOption(option, name) {
-	return typeof option === "undefined" ? unsupported(`You should not take \`NormalizedOutputOptions#${name}\` and call it directly`) : option;
+	return typeof option === "undefined" ? () => {
+		unsupported(`You should not take \`NormalizedOutputOptions#${name}\` and call it directly`);
+	} : option;
 }
 var NormalizedOutputOptionsImpl = class {
 	inner;
@@ -1582,6 +1628,9 @@ var NormalizedOutputOptionsImpl = class {
 	get comments() {
 		return this.inner.comments;
 	}
+	get polyfillRequire() {
+		return this.inner.polyfillRequire;
+	}
 };
 
 //#endregion
@@ -1632,7 +1681,7 @@ function bindingifyRenderError(args) {
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, err) => {
-			handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), new Error(err));
+			handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), normalizeErrors(err));
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
@@ -1933,7 +1982,7 @@ function normalizedStringOrRegex(pattern) {
 
 //#endregion
 //#region src/utils/bindingify-input-options.ts
-var import_binding$2 = require_chunk.__toESM(require_binding());
+var import_binding$3 = require_chunk.__toESM(require_binding());
 function bindingifyInputOptions(rawPlugins, inputOptions, outputOptions, onLog, logLevel) {
 	const pluginContextData = new PluginContextData();
 	const plugins = rawPlugins.map((plugin) => {
@@ -1964,7 +2013,9 @@ function bindingifyInputOptions(rawPlugins, inputOptions, outputOptions, onLog,
 		profilerNames: inputOptions?.profilerNames,
 		jsx: bindingifyJsx(inputOptions.jsx),
 		watch: bindingifyWatch(inputOptions.watch),
-		dropLabels: inputOptions.dropLabels
+		dropLabels: inputOptions.dropLabels,
+		keepNames: inputOptions.keepNames,
+		checks: inputOptions.checks
 	};
 }
 function bindingifyExternal(external) {
@@ -1988,7 +2039,7 @@ function bindingifyResolve(resolve) {
 		return {
 			alias: alias ? Object.entries(alias).map(([name, replacement]) => ({
 				find: name,
-				replacements: [replacement]
+				replacements: arraify(replacement)
 			})) : undefined,
 			extensionAlias: extensionAlias ? Object.entries(extensionAlias).map(([name, value]) => ({
 				target: name,
@@ -2022,10 +2073,10 @@ function bindingifyInject(inject) {
 }
 function bindingifyLogLevel(logLevel) {
 	switch (logLevel) {
-		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;
+		case "silent": return import_binding$3.BindingLogLevel.Silent;
+		case "debug": return import_binding$3.BindingLogLevel.Debug;
+		case "warn": return import_binding$3.BindingLogLevel.Warn;
+		case "info": return import_binding$3.BindingLogLevel.Info;
 		default: throw new Error(`Unexpected log level: ${logLevel}`);
 	}
 }
@@ -2041,15 +2092,20 @@ function bindingifyInput(input) {
 	});
 }
 function bindingifyJsx(input) {
+	if (input === false) return { type: "Disable" };
 	if (input) {
-		const mode = input.mode ?? "classic";
+		if (input.mode === "preserve") return { type: "Preserve" };
+		const mode = input.mode ?? "automatic";
 		return {
-			runtime: mode,
-			importSource: mode === "classic" ? input.importSource : mode === "automatic" ? input.jsxImportSource : undefined,
-			pragma: input.factory,
-			pragmaFrag: input.fragment,
-			development: input.development,
-			refresh: input.refresh
+			type: "Enable",
+			field0: {
+				runtime: mode,
+				importSource: mode === "classic" ? input.importSource : mode === "automatic" ? input.jsxImportSource : undefined,
+				pragma: input.factory,
+				pragmaFrag: input.fragment,
+				development: input.development,
+				refresh: input.refresh
+			}
 		};
 	}
 }
@@ -2060,10 +2116,6 @@ function bindingifyWatch(watch$1) {
 			include: normalizedStringOrRegex(watch$1.include),
 			exclude: normalizedStringOrRegex(watch$1.exclude)
 		};
-		if (watch$1.notify) value.notify = {
-			pollInterval: watch$1.notify.pollInterval,
-			compareContents: watch$1.notify.compareContents
-		};
 		if (watch$1.chokidar) unsupported("The watch chokidar option is deprecated, please use notify options instead of it.");
 		return value;
 	}
@@ -2118,7 +2170,8 @@ function bindingifyOutputOptions(outputOptions) {
 		minify: outputOptions.minify,
 		externalLiveBindings: outputOptions.externalLiveBindings,
 		inlineDynamicImports: outputOptions.inlineDynamicImports,
-		advancedChunks: outputOptions.advancedChunks
+		advancedChunks: outputOptions.advancedChunks,
+		polyfillRequire: outputOptions.polyfillRequire
 	};
 }
 function bindingifyAddon(configAddon) {
@@ -2287,10 +2340,7 @@ function createComposedPlugin(plugins) {
 	const createFixedPluginResolveFnMap = new Map();
 	function applyFixedPluginResolveFn(ctx, plugin) {
 		const createFixedPluginResolveFn = createFixedPluginResolveFnMap.get(plugin);
-		if (createFixedPluginResolveFn) return {
-			...ctx,
-			resolve: createFixedPluginResolveFn(ctx)
-		};
+		if (createFixedPluginResolveFn) ctx.resolve = createFixedPluginResolveFn(ctx, ctx.resolve.bind(ctx));
 		return ctx;
 	}
 	if (batchedHooks.resolveId) {
@@ -2299,14 +2349,14 @@ function createComposedPlugin(plugins) {
 		for (let handlerIdx = 0; handlerIdx < batchedHandlers.length; handlerIdx++) {
 			const [_handler, plugin] = batchedHandlers[handlerIdx];
 			const handlerSymbol = handlerSymbols[handlerIdx];
-			const createFixedPluginResolveFn = (ctx) => {
+			const createFixedPluginResolveFn = (ctx, resolve) => {
 				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);
+					return resolve(source, importer, contextResolveOptions);
 				};
 			};
 			createFixedPluginResolveFnMap.set(plugin, createFixedPluginResolveFn);
@@ -2364,12 +2414,10 @@ function createComposedPlugin(plugins) {
 						}
 						for (const [handler, plugin] of batchedHandlers) {
 							const { handler: handlerFn } = normalizeHook(handler);
-							const result = await handlerFn.call({
-								...applyFixedPluginResolveFn(this, plugin),
-								getCombinedSourcemap() {
-									throw new Error(`The getCombinedSourcemap is not implement in transform hook at composedJsPlugins`);
-								}
-							}, code, id, moduleType);
+							this.getCombinedSourcemap = () => {
+								throw new Error(`The getCombinedSourcemap is not implement in transform hook at composedJsPlugins`);
+							};
+							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);
@@ -2504,7 +2552,7 @@ else newPlugins.push(toBeComposed[0]);
 
 //#endregion
 //#region src/utils/initialize-parallel-plugins.ts
-var import_binding$1 = require_chunk.__toESM(require_binding());
+var import_binding$2 = require_chunk.__toESM(require_binding());
 async function initializeParallelPlugins(plugins) {
 	const pluginInfos = [];
 	for (const [index, plugin] of plugins.entries()) if ("_parallel" in plugin) {
@@ -2517,7 +2565,7 @@ async function initializeParallelPlugins(plugins) {
 	}
 	if (pluginInfos.length <= 0) return undefined;
 	const count = Math.min((0, node_os.availableParallelism)(), 8);
-	const parallelJsPluginRegistry = new import_binding$1.ParallelJsPluginRegistry(count);
+	const parallelJsPluginRegistry = new import_binding$2.ParallelJsPluginRegistry(count);
 	const registryId = parallelJsPluginRegistry.id;
 	const workers = await initializeWorkers(registryId, count, pluginInfos);
 	const stopWorkers = async () => {
@@ -2556,17 +2604,17 @@ else resolve();
 }
 
 //#endregion
-//#region src/utils/create-bundler.ts
-var import_binding = require_chunk.__toESM(require_binding());
-async function createBundler(inputOptions, outputOptions) {
+//#region src/utils/create-bundler-option.ts
+async function createBundlerOptions(inputOptions, outputOptions) {
 	const pluginDriver = new PluginDriver();
 	inputOptions = await pluginDriver.callOptionsHook(inputOptions);
 	if (inputOptions.treeshake !== undefined) TreeshakingOptionsSchema.parse(inputOptions.treeshake);
 	const inputPlugins = await normalizePluginOption(inputOptions.plugins);
 	const outputPlugins = await normalizePluginOption(outputOptions.plugins);
-	outputOptions = pluginDriver.callOutputOptionsHook([...inputPlugins, ...outputPlugins], outputOptions);
 	const logLevel = inputOptions.logLevel || LOG_LEVEL_INFO;
 	const onLog = getLogger(getObjectPlugins(inputPlugins), getOnLog(inputOptions, logLevel), logLevel);
+	outputOptions = pluginDriver.callOutputOptionsHook([...inputPlugins, ...outputPlugins], outputOptions);
+	if (outputOptions.minify === true) onLog(LOG_LEVEL_WARN, logMinifyWarning());
 	let plugins = [...normalizePlugins(inputPlugins, ANONYMOUS_PLUGIN_PREFIX), ...checkOutputPluginOption(normalizePlugins(await normalizePluginOption(outputOptions.plugins), ANONYMOUS_OUTPUT_PLUGIN_PREFIX), onLog)];
 	if (inputOptions.experimental?.enableComposingJsPlugins ?? false) plugins = composeJsPlugins(plugins);
 	const parallelPluginInitResult = await initializeParallelPlugins(plugins);
@@ -2574,7 +2622,13 @@ async function createBundler(inputOptions, outputOptions) {
 		const bindingInputOptions = bindingifyInputOptions(plugins, inputOptions, outputOptions, onLog, logLevel);
 		const bindingOutputOptions = bindingifyOutputOptions(outputOptions);
 		return {
-			bundler: new import_binding.Bundler(bindingInputOptions, bindingOutputOptions, parallelPluginInitResult?.registry),
+			bundlerOptions: {
+				inputOptions: bindingInputOptions,
+				outputOptions: bindingOutputOptions,
+				parallelPluginsRegistry: parallelPluginInitResult?.registry
+			},
+			inputOptions,
+			onLog,
 			stopWorkers: parallelPluginInitResult?.stopWorkers
 		};
 	} catch (e) {
@@ -2583,6 +2637,22 @@ async function createBundler(inputOptions, outputOptions) {
 	}
 }
 
+//#endregion
+//#region src/utils/create-bundler.ts
+var import_binding$1 = require_chunk.__toESM(require_binding());
+async function createBundler(inputOptions, outputOptions) {
+	const option = await createBundlerOptions(inputOptions, outputOptions);
+	try {
+		return {
+			bundler: new import_binding$1.Bundler(option.bundlerOptions),
+			stopWorkers: option.stopWorkers
+		};
+	} catch (e) {
+		await option.stopWorkers?.();
+		throw e;
+	}
+}
+
 //#endregion
 //#region src/api/rolldown/rolldown-build.ts
 Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose");
@@ -2625,98 +2695,129 @@ const rolldown = async (input) => {
 	return new RolldownBuild(input);
 };
 
+//#endregion
+//#region src/api/watch/watch-emitter.ts
+var WatcherEmitter = class {
+	listeners = new Map();
+	timer;
+	constructor() {
+		this.timer = setInterval(
+			() => {},
+			1e9
+			/* Low power usage */
+);
+	}
+	on(event, listener) {
+		const listeners = this.listeners.get(event);
+		if (listeners) listeners.push(listener);
+else this.listeners.set(event, [listener]);
+		return this;
+	}
+	async onEvent(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, 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 } = event.watchChangeData();
+					await listener(path$2, { event: kind });
+				}
+				break;
+			default: throw new Error(`Unknown event: ${event}`);
+		}
+	}
+	async close() {
+		clearInterval(this.timer);
+	}
+};
+
 //#endregion
 //#region src/api/watch/watcher.ts
+var import_binding = require_chunk.__toESM(require_binding());
 var Watcher = class {
 	closed;
-	controller;
 	inner;
+	emitter;
 	stopWorkers;
-	listeners = new Map();
-	constructor(inner, stopWorkers) {
+	constructor(emitter, inner, stopWorkers) {
 		this.closed = false;
-		this.controller = new AbortController();
 		this.inner = inner;
+		this.emitter = emitter;
+		const originClose = emitter.close.bind(emitter);
+		emitter.close = async () => {
+			await this.close();
+			originClose();
+		};
 		this.stopWorkers = stopWorkers;
 	}
 	async close() {
+		if (this.closed) return;
 		this.closed = true;
-		await this.stopWorkers?.();
+		for (const stop of this.stopWorkers) await stop?.();
 		await this.inner.close();
-		this.controller.abort();
 	}
-	on(event, listener) {
-		const listeners = this.listeners.get(event);
-		if (listeners) listeners.push(listener);
-else this.listeners.set(event, [listener]);
-		return this;
-	}
-	watch() {
-		const timer = setInterval(
-			() => {},
-			1e9
-			/* Low power usage */
-);
-		this.controller.signal.addEventListener("abort", () => {
-			clearInterval(timer);
-		});
-		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, 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 } = event.watchChangeData();
-						await listener(path$2, { event: kind });
-					}
-					break;
-				default: throw new Error(`Unknown event: ${event}`);
-			}
-		}));
+	start() {
+		process.nextTick(() => this.inner.start(this.emitter.onEvent.bind(this.emitter)));
 	}
 };
+async function createWatcher(emitter, input) {
+	const options = Array.isArray(input) ? input : [input];
+	const bundlerOptions = await Promise.all(options.map((option) => createBundlerOptions(option, option.output || {})));
+	const notifyOptions = getValidNotifyOption(bundlerOptions);
+	const bindingWatcher = new import_binding.BindingWatcher(bundlerOptions.map((option) => option.bundlerOptions), notifyOptions);
+	const watcher = new Watcher(emitter, bindingWatcher, bundlerOptions.map((option) => option.stopWorkers));
+	watcher.start();
+}
+function getValidNotifyOption(bundlerOptions) {
+	let result;
+	for (const option of bundlerOptions) if (option.inputOptions.watch) {
+		const notifyOption = option.inputOptions.watch.notify;
+		if (notifyOption) if (result) {
+			option.onLog(LOG_LEVEL_WARN, logMultiplyNotifyOption());
+			return result;
+		} else result = notifyOption;
+	}
+}
 
 //#endregion
 //#region src/api/watch/index.ts
-const watch = async (input) => {
-	const { bundler, stopWorkers } = await createBundler(input, input.output || {});
-	const bindingWatcher = await bundler.watch();
-	const watcher = new Watcher(bindingWatcher, stopWorkers);
-	watcher.watch();
-	return watcher;
+const watch = (input) => {
+	const emitter = new WatcherEmitter();
+	createWatcher(emitter, input);
+	return emitter;
 };
 
 //#endregion
 //#region package.json
-var version = "0.15.0";
+var version = "0.15.1-commit.cc6f557";
 var description = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
 
 //#endregion
@@ -2724,10 +2825,14 @@ var description = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compat
 async function build(options) {
 	if (Array.isArray(options)) return Promise.all(options.map((opts) => build(opts)));
 else {
-		const { output,...inputOptions } = options;
+		const { output, write = true,...inputOptions } = options;
 		const build$1 = await rolldown(inputOptions);
-		if (options.write) return build$1.write(output);
-else return build$1.generate(output);
+		try {
+			if (write) return await build$1.write(output);
+else return await build$1.generate(output);
+		} finally {
+			await build$1.close();
+		}
 	}
 }