rolldown 1.0.0-beta.8-commit.c76291c → 1.0.0-beta.8-commit.56abf23

package/dist/shared/{src-_pefwDkF.cjs → src-RTReWFUn.cjs}

@@ -1,20 +1,22 @@
 "use strict";
 const require_chunk = require('./chunk-qZFfknuJ.cjs');
-const require_parse_ast_index = require('./parse-ast-index-n6Ys2h9o.cjs');
-const require_filter_index = require('./filter-index-DblXSw9s.cjs');
+const require_parse_ast_index = require('./parse-ast-index-C37DYnt2.cjs');
+const require_misc = require('./misc-BWx4LNta.cjs');
 const node_path = require_chunk.__toESM(require("node:path"));
 const ansis = require_chunk.__toESM(require("ansis"));
+const __rolldown_pluginutils = require_chunk.__toESM(require("@rolldown/pluginutils"));
 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.c76291c";
+var version = "1.0.0-beta.8-commit.56abf23";
 var description$1 = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
 
 //#endregion
 //#region src/builtin-plugin/utils.ts
+var import_binding$6 = require_chunk.__toESM(require_parse_ast_index.require_binding());
 function makeBuiltinPluginCallable(plugin) {
-	let callablePlugin = new require_parse_ast_index.import_binding.BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
+	let callablePlugin = new import_binding$6.BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
 	const wrappedPlugin = plugin;
 	for (const key in callablePlugin) wrappedPlugin[key] = function(...args$1) {
 		return callablePlugin[key](...args$1);
@@ -112,13 +114,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$1, logger, pluginName, logLevel) {
-	if (logLevelPriority[level] < logLevelPriority[logLevel]) return require_filter_index.noop;
+function getLogHandler(level, code, logger, pluginName, logLevel) {
+	if (logLevelPriority[level] < logLevelPriority[logLevel]) return require_misc.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$1;
+		log.code = code;
 		log.plugin = pluginName;
 		logger(level, log);
 	};
@@ -195,9 +197,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$1) {
-	if (!node_path.default.isAbsolute(id$1)) return id$1;
-	return node_path.default.relative(node_path.default.resolve(), id$1);
+function relativeId(id) {
+	if (!node_path.default.isAbsolute(id)) return id;
+	return node_path.default.relative(node_path.default.resolve(), id);
 }
 
 //#endregion
@@ -216,7 +218,7 @@ function normalizeHook(hook) {
 			meta: { order }
 		};
 	}
-	require_filter_index.unreachable("Invalid hook type");
+	require_misc.unreachable("Invalid hook type");
 }
 
 //#endregion
