@rolldown/browser 1.0.0-beta.8-commit.1fd551c → 1.0.0-beta.8-commit.852c603

package/dist/browser.mjs

@@ -5,7 +5,7 @@ import colors from "ansis";
 import * as v from "valibot";
 
 //#region package.json
-var version = "1.0.0-beta.8-commit.1fd551c";
+var version = "1.0.0-beta.8-commit.852c603";
 
 //#endregion
 //#region src/builtin-plugin/utils.ts
@@ -119,18 +119,18 @@ function rangeContains(range, index) {
 function getLocator(source, options = {}) {
 	const { offsetLine = 0, offsetColumn = 0 } = options;
 	let start = 0;
-	const ranges = source.split("\n").map((line, i$1) => {
+	const ranges = source.split("\n").map((line, i$2) => {
 		const end = start + line.length + 1;
 		/** @type {import('./types').Range} */
 		const range = {
 			start,
 			end,
-			line: i$1
+			line: i$2
 		};
 		start = end;
 		return range;
 	});
-	let i = 0;
+	let i$1 = 0;
 	/**
 	* @param {string | number} search
 	* @param {number} [index]
@@ -139,16 +139,16 @@ function getLocator(source, options = {}) {
 	function locator(search, index) {
 		if (typeof search === "string") search = source.indexOf(search, index ?? 0);
 		if (search === -1) return void 0;
-		let range = ranges[i];
-		const d = search >= range.end ? 1 : -1;
+		let range = ranges[i$1];
+		const d$1 = search >= range.end ? 1 : -1;
 		while (range) {
 			if (rangeContains(range, search)) return {
 				line: offsetLine + range.line,
 				column: offsetColumn + search - range.start,
 				character: search
 			};
-			i += d;
-			range = ranges[i];
+			i$1 += d$1;
+			range = ranges[i$1];
 		}
 	}
 	return locator;
@@ -196,14 +196,14 @@ function logMultiplyNotifyOption() {
 		message: `Found multiply notify option at watch options, using first one to start notify watcher.`
 	};
 }
-function logPluginError(error$1, plugin, { hook, id } = {}) {
+function logPluginError(error$1, plugin, { hook, id: id$1 } = {}) {
 	try {
-		const code = error$1.code;
-		if (!error$1.pluginCode && code != null && (typeof code !== "string" || !code.startsWith("PLUGIN_"))) error$1.pluginCode = code;
+		const code$1 = error$1.code;
+		if (!error$1.pluginCode && code$1 != null && (typeof code$1 !== "string" || !code$1.startsWith("PLUGIN_"))) error$1.pluginCode = code$1;
 		error$1.code = PLUGIN_ERROR;
 		error$1.plugin = plugin;
 		if (hook) error$1.hook = hook;
-		if (id) error$1.id = id;
+		if (id$1) error$1.id = id$1;
 	} catch (_) {} finally {
 		return error$1;
 	}
@@ -218,12 +218,12 @@ function error(base) {
 	}
 	throw base;
 }
-function augmentCodeLocation(properties, pos, source, id) {
+function augmentCodeLocation(properties, pos, source, id$1) {
 	if (typeof pos === "object") {
 		const { line, column } = pos;
 		properties.loc = {
 			column,
-			file: id,
+			file: id$1,
 			line
 		};
 	} else {
@@ -233,7 +233,7 @@ function augmentCodeLocation(properties, pos, source, id) {
 		const { line, column } = location;
 		properties.loc = {
 			column,
-			file: id,
+			file: id$1,
 			line
 		};
 	}
@@ -246,13 +246,13 @@ function augmentCodeLocation(properties, pos, source, id) {
 //#endregion
 //#region src/log/log-handler.ts
 const normalizeLog = (log) => typeof log === "string" ? { message: log } : typeof log === "function" ? normalizeLog(log()) : log;
-function getLogHandler(level, code, logger, pluginName, logLevel) {
+function getLogHandler(level, code$1, logger, pluginName, logLevel) {
 	if (logLevelPriority[level] < logLevelPriority[logLevel]) return noop;
 	return (log, pos) => {
 		if (pos != null) logger(LOG_LEVEL_WARN, logInvalidLogPosition(pluginName));
 		log = normalizeLog(log);
 		if (log.code && !log.pluginCode) log.pluginCode = log.code;
-		log.code = code;
+		log.code = code$1;
 		log.plugin = pluginName;
 		logger(level, log);
 	};
@@ -329,9 +329,9 @@ const getExtendedLogMessage = (log) => {
 	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);
+function relativeId(id$1) {
+	if (!path.isAbsolute(id$1)) return id$1;
+	return path.relative(path.resolve(), id$1);
 }
 
 //#endregion
@@ -898,7 +898,7 @@ function validateOption(key, options) {
 			const issuePaths = issue.path.map((path$1) => path$1.key);
 			let issueMsg = issue.message;
 			if (issue.type === "union") {
-				const subIssue = issue.issues?.find((i) => !(i.type !== issue.received && i.input === issue.input));
+				const subIssue = issue.issues?.find((i$1) => !(i$1.type !== issue.received && i$1.input === issue.input));
 				if (subIssue) {
 					if (subIssue.path) issuePaths.push(subIssue.path.map((path$1) => path$1.key));
 					issueMsg = subIssue.message;
@@ -970,13 +970,13 @@ function normalizeErrors(rawErrors) {
 		stack: void 0
 	}));
 	let summary = `Build failed with ${errors.length} error${errors.length < 2 ? "" : "s"}:\n`;
-	for (let i = 0; i < errors.length; i++) {
+	for (let i$1 = 0; i$1 < errors.length; i$1++) {
 		summary += "\n";
-		if (i >= 5) {
+		if (i$1 >= 5) {
 			summary += "...";
 			break;
 		}
-		summary += getErrorMessage(errors[i]);
+		summary += getErrorMessage(errors[i$1]);
 	}
 	const wrapper = new Error(summary);
 	Object.defineProperty(wrapper, "errors", {
@@ -995,9 +995,9 @@ function getErrorMessage(e) {
 	if (Object.hasOwn(e, "kind")) return e.message;
 	let s = "";
 	if (e.plugin) s += `[plugin ${e.plugin}]`;
-	const id = e.id ?? e.loc?.file;
-	if (id) {
-		s += " " + id;
+	const id$1 = e.id ?? e.loc?.file;
+	if (id$1) {
+		s += " " + id$1;
 		if (e.loc) s += `:${e.loc.line}:${e.loc.column}`;
 	}
 	if (s) s += "\n";
@@ -1052,41 +1052,220 @@ function isEmptySourcemapFiled(array) {
 	if (array.length === 0 || !array[0]) return true;
 	return false;
 }
-function normalizeTransformHookSourcemap(id, originalCode, rawMap) {
+function normalizeTransformHookSourcemap(id$1, originalCode, rawMap) {
 	if (!rawMap) return;
 	let map = typeof rawMap === "object" ? rawMap : JSON.parse(rawMap);
 	if (isEmptySourcemapFiled(map.sourcesContent)) map.sourcesContent = [originalCode];
-	if (isEmptySourcemapFiled(map.sources) || map.sources && map.sources.length === 1 && map.sources[0] !== id) map.sources = [id];
+	if (isEmptySourcemapFiled(map.sources) || map.sources && map.sources.length === 1 && map.sources[0] !== id$1) map.sources = [id$1];
 	return map;
 }
 
 //#endregion
-//#region src/plugin/bindingify-hook-filter.ts
-function bindingifyStringFilter(matcher) {
-	if (typeof matcher === "string" || matcher instanceof RegExp) return { include: [matcher] };
-	if (Array.isArray(matcher)) return { include: matcher };
+//#region ../../node_modules/.pnpm/remeda@2.21.2/node_modules/remeda/dist/chunk-D6FCK2GA.js
+function u$1(o, n, a) {
+	let t$1 = (r) => o(r, ...n);
+	return a === void 0 ? t$1 : Object.assign(t$1, {
+		lazy: a,
+		lazyArgs: n
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.21.2/node_modules/remeda/dist/chunk-WIMGWYZL.js
+function u(r, n, o) {
+	let a = r.length - n.length;
+	if (a === 0) return r(...n);
+	if (a === 1) return u$1(r, n, o);
+	throw new Error("Wrong number of arguments");
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.21.2/node_modules/remeda/dist/chunk-3IFJP4R5.js
+function d(...r) {
+	return u(i, r);
+}
+var i = (r, t$1) => {
+	let a = [[], []];
+	for (let [o, e] of r.entries()) t$1(e, o, r) ? a[0].push(e) : a[1].push(e);
+	return a;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.21.2/node_modules/remeda/dist/chunk-5NQBDF4H.js
+function t(...n) {
+	return u(Object.keys, n);
+}
+
+//#endregion
+//#region src/filter-expression-index.ts
+function and(left, right) {
+	return {
+		kind: "and",
+		left,
+		right
+	};
+}
+function or(left, right) {
+	return {
+		kind: "or",
+		left,
+		right
+	};
+}
+function id(pattern) {
 	return {
-		include: matcher.include ? arraify(matcher.include) : void 0,
-		exclude: matcher.exclude ? arraify(matcher.exclude) : void 0
+		kind: "id",
+		pattern
 	};
 }
+function moduleType(pattern) {
+	return {
+		kind: "moduleType",
+		pattern
+	};
+}
+function code(pattern) {
+	return {
+		kind: "code",
+		pattern
+	};
+}
+function include(expr) {
+	return {
+		kind: "include",
+		expr
+	};
+}
+function exclude(expr) {
+	return {
+		kind: "exclude",
+		expr
+	};
+}
+
+//#endregion
+//#region src/plugin/bindingify-hook-filter.ts
+function generalHookFilterMatcherToFilterExprs(matcher, stringKind) {
+	if (typeof matcher === "string" || matcher instanceof RegExp) return [include(id(matcher))];
+	if (Array.isArray(matcher)) return matcher.map((m) => include(id(m)));
+	if (matcher.custom) return matcher.custom;
+	let ret = [];
+	let isCode = stringKind === "code";
+	if (matcher.exclude) ret.push(...arraify(matcher.exclude).map((m) => exclude(isCode ? code(m) : id(m))));
+	if (matcher.include) ret.push(...arraify(matcher.include).map((m) => include(isCode ? code(m) : id(m))));
+	return ret;
+}
+function transformFilterMatcherToFilterExprs(filterOption) {
+	if (!filterOption) return void 0;
+	const { id: id$1, code: code$1, moduleType: moduleType$1, custom } = filterOption;
+	if (custom) return custom;
+	let ret = [];
+	let idIncludes = [];
+	let idExcludes = [];
+	let codeIncludes = [];
+	let codeExcludes = [];
+	if (id$1) [idIncludes, idExcludes] = d(generalHookFilterMatcherToFilterExprs(id$1, "id") ?? [], (m) => m.kind === "include");
+	if (code$1) [codeIncludes, codeExcludes] = d(generalHookFilterMatcherToFilterExprs(code$1, "code") ?? [], (m) => m.kind === "include");
+	ret.push(...idExcludes);
+	ret.push(...codeExcludes);
+	let cursor;
+	if (moduleType$1) {
+		let moduleTypes = Array.isArray(moduleType$1) ? moduleType$1 : moduleType$1.include ?? [];
+		cursor = joinFilterExprsWithOr(moduleTypes.map((m) => moduleType(m)));
+	}
+	if (idIncludes.length) {
+		let joinedOrExpr = joinFilterExprsWithOr(idIncludes.map((item) => item.expr));
+		if (!cursor) cursor = joinedOrExpr;
+		else cursor = and(cursor, joinedOrExpr);
+	}
+	if (codeIncludes.length) {
+		let joinedOrExpr = joinFilterExprsWithOr(codeIncludes.map((item) => item.expr));
+		if (!cursor) cursor = joinedOrExpr;
+		else cursor = and(cursor, joinedOrExpr);
+	}
+	if (cursor) ret.push(include(cursor));
+	return ret;
+}
+function joinFilterExprsWithOr(filterExprs) {
+	if (filterExprs.length === 1) return filterExprs[0];
+	return or(filterExprs[0], joinFilterExprsWithOr(filterExprs.slice(1)));
+}
+function bindingifyGeneralHookFilter(matcher, stringKind) {
+	let filterExprs = generalHookFilterMatcherToFilterExprs(matcher, stringKind);
+	let custom = [];
+	if (filterExprs) custom = filterExprs.map(bindingifyFilterExpr);
+	return { custom: custom.length > 0 ? custom : void 0 };
+}
+function bindingifyFilterExpr(expr) {
+	let list = [];
+	bindingifyFilterExprImpl(expr, list);
+	return list;
+}
+function bindingifyFilterExprImpl(expr, list) {
+	switch (expr.kind) {
+		case "and": {
+			bindingifyFilterExprImpl(expr.right, list);
+			bindingifyFilterExprImpl(expr.left, list);
+			list.push({ kind: "And" });
+			break;
+		}
+		case "not": {
+			bindingifyFilterExprImpl(expr.expr, list);
+			list.push({ kind: "Not" });
+			break;
+		}
+		case "id": {
+			list.push({
+				kind: "Id",
+				value: expr.pattern
+			});
+			break;
+		}
+		case "moduleType": {
+			list.push({
+				kind: "ModuleType",
+				value: expr.pattern
+			});
+			break;
+		}
+		case "code": {
+			list.push({
+				kind: "Code",
+				value: expr.pattern
+			});
+			break;
+		}
+		case "include": {
+			bindingifyFilterExprImpl(expr.expr, list);
+			list.push({ kind: "Include" });
+			break;
+		}
+		case "exclude": {
+			bindingifyFilterExprImpl(expr.expr, list);
+			list.push({ kind: "Exclude" });
+			break;
+		}
+		default: throw new Error(`Unknown filter expression kind: ${expr.kind}`);
+	}
+}
 function bindingifyResolveIdFilter(filterOption) {
-	return filterOption?.id ? bindingifyStringFilter(filterOption.id) : void 0;
+	return filterOption?.id ? bindingifyGeneralHookFilter(filterOption.id, "id") : void 0;
 }
 function bindingifyLoadFilter(filterOption) {
-	return filterOption?.id ? bindingifyStringFilter(filterOption.id) : void 0;
+	return filterOption?.id ? bindingifyGeneralHookFilter(filterOption.id, "id") : void 0;
 }
 function bindingifyTransformFilter(filterOption) {
 	if (!filterOption) return void 0;
-	const { id, code, moduleType } = filterOption;
-	let moduleTypeRet;
-	if (moduleType) if (Array.isArray(moduleType)) moduleTypeRet = moduleType;
-	else moduleTypeRet = moduleType.include;
-	return {
-		id: id ? bindingifyStringFilter(id) : void 0,
-		code: code ? bindingifyStringFilter(code) : void 0,
-		moduleType: moduleTypeRet
-	};
+	let custom = transformFilterMatcherToFilterExprs(filterOption);
+	let ret = [];
+	if (custom) ret = custom.map(bindingifyFilterExpr);
+	return { custom: ret.length > 0 ? ret : void 0 };
+}
+function bindingifyRenderChunkFilter(filterOption) {
+	if (filterOption) {
+		const { code: code$1 } = filterOption;
+		return { custom: code$1 ? bindingifyGeneralHookFilter(code$1, "code").custom : void 0 };
+	}
 }
 
 //#endregion
@@ -1105,7 +1284,7 @@ function bindingPluginOrder(order) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/oxc-parser@0.66.0/node_modules/oxc-parser/wrap.mjs
+//#region ../../node_modules/.pnpm/oxc-parser@0.67.0/node_modules/oxc-parser/wrap.mjs
 function wrap$1(result) {
 	let program, module, comments, errors;
 	return {
@@ -1127,19 +1306,20 @@ function wrap$1(result) {
 		}
 	};
 }
-function jsonParseAst(ast) {
-	return JSON.parse(ast, function(key, value) {
-		if (value === null && key === "value" && Object.hasOwn(this, "type") && this.type === "Literal") {
-			if (Object.hasOwn(this, "bigint")) return BigInt(this.bigint);
-			if (Object.hasOwn(this, "regex")) {
-				const { regex } = this;
-				try {
-					return RegExp(regex.pattern, regex.flags);
-				} catch (_err) {}
-			}
+function jsonParseAst(program) {
+	return JSON.parse(program, transform);
+}
+function transform(key, value) {
+	if (value === null && key === "value" && Object.hasOwn(this, "type") && this.type === "Literal") {
+		if (Object.hasOwn(this, "bigint")) return BigInt(this.bigint);
+		if (Object.hasOwn(this, "regex")) {
+			const { regex } = this;
+			try {
+				return RegExp(regex.pattern, regex.flags);
+			} catch (_err) {}
 		}
-		return value;
-	});
+	}
+	return value;
 }
 
 //#endregion
@@ -1151,12 +1331,12 @@ function wrap(result, sourceText) {
 }
 function normalizeParseError(sourceText, errors) {
 	let message = `Parse failed with ${errors.length} error${errors.length < 2 ? "" : "s"}:\n`;
-	for (let i = 0; i < errors.length; i++) {
-		if (i >= 5) {
+	for (let i$1 = 0; i$1 < errors.length; i$1++) {
+		if (i$1 >= 5) {
 			message += "\n...";
 			break;
 		}
-		const e = errors[i];
+		const e = errors[i$1];
 		message += e.message + "\n" + e.labels.map((label) => {
 			const location = locate(sourceText, label.start, { offsetLine: 1 });
 			if (!location) return;
@@ -1196,39 +1376,37 @@ var PluginContextImpl = class extends MinimalPluginContextImpl {
 		this.data = data;
 		this.onLog = onLog;
 		this.currentLoadingModule = currentLoadingModule;
-		this.getModuleInfo = (id) => this.data.getModuleInfo(id, context);
+		this.getModuleInfo = (id$1) => this.data.getModuleInfo(id$1, context);
 	}
 	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);
+		const id$1 = options.id;
+		if (id$1 === this.currentLoadingModule) this.onLog(LOG_LEVEL_WARN, logCycleLoading(this.pluginName, this.currentLoadingModule));
+		const moduleInfo = this.data.getModuleInfo(id$1, this.context);
 		if (moduleInfo && moduleInfo.code !== null) return moduleInfo;
 		const rawOptions = {
 			meta: options.meta || {},
 			moduleSideEffects: options.moduleSideEffects || null,
 			invalidate: false
 		};
-		this.data.updateModuleOption(id, rawOptions);
+		this.data.updateModuleOption(id$1, rawOptions);
 		async function createLoadModulePromise(context, data) {
-			const loadPromise = data.loadModulePromiseMap.get(id);
+			const loadPromise = data.loadModulePromiseMap.get(id$1);
 			if (loadPromise) return loadPromise;
-			let resolveFn;
 			const promise = new Promise((resolve, _) => {
-				resolveFn = resolve;
+				data.loadModulePromiseResolveFnMap.set(id$1, resolve);
 			});
-			data.loadModulePromiseMap.set(id, promise);
+			data.loadModulePromiseMap.set(id$1, promise);
 			try {
-				await context.load(id, bindingifySideEffects(options.moduleSideEffects), (_success) => {
-					resolveFn();
-				});
+				await context.load(id$1, bindingifySideEffects(options.moduleSideEffects));
 			} catch (e) {
-				data.loadModulePromiseMap.delete(id);
+				data.loadModulePromiseMap.delete(id$1);
+				data.loadModulePromiseResolveFnMap.delete(id$1);
 				throw e;
 			}
 			return promise;
 		}
 		await createLoadModulePromise(this.context, this.data);
-		return this.data.getModuleInfo(id, this.context);
+		return this.data.getModuleInfo(id$1, this.context);
 	}
 	async resolve(source, importer, options) {
 		let receipt = void 0;
@@ -1271,8 +1449,8 @@ var PluginContextImpl = class extends MinimalPluginContextImpl {
 	getModuleIds() {
 		return this.data.getModuleIds(this.context);
 	}
-	addWatchFile(id) {
-		this.context.addWatchFile(id);
+	addWatchFile(id$1) {
+		this.context.addWatchFile(id$1);
 	}
 	parse(input, options) {
 		return parseAst(input, options);
@@ -1406,18 +1584,18 @@ function bindingifyTransform(args) {
 	if (!hook) return {};
 	const { handler, meta, options } = normalizeHook(hook);
 	return {
-		plugin: async (ctx, code, id, meta$1) => {
-			const ret = await handler.call(new TransformPluginContextImpl(args.outputOptions, ctx.inner(), args.plugin, args.pluginContextData, ctx, id, code, args.onLog, args.logLevel, args.watchMode), code, id, meta$1);
+		plugin: async (ctx, code$1, id$1, meta$1) => {
+			const ret = await handler.call(new TransformPluginContextImpl(args.outputOptions, ctx.inner(), args.plugin, args.pluginContextData, ctx, id$1, code$1, args.onLog, args.logLevel, args.watchMode), code$1, id$1, meta$1);
 			if (ret == null) return void 0;
 			if (typeof ret === "string") return { code: ret };
-			let moduleOption = args.pluginContextData.updateModuleOption(id, {
+			let moduleOption = args.pluginContextData.updateModuleOption(id$1, {
 				meta: ret.meta ?? {},
 				moduleSideEffects: ret.moduleSideEffects ?? null,
 				invalidate: false
 			});
 			return {
 				code: ret.code,
-				map: bindingifySourcemap$1(normalizeTransformHookSourcemap(id, code, ret.map)),
+				map: bindingifySourcemap$1(normalizeTransformHookSourcemap(id$1, code$1, ret.map)),
 				sideEffects: bindingifySideEffects(moduleOption.moduleSideEffects),
 				moduleType: ret.moduleType
 			};
@@ -1431,16 +1609,16 @@ function bindingifyLoad(args) {
 	if (!hook) return {};
 	const { handler, meta, options } = normalizeHook(hook);
 	return {
-		plugin: async (ctx, id) => {
-			const ret = await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode, id), id);
+		plugin: async (ctx, id$1) => {
+			const ret = await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode, id$1), id$1);
 			if (ret == null) return;
 			if (typeof ret === "string") return { code: ret };
-			let moduleOption = args.pluginContextData.updateModuleOption(id, {
+			let moduleOption = args.pluginContextData.updateModuleOption(id$1, {
 				meta: ret.meta || {},
 				moduleSideEffects: ret.moduleSideEffects ?? null,
 				invalidate: false
 			});
-			let map = preProcessSourceMap(ret, id);
+			let map = preProcessSourceMap(ret, id$1);
 			return {
 				code: ret.code,
 				map: bindingifySourcemap$1(map),
@@ -1452,11 +1630,11 @@ function bindingifyLoad(args) {
 		filter: bindingifyLoadFilter(options.filter)
 	};
 }
-function preProcessSourceMap(ret, id) {
+function preProcessSourceMap(ret, id$1) {
 	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 directory = path.dirname(id$1) || ".";
 		const sourceRoot = map.sourceRoot || ".";
 		map.sources = map.sources.map((source) => path.resolve(directory, sourceRoot, source));
 	}
@@ -1530,9 +1708,9 @@ function transformRenderedChunk(chunk) {
 }
 function transformChunkModules(modules) {
 	const result = {};
-	for (let i = 0; i < modules.values.length; i++) {
-		let key = modules.keys[i];
-		const mod = modules.values[i];
+	for (let i$1 = 0; i$1 < modules.values.length; i$1++) {
+		let key = modules.keys[i$1];
+		const mod = modules.values[i$1];
 		result[key] = transformToRenderedModule(mod);
 	}
 	return result;
@@ -1880,11 +2058,11 @@ function bindingifyRenderStart(args) {
 function bindingifyRenderChunk(args) {
 	const hook = args.plugin.renderChunk;
 	if (!hook) return {};
-	const { handler, meta } = normalizeHook(hook);
+	const { handler, meta, options } = normalizeHook(hook);
 	return {
-		plugin: async (ctx, code, chunk, opts, meta$1) => {
+		plugin: async (ctx, code$1, chunk, opts, meta$1) => {
 			if (args.pluginContextData.getRenderChunkMeta() == null) args.pluginContextData.setRenderChunkMeta({ chunks: Object.fromEntries(Object.entries(meta$1.chunks).map(([key, value]) => [key, transformRenderedChunk(value)])) });
-			const ret = await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), code, transformRenderedChunk(chunk), new NormalizedOutputOptionsImpl(opts, args.outputOptions, args.normalizedOutputPlugins), args.pluginContextData.getRenderChunkMeta());
+			const ret = await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), code$1, transformRenderedChunk(chunk), new NormalizedOutputOptionsImpl(opts, args.outputOptions, args.normalizedOutputPlugins), args.pluginContextData.getRenderChunkMeta());
 			if (ret == null) return;
 			if (typeof ret === "string") return { code: ret };
 			if (!ret.map) return { code: ret.code };
@@ -1893,7 +2071,8 @@ function bindingifyRenderChunk(args) {
 				map: bindingifySourcemap$1(ret.map)
 			};
 		},
-		meta: bindingifyPluginHookMeta(meta)
+		meta: bindingifyPluginHookMeta(meta),
+		filter: bindingifyRenderChunkFilter(options.filter)
 	};
 }
 function bindingifyAugmentChunkHash(args) {
@@ -2019,8 +2198,8 @@ function bindingifyWatchChange(args) {
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
-		plugin: async (ctx, id, event) => {
-			await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), id, { event });
+		plugin: async (ctx, id$1, event) => {
+			await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), id$1, { event });
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
@@ -2115,10 +2294,10 @@ function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, nor
 	const { plugin: resolveId, meta: resolveIdMeta, filter: resolveIdFilter } = bindingifyResolveId(args);
 	const { plugin: resolveDynamicImport, meta: resolveDynamicImportMeta } = bindingifyResolveDynamicImport(args);
 	const { plugin: buildEnd, meta: buildEndMeta } = bindingifyBuildEnd(args);
-	const { plugin: transform, meta: transformMeta, filter: transformFilter } = bindingifyTransform(args);
+	const { plugin: transform$1, meta: transformMeta, filter: transformFilter } = bindingifyTransform(args);
 	const { plugin: moduleParsed, meta: moduleParsedMeta } = bindingifyModuleParsed(args);
 	const { plugin: load, meta: loadMeta, filter: loadFilter } = bindingifyLoad(args);
-	const { plugin: renderChunk, meta: renderChunkMeta } = bindingifyRenderChunk(args);
+	const { plugin: renderChunk, meta: renderChunkMeta, filter: renderChunkFilter } = bindingifyRenderChunk(args);
 	const { plugin: augmentChunkHash, meta: augmentChunkHashMeta } = bindingifyAugmentChunkHash(args);
 	const { plugin: renderStart, meta: renderStartMeta } = bindingifyRenderStart(args);
 	const { plugin: renderError, meta: renderErrorMeta } = bindingifyRenderError(args);
@@ -2143,7 +2322,7 @@ function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, nor
 		resolveDynamicImportMeta,
 		buildEnd,
 		buildEndMeta,
-		transform,
+		transform: transform$1,
 		transformMeta,
 		transformFilter,
 		moduleParsed,
@@ -2153,6 +2332,7 @@ function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, nor
 		loadFilter,
 		renderChunk,
 		renderChunkMeta,
+		renderChunkFilter,
 		augmentChunkHash,
 		augmentChunkHashMeta,
 		renderStart,
@@ -2225,47 +2405,48 @@ var PluginContextData = class {
 	moduleOptionMap = new Map();
 	resolveOptionsMap = new Map();
 	loadModulePromiseMap = new Map();
+	loadModulePromiseResolveFnMap = new Map();
 	renderedChunkMeta = null;
-	updateModuleOption(id, option) {
-		const existing = this.moduleOptionMap.get(id);
+	updateModuleOption(id$1, option) {
+		const existing = this.moduleOptionMap.get(id$1);
 		if (existing) {
 			if (option.moduleSideEffects != null) existing.moduleSideEffects = option.moduleSideEffects;
 			if (option.meta != null) Object.assign(existing.meta, option.meta);
 			if (option.invalidate != null) existing.invalidate = option.invalidate;
 		} else {
-			this.moduleOptionMap.set(id, option);
+			this.moduleOptionMap.set(id$1, option);
 			return option;
 		}
 		return existing;
 	}
-	getModuleOption(id) {
-		const option = this.moduleOptionMap.get(id);
+	getModuleOption(id$1) {
+		const option = this.moduleOptionMap.get(id$1);
 		if (!option) {
 			const raw = {
 				moduleSideEffects: null,
 				meta: {}
 			};
-			this.moduleOptionMap.set(id, raw);
+			this.moduleOptionMap.set(id$1, raw);
 			return raw;
 		}
 		return option;
 	}
-	getModuleInfo(id, context) {
-		const bindingInfo = context.getModuleInfo(id);
+	getModuleInfo(id$1, context) {
+		const bindingInfo = context.getModuleInfo(id$1);
 		if (bindingInfo) {
-			const info = transformModuleInfo(bindingInfo, this.getModuleOption(id));
-			return this.proxyModuleInfo(id, info);
+			const info = transformModuleInfo(bindingInfo, this.getModuleOption(id$1));
+			return this.proxyModuleInfo(id$1, info);
 		}
 		return null;
 	}
-	proxyModuleInfo(id, info) {
+	proxyModuleInfo(id$1, info) {
 		let moduleSideEffects = info.moduleSideEffects;
 		Object.defineProperty(info, "moduleSideEffects", {
 			get() {
 				return moduleSideEffects;
 			},
 			set: (v$1) => {
-				this.updateModuleOption(id, {
+				this.updateModuleOption(id$1, {
 					moduleSideEffects: v$1,
 					meta: info.meta,
 					invalidate: true
@@ -2296,9 +2477,14 @@ var PluginContextData = class {
 	getRenderChunkMeta() {
 		return this.renderedChunkMeta;
 	}
+	markModuleLoaded(id$1, _success) {
+		const resolve = this.loadModulePromiseResolveFnMap.get(id$1);
+		if (resolve) resolve();
+	}
 	clear() {
 		this.renderedChunkMeta = null;
 		this.loadModulePromiseMap.clear();
+		this.loadModulePromiseResolveFnMap.clear();
 	}
 };
 
@@ -2362,7 +2548,8 @@ function bindingifyInputOptions(rawPlugins, inputOptions, outputOptions, normali
 		},
 		makeAbsoluteExternalsRelative: bindingifyMakeAbsoluteExternalsRelative(inputOptions.makeAbsoluteExternalsRelative),
 		debug: inputOptions.debug,
-		invalidateJsSideCache: pluginContextData.clear.bind(pluginContextData)
+		invalidateJsSideCache: pluginContextData.clear.bind(pluginContextData),
+		markModuleLoaded: pluginContextData.markModuleLoaded.bind(pluginContextData)
 	};
 }
 function bindingifyHmr(hmr) {
@@ -2373,15 +2560,15 @@ function bindingifyHmr(hmr) {
 }
 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;
+		if (typeof external === "function") return (id$1, importer, isResolved) => {
+			if (id$1.startsWith("\0")) return false;
+			return external(id$1, importer, isResolved) ?? false;
 		};
 		const externalArr = arraify(external);
-		return (id, _importer, _isResolved) => {
+		return (id$1, _importer, _isResolved) => {
 			return externalArr.some((pat) => {
-				if (pat instanceof RegExp) return pat.test(id);
-				return id === pat;
+				if (pat instanceof RegExp) return pat.test(id$1);
+				return id$1 === pat;
 			});
 		};
 	}
@@ -2502,31 +2689,6 @@ function bindingifyMakeAbsoluteExternalsRelative(makeAbsoluteExternalsRelative)
 	};
 }
 
-//#endregion
-//#region ../../node_modules/.pnpm/remeda@2.21.2/node_modules/remeda/dist/chunk-D6FCK2GA.js
-function u$1(o, n, a) {
-	let t$1 = (r) => o(r, ...n);
-	return a === void 0 ? t$1 : Object.assign(t$1, {
-		lazy: a,
-		lazyArgs: n
-	});
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/remeda@2.21.2/node_modules/remeda/dist/chunk-WIMGWYZL.js
-function u(r, n, o) {
-	let a = r.length - n.length;
-	if (a === 0) return r(...n);
-	if (a === 1) return u$1(r, n, o);
-	throw new Error("Wrong number of arguments");
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/remeda@2.21.2/node_modules/remeda/dist/chunk-5NQBDF4H.js
-function t(...n) {
-	return u(Object.keys, n);
-}
-
 //#endregion
 //#region src/utils/plugin/index.ts
 const isPluginHookName = function() {
@@ -2686,10 +2848,10 @@ function createComposedPlugin(plugins) {
 			case "load": {
 				if (batchedHooks.load) {
 					const batchedHandlers = batchedHooks.load;
-					composed.load = async function(id) {
+					composed.load = async function(id$1) {
 						for (const [handler, plugin] of batchedHandlers) {
 							const { handler: handlerFn } = normalizeHook(handler);
-							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), id);
+							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), id$1);
 							if (!isNullish(result)) return result;
 						}
 					};
@@ -2699,11 +2861,11 @@ function createComposedPlugin(plugins) {
 			case "transform": {
 				if (batchedHooks.transform) {
 					const batchedHandlers = batchedHooks.transform;
-					composed.transform = async function(initialCode, id, moduleType) {
-						let code = initialCode;
+					composed.transform = async function(initialCode, id$1, moduleType$1) {
+						let code$1 = initialCode;
 						let moduleSideEffects = void 0;
 						function updateOutput(newCode, newModuleSideEffects) {
-							code = newCode;
+							code$1 = newCode;
 							moduleSideEffects = newModuleSideEffects ?? void 0;
 						}
 						for (const [handler, plugin] of batchedHandlers) {
@@ -2711,14 +2873,14 @@ function createComposedPlugin(plugins) {
 							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);
+							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), code$1, id$1, moduleType$1);
 							if (!isNullish(result)) {
 								if (typeof result === "string") updateOutput(result);
 								else if (result.code) updateOutput(result.code, result.moduleSideEffects);
 							}
 						}
 						return {
-							code,
+							code: code$1,
 							moduleSideEffects
 						};
 					};
@@ -2740,10 +2902,10 @@ function createComposedPlugin(plugins) {
 			case "renderChunk": {
 				if (batchedHooks.renderChunk) {
 					const batchedHandlers = batchedHooks.renderChunk;
-					composed.renderChunk = async function(code, chunk, options, meta) {
+					composed.renderChunk = async function(code$1, chunk, options, meta) {
 						for (const [handler, plugin] of batchedHandlers) {
 							const { handler: handlerFn } = normalizeHook(handler);
-							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), code, chunk, options, meta);
+							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), code$1, chunk, options, meta);
 							if (!isNullish(result)) return result;
 						}
 					};
@@ -2780,10 +2942,10 @@ function createComposedPlugin(plugins) {
 			case "watchChange": {
 				if (batchedHooks.watchChange) {
 					const batchedHandlers = batchedHooks.watchChange;
-					composed.watchChange = async function(id, event) {
+					composed.watchChange = async function(id$1, event) {
 						await Promise.all(batchedHandlers.map(([handler, plugin]) => {
 							const { handler: handlerFn } = normalizeHook(handler);
-							return handlerFn.call(applyFixedPluginResolveFn(this, plugin), id, event);
+							return handlerFn.call(applyFixedPluginResolveFn(this, plugin), id$1, event);
 						}));
 					};
 				}
@@ -2992,8 +3154,8 @@ var WatcherEmitter = class {
 				break;
 			case "event":
 				for (const listener of listeners) {
-					const code = event.bundleEventKind();
-					switch (code) {
+					const code$1 = event.bundleEventKind();
+					switch (code$1) {
 						case "BUNDLE_END":
 							const { duration, output } = event.bundleEndData();
 							await listener({
@@ -3010,7 +3172,7 @@ var WatcherEmitter = class {
 							});
 							break;
 						default:
-							await listener({ code });
+							await listener({ code: code$1 });
 							break;
 					}
 				}
@@ -3120,10 +3282,10 @@ function withFilter(pluginOption, filterObject) {
 }
 function findMatchedFilterObject(pluginName, overrideFilterObjectList) {
 	if (overrideFilterObjectList.length === 1 && overrideFilterObjectList[0].pluginNamePattern === void 0) return 0;
-	for (let i = 0; i < overrideFilterObjectList.length; i++) for (let j = 0; j < (overrideFilterObjectList[i].pluginNamePattern ?? []).length; j++) {
-		let pattern = overrideFilterObjectList[i].pluginNamePattern[j];
-		if (typeof pattern === "string" && pattern === pluginName) return i;
-		else if (pattern instanceof RegExp && pattern.test(pluginName)) return i;
+	for (let i$1 = 0; i$1 < overrideFilterObjectList.length; i$1++) for (let j = 0; j < (overrideFilterObjectList[i$1].pluginNamePattern ?? []).length; j++) {
+		let pattern = overrideFilterObjectList[i$1].pluginNamePattern[j];
+		if (typeof pattern === "string" && pattern === pluginName) return i$1;
+		else if (pattern instanceof RegExp && pattern.test(pluginName)) return i$1;
 	}
 	return -1;
 }