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

package/dist/shared/{src-CJ9XODOK.cjs → src-DbbYa-_8.cjs}

@@ -1,6 +1,7 @@
 "use strict";
 const require_chunk = require('./chunk-qZFfknuJ.cjs');
 const require_parse_ast_index = require('./parse-ast-index-B9pj8J1q.cjs');
+const require_filter_expression_index = require('./filter-expression-index-CRtoeipP.cjs');
 const src_rolldown_binding_wasi_cjs = require_chunk.__toESM(require("../rolldown-binding.wasi.cjs"));
 const node_path = require_chunk.__toESM(require("node:path"));
 const __valibot_to_json_schema = require_chunk.__toESM(require("@valibot/to-json-schema"));
@@ -10,7 +11,7 @@ const node_os = require_chunk.__toESM(require("node:os"));
 const node_worker_threads = require_chunk.__toESM(require("node:worker_threads"));
 
 //#region package.json
-var version = "1.0.0-beta.8-commit.a98d94e";
+var version = "1.0.0-beta.8-commit.852c603";
 var description = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
 
 //#endregion
@@ -138,13 +139,13 @@ const logLevelPriority = {
 //#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, require_parse_ast_index.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);
 	};
@@ -221,9 +222,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 (!node_path.default.isAbsolute(id)) return id;
-	return node_path.default.relative(node_path.default.resolve(), id);
+function relativeId(id$1) {
+	if (!node_path.default.isAbsolute(id$1)) return id$1;
+	return node_path.default.relative(node_path.default.resolve(), id$1);
 }
 
 //#endregion
@@ -797,7 +798,7 @@ function validateOption(key, options) {
 			const issuePaths = issue.path.map((path$2) => path$2.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$2) => path$2.key));
 					issueMsg = subIssue.message;
@@ -878,13 +879,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", {
@@ -903,9 +904,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";
@@ -960,41 +961,173 @@ 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 ../../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/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 };
-	return {
-		include: matcher.include ? arraify(matcher.include) : void 0,
-		exclude: matcher.exclude ? arraify(matcher.exclude) : void 0
-	};
+function generalHookFilterMatcherToFilterExprs(matcher, stringKind) {
+	if (typeof matcher === "string" || matcher instanceof RegExp) return [require_filter_expression_index.include(require_filter_expression_index.id(matcher))];
+	if (Array.isArray(matcher)) return matcher.map((m) => require_filter_expression_index.include(require_filter_expression_index.id(m)));
+	if (matcher.custom) return matcher.custom;
+	let ret = [];
+	let isCode = stringKind === "code";
+	if (matcher.exclude) ret.push(...arraify(matcher.exclude).map((m) => require_filter_expression_index.exclude(isCode ? require_filter_expression_index.code(m) : require_filter_expression_index.id(m))));
+	if (matcher.include) ret.push(...arraify(matcher.include).map((m) => require_filter_expression_index.include(isCode ? require_filter_expression_index.code(m) : require_filter_expression_index.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) => require_filter_expression_index.moduleType(m)));
+	}
+	if (idIncludes.length) {
+		let joinedOrExpr = joinFilterExprsWithOr(idIncludes.map((item) => item.expr));
+		if (!cursor) cursor = joinedOrExpr;
+		else cursor = require_filter_expression_index.and(cursor, joinedOrExpr);
+	}
+	if (codeIncludes.length) {
+		let joinedOrExpr = joinFilterExprsWithOr(codeIncludes.map((item) => item.expr));
+		if (!cursor) cursor = joinedOrExpr;
+		else cursor = require_filter_expression_index.and(cursor, joinedOrExpr);
+	}
+	if (cursor) ret.push(require_filter_expression_index.include(cursor));
+	return ret;
+}
+function joinFilterExprsWithOr(filterExprs) {
+	if (filterExprs.length === 1) return filterExprs[0];
+	return require_filter_expression_index.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
@@ -1032,39 +1165,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, require_parse_ast_index.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, require_parse_ast_index.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;
@@ -1107,8 +1238,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 require_parse_ast_index.parseAst(input, options);
@@ -1242,18 +1373,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
 			};
@@ -1267,16 +1398,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),
@@ -1288,11 +1419,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 = node_path.default.dirname(id) || ".";
+		const directory = node_path.default.dirname(id$1) || ".";
 		const sourceRoot = map.sourceRoot || ".";
 		map.sources = map.sources.map((source) => node_path.default.resolve(directory, sourceRoot, source));
 	}
@@ -1366,9 +1497,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;
@@ -1716,11 +1847,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 };
@@ -1729,7 +1860,8 @@ function bindingifyRenderChunk(args) {
 				map: bindingifySourcemap$1(ret.map)
 			};
 		},
-		meta: bindingifyPluginHookMeta(meta)
+		meta: bindingifyPluginHookMeta(meta),
+		filter: bindingifyRenderChunkFilter(options.filter)
 	};
 }
 function bindingifyAugmentChunkHash(args) {
@@ -1855,8 +1987,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)
 	};
@@ -1954,7 +2086,7 @@ function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, nor
 	const { plugin: transform, 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);
@@ -1989,6 +2121,7 @@ function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, nor
 		loadFilter,
 		renderChunk,
 		renderChunkMeta,
+		renderChunkFilter,
 		augmentChunkHash,
 		augmentChunkHashMeta,
 		renderStart,
@@ -2061,47 +2194,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) => {
-				this.updateModuleOption(id, {
+				this.updateModuleOption(id$1, {
 					moduleSideEffects: v,
 					meta: info.meta,
 					invalidate: true
@@ -2132,9 +2266,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();
 	}
 };
 
@@ -2198,7 +2337,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) {
@@ -2209,15 +2349,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;
 			});
 		};
 	}
@@ -2338,31 +2478,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() {
@@ -2522,10 +2637,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;
 						}
 					};
@@ -2535,11 +2650,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) {
@@ -2547,14 +2662,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
 						};
 					};
@@ -2576,10 +2691,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;
 						}
 					};
@@ -2616,10 +2731,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);
 						}));
 					};
 				}
@@ -2706,7 +2821,7 @@ async function initializeParallelPlugins(plugins) {
 	};
 }
 function initializeWorkers(registryId, count, pluginInfos) {
-	return Promise.all(Array.from({ length: count }, (_, i) => initializeWorker(registryId, pluginInfos, i)));
+	return Promise.all(Array.from({ length: count }, (_, i$1) => initializeWorker(registryId, pluginInfos, i$1)));
 }
 async function initializeWorker(registryId, pluginInfos, threadNumber) {
 	const urlString = (void 0)("#parallel-plugin-worker");
@@ -2880,8 +2995,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({
@@ -2898,7 +3013,7 @@ var WatcherEmitter = class {
 							});
 							break;
 						default:
-							await listener({ code });
+							await listener({ code: code$1 });
 							break;
 					}
 				}
@@ -3008,10 +3123,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;
 }