@@ -2161,9 +2163,9 @@ function getErrorMessage(e) {
 	if (Object.hasOwn(e, "kind")) return e.message;
 	let s = "";
 	if (e.plugin) s += `[plugin ${e.plugin}]`;
-	const id$1 = e.id ?? e.loc?.file;
-	if (id$1) {
-		s += " " + id$1;
+	const id = e.id ?? e.loc?.file;
+	if (id) {
+		s += " " + id;
 		if (e.loc) s += `:${e.loc.line}:${e.loc.column}`;
 	}
 	if (s) s += "\n";
@@ -2182,7 +2184,7 @@ function joinNewLine(s1, s2) {
 function transformModuleInfo(info, option) {
 	return {
 		get ast() {
-			return require_filter_index.unsupported("ModuleInfo#ast");
+			return require_misc.unsupported("ModuleInfo#ast");
 		},
 		get code() {
 			return info.code;
@@ -2200,11 +2202,12 @@ function transformModuleInfo(info, option) {
 
 //#endregion
 //#region src/utils/transform-side-effects.ts
+var import_binding$5 = require_chunk.__toESM(require_parse_ast_index.require_binding());
 function bindingifySideEffects(sideEffects) {
 	switch (sideEffects) {
-		case true: return require_parse_ast_index.import_binding.BindingHookSideEffects.True;
-		case false: return require_parse_ast_index.import_binding.BindingHookSideEffects.False;
-		case "no-treeshake": return require_parse_ast_index.import_binding.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 void 0: return void 0;
 		default: throw new Error(`Unexpected side effects: ${sideEffects}`);
@@ -2218,11 +2221,11 @@ function isEmptySourcemapFiled(array$1) {
 	if (array$1.length === 0 || !array$1[0]) return true;
 	return false;
 }
-function normalizeTransformHookSourcemap(id$1, originalCode, rawMap) {
+function normalizeTransformHookSourcemap(id, 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$1) map.sources = [id$1];
+	if (isEmptySourcemapFiled(map.sources) || map.sources && map.sources.length === 1 && map.sources[0] !== id) map.sources = [id];
 	return map;
 }
 
@@ -2265,37 +2268,37 @@ function t(...n) {
 //#endregion
 //#region src/plugin/bindingify-hook-filter.ts
 function generalHookFilterMatcherToFilterExprs(matcher, stringKind) {
-	if (typeof matcher === "string" || matcher instanceof RegExp) return [require_filter_index.include(generateAtomMatcher(stringKind, matcher))];
-	if (Array.isArray(matcher)) return matcher.map((m) => require_filter_index.include(generateAtomMatcher(stringKind, m)));
+	if (typeof matcher === "string" || matcher instanceof RegExp) return [__rolldown_pluginutils.include(generateAtomMatcher(stringKind, matcher))];
+	if (Array.isArray(matcher)) return matcher.map((m) => __rolldown_pluginutils.include(generateAtomMatcher(stringKind, m)));
 	let ret = [];
-	if (matcher.exclude) ret.push(...require_filter_index.arraify(matcher.exclude).map((m) => require_filter_index.exclude(generateAtomMatcher(stringKind, m))));
-	if (matcher.include) ret.push(...require_filter_index.arraify(matcher.include).map((m) => require_filter_index.include(generateAtomMatcher(stringKind, m))));
+	if (matcher.exclude) ret.push(...require_misc.arraify(matcher.exclude).map((m) => __rolldown_pluginutils.exclude(generateAtomMatcher(stringKind, m))));
+	if (matcher.include) ret.push(...require_misc.arraify(matcher.include).map((m) => __rolldown_pluginutils.include(generateAtomMatcher(stringKind, m))));
 	return ret;
 }
 function generateAtomMatcher(kind, matcher) {
-	return kind === "code" ? require_filter_index.code(matcher) : require_filter_index.id(matcher);
+	return kind === "code" ? __rolldown_pluginutils.code(matcher) : __rolldown_pluginutils.id(matcher);
 }
 function transformFilterMatcherToFilterExprs(filterOption) {
 	if (!filterOption) return void 0;
 	if (Array.isArray(filterOption)) return filterOption;
-	const { id: id$1, code: code$1, moduleType: moduleType$1 } = filterOption;
+	const { id, code, moduleType } = filterOption;
 	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");
+	if (id) [idIncludes, idExcludes] = d(generalHookFilterMatcherToFilterExprs(id, "id") ?? [], (m) => m.kind === "include");
+	if (code) [codeIncludes, codeExcludes] = d(generalHookFilterMatcherToFilterExprs(code, "code") ?? [], (m) => m.kind === "include");
 	ret.push(...idExcludes);
 	ret.push(...codeExcludes);
 	let andExprList = [];
-	if (moduleType$1) {
-		let moduleTypes = Array.isArray(moduleType$1) ? moduleType$1 : moduleType$1.include ?? [];
-		andExprList.push(require_filter_index.or(...moduleTypes.map((m) => require_filter_index.moduleType(m))));
+	if (moduleType) {
+		let moduleTypes = Array.isArray(moduleType) ? moduleType : moduleType.include ?? [];
+		andExprList.push(__rolldown_pluginutils.or(...moduleTypes.map((m) => __rolldown_pluginutils.moduleType(m))));
 	}
-	if (idIncludes.length) andExprList.push(require_filter_index.or(...idIncludes.map((item) => item.expr)));
-	if (codeIncludes.length) andExprList.push(require_filter_index.or(...codeIncludes.map((item) => item.expr)));
-	if (andExprList.length) ret.push(require_filter_index.include(require_filter_index.and(...andExprList)));
+	if (idIncludes.length) andExprList.push(__rolldown_pluginutils.or(...idIncludes.map((item) => item.expr)));
+	if (codeIncludes.length) andExprList.push(__rolldown_pluginutils.or(...codeIncludes.map((item) => item.expr)));
+	if (andExprList.length) ret.push(__rolldown_pluginutils.include(__rolldown_pluginutils.and(...andExprList)));
 	return ret;
 }
 function bindingifyGeneralHookFilter(stringKind, pattern) {
@@ -2393,13 +2396,14 @@ function bindingifyRenderChunkFilter(filterOption) {
 
 //#endregion
 //#region src/plugin/bindingify-plugin-hook-meta.ts
+var import_binding$4 = require_chunk.__toESM(require_parse_ast_index.require_binding());
 function bindingifyPluginHookMeta(options) {
 	return { order: bindingPluginOrder(options.order) };
 }
 function bindingPluginOrder(order) {
 	switch (order) {
-		case "post": return require_parse_ast_index.import_binding.BindingPluginOrder.Post;
-		case "pre": return require_parse_ast_index.import_binding.BindingPluginOrder.Pre;
+		case "post": return import_binding$4.BindingPluginOrder.Post;
+		case "pre": return import_binding$4.BindingPluginOrder.Pre;
 		case null:
 		case void 0: return void 0;
 		default: throw new Error(`Unknown plugin order: ${order}`);
@@ -2426,37 +2430,37 @@ var PluginContextImpl = class extends MinimalPluginContextImpl {
 		this.data = data;
 		this.onLog = onLog;
 		this.currentLoadingModule = currentLoadingModule;
-		this.getModuleInfo = (id$1) => this.data.getModuleInfo(id$1, context);
+		this.getModuleInfo = (id) => this.data.getModuleInfo(id, context);
 	}
 	async load(options) {
-		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);
+		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);
 		if (moduleInfo && moduleInfo.code !== null) return moduleInfo;
 		const rawOptions = {
 			meta: options.meta || {},
 			moduleSideEffects: options.moduleSideEffects || null,
 			invalidate: false
 		};
-		this.data.updateModuleOption(id$1, rawOptions);
+		this.data.updateModuleOption(id, rawOptions);
 		async function createLoadModulePromise(context, data) {
-			const loadPromise = data.loadModulePromiseMap.get(id$1);
+			const loadPromise = data.loadModulePromiseMap.get(id);
 			if (loadPromise) return loadPromise;
 			const promise$1 = new Promise((resolve, _) => {
-				data.loadModulePromiseResolveFnMap.set(id$1, resolve);
+				data.loadModulePromiseResolveFnMap.set(id, resolve);
 			});
-			data.loadModulePromiseMap.set(id$1, promise$1);
+			data.loadModulePromiseMap.set(id, promise$1);
 			try {
-				await context.load(id$1, bindingifySideEffects(options.moduleSideEffects));
+				await context.load(id, bindingifySideEffects(options.moduleSideEffects));
 			} catch (e) {
-				data.loadModulePromiseMap.delete(id$1);
-				data.loadModulePromiseResolveFnMap.delete(id$1);
+				data.loadModulePromiseMap.delete(id);
+				data.loadModulePromiseResolveFnMap.delete(id);
 				throw e;
 			}
 			return promise$1;
 		}
 		await createLoadModulePromise(this.context, this.data);
-		return this.data.getModuleInfo(id$1, this.context);
+		return this.data.getModuleInfo(id, this.context);
 	}
 	async resolve(source, importer, options) {
 		let receipt = void 0;
@@ -2470,12 +2474,12 @@ var PluginContextImpl = class extends MinimalPluginContextImpl {
 		const info = this.data.getModuleOption(res.id) || {};
 		return {
 			...res,
-			external: res.external === "relative" ? require_filter_index.unreachable(`The PluginContext resolve result external couldn't be 'relative'`) : res.external,
+			external: res.external === "relative" ? require_misc.unreachable(`The PluginContext resolve result external couldn't be 'relative'`) : res.external,
 			...info
 		};
 	}
 	emitFile = (file) => {
-		if (file.type === "prebuilt-chunk") return require_filter_index.unimplemented("PluginContext.emitFile with type prebuilt-chunk");
+		if (file.type === "prebuilt-chunk") return require_misc.unimplemented("PluginContext.emitFile with type prebuilt-chunk");
 		if (file.type === "chunk") return this.context.emitChunk(file);
 		const fnSanitizedFileName = file.fileName || typeof this.outputOptions.sanitizeFileName !== "function" ? void 0 : this.outputOptions.sanitizeFileName(file.name || "asset");
 		const filename = file.fileName ? void 0 : this.getAssetFileNames(file);
@@ -2499,8 +2503,8 @@ var PluginContextImpl = class extends MinimalPluginContextImpl {
 	getModuleIds() {
 		return this.data.getModuleIds(this.context);
 	}
-	addWatchFile(id$1) {
-		this.context.addWatchFile(id$1);
+	addWatchFile(id) {
+		this.context.addWatchFile(id);
 	}
 	parse(input, options) {
 		return require_parse_ast_index.parseAst(input, options);
@@ -2634,18 +2638,18 @@ function bindingifyTransform(args$1) {
 	if (!hook) return {};
 	const { handler, meta, options } = normalizeHook(hook);
 	return {
-		plugin: async (ctx, code$1, id$1, meta$1) => {
-			const ret = await handler.call(new TransformPluginContextImpl(args$1.outputOptions, ctx.inner(), args$1.plugin, args$1.pluginContextData, ctx, id$1, code$1, args$1.onLog, args$1.logLevel, args$1.watchMode), code$1, id$1, meta$1);
+		plugin: async (ctx, code, id, meta$1) => {
+			const ret = await handler.call(new TransformPluginContextImpl(args$1.outputOptions, ctx.inner(), args$1.plugin, args$1.pluginContextData, ctx, id, code, args$1.onLog, args$1.logLevel, args$1.watchMode), code, id, meta$1);
 			if (ret == null) return void 0;
 			if (typeof ret === "string") return { code: ret };
-			let moduleOption = args$1.pluginContextData.updateModuleOption(id$1, {
+			let moduleOption = args$1.pluginContextData.updateModuleOption(id, {
 				meta: ret.meta ?? {},
 				moduleSideEffects: ret.moduleSideEffects ?? null,
 				invalidate: false
 			});
 			return {
 				code: ret.code,
-				map: bindingifySourcemap$1(normalizeTransformHookSourcemap(id$1, code$1, ret.map)),
+				map: bindingifySourcemap$1(normalizeTransformHookSourcemap(id, code, ret.map)),
 				sideEffects: bindingifySideEffects(moduleOption.moduleSideEffects),
 				moduleType: ret.moduleType
 			};
@@ -2659,16 +2663,16 @@ function bindingifyLoad(args$1) {
 	if (!hook) return {};
 	const { handler, meta, options } = normalizeHook(hook);
 	return {
-		plugin: async (ctx, id$1) => {
-			const ret = await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode, id$1), id$1);
+		plugin: async (ctx, id) => {
+			const ret = await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode, id), id);
 			if (ret == null) return;
 			if (typeof ret === "string") return { code: ret };
-			let moduleOption = args$1.pluginContextData.updateModuleOption(id$1, {
+			let moduleOption = args$1.pluginContextData.updateModuleOption(id, {
 				meta: ret.meta || {},
 				moduleSideEffects: ret.moduleSideEffects ?? null,
 				invalidate: false
 			});
-			let map = preProcessSourceMap(ret, id$1);
+			let map = preProcessSourceMap(ret, id);
 			return {
 				code: ret.code,
 				map: bindingifySourcemap$1(map),
@@ -2680,11 +2684,11 @@ function bindingifyLoad(args$1) {
 		filter: bindingifyLoadFilter(options.filter)
 	};
 }
-function preProcessSourceMap(ret, id$1) {
+function preProcessSourceMap(ret, id) {
 	if (!ret.map) return;
 	let map = typeof ret.map === "object" ? ret.map : JSON.parse(ret.map);
 	if (!isEmptySourcemapFiled(map.sources)) {
-		const directory = node_path.default.dirname(id$1) || ".";
+		const directory = node_path.default.dirname(id) || ".";
 		const sourceRoot = map.sourceRoot || ".";
 		map.sources = map.sources.map((source) => node_path.default.resolve(directory, sourceRoot, source));
 	}
@@ -2820,7 +2824,7 @@ function bindingifyFormat(format) {
 		case "iife": return "iife";
 		case "umd": return "umd";
 		case "experimental-app": return "app";
-		default: require_filter_index.unimplemented(`output.format: ${format}`);
+		default: require_misc.unimplemented(`output.format: ${format}`);
 	}
 }
 function bindingifySourcemap(sourcemap) {
@@ -3110,9 +3114,9 @@ function bindingifyRenderChunk(args$1) {
 	if (!hook) return {};
 	const { handler, meta, options } = normalizeHook(hook);
 	return {
-		plugin: async (ctx, code$1, chunk, opts, meta$1) => {
+		plugin: async (ctx, code, chunk, opts, meta$1) => {
 			if (args$1.pluginContextData.getRenderChunkMeta() == null) args$1.pluginContextData.setRenderChunkMeta({ chunks: Object.fromEntries(Object.entries(meta$1.chunks).map(([key, value]) => [key, transformRenderedChunk(value)])) });
-			const ret = await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), code$1, transformRenderedChunk(chunk), new NormalizedOutputOptionsImpl(opts, args$1.outputOptions, args$1.normalizedOutputPlugins), args$1.pluginContextData.getRenderChunkMeta());
+			const ret = await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), code, transformRenderedChunk(chunk), new NormalizedOutputOptionsImpl(opts, args$1.outputOptions, args$1.normalizedOutputPlugins), args$1.pluginContextData.getRenderChunkMeta());
 			if (ret == null) return;
 			if (typeof ret === "string") return { code: ret };
 			if (!ret.map) return { code: ret.code };
@@ -3248,8 +3252,8 @@ function bindingifyWatchChange(args$1) {
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
-		plugin: async (ctx, id$1, event) => {
-			await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), id$1, { event });
+		plugin: async (ctx, id, event) => {
+			await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), id, { event });
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
@@ -3457,46 +3461,46 @@ var PluginContextData = class {
 	loadModulePromiseMap = new Map();
 	loadModulePromiseResolveFnMap = new Map();
 	renderedChunkMeta = null;
-	updateModuleOption(id$1, option) {
-		const existing = this.moduleOptionMap.get(id$1);
+	updateModuleOption(id, option) {
+		const existing = this.moduleOptionMap.get(id);
 		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$1, option);
+			this.moduleOptionMap.set(id, option);
 			return option;
 		}
 		return existing;
 	}
-	getModuleOption(id$1) {
-		const option = this.moduleOptionMap.get(id$1);
+	getModuleOption(id) {
+		const option = this.moduleOptionMap.get(id);
 		if (!option) {
 			const raw = {
 				moduleSideEffects: null,
 				meta: {}
 			};
-			this.moduleOptionMap.set(id$1, raw);
+			this.moduleOptionMap.set(id, raw);
 			return raw;
 		}
 		return option;
 	}
-	getModuleInfo(id$1, context) {
-		const bindingInfo = context.getModuleInfo(id$1);
+	getModuleInfo(id, context) {
+		const bindingInfo = context.getModuleInfo(id);
 		if (bindingInfo) {
-			const info = transformModuleInfo(bindingInfo, this.getModuleOption(id$1));
-			return this.proxyModuleInfo(id$1, info);
+			const info = transformModuleInfo(bindingInfo, this.getModuleOption(id));
+			return this.proxyModuleInfo(id, info);
 		}
 		return null;
 	}
-	proxyModuleInfo(id$1, info) {
+	proxyModuleInfo(id, info) {
 		let moduleSideEffects = info.moduleSideEffects;
 		Object.defineProperty(info, "moduleSideEffects", {
 			get() {
 				return moduleSideEffects;
 			},
 			set: (v) => {
-				this.updateModuleOption(id$1, {
+				this.updateModuleOption(id, {
 					moduleSideEffects: v,
 					meta: info.meta,
 					invalidate: true
@@ -3527,8 +3531,8 @@ var PluginContextData = class {
 	getRenderChunkMeta() {
 		return this.renderedChunkMeta;
 	}
-	markModuleLoaded(id$1, _success) {
-		const resolve = this.loadModulePromiseResolveFnMap.get(id$1);
+	markModuleLoaded(id, _success) {
+		const resolve = this.loadModulePromiseResolveFnMap.get(id);
 		if (resolve) resolve();
 	}
 	clear() {
@@ -3551,6 +3555,7 @@ function isReadonlyArray(input) {
 
 //#endregion
 //#region src/utils/bindingify-input-options.ts
+var import_binding$3 = require_chunk.__toESM(require_parse_ast_index.require_binding());
 function bindingifyInputOptions(rawPlugins, inputOptions, outputOptions, normalizedOutputPlugins, onLog, logLevel, watchMode) {
 	const pluginContextData = new PluginContextData();
 	const plugins = rawPlugins.map((plugin) => {
@@ -3610,15 +3615,15 @@ function bindingifyHmr(hmr) {
 }
 function bindingifyExternal(external) {
 	if (external) {
-		if (typeof external === "function") return (id$1, importer, isResolved) => {
-			if (id$1.startsWith("\0")) return false;
-			return external(id$1, importer, isResolved) ?? false;
+		if (typeof external === "function") return (id, importer, isResolved) => {
+			if (id.startsWith("\0")) return false;
+			return external(id, importer, isResolved) ?? false;
 		};
-		const externalArr = require_filter_index.arraify(external);
-		return (id$1, _importer, _isResolved) => {
+		const externalArr = require_misc.arraify(external);
+		return (id, _importer, _isResolved) => {
 			return externalArr.some((pat) => {
-				if (pat instanceof RegExp) return pat.test(id$1);
-				return id$1 === pat;
+				if (pat instanceof RegExp) return pat.test(id);
+				return id === pat;
 			});
 		};
 	}
@@ -3629,7 +3634,7 @@ function bindingifyResolve(resolve) {
 		return {
 			alias: alias ? Object.entries(alias).map(([name, replacement]) => ({
 				find: name,
-				replacements: require_filter_index.arraify(replacement)
+				replacements: require_misc.arraify(replacement)
 			})) : void 0,
 			extensionAlias: extensionAlias ? Object.entries(extensionAlias).map(([name, value]) => ({
 				target: name,
@@ -3663,10 +3668,10 @@ function bindingifyInject(inject) {
 }
 function bindingifyLogLevel(logLevel) {
 	switch (logLevel) {
-		case "silent": return require_parse_ast_index.import_binding.BindingLogLevel.Silent;
-		case "debug": return require_parse_ast_index.import_binding.BindingLogLevel.Debug;
-		case "warn": return require_parse_ast_index.import_binding.BindingLogLevel.Warn;
-		case "info": return require_parse_ast_index.import_binding.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}`);
 	}
 }
@@ -3876,7 +3881,7 @@ function createComposedPlugin(plugins) {
 				if (symbolForCallerThatSkipSelf === handlerSymbol) continue;
 				const { handler: handlerFn } = normalizeHook(handler);
 				const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), source, importer, rawHookResolveIdOptions);
-				if (!require_filter_index.isNullish(result)) return result;
+				if (!require_misc.isNullish(result)) return result;
 			}
 		};
 	}
@@ -3898,11 +3903,11 @@ function createComposedPlugin(plugins) {
 			case "load": {
 				if (batchedHooks.load) {
 					const batchedHandlers = batchedHooks.load;
-					composed.load = async function(id$1) {
+					composed.load = async function(id) {
 						for (const [handler, plugin] of batchedHandlers) {
 							const { handler: handlerFn } = normalizeHook(handler);
-							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), id$1);
-							if (!require_filter_index.isNullish(result)) return result;
+							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), id);
+							if (!require_misc.isNullish(result)) return result;
 						}
 					};
 				}
@@ -3911,11 +3916,11 @@ function createComposedPlugin(plugins) {
 			case "transform": {
 				if (batchedHooks.transform) {
 					const batchedHandlers = batchedHooks.transform;
-					composed.transform = async function(initialCode, id$1, moduleType$1) {
-						let code$1 = initialCode;
+					composed.transform = async function(initialCode, id, moduleType) {
+						let code = initialCode;
 						let moduleSideEffects = void 0;
 						function updateOutput(newCode, newModuleSideEffects) {
-							code$1 = newCode;
+							code = newCode;
 							moduleSideEffects = newModuleSideEffects ?? void 0;
 						}
 						for (const [handler, plugin] of batchedHandlers) {
@@ -3923,14 +3928,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$1, id$1, moduleType$1);
-							if (!require_filter_index.isNullish(result)) {
+							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), code, id, moduleType);
+							if (!require_misc.isNullish(result)) {
 								if (typeof result === "string") updateOutput(result);
 								else if (result.code) updateOutput(result.code, result.moduleSideEffects);
 							}
 						}
 						return {
-							code: code$1,
+							code,
 							moduleSideEffects
 						};
 					};
@@ -3952,11 +3957,11 @@ function createComposedPlugin(plugins) {
 			case "renderChunk": {
 				if (batchedHooks.renderChunk) {
 					const batchedHandlers = batchedHooks.renderChunk;
-					composed.renderChunk = async function(code$1, chunk, options, meta) {
+					composed.renderChunk = async function(code, chunk, options, meta) {
 						for (const [handler, plugin] of batchedHandlers) {
 							const { handler: handlerFn } = normalizeHook(handler);
-							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), code$1, chunk, options, meta);
-							if (!require_filter_index.isNullish(result)) return result;
+							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), code, chunk, options, meta);
+							if (!require_misc.isNullish(result)) return result;
 						}
 					};
 				}
@@ -3992,10 +3997,10 @@ function createComposedPlugin(plugins) {
 			case "watchChange": {
 				if (batchedHooks.watchChange) {
 					const batchedHandlers = batchedHooks.watchChange;
-					composed.watchChange = async function(id$1, event) {
+					composed.watchChange = async function(id, event) {
 						await Promise.all(batchedHandlers.map(([handler, plugin]) => {
 							const { handler: handlerFn } = normalizeHook(handler);
-							return handlerFn.call(applyFixedPluginResolveFn(this, plugin), id$1, event);
+							return handlerFn.call(applyFixedPluginResolveFn(this, plugin), id, event);
 						}));
 					};
 				}
@@ -4058,6 +4063,7 @@ function composeJsPlugins(plugins) {
 
 //#endregion
 //#region src/utils/initialize-parallel-plugins.ts
+var import_binding$2 = require_chunk.__toESM(require_parse_ast_index.require_binding());
 async function initializeParallelPlugins(plugins) {
 	const pluginInfos = [];
 	for (const [index, plugin] of plugins.entries()) if ("_parallel" in plugin) {
@@ -4070,7 +4076,7 @@ async function initializeParallelPlugins(plugins) {
 	}
 	if (pluginInfos.length <= 0) return void 0;
 	const count = Math.min((0, node_os.availableParallelism)(), 8);
-	const parallelJsPluginRegistry = new require_parse_ast_index.import_binding.ParallelJsPluginRegistry(count);
+	const parallelJsPluginRegistry = new import_binding$2.ParallelJsPluginRegistry(count);
 	const registryId = parallelJsPluginRegistry.id;
 	const workers = await initializeWorkers(registryId, count, pluginInfos);
 	const stopWorkers = async () => {
@@ -4141,16 +4147,17 @@ async function createBundlerOptions(inputOptions, outputOptions, watchMode, isCl
 
 //#endregion
 //#region src/utils/create-bundler.ts
+var import_binding$1 = require_chunk.__toESM(require_parse_ast_index.require_binding());
 let asyncRuntimeShutdown = false;
 async function createBundler(inputOptions, outputOptions, isClose) {
 	const option = await createBundlerOptions(inputOptions, outputOptions, false, isClose);
-	if (asyncRuntimeShutdown) (0, require_parse_ast_index.import_binding.startAsyncRuntime)();
+	if (asyncRuntimeShutdown) (0, import_binding$1.startAsyncRuntime)();
 	try {
 		return {
-			bundler: new require_parse_ast_index.import_binding.Bundler(option.bundlerOptions),
+			bundler: new import_binding$1.Bundler(option.bundlerOptions),
 			stopWorkers: option.stopWorkers,
 			shutdown: () => {
-				(0, require_parse_ast_index.import_binding.shutdownAsyncRuntime)();
+				(0, import_binding$1.shutdownAsyncRuntime)();
 				asyncRuntimeShutdown = true;
 			}
 		};
@@ -4267,8 +4274,8 @@ var WatcherEmitter = class {
 				break;
 			case "event":
 				for (const listener of listeners) {
-					const code$1 = event.bundleEventKind();
-					switch (code$1) {
+					const code = event.bundleEventKind();
+					switch (code) {
 						case "BUNDLE_END":
 							const { duration, output, result } = event.bundleEndData();
 							await listener({
@@ -4287,7 +4294,7 @@ var WatcherEmitter = class {
 							});
 							break;
 						default:
-							await listener({ code: code$1 });
+							await listener({ code });
 							break;
 					}
 				}
@@ -4308,6 +4315,7 @@ var WatcherEmitter = class {
 
 //#endregion
 //#region src/api/watch/watcher.ts
+var import_binding = require_chunk.__toESM(require_parse_ast_index.require_binding());
 var Watcher = class {
 	closed;
 	inner;
@@ -4329,20 +4337,20 @@ var Watcher = class {
 		this.closed = true;
 		for (const stop of this.stopWorkers) await stop?.();
 		await this.inner.close();
-		(0, require_parse_ast_index.import_binding.shutdownAsyncRuntime)();
+		(0, import_binding.shutdownAsyncRuntime)();
 	}
 	start() {
 		process.nextTick(() => this.inner.start(this.emitter.onEvent.bind(this.emitter)));
 	}
 };
 async function createWatcher(emitter, input) {
-	const options = require_filter_index.arraify(input);
-	const bundlerOptions = await Promise.all(options.map((option) => require_filter_index.arraify(option.output || {}).map(async (output) => {
+	const options = require_misc.arraify(input);
+	const bundlerOptions = await Promise.all(options.map((option) => require_misc.arraify(option.output || {}).map(async (output) => {
 		const inputOptions = await PluginDriver.callOptionsHook(option, true);
 		return createBundlerOptions(inputOptions, output, true);
 	})).flat());
 	const notifyOptions = getValidNotifyOption(bundlerOptions);
-	const bindingWatcher = new require_parse_ast_index.import_binding.BindingWatcher(bundlerOptions.map((option) => option.bundlerOptions), notifyOptions);
+	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();
 }