rolldown 0.14.0 → 0.15.0-commit.6d5a1b0

package/dist/shared/src_index-3pqhEViJ.cjs

@@ -1,2785 +0,0 @@
-const { __commonJSMin, __toESM } = require("./chunk-JoMxl5V2.cjs");
-const { spawn } = __toESM(require("node:child_process"));
-const { default: path, default: path$1 } = __toESM(require("node:path"));
-const { z } = __toESM(require("zod"));
-const { Worker } = __toESM(require("node:worker_threads"));
-const { availableParallelism } = __toESM(require("node:os"));
-const { isRegExp } = __toESM(require("node:util/types"));
-
-//#region src/utils/define-config.ts
-function defineConfig(config) {
-	return config;
-}
-
-//#endregion
-//#region src/utils/asset-source.ts
-function transformAssetSource(bindingAssetSource$1) {
-	return bindingAssetSource$1.inner;
-}
-function bindingAssetSource(source) {
-	return {inner: source};
-}
-
-//#endregion
-//#region src/types/sourcemap.ts
-function bindingifySourcemap$1(map) {
-	if (map == null) return;
-	return {inner: typeof map === "string" ? map : {
-		file: map.file ?? undefined,
-		mappings: map.mappings,
-		sourceRoot: map.sourceRoot,
-		sources: map.sources?.map((s) => s ?? undefined),
-		sourcesContent: map.sourcesContent?.map((s) => s ?? undefined),
-		names: map.names
-	}};
-}
-
-//#endregion
-//#region src/utils/transform-to-rollup-output.ts
-function transformToRollupOutputChunk(bindingChunk, changed) {
-	const chunk = {
-		type: "chunk",
-		get code() {
-			return bindingChunk.code;
-		},
-		fileName: bindingChunk.fileName,
-		name: bindingChunk.name,
-		get modules() {
-			return Object.fromEntries((Object.entries(bindingChunk.modules)).map(([key, _]) => [key, {}]));
-		},
-		get imports() {
-			return bindingChunk.imports;
-		},
-		get dynamicImports() {
-			return bindingChunk.dynamicImports;
-		},
-		exports: bindingChunk.exports,
-		isEntry: bindingChunk.isEntry,
-		facadeModuleId: bindingChunk.facadeModuleId || null,
-		isDynamicEntry: bindingChunk.isDynamicEntry,
-		get moduleIds() {
-			return bindingChunk.moduleIds;
-		},
-		get map() {
-			return bindingChunk.map ? JSON.parse(bindingChunk.map) : null;
-		},
-		sourcemapFileName: bindingChunk.sourcemapFileName || null,
-		preliminaryFileName: bindingChunk.preliminaryFileName
-	};
-	const cache = {};
-	return new Proxy(chunk, {
-		get(target, p) {
-			if (p in cache) {
-				return cache[p];
-			}
-			return target[p];
-		},
-		set(target, p, newValue) {
-			cache[p] = newValue;
-			changed?.updated.add(bindingChunk.fileName);
-			return true;
-		}
-	});
-}
-function transformToRollupOutputAsset(bindingAsset, changed) {
-	const asset = {
-		type: "asset",
-		fileName: bindingAsset.fileName,
-		originalFileName: bindingAsset.originalFileName || null,
-		get source() {
-			return transformAssetSource(bindingAsset.source);
-		},
-		name: bindingAsset.name ?? undefined
-	};
-	const cache = {};
-	return new Proxy(asset, {
-		get(target, p) {
-			if (p in cache) {
-				return cache[p];
-			}
-			return target[p];
-		},
-		set(target, p, newValue) {
-			cache[p] = newValue;
-			changed?.updated.add(bindingAsset.fileName);
-			return true;
-		}
-	});
-}
-function transformToRollupOutput(output, changed) {
-	const { chunks: chunks, assets: assets } = output;
-	return {output: [...chunks.map((chunk) => transformToRollupOutputChunk(chunk, changed)), ...assets.map((asset) => transformToRollupOutputAsset(asset, changed)),]};
-}
-function transformToOutputBundle(output, changed) {
-	const bundle = Object.fromEntries((transformToRollupOutput(output, changed)).output.map((item) => [item.fileName, item,]));
-	return new Proxy(bundle, {deleteProperty(target, property) {
-		if (typeof property === "string") {
-			changed.deleted.add(property);
-		}
-		return true;
-	}});
-}
-function collectChangedBundle(changed, bundle) {
-	const assets = [];
-	const chunks = [];
-	for (const key in bundle) {
-		if (changed.deleted.has(key) || !changed.updated.has(key)) {
-			continue;
-		}
-		const item = bundle[key];
-		if (item.type === "asset") {
-			assets.push({
-				filename: item.fileName,
-				originalFileName: item.originalFileName || undefined,
-				source: bindingAssetSource(item.source),
-				name: item.name
-			});
-		} else {
-			chunks.push({
-				code: item.code,
-				filename: item.fileName,
-				name: item.name,
-				isEntry: item.isEntry,
-				exports: item.exports,
-				modules: Object.fromEntries((Object.entries(item.modules)).map(([key$1, _]) => [key$1, {}])),
-				imports: item.imports,
-				dynamicImports: item.dynamicImports,
-				facadeModuleId: item.facadeModuleId || undefined,
-				isDynamicEntry: item.isDynamicEntry,
-				moduleIds: item.moduleIds,
-				map: bindingifySourcemap$1(item.map),
-				sourcemapFilename: item.sourcemapFileName || undefined,
-				preliminaryFilename: item.preliminaryFileName
-			});
-		}
-	}
-	return {
-		assets,
-		chunks,
-		deleted: Array.from(changed.deleted)
-	};
-}
-
-//#endregion
-//#region src/binding.js
-var require_binding = __commonJSMin((exports, module) => {
-	const { createRequire: createRequire } = require("node:module");
-	require = createRequire(__filename);
-	const { readFileSync: readFileSync } = require("node:fs");
-	let nativeBinding = null;
-	const loadErrors = [];
-	const isMusl = () => {
-		let musl = false;
-		if (process.platform === "linux") {
-			musl = isMuslFromFilesystem();
-			if (musl === null) {
-				musl = isMuslFromReport();
-			}
-			if (musl === null) {
-				musl = isMuslFromChildProcess();
-			}
-		}
-		return musl;
-	};
-	const isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
-	const isMuslFromFilesystem = () => {
-		try {
-			return (readFileSync("/usr/bin/ldd", "utf-8")).includes("musl");
-		} catch {
-			return null;
-		}
-	};
-	const isMuslFromReport = () => {
-		const report = typeof process.report.getReport === "function" ? process.report.getReport() : null;
-		if (!report) {
-			return null;
-		}
-		if (report.header && report.header.glibcVersionRuntime) {
-			return false;
-		}
-		if (Array.isArray(report.sharedObjects)) {
-			if (report.sharedObjects.some(isFileMusl)) {
-				return true;
-			}
-		}
-		return false;
-	};
-	const isMuslFromChildProcess = () => {
-		try {
-			return ((require("node:child_process")).execSync("ldd --version", {encoding: "utf8"})).includes("musl");
-		} catch (e) {
-			return false;
-		}
-	};
-	function requireNative() {
-		if (process.platform === "android") {
-			if (process.arch === "arm64") {
-				try {
-					return require("./rolldown-binding.android-arm64.node");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-				try {
-					return require("@rolldown/binding-android-arm64");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-			} else if (process.arch === "arm") {
-				try {
-					return require("./rolldown-binding.android-arm-eabi.node");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-				try {
-					return require("@rolldown/binding-android-arm-eabi");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-			} else {
-				loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`));
-			}
-		} else if (process.platform === "win32") {
-			if (process.arch === "x64") {
-				try {
-					return require("./rolldown-binding.win32-x64-msvc.node");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-				try {
-					return require("@rolldown/binding-win32-x64-msvc");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-			} else if (process.arch === "ia32") {
-				try {
-					return require("./rolldown-binding.win32-ia32-msvc.node");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-				try {
-					return require("@rolldown/binding-win32-ia32-msvc");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-			} else if (process.arch === "arm64") {
-				try {
-					return require("./rolldown-binding.win32-arm64-msvc.node");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-				try {
-					return require("@rolldown/binding-win32-arm64-msvc");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-			} else {
-				loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`));
-			}
-		} else if (process.platform === "darwin") {
-			try {
-				return require("./rolldown-binding.darwin-universal.node");
-			} catch (e) {
-				loadErrors.push(e);
-			}
-			try {
-				return require("@rolldown/binding-darwin-universal");
-			} catch (e) {
-				loadErrors.push(e);
-			}
-			if (process.arch === "x64") {
-				try {
-					return require("./rolldown-binding.darwin-x64.node");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-				try {
-					return require("@rolldown/binding-darwin-x64");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-			} else if (process.arch === "arm64") {
-				try {
-					return require("./rolldown-binding.darwin-arm64.node");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-				try {
-					return require("@rolldown/binding-darwin-arm64");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-			} else {
-				loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`));
-			}
-		} else if (process.platform === "freebsd") {
-			if (process.arch === "x64") {
-				try {
-					return require("./rolldown-binding.freebsd-x64.node");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-				try {
-					return require("@rolldown/binding-freebsd-x64");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-			} else if (process.arch === "arm64") {
-				try {
-					return require("./rolldown-binding.freebsd-arm64.node");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-				try {
-					return require("@rolldown/binding-freebsd-arm64");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-			} else {
-				loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
-			}
-		} else if (process.platform === "linux") {
-			if (process.arch === "x64") {
-				if (isMusl()) {
-					try {
-						return require("./rolldown-binding.linux-x64-musl.node");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-					try {
-						return require("@rolldown/binding-linux-x64-musl");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-				} else {
-					try {
-						return require("./rolldown-binding.linux-x64-gnu.node");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-					try {
-						return require("@rolldown/binding-linux-x64-gnu");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-				}
-			} else if (process.arch === "arm64") {
-				if (isMusl()) {
-					try {
-						return require("./rolldown-binding.linux-arm64-musl.node");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-					try {
-						return require("@rolldown/binding-linux-arm64-musl");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-				} else {
-					try {
-						return require("./rolldown-binding.linux-arm64-gnu.node");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-					try {
-						return require("@rolldown/binding-linux-arm64-gnu");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-				}
-			} else if (process.arch === "arm") {
-				if (isMusl()) {
-					try {
-						return require("./rolldown-binding.linux-arm-musleabihf.node");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-					try {
-						return require("@rolldown/binding-linux-arm-musleabihf");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-				} else {
-					try {
-						return require("./rolldown-binding.linux-arm-gnueabihf.node");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-					try {
-						return require("@rolldown/binding-linux-arm-gnueabihf");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-				}
-			} else if (process.arch === "riscv64") {
-				if (isMusl()) {
-					try {
-						return require("./rolldown-binding.linux-riscv64-musl.node");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-					try {
-						return require("@rolldown/binding-linux-riscv64-musl");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-				} else {
-					try {
-						return require("./rolldown-binding.linux-riscv64-gnu.node");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-					try {
-						return require("@rolldown/binding-linux-riscv64-gnu");
-					} catch (e) {
-						loadErrors.push(e);
-					}
-				}
-			} else if (process.arch === "ppc64") {
-				try {
-					return require("./rolldown-binding.linux-ppc64-gnu.node");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-				try {
-					return require("@rolldown/binding-linux-ppc64-gnu");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-			} else if (process.arch === "s390x") {
-				try {
-					return require("./rolldown-binding.linux-s390x-gnu.node");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-				try {
-					return require("@rolldown/binding-linux-s390x-gnu");
-				} catch (e) {
-					loadErrors.push(e);
-				}
-			} else {
-				loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`));
-			}
-		} else {
-			loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
-		}
-	}
-	nativeBinding = requireNative();
-	if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
-		try {
-			nativeBinding = require("./rolldown-binding.wasi.cjs");
-		} catch (err) {
-			if (process.env.NAPI_RS_FORCE_WASI) {
-				loadErrors.push(err);
-			}
-		}
-		if (!nativeBinding) {
-			try {
-				nativeBinding = require("@rolldown/binding-wasm32-wasi");
-			} catch (err) {
-				if (process.env.NAPI_RS_FORCE_WASI) {
-					loadErrors.push(err);
-				}
-			}
-		}
-	}
-	if (!nativeBinding) {
-		if (loadErrors.length > 0) {
-			throw new Error("Failed to load native binding", {cause: loadErrors});
-		}
-		throw new Error(`Failed to load native binding`);
-	}
-	module.exports.BindingLog = nativeBinding.BindingLog;
-	module.exports.BindingModuleInfo = nativeBinding.BindingModuleInfo;
-	module.exports.BindingOutputAsset = nativeBinding.BindingOutputAsset;
-	module.exports.BindingOutputChunk = nativeBinding.BindingOutputChunk;
-	module.exports.BindingOutputs = nativeBinding.BindingOutputs;
-	module.exports.BindingPluginContext = nativeBinding.BindingPluginContext;
-	module.exports.BindingTransformPluginContext = nativeBinding.BindingTransformPluginContext;
-	module.exports.BindingWatcher = nativeBinding.BindingWatcher;
-	module.exports.Bundler = nativeBinding.Bundler;
-	module.exports.ParallelJsPluginRegistry = nativeBinding.ParallelJsPluginRegistry;
-	module.exports.BindingBuiltinPluginName = nativeBinding.BindingBuiltinPluginName;
-	module.exports.BindingHookSideEffects = nativeBinding.BindingHookSideEffects;
-	module.exports.BindingLogLevel = nativeBinding.BindingLogLevel;
-	module.exports.BindingPluginOrder = nativeBinding.BindingPluginOrder;
-	module.exports.BindingWatcherEvent = nativeBinding.BindingWatcherEvent;
-	module.exports.isolatedDeclaration = nativeBinding.isolatedDeclaration;
-	module.exports.registerPlugins = nativeBinding.registerPlugins;
-	module.exports.transform = nativeBinding.transform;
-});
-
-//#endregion
-//#region src/utils/misc.ts
-function arraify(value) {
-	return Array.isArray(value) ? value : [value];
-}
-function isNullish(value) {
-	return value === null || value === undefined;
-}
-function unimplemented(info) {
-	if (info) {
-		throw new Error(`unimplemented: ${info}`);
-	}
-	throw new Error("unimplemented");
-}
-function unreachable(info) {
-	if (info) {
-		throw new Error(`unreachable: ${info}`);
-	}
-	throw new Error("unreachable");
-}
-function unsupported(info) {
-	return () => {
-		throw new Error(`UNSUPPORTED: ${info}`);
-	};
-}
-function noop(..._args) {}
-
-//#endregion
-//#region src/utils/normalize-hook.ts
-function normalizeHook(hook) {
-	if (typeof hook === "function" || typeof hook === "string") {
-		return {
-			handler: hook,
-			options: {},
-			meta: {}
-		};
-	} else if (typeof hook === "object" && hook !== null) {
-		const { handler: handler, order: order,...options } = hook;
-		return {
-			handler,
-			options,
-			meta: {order}
-		};
-	}
-	unreachable("Invalid hook type");
-}
-
-//#endregion
-//#region src/utils/transform-sourcemap.ts
-function isEmptySourcemapFiled(array) {
-	if (!array) {
-		return true;
-	}
-	if (array.length === 0 || !array[0]) {
-		return true;
-	}
-	return false;
-}
-
-//#endregion
-//#region src/utils/transform-module-info.ts
-function transformModuleInfo(info, option) {
-	return {
-		get ast() {
-			return unsupported("ModuleInfo#ast");
-		},
-		get code() {
-			return info.code;
-		},
-		id: info.id,
-		importers: info.importers,
-		dynamicImporters: info.dynamicImporters,
-		importedIds: info.importedIds,
-		dynamicallyImportedIds: info.dynamicallyImportedIds,
-		isEntry: info.isEntry,
-		...option
-	};
-}
-
-//#endregion
-//#region src/log/logging.ts
-const LogLevelSchema = ((z.literal("info")).or(z.literal("debug"))).or(z.literal("warn"));
-const LogLevelWithErrorSchema = LogLevelSchema.or(z.literal("error"));
-const LogLevelOptionSchema = LogLevelSchema.or(z.literal("silent"));
-const LOG_LEVEL_SILENT = "silent";
-const LOG_LEVEL_ERROR = "error";
-const LOG_LEVEL_WARN = "warn";
-const LOG_LEVEL_INFO = "info";
-const LOG_LEVEL_DEBUG = "debug";
-const logLevelPriority = {
-	[LOG_LEVEL_DEBUG]: 0,
-	[LOG_LEVEL_INFO]: 1,
-	[LOG_LEVEL_WARN]: 2,
-	[LOG_LEVEL_SILENT]: 3
-};
-const RollupLogSchema = z.any();
-const RollupLogWithStringSchema = RollupLogSchema.or(z.string());
-
-//#endregion
-//#region src/utils/code-frame.ts
-function spaces(index) {
-	let result = "";
-	while (index--) result += " ";
-	return result;
-}
-function tabsToSpaces(value) {
-	return value.replace(/^\t+/, (match) => (match.split("	")).join("  "));
-}
-const LINE_TRUNCATE_LENGTH = 120;
-const MIN_CHARACTERS_SHOWN_AFTER_LOCATION = 10;
-const ELLIPSIS = "...";
-function getCodeFrame(source, line, column) {
-	let lines = source.split("\n");
-	if (line > lines.length) return "";
-	const maxLineLength = Math.max((tabsToSpaces(lines[line - 1].slice(0, column))).length + MIN_CHARACTERS_SHOWN_AFTER_LOCATION + ELLIPSIS.length, LINE_TRUNCATE_LENGTH);
-	const frameStart = Math.max(0, line - 3);
-	let frameEnd = Math.min(line + 2, lines.length);
-	lines = lines.slice(frameStart, frameEnd);
-	while (!/\S/.test(lines[lines.length - 1])) {
-		lines.pop();
-		frameEnd -= 1;
-	}
-	const digits = (String(frameEnd)).length;
-	return (lines.map((sourceLine, index) => {
-		const isErrorLine = frameStart + index + 1 === line;
-		let lineNumber = String(index + frameStart + 1);
-		while (lineNumber.length < digits) lineNumber = ` ${lineNumber}`;
-		let displayedLine = tabsToSpaces(sourceLine);
-		if (displayedLine.length > maxLineLength) {
-			displayedLine = `${displayedLine.slice(0, maxLineLength - ELLIPSIS.length)}${ELLIPSIS}`;
-		}
-		if (isErrorLine) {
-			const indicator = spaces(digits + 2 + (tabsToSpaces(sourceLine.slice(0, column))).length) + "^";
-			return `${lineNumber}: ${displayedLine}\n${indicator}`;
-		}
-		return `${lineNumber}: ${displayedLine}`;
-	})).join("\n");
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/locate-character@3.0.0/node_modules/locate-character/src/index.js
-function rangeContains(range, index) {
-	return range.start <= index && index < range.end;
-}
-function getLocator(source, options = {}) {
-	const { offsetLine: offsetLine = 0, offsetColumn: offsetColumn = 0 } = options;
-	let start = 0;
-	const ranges = (source.split("\n")).map((line, i$1) => {
-		const end = start + line.length + 1;
-		const range = {
-			start,
-			end,
-			line: i$1
-		};
-		start = end;
-		return range;
-	});
-	let i = 0;
-	function locator(search, index) {
-		if (typeof search === "string") {
-			search = source.indexOf(search, index ?? 0);
-		}
-		if (search === -1) return undefined;
-		let range = ranges[i];
-		const d = 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];
-		}
-	}
-	return locator;
-}
-function locate(source, search, options) {
-	return getLocator(source, options)(search, options && options.startIndex);
-}
-
-//#endregion
-//#region src/log/logs.ts
-const INVALID_LOG_POSITION = "INVALID_LOG_POSITION", PLUGIN_ERROR = "PLUGIN_ERROR";
-function logInvalidLogPosition(pluginName) {
-	return {
-		code: INVALID_LOG_POSITION,
-		message: `Plugin "${pluginName}" tried to add a file position to a log or warning. This is only supported in the "transform" hook at the moment and will be ignored.`
-	};
-}
-function logPluginError(error$1, plugin, { hook: hook, id: id } = {}) {
-	const code = error$1.code;
-	if (!error$1.pluginCode && code != null && (typeof code !== "string" || !code.startsWith("PLUGIN_"))) {
-		error$1.pluginCode = code;
-	}
-	error$1.code = PLUGIN_ERROR;
-	error$1.plugin = plugin;
-	if (hook) {
-		error$1.hook = hook;
-	}
-	if (id) {
-		error$1.id = id;
-	}
-	return error$1;
-}
-function error(base) {
-	if (!(base instanceof Error)) {
-		base = Object.assign(new Error(base.message), base);
-		Object.defineProperty(base, "name", {
-			value: "RollupError",
-			writable: true
-		});
-	}
-	throw base;
-}
-function augmentCodeLocation(properties, pos, source, id) {
-	if (typeof pos === "object") {
-		const { line: line, column: column } = pos;
-		properties.loc = {
-			column,
-			file: id,
-			line
-		};
-	} else {
-		properties.pos = pos;
-		const location = locate(source, pos, {offsetLine: 1});
-		if (!location) {
-			return;
-		}
-		const { line: line, column: column } = location;
-		properties.loc = {
-			column,
-			file: id,
-			line
-		};
-	}
-	if (properties.frame === undefined) {
-		const { line: line, column: column } = properties.loc;
-		properties.frame = getCodeFrame(source, line, column);
-	}
-}
-
-//#endregion
-//#region src/log/logHandler.ts
-const normalizeLog = (log) => typeof log === "string" ? {message: log} : typeof log === "function" ? normalizeLog(log()) : log;
-function getLogHandler(level, code, 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.plugin = pluginName;
-		logger(level, log);
-	};
-}
-
-//#endregion
-//#region src/options/utils.ts
-function normalizedStringOrRegex(pattern) {
-	if (!pattern) {
-		return undefined;
-	}
-	if (!Array.isArray(pattern)) {
-		pattern = [pattern];
-	}
-	return pattern;
-}
-
-//#endregion
-//#region src/options/normalized-ecma-transform-plugin-config.ts
-function normalizeEcmaTransformPluginConfig(config) {
-	if (!config) {
-		return undefined;
-	}
-	let normalizedConfig = {
-		jsxInject: config?.jsxInject,
-		exclude: normalizedStringOrRegex(config.exclude),
-		include: normalizedStringOrRegex(config.include),
-		targets: config.targets
-	};
-	return normalizedConfig;
-}
-
-//#endregion
-//#region src/plugin/builtin-plugin.ts
-var import_binding$6 = __toESM(require_binding());
-class BuiltinPlugin {
-	constructor(name, options) {
-		this.name = name;
-		this.options = options;
-		this.name = name;
-		this.options = options;
-	}
-}
-class ModulePreloadPolyfillPlugin extends BuiltinPlugin {
-	constructor(config) {
-		super(import_binding$6.BindingBuiltinPluginName.ModulePreloadPolyfillPlugin, config);
-	}
-}
-class DynamicImportVarsPlugin extends BuiltinPlugin {
-	constructor() {
-		super(import_binding$6.BindingBuiltinPluginName.DynamicImportVarsPlugin);
-	}
-}
-class ImportGlobPlugin extends BuiltinPlugin {
-	constructor(config) {
-		super(import_binding$6.BindingBuiltinPluginName.ImportGlobPlugin, config);
-	}
-}
-class ManifestPlugin extends BuiltinPlugin {
-	constructor(config) {
-		super(import_binding$6.BindingBuiltinPluginName.ManifestPlugin, config);
-	}
-}
-class WasmHelperPlugin extends BuiltinPlugin {
-	constructor() {
-		super(import_binding$6.BindingBuiltinPluginName.WasmHelperPlugin);
-	}
-}
-class WasmFallbackPlugin extends BuiltinPlugin {
-	constructor() {
-		super(import_binding$6.BindingBuiltinPluginName.WasmFallbackPlugin);
-	}
-}
-class LoadFallbackPlugin extends BuiltinPlugin {
-	constructor() {
-		super(import_binding$6.BindingBuiltinPluginName.LoadFallbackPlugin);
-	}
-}
-class AliasPlugin extends BuiltinPlugin {
-	constructor(config) {
-		super(import_binding$6.BindingBuiltinPluginName.AliasPlugin, config);
-	}
-}
-class TransformPlugin extends BuiltinPlugin {
-	constructor(config) {
-		let normalizedConfig = normalizeEcmaTransformPluginConfig(config);
-		super(import_binding$6.BindingBuiltinPluginName.TransformPlugin, normalizedConfig);
-	}
-}
-class JsonPlugin extends BuiltinPlugin {
-	constructor(config) {
-		super(import_binding$6.BindingBuiltinPluginName.JsonPlugin, config);
-	}
-}
-class BuildImportAnalysisPlugin extends BuiltinPlugin {
-	constructor(config) {
-		super(import_binding$6.BindingBuiltinPluginName.BuildImportAnalysisPlugin, config);
-	}
-}
-class ReplacePlugin extends BuiltinPlugin {
-	constructor(config) {
-		super(import_binding$6.BindingBuiltinPluginName.ReplacePlugin, config);
-	}
-}
-function modulePreloadPolyfillPlugin(config) {
-	return new ModulePreloadPolyfillPlugin(config);
-}
-function dynamicImportVarsPlugin() {
-	return new DynamicImportVarsPlugin();
-}
-function importGlobPlugin(config) {
-	return new ImportGlobPlugin(config);
-}
-function manifestPlugin(config) {
-	return new ManifestPlugin(config);
-}
-function wasmHelperPlugin() {
-	return new WasmHelperPlugin();
-}
-function wasmFallbackPlugin() {
-	return new WasmFallbackPlugin();
-}
-function transformPlugin(config) {
-	return new TransformPlugin(config);
-}
-function loadFallbackPlugin() {
-	return new LoadFallbackPlugin();
-}
-function aliasPlugin(config) {
-	return new AliasPlugin(config);
-}
-function jsonPlugin(config) {
-	return new JsonPlugin(config);
-}
-function buildImportAnalysisPlugin(config) {
-	return new BuildImportAnalysisPlugin(config);
-}
-function replacePlugin(values = {}, options = {}) {
-	return new ReplacePlugin({
-		...options,
-		values
-	});
-}
-function bindingifyBuiltInPlugin(plugin) {
-	return {
-		__name: plugin.name,
-		options: plugin.options
-	};
-}
-
-//#endregion
-//#region src/plugin/plugin-driver.ts
-class PluginDriver {
-	async callOptionsHook(inputOptions) {
-		const logLevel = inputOptions.logLevel || LOG_LEVEL_INFO;
-		const plugins = getSortedPlugins("options", getObjectPlugins(inputOptions.plugins ?? []));
-		const logger = getLogger(plugins, getOnLog(inputOptions, logLevel), logLevel);
-		for (const plugin of plugins) {
-			const name = plugin.name || "unknown";
-			const options = plugin.options;
-			if (options) {
-				const { handler: handler } = normalizeHook(options);
-				const result = await handler.call({
-					debug: getLogHandler(LOG_LEVEL_DEBUG, "PLUGIN_LOG", logger, name, logLevel),
-					error: (e) => error(logPluginError(normalizeLog(e), name, {hook: "onLog"})),
-					info: getLogHandler(LOG_LEVEL_INFO, "PLUGIN_LOG", logger, name, logLevel),
-					meta: {
-						rollupVersion: "4.23.0",
-						rolldownVersion: VERSION,
-						watchMode: false
-					},
-					warn: getLogHandler(LOG_LEVEL_WARN, "PLUGIN_WARNING", logger, name, logLevel)
-				}, inputOptions);
-				if (result) {
-					inputOptions = result;
-				}
-			}
-		}
-		return inputOptions;
-	}
-	callOutputOptionsHook(inputOptions, outputOptions) {
-		const plugins = getSortedPlugins("outputOptions", getObjectPlugins(inputOptions.plugins));
-		for (const plugin of plugins) {
-			const options = plugin.outputOptions;
-			if (options) {
-				const { handler: handler } = normalizeHook(options);
-				const result = handler.call(null, outputOptions);
-				if (result) {
-					outputOptions = result;
-				}
-			}
-		}
-		return outputOptions;
-	}
-}
-function getObjectPlugins(plugins) {
-	return plugins.filter((plugin) => {
-		if ("_parallel"in plugin) {
-			return undefined;
-		}
-		if (plugin instanceof BuiltinPlugin) {
-			return undefined;
-		}
-		return plugin;
-	});
-}
-function getSortedPlugins(hookName, plugins) {
-	const pre = [];
-	const normal = [];
-	const post = [];
-	for (const plugin of plugins) {
-		const hook = plugin[hookName];
-		if (hook) {
-			if (typeof hook === "object") {
-				if (hook.order === "pre") {
-					pre.push(plugin);
-					continue;
-				}
-				if (hook.order === "post") {
-					post.push(plugin);
-					continue;
-				}
-			}
-			normal.push(plugin);
-		}
-	}
-	return [...pre, ...normal, ...post];
-}
-
-//#endregion
-//#region src/log/logger.ts
-class MinimalPluginContext {
-	debug;
-	info;
-	meta;
-	warn;
-	error;
-	constructor(options, plugin) {
-		const onLog = options.onLog;
-		const pluginName = plugin.name || "unknown";
-		const logLevel = options.logLevel;
-		this.debug = getLogHandler(LOG_LEVEL_DEBUG, "PLUGIN_LOG", onLog, pluginName, logLevel);
-		this.info = getLogHandler(LOG_LEVEL_INFO, "PLUGIN_LOG", onLog, pluginName, logLevel);
-		this.warn = getLogHandler(LOG_LEVEL_WARN, "PLUGIN_WARNING", onLog, pluginName, logLevel);
-		this.error = (e) => {
-			return error(logPluginError(normalizeLog(e), pluginName));
-		};
-		this.meta = {
-			rollupVersion: "4.23.0",
-			rolldownVersion: VERSION,
-			watchMode: false
-		};
-	}
-}
-function getLogger(plugins, onLog, logLevel) {
-	const minimalPriority = logLevelPriority[logLevel];
-	const logger = (level, log, skipped = new Set()) => {
-		const logPriority = logLevelPriority[level];
-		if (logPriority < minimalPriority) {
-			return;
-		}
-		for (const plugin of getSortedPlugins("onLog", plugins)) {
-			if (skipped.has(plugin)) continue;
-			const { onLog: pluginOnLog } = plugin;
-			if (pluginOnLog) {
-				const getLogHandler$1 = (level$1) => {
-					if (logLevelPriority[level$1] < minimalPriority) {
-						return () => {};
-					}
-					return (log$1) => logger(level$1, normalizeLog(log$1), (new Set(skipped)).add(plugin));
-				};
-				const handler = "handler"in pluginOnLog ? pluginOnLog.handler : pluginOnLog;
-				if (handler.call({
-					debug: getLogHandler$1(LOG_LEVEL_DEBUG),
-					error: (log$1) => error(normalizeLog(log$1)),
-					info: getLogHandler$1(LOG_LEVEL_INFO),
-					meta: {
-						rollupVersion: "4.23.0",
-						rolldownVersion: VERSION,
-						watchMode: false
-					},
-					warn: getLogHandler$1(LOG_LEVEL_WARN)
-				}, level, log) === false) {
-					return;
-				}
-			}
-		}
-		onLog(level, log);
-	};
-	return logger;
-}
-const getOnLog = (config, logLevel, printLog = defaultPrintLog) => {
-	const { onwarn: onwarn, onLog: onLog } = config;
-	const defaultOnLog = getDefaultOnLog(printLog, onwarn);
-	if (onLog) {
-		const minimalPriority = logLevelPriority[logLevel];
-		return (level, log) => onLog(level, addLogToString(log), (level$1, handledLog) => {
-			if (level$1 === LOG_LEVEL_ERROR) {
-				return error(normalizeLog(handledLog));
-			}
-			if (logLevelPriority[level$1] >= minimalPriority) {
-				defaultOnLog(level$1, normalizeLog(handledLog));
-			}
-		});
-	}
-	return defaultOnLog;
-};
-const getDefaultOnLog = (printLog, onwarn) => onwarn ? (level, log) => {
-	if (level === LOG_LEVEL_WARN) {
-		onwarn(addLogToString(log), (warning) => printLog(LOG_LEVEL_WARN, normalizeLog(warning)));
-	} else {
-		printLog(level, log);
-	}
-} : printLog;
-const addLogToString = (log) => {
-	Object.defineProperty(log, "toString", {
-		value: () => getExtendedLogMessage(log),
-		writable: true
-	});
-	return log;
-};
-const defaultPrintLog = (level, log) => {
-	const message = getExtendedLogMessage(log);
-	switch (level) {
-		case LOG_LEVEL_WARN: {
-			return console.warn(message);
-		}
-		case LOG_LEVEL_DEBUG: {
-			return console.debug(message);
-		}
-		default: {
-			return console.info(message);
-		}
-	}
-};
-const getExtendedLogMessage = (log) => {
-	let prefix = "";
-	if (log.plugin) {
-		prefix += `(${log.plugin} plugin) `;
-	}
-	if (log.loc) {
-		prefix += `${relativeId(log.loc.file)} (${log.loc.line}:${log.loc.column}) `;
-	}
-	return prefix + log.message;
-};
-function relativeId(id) {
-	if (!path$1.isAbsolute(id)) return id;
-	return path$1.relative(path$1.resolve(), id);
-}
-
-//#endregion
-//#region src/plugin/plugin-context.ts
-class PluginContext extends MinimalPluginContext {
-	resolve;
-	emitFile;
-	getFileName;
-	getModuleInfo;
-	getModuleIds;
-	addWatchFile;
-	parse;
-	constructor(options, context, plugin, data) {
-		super(options, plugin);
-		this.resolve = async (source, importer, options$1) => {
-			let receipt = undefined;
-			if (options$1 != null) {
-				receipt = data.saveResolveOptions(options$1);
-			}
-			const res = await context.resolve(source, importer, {
-				custom: receipt,
-				skipSelf: options$1?.skipSelf
-			});
-			if (receipt != null) {
-				data.removeSavedResolveOptions(receipt);
-			}
-			if (res == null) return null;
-			const info = data.getModuleOption(res.id) || {};
-			return {
-				...res,
-				...info
-			};
-		};
-		this.emitFile = (file) => {
-			if (file.type !== "asset") {
-				return unimplemented("PluginContext.emitFile: only asset type is supported");
-			}
-			return context.emitFile({
-				...file,
-				originalFileName: file.originalFileName || undefined,
-				source: bindingAssetSource(file.source)
-			});
-		};
-		this.getFileName = context.getFileName.bind(context);
-		this.getModuleInfo = (id) => data.getModuleInfo(id, context);
-		this.getModuleIds = () => data.getModuleIds(context);
-		this.parse = unsupported("`PluginContext#parse` is not supported by rolldown.");
-		this.addWatchFile = context.addWatchFile.bind(context);
-	}
-}
-
-//#endregion
-//#region src/plugin/transform-plugin-context.ts
-class TransformPluginContext extends PluginContext {
-	error;
-	constructor(options, context, plugin, data, inner, moduleId, moduleSource) {
-		super(options, context, plugin, data);
-		const getLogHandler$1 = (handler) => (log, pos) => {
-			log = normalizeLog(log);
-			if (pos) augmentCodeLocation(log, pos, moduleSource, moduleId);
-			log.id = moduleId;
-			log.hook = "transform";
-			handler(log);
-		};
-		this.debug = getLogHandler$1(this.debug);
-		this.warn = getLogHandler$1(this.warn);
-		this.info = getLogHandler$1(this.info);
-		this.error = (e, pos) => {
-			if (typeof e === "string") e = {message: e};
-			if (pos) augmentCodeLocation(e, pos, moduleSource, moduleId);
-			e.id = moduleId;
-			e.hook = "transform";
-			return error(logPluginError(normalizeLog(e), plugin.name || "unknown"));
-		};
-	}
-}
-
-//#endregion
-//#region src/utils/transform-side-effects.ts
-var import_binding$5 = __toESM(require_binding());
-function bindingifySideEffects(sideEffects) {
-	switch (sideEffects) {
-		case true: return import_binding$5.BindingHookSideEffects.True;
-		case false: return import_binding$5.BindingHookSideEffects.False;
-		case "no-treeshake": return import_binding$5.BindingHookSideEffects.NoTreeshake;
-		case null:
-		case undefined: return undefined;
-		default: throw new Error(`Unexpected side effects: ${sideEffects}`);
-	}
-}
-
-//#endregion
-//#region src/plugin/bindingify-plugin-hook-meta.ts
-var import_binding$4 = __toESM(require_binding());
-function bindingifyPluginHookMeta(options) {
-	return {order: bindingPluginOrder(options.order)};
-}
-function bindingPluginOrder(order) {
-	switch (order) {
-		case "post": return import_binding$4.BindingPluginOrder.Post;
-		case "pre": return import_binding$4.BindingPluginOrder.Pre;
-		case null:
-		case undefined: return undefined;
-		default: throw new Error(`Unknown plugin order: ${order}`);
-	}
-}
-
-//#endregion
-//#region src/constants/plugin-context.ts
-const SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF = Symbol("plugin-context-resolve-caller");
-
-//#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) : undefined,
-		exclude: matcher.exclude ? arraify(matcher.exclude) : undefined
-	};
-}
-function bindingifyResolveIdFilter(filterOption) {
-	return filterOption?.id ? bindingifyStringFilter(filterOption.id) : undefined;
-}
-function bindingifyLoadFilter(filterOption) {
-	return filterOption?.id ? bindingifyStringFilter(filterOption.id) : undefined;
-}
-function bindingifyTransformFilter(filterOption) {
-	if (!filterOption) {
-		return undefined;
-	}
-	const { id: id, code: code, moduleType: moduleType } = filterOption;
-	let moduleTypeRet;
-	if (moduleType) {
-		if (Array.isArray(moduleType)) {
-			moduleTypeRet = moduleType;
-		} else {
-			moduleTypeRet = moduleType.include;
-		}
-	}
-	return {
-		id: id ? bindingifyStringFilter(id) : undefined,
-		code: code ? bindingifyStringFilter(code) : undefined,
-		moduleType: moduleTypeRet
-	};
-}
-
-//#endregion
-//#region src/plugin/bindingify-build-hooks.ts
-function bindingifyBuildStart(plugin, options, pluginContextData) {
-	const hook = plugin.buildStart;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx) => {
-			await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), options);
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-function bindingifyBuildEnd(plugin, options, pluginContextData) {
-	const hook = plugin.buildEnd;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, err) => {
-			await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), err ? new Error(err) : undefined);
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-function bindingifyResolveId(plugin, normalizedOptions, pluginContextData) {
-	const hook = plugin.resolveId;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta, options: options } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, specifier, importer, extraOptions) => {
-			const contextResolveOptions = extraOptions.custom != null ? pluginContextData.getSavedResolveOptions(extraOptions.custom) : undefined;
-			const newExtraOptions = {
-				...extraOptions,
-				custom: contextResolveOptions?.custom,
-				[SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF]: contextResolveOptions?.[SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF]
-			};
-			const ret = await handler.call(new PluginContext(normalizedOptions, ctx, plugin, pluginContextData), specifier, importer ?? undefined, newExtraOptions);
-			if (ret == null) {
-				return;
-			}
-			if (ret === false) {
-				return {
-					id: specifier,
-					external: true
-				};
-			}
-			if (typeof ret === "string") {
-				return {id: ret};
-			}
-			const result = {
-				id: ret.id,
-				external: ret.external
-			};
-			if (ret.moduleSideEffects !== null) {
-				result.sideEffects = bindingifySideEffects(ret.moduleSideEffects);
-			}
-			pluginContextData.updateModuleOption(ret.id, {
-				meta: ret.meta || {},
-				moduleSideEffects: ret.moduleSideEffects || null
-			});
-			return result;
-		},
-		meta: bindingifyPluginHookMeta(meta),
-		filter: bindingifyResolveIdFilter(options.filter)
-	};
-}
-function bindingifyResolveDynamicImport(plugin, options, pluginContextData) {
-	const hook = plugin.resolveDynamicImport;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, specifier, importer) => {
-			const ret = await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), specifier, importer ?? undefined);
-			if (ret == null) {
-				return;
-			}
-			if (ret === false) {
-				return {
-					id: specifier,
-					external: true
-				};
-			}
-			if (typeof ret === "string") {
-				return {id: ret};
-			}
-			const result = {
-				id: ret.id,
-				external: ret.external
-			};
-			if (ret.moduleSideEffects !== null) {
-				result.sideEffects = bindingifySideEffects(ret.moduleSideEffects);
-			}
-			pluginContextData.updateModuleOption(ret.id, {
-				meta: ret.meta || {},
-				moduleSideEffects: ret.moduleSideEffects || null
-			});
-			return result;
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-function bindingifyTransform(plugin, normalizedOptions, pluginContextData) {
-	const hook = plugin.transform;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta, options: options } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, code, id, meta$1) => {
-			const ret = await handler.call(new TransformPluginContext(normalizedOptions, ctx.inner(), plugin, pluginContextData, ctx, id, code), code, id, meta$1);
-			if (ret == null) {
-				return undefined;
-			}
-			if (typeof ret === "string") {
-				return {code: ret};
-			}
-			pluginContextData.updateModuleOption(id, {
-				meta: ret.meta || {},
-				moduleSideEffects: ret.moduleSideEffects || null
-			});
-			return {
-				code: ret.code,
-				map: bindingifySourcemap$1(ret.map),
-				sideEffects: bindingifySideEffects(ret.moduleSideEffects),
-				moduleType: ret.moduleType
-			};
-		},
-		meta: bindingifyPluginHookMeta(meta),
-		filter: bindingifyTransformFilter(options.filter)
-	};
-}
-function bindingifyLoad(plugin, normalized_options, pluginContextData) {
-	const hook = plugin.load;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta, options: options } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, id) => {
-			const ret = await handler.call(new PluginContext(normalized_options, ctx, plugin, pluginContextData), id);
-			if (ret == null) {
-				return;
-			}
-			if (typeof ret === "string") {
-				return {code: ret};
-			}
-			if (!ret.map) {
-				return {
-					code: ret.code,
-					moduleType: ret.moduleType
-				};
-			}
-			let map = typeof ret.map === "object" ? ret.map : JSON.parse(ret.map);
-			if (!isEmptySourcemapFiled(map.sources)) {
-				const directory = path.dirname(id) || ".";
-				const sourceRoot = map.sourceRoot || ".";
-				map.sources = map.sources.map((source) => path.resolve(directory, sourceRoot, source));
-			}
-			const result = {
-				code: ret.code,
-				map: bindingifySourcemap$1(map),
-				moduleType: ret.moduleType
-			};
-			if (ret.moduleSideEffects !== null) {
-				result.sideEffects = bindingifySideEffects(ret.moduleSideEffects);
-			}
-			pluginContextData.updateModuleOption(id, {
-				meta: ret.meta || {},
-				moduleSideEffects: ret.moduleSideEffects || null
-			});
-			return result;
-		},
-		meta: bindingifyPluginHookMeta(meta),
-		filter: bindingifyLoadFilter(options.filter)
-	};
-}
-function bindingifyModuleParsed(plugin, options, pluginContextData) {
-	const hook = plugin.moduleParsed;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, moduleInfo) => {
-			await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), transformModuleInfo(moduleInfo, pluginContextData.moduleOptionMap.get(moduleInfo.id)));
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-
-//#endregion
-//#region src/plugin/bindingify-output-hooks.ts
-function bindingifyRenderStart(plugin, options, outputOptions, pluginContextData) {
-	const hook = plugin.renderStart;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx) => {
-			handler.call(new PluginContext(options, ctx, plugin, pluginContextData), outputOptions, options);
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-function bindingifyRenderChunk(plugin, options, outputOptions, pluginContextData) {
-	const hook = plugin.renderChunk;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, code, chunk) => {
-			const ret = await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), code, chunk, outputOptions);
-			if (ret == null) {
-				return;
-			}
-			if (typeof ret === "string") {
-				return {code: ret};
-			}
-			if (!ret.map) {
-				return {code: ret.code};
-			}
-			return {
-				code: ret.code,
-				map: bindingifySourcemap$1(ret.map)
-			};
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-function bindingifyAugmentChunkHash(plugin, options, pluginContextData) {
-	const hook = plugin.augmentChunkHash;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, chunk) => {
-			return await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), chunk);
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-function bindingifyRenderError(plugin, options, pluginContextData) {
-	const hook = plugin.renderError;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, err) => {
-			handler.call(new PluginContext(options, ctx, plugin, pluginContextData), new Error(err));
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-function bindingifyGenerateBundle(plugin, options, outputOptions, pluginContextData) {
-	const hook = plugin.generateBundle;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, bundle, isWrite) => {
-			const changed = {
-				updated: new Set(),
-				deleted: new Set()
-			};
-			const output = transformToOutputBundle(bundle, changed);
-			await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), outputOptions, output, isWrite);
-			return collectChangedBundle(changed, output);
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-function bindingifyWriteBundle(plugin, options, outputOptions, pluginContextData) {
-	const hook = plugin.writeBundle;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, bundle) => {
-			const changed = {
-				updated: new Set(),
-				deleted: new Set()
-			};
-			const output = transformToOutputBundle(bundle, changed);
-			await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), outputOptions, output);
-			return collectChangedBundle(changed, output);
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-function bindingifyCloseBundle(plugin, options, pluginContextData) {
-	const hook = plugin.closeBundle;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx) => {
-			await handler.call(new PluginContext(options, ctx, plugin, pluginContextData));
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-function bindingifyBanner(plugin, options, pluginContextData) {
-	const hook = plugin.banner;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, chunk) => {
-			if (typeof handler === "string") {
-				return handler;
-			}
-			return handler.call(new PluginContext(options, ctx, plugin, pluginContextData), chunk);
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-function bindingifyFooter(plugin, options, pluginContextData) {
-	const hook = plugin.footer;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, chunk) => {
-			if (typeof handler === "string") {
-				return handler;
-			}
-			return handler.call(new PluginContext(options, ctx, plugin, pluginContextData), chunk);
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-function bindingifyIntro(plugin, options, pluginContextData) {
-	const hook = plugin.intro;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, chunk) => {
-			if (typeof handler === "string") {
-				return handler;
-			}
-			return handler.call(new PluginContext(options, ctx, plugin, pluginContextData), chunk);
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-function bindingifyOutro(plugin, options, pluginContextData) {
-	const hook = plugin.outro;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, chunk) => {
-			if (typeof handler === "string") {
-				return handler;
-			}
-			return handler.call(new PluginContext(options, ctx, plugin, pluginContextData), chunk);
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-
-//#endregion
-//#region src/plugin/bindingify-watch-hooks.ts
-function bindingifyWatchChange(plugin, options, pluginContextData) {
-	const hook = plugin.watchChange;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx, id, event) => {
-			await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), id, {event: event});
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-function bindingifyCloseWatcher(plugin, options, pluginContextData) {
-	const hook = plugin.closeWatcher;
-	if (!hook) {
-		return {};
-	}
-	const { handler: handler, meta: meta } = normalizeHook(hook);
-	return {
-		plugin: async (ctx) => {
-			await handler.call(new PluginContext(options, ctx, plugin, pluginContextData));
-		},
-		meta: bindingifyPluginHookMeta(meta)
-	};
-}
-
-//#endregion
-//#region src/plugin/bindingify-plugin.ts
-function bindingifyPlugin(plugin, options, outputOptions, pluginContextData) {
-	const { plugin: buildStart, meta: buildStartMeta } = bindingifyBuildStart(plugin, options, pluginContextData);
-	const { plugin: resolveId, meta: resolveIdMeta, filter: resolveIdFilter } = bindingifyResolveId(plugin, options, pluginContextData);
-	const { plugin: resolveDynamicImport, meta: resolveDynamicImportMeta } = bindingifyResolveDynamicImport(plugin, options, pluginContextData);
-	const { plugin: buildEnd, meta: buildEndMeta } = bindingifyBuildEnd(plugin, options, pluginContextData);
-	const { plugin: transform, meta: transformMeta, filter: transformFilter } = bindingifyTransform(plugin, options, pluginContextData);
-	const { plugin: moduleParsed, meta: moduleParsedMeta } = bindingifyModuleParsed(plugin, options, pluginContextData);
-	const { plugin: load, meta: loadMeta, filter: loadFilter } = bindingifyLoad(plugin, options, pluginContextData);
-	const { plugin: renderChunk, meta: renderChunkMeta } = bindingifyRenderChunk(plugin, options, outputOptions, pluginContextData);
-	const { plugin: augmentChunkHash, meta: augmentChunkHashMeta } = bindingifyAugmentChunkHash(plugin, options, pluginContextData);
-	const { plugin: renderStart, meta: renderStartMeta } = bindingifyRenderStart(plugin, options, outputOptions, pluginContextData);
-	const { plugin: renderError, meta: renderErrorMeta } = bindingifyRenderError(plugin, options, pluginContextData);
-	const { plugin: generateBundle, meta: generateBundleMeta } = bindingifyGenerateBundle(plugin, options, outputOptions, pluginContextData);
-	const { plugin: writeBundle, meta: writeBundleMeta } = bindingifyWriteBundle(plugin, options, outputOptions, pluginContextData);
-	const { plugin: closeBundle, meta: closeBundleMeta } = bindingifyCloseBundle(plugin, options, pluginContextData);
-	const { plugin: banner, meta: bannerMeta } = bindingifyBanner(plugin, options, pluginContextData);
-	const { plugin: footer, meta: footerMeta } = bindingifyFooter(plugin, options, pluginContextData);
-	const { plugin: intro, meta: introMeta } = bindingifyIntro(plugin, options, pluginContextData);
-	const { plugin: outro, meta: outroMeta } = bindingifyOutro(plugin, options, pluginContextData);
-	const { plugin: watchChange, meta: watchChangeMeta } = bindingifyWatchChange(plugin, options, pluginContextData);
-	const { plugin: closeWatcher, meta: closeWatcherMeta } = bindingifyCloseWatcher(plugin, options, pluginContextData);
-	return {
-		name: plugin.name ?? "unknown",
-		buildStart,
-		buildStartMeta,
-		resolveId,
-		resolveIdMeta,
-		resolveIdFilter,
-		resolveDynamicImport,
-		resolveDynamicImportMeta,
-		buildEnd,
-		buildEndMeta,
-		transform,
-		transformMeta,
-		transformFilter,
-		moduleParsed,
-		moduleParsedMeta,
-		load,
-		loadMeta,
-		loadFilter,
-		renderChunk,
-		renderChunkMeta,
-		augmentChunkHash,
-		augmentChunkHashMeta,
-		renderStart,
-		renderStartMeta,
-		renderError,
-		renderErrorMeta,
-		generateBundle,
-		generateBundleMeta,
-		writeBundle,
-		writeBundleMeta,
-		closeBundle,
-		closeBundleMeta,
-		banner,
-		bannerMeta,
-		footer,
-		footerMeta,
-		intro,
-		introMeta,
-		outro,
-		outroMeta,
-		watchChange,
-		watchChangeMeta,
-		closeWatcher,
-		closeWatcherMeta
-	};
-}
-
-//#endregion
-//#region src/plugin/plugin-context-data.ts
-class PluginContextData {
-	modules = new Map();
-	moduleIds = null;
-	moduleOptionMap = new Map();
-	resolveOptionsMap = new Map();
-	updateModuleOption(id, option) {
-		const existing = this.moduleOptionMap.get(id);
-		if (existing) {
-			Object.assign(existing, option);
-			if (option.meta != null) {
-				Object.assign(existing.meta, option.meta);
-			}
-		} else {
-			this.moduleOptionMap.set(id, option);
-		}
-	}
-	getModuleOption(id) {
-		return this.moduleOptionMap.get(id);
-	}
-	getModuleInfo(id, context) {
-		if (this.modules.has(id)) {
-			return this.modules.get(id) ?? null;
-		}
-		const bindingInfo = context.getModuleInfo(id);
-		if (bindingInfo) {
-			const info = transformModuleInfo(bindingInfo, this.moduleOptionMap.get(id));
-			this.modules.set(id, info);
-			return info;
-		}
-		return null;
-	}
-	getModuleIds(context) {
-		if (this.moduleIds) {
-			return this.moduleIds.values();
-		}
-		const moduleIds = context.getModuleIds();
-		if (moduleIds) {
-			this.moduleIds = moduleIds;
-			return moduleIds.values();
-		}
-		return [].values();
-	}
-	saveResolveOptions(options) {
-		const index = this.resolveOptionsMap.size;
-		this.resolveOptionsMap.set(index, options);
-		return index;
-	}
-	getSavedResolveOptions(receipt) {
-		return this.resolveOptionsMap.get(receipt);
-	}
-	removeSavedResolveOptions(receipt) {
-		this.resolveOptionsMap.delete(receipt);
-	}
-}
-
-//#endregion
-//#region src/options/bindingify-input-options.ts
-var import_binding$3 = __toESM(require_binding());
-function bindingifyInputOptions(options, outputOptions) {
-	const pluginContextData = new PluginContextData();
-	return {
-		input: bindingifyInput(options.input),
-		plugins: options.plugins.map((plugin) => {
-			if ("_parallel"in plugin) {
-				return undefined;
-			}
-			if (plugin instanceof BuiltinPlugin) {
-				return bindingifyBuiltInPlugin(plugin);
-			}
-			return bindingifyPlugin(plugin, options, outputOptions, pluginContextData);
-		}),
-		cwd: options.cwd ?? process.cwd(),
-		external: options.external ? function bindingifyExternal() {
-			const external = options.external;
-			if (typeof external === "function") {
-				return (id, importer, isResolved) => {
-					if (id.startsWith("\0")) return false;
-					return external(id, importer, isResolved) ?? false;
-				};
-			}
-			const externalArr = arraify(external);
-			return (id, _importer, _isResolved) => {
-				return externalArr.some((pat) => {
-					if (pat instanceof RegExp) {
-						return pat.test(id);
-					}
-					return id === pat;
-				});
-			};
-		}() : undefined,
-		resolve: options.resolve ? function bindingifyResolve() {
-			const { alias: alias, extensionAlias: extensionAlias,...rest } = options.resolve;
-			return {
-				alias: alias ? (Object.entries(alias)).map(([name, replacement]) => ({
-					find: name,
-					replacements: [replacement]
-				})) : undefined,
-				extensionAlias: extensionAlias ? (Object.entries(extensionAlias)).map(([name, value]) => ({
-					target: name,
-					replacements: value
-				})) : undefined,
-				...rest
-			};
-		}() : undefined,
-		platform: options.platform,
-		shimMissingExports: options.shimMissingExports,
-		logLevel: bindingifyLogLevel(options.logLevel),
-		onLog: (level, log) => {
-			options.onLog(level, {
-				code: log.code,
-				message: log.message
-			});
-		},
-		treeshake: options.treeshake,
-		moduleTypes: options.moduleTypes,
-		define: options.define ? Object.entries(options.define) : undefined,
-		inject: options.inject ? (Object.entries(options.inject)).map(([alias, item]) => {
-			if (Array.isArray(item)) {
-				if (item[1] === "*") {
-					return {
-						tagNamespace: true,
-						alias,
-						from: item[0]
-					};
-				}
-				return {
-					tagNamed: true,
-					alias,
-					from: item[0],
-					imported: item[1]
-				};
-			} else {
-				return {
-					tagNamed: true,
-					imported: "default",
-					alias,
-					from: item
-				};
-			}
-		}) : undefined,
-		experimental: {
-			strictExecutionOrder: options.experimental?.strictExecutionOrder,
-			disableLiveBindings: options.experimental?.disableLiveBindings
-		},
-		profilerNames: options?.profilerNames,
-		jsx: bindingifyJsx(options.jsx),
-		watch: bindingifyWatch(options.watch)
-	};
-}
-function bindingifyLogLevel(logLevel) {
-	switch (logLevel) {
-		case "silent": return import_binding$3.BindingLogLevel.Silent;
-		case "warn": return import_binding$3.BindingLogLevel.Warn;
-		case "info": return import_binding$3.BindingLogLevel.Info;
-		case "debug": return import_binding$3.BindingLogLevel.Debug;
-		default: throw new Error(`Unexpected log level: ${logLevel}`);
-	}
-}
-function bindingifyInput(input) {
-	if (Array.isArray(input)) {
-		return input.map((src) => {
-			return {import: src};
-		});
-	} else {
-		return (Object.entries(input)).map((value) => {
-			return {
-				name: value[0],
-				import: value[1]
-			};
-		});
-	}
-}
-function bindingifyJsx(input) {
-	if (input) {
-		const mode = input.mode ?? "classic";
-		return {
-			runtime: mode,
-			importSource: mode === "classic" ? input.importSource : mode === "automatic" ? input.jsxImportSource : undefined,
-			pragma: input.factory,
-			pragmaFrag: input.fragment,
-			development: input.development,
-			refresh: input.refresh
-		};
-	}
-}
-function bindingifyWatch(watch$1) {
-	if (watch$1) {
-		let value = {
-			skipWrite: watch$1.skipWrite,
-			include: normalizedStringOrRegex(watch$1.include),
-			exclude: normalizedStringOrRegex(watch$1.exclude)
-		};
-		if (watch$1.notify) {
-			value.notify = {
-				pollInterval: watch$1.notify.pollInterval,
-				compareContents: watch$1.notify.compareContents
-			};
-		}
-		if (watch$1.chokidar) {
-			unsupported("The watch chokidar option is deprecated, please use notify options instead of it.");
-		}
-		return value;
-	}
-}
-
-//#endregion
-//#region src/utils/initialize-parallel-plugins.ts
-var import_binding$2 = __toESM(require_binding());
-async function initializeParallelPlugins(plugins) {
-	const pluginInfos = [];
-	for (const [index, plugin] of plugins.entries()) {
-		if ("_parallel"in plugin) {
-			const { fileUrl: fileUrl, options: options } = plugin._parallel;
-			pluginInfos.push({
-				index,
-				fileUrl,
-				options
-			});
-		}
-	}
-	if (pluginInfos.length <= 0) {
-		return undefined;
-	}
-	const count = Math.min(availableParallelism(), 8);
-	const parallelJsPluginRegistry = new import_binding$2.ParallelJsPluginRegistry(count);
-	const registryId = parallelJsPluginRegistry.id;
-	const workers = await initializeWorkers(registryId, count, pluginInfos);
-	const stopWorkers = async () => {
-		await Promise.all(workers.map((worker) => worker.terminate()));
-	};
-	return {
-		registry: parallelJsPluginRegistry,
-		stopWorkers
-	};
-}
-function initializeWorkers(registryId, count, pluginInfos) {
-	return Promise.all(Array.from({length: count}, (_, i) => initializeWorker(registryId, pluginInfos, i)));
-}
-async function initializeWorker(registryId, pluginInfos, threadNumber) {
-	const urlString = undefined("#parallel-plugin-worker");
-	const workerData = {
-		registryId,
-		pluginInfos,
-		threadNumber
-	};
-	let worker;
-	try {
-		worker = new Worker(new URL(urlString), {workerData});
-		worker.unref();
-		await new Promise((resolve, reject) => {
-			worker.once("message", async (message) => {
-				if (message.type === "error") {
-					reject(message.error);
-				} else {
-					resolve();
-				}
-			});
-		});
-		return worker;
-	} catch (e) {
-		worker?.terminate();
-		throw e;
-	}
-}
-
-//#endregion
-//#region src/utils/async-flatten.ts
-async function asyncFlatten(array) {
-	do {
-		array = (await Promise.all(array)).flat(Infinity);
-	} while (array.some((v) => v?.then));
-	return array;
-}
-
-//#endregion
-//#region src/utils/normalize-plugin-option.ts
-const normalizePluginOption = async (plugins) => (await asyncFlatten([plugins])).filter(Boolean);
-
-//#endregion
-//#region src/utils/normalize-tree-shake.ts
-function normalizeTreeshakeOptions(config) {
-	if (config === false) {
-		return undefined;
-	}
-	if (config === true || config === undefined) {
-		return {moduleSideEffects: "true"};
-	}
-	let normalizedConfig = {moduleSideEffects: ""};
-	if (config.moduleSideEffects === undefined) {
-		normalizedConfig.moduleSideEffects = "true";
-	} else if (isRegExp(config.moduleSideEffects)) {
-		normalizedConfig.moduleSideEffects = config.moduleSideEffects.source;
-	} else {
-		normalizedConfig.moduleSideEffects = config.moduleSideEffects.toString();
-	}
-	return normalizedConfig;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/remeda@2.16.0/node_modules/remeda/dist/chunk-K26VP6CL.js
-function u$1(t$1, n, a) {
-	let o = (r) => t$1(r, ...n);
-	return a === void 0 ? o : Object.assign(o, {
-		lazy: a,
-		lazyArgs: n
-	});
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/remeda@2.16.0/node_modules/remeda/dist/chunk-RAAYCPUM.js
-function u(r, n, a) {
-	let o = r.length - n.length;
-	if (o === 0) return r(...n);
-	if (o === 1) return u$1(r, n, a);
-	throw new Error("Wrong number of arguments");
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/remeda@2.16.0/node_modules/remeda/dist/chunk-NMJS7ULY.js
-function t(...n) {
-	return u(Object.keys, n);
-}
-
-//#endregion
-//#region src/constants/plugin.ts
-const ENUMERATED_PLUGIN_HOOK_NAMES = ["options", "buildStart", "resolveId", "load", "transform", "moduleParsed", "augmentChunkHash", "buildEnd", "onLog", "resolveDynamicImport", "generateBundle", "outputOptions", "renderChunk", "renderStart", "renderError", "writeBundle", "footer", "banner", "intro", "outro", "closeBundle", "watchChange", "closeWatcher",];
-const DEFINED_HOOK_NAMES = {
-	[ENUMERATED_PLUGIN_HOOK_NAMES[0]]: ENUMERATED_PLUGIN_HOOK_NAMES[0],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[1]]: ENUMERATED_PLUGIN_HOOK_NAMES[1],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[2]]: ENUMERATED_PLUGIN_HOOK_NAMES[2],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[3]]: ENUMERATED_PLUGIN_HOOK_NAMES[3],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[4]]: ENUMERATED_PLUGIN_HOOK_NAMES[4],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[5]]: ENUMERATED_PLUGIN_HOOK_NAMES[5],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[6]]: ENUMERATED_PLUGIN_HOOK_NAMES[6],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[7]]: ENUMERATED_PLUGIN_HOOK_NAMES[7],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[8]]: ENUMERATED_PLUGIN_HOOK_NAMES[8],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[9]]: ENUMERATED_PLUGIN_HOOK_NAMES[9],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[10]]: ENUMERATED_PLUGIN_HOOK_NAMES[10],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[11]]: ENUMERATED_PLUGIN_HOOK_NAMES[11],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[12]]: ENUMERATED_PLUGIN_HOOK_NAMES[12],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[13]]: ENUMERATED_PLUGIN_HOOK_NAMES[13],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[14]]: ENUMERATED_PLUGIN_HOOK_NAMES[14],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[15]]: ENUMERATED_PLUGIN_HOOK_NAMES[15],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[16]]: ENUMERATED_PLUGIN_HOOK_NAMES[16],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[17]]: ENUMERATED_PLUGIN_HOOK_NAMES[17],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[18]]: ENUMERATED_PLUGIN_HOOK_NAMES[18],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[19]]: ENUMERATED_PLUGIN_HOOK_NAMES[19],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[20]]: ENUMERATED_PLUGIN_HOOK_NAMES[20],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[21]]: ENUMERATED_PLUGIN_HOOK_NAMES[21],
-	[ENUMERATED_PLUGIN_HOOK_NAMES[22]]: ENUMERATED_PLUGIN_HOOK_NAMES[22]
-};
-
-//#endregion
-//#region src/utils/plugin/index.ts
-const isPluginHookName = function() {
-	const PLUGIN_HOOK_NAMES_SET = new Set(ENUMERATED_PLUGIN_HOOK_NAMES);
-	return function isPluginHookName$1(hookName) {
-		return PLUGIN_HOOK_NAMES_SET.has(hookName);
-	};
-}();
-
-//#endregion
-//#region src/utils/compose-js-plugins.ts
-const unsupportedHookName = ["augmentChunkHash", "generateBundle", "moduleParsed", "onLog", "options", "outputOptions", "renderError", "renderStart", "resolveDynamicImport", "writeBundle",];
-const unsupportedHooks = new Set(unsupportedHookName);
-function isUnsupportedHooks(hookName) {
-	return unsupportedHooks.has(hookName);
-}
-function createComposedPlugin(plugins) {
-	const names = [];
-	const batchedHooks = {};
-	plugins.forEach((plugin, index) => {
-		const pluginName = plugin.name || `Anonymous(index: ${index})`;
-		names.push(pluginName);
-		(t(plugin)).forEach((pluginProp) => {
-			if (isUnsupportedHooks(pluginProp)) {
-				throw new Error(`Failed to compose js plugins. Plugin ${pluginName} has an unsupported hook: ${pluginProp}`);
-			}
-			if (!isPluginHookName(pluginProp)) {
-				return;
-			}
-			switch (pluginProp) {
-				case "buildStart": {
-					const handlers = batchedHooks.buildStart ?? [];
-					batchedHooks.buildStart = handlers;
-					if (plugin.buildStart) {
-						handlers.push([plugin.buildStart, plugin]);
-					}
-					break;
-				}
-				case "load": {
-					const handlers = batchedHooks.load ?? [];
-					batchedHooks.load = handlers;
-					if (plugin.load) {
-						handlers.push([plugin.load, plugin]);
-					}
-					break;
-				}
-				case "transform": {
-					const handlers = batchedHooks.transform ?? [];
-					batchedHooks.transform = handlers;
-					if (plugin.transform) {
-						handlers.push([plugin.transform, plugin]);
-					}
-					break;
-				}
-				case "resolveId": {
-					const handlers = batchedHooks.resolveId ?? [];
-					batchedHooks.resolveId = handlers;
-					if (plugin.resolveId) {
-						handlers.push([plugin.resolveId, plugin]);
-					}
-					break;
-				}
-				case "buildEnd": {
-					const handlers = batchedHooks.buildEnd ?? [];
-					batchedHooks.buildEnd = handlers;
-					if (plugin.buildEnd) {
-						handlers.push([plugin.buildEnd, plugin]);
-					}
-					break;
-				}
-				case "renderChunk": {
-					const handlers = batchedHooks.renderChunk ?? [];
-					batchedHooks.renderChunk = handlers;
-					if (plugin.renderChunk) {
-						handlers.push([plugin.renderChunk, plugin]);
-					}
-					break;
-				}
-				case "banner":
-				case "footer":
-				case "intro":
-				case "outro": {
-					const hook = plugin[pluginProp];
-					if (hook) {
-						;
-						(batchedHooks[pluginProp] ??= []).push([hook, plugin]);
-					}
-					break;
-				}
-				case "closeBundle": {
-					const handlers = batchedHooks.closeBundle ?? [];
-					batchedHooks.closeBundle = handlers;
-					if (plugin.closeBundle) {
-						handlers.push([plugin.closeBundle, plugin]);
-					}
-					break;
-				}
-				case "watchChange": {
-					const handlers = batchedHooks.watchChange ?? [];
-					batchedHooks.watchChange = handlers;
-					if (plugin.watchChange) {
-						handlers.push([plugin.watchChange, plugin]);
-					}
-					break;
-				}
-				case "closeWatcher": {
-					const handlers = batchedHooks.closeWatcher ?? [];
-					batchedHooks.closeWatcher = handlers;
-					if (plugin.closeWatcher) {
-						handlers.push([plugin.closeWatcher, plugin]);
-					}
-					break;
-				}
-				default: {}
-			}
-		});
-	});
-	const composed = {name: `Composed(${names.join(", ")})`};
-	const createFixedPluginResolveFnMap = new Map();
-	function applyFixedPluginResolveFn(ctx, plugin) {
-		const createFixedPluginResolveFn = createFixedPluginResolveFnMap.get(plugin);
-		if (createFixedPluginResolveFn) {
-			return {
-				...ctx,
-				resolve: createFixedPluginResolveFn(ctx)
-			};
-		}
-		return ctx;
-	}
-	if (batchedHooks.resolveId) {
-		const batchedHandlers = batchedHooks.resolveId;
-		const handlerSymbols = batchedHandlers.map(([_handler, plugin]) => Symbol(plugin.name ?? `Anonymous`));
-		for (let handlerIdx = 0; handlerIdx < batchedHandlers.length; handlerIdx++) {
-			const [_handler, plugin] = batchedHandlers[handlerIdx];
-			const handlerSymbol = handlerSymbols[handlerIdx];
-			const createFixedPluginResolveFn = (ctx) => {
-				return (source, importer, rawContextResolveOptions) => {
-					const contextResolveOptions = rawContextResolveOptions ?? {};
-					if (contextResolveOptions.skipSelf) {
-						contextResolveOptions[SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF] = handlerSymbol;
-						contextResolveOptions.skipSelf = false;
-					}
-					return ctx.resolve(source, importer, contextResolveOptions);
-				};
-			};
-			createFixedPluginResolveFnMap.set(plugin, createFixedPluginResolveFn);
-		}
-		composed.resolveId = async function(source, importer, rawHookResolveIdOptions) {
-			const hookResolveIdOptions = rawHookResolveIdOptions;
-			const symbolForCallerThatSkipSelf = hookResolveIdOptions?.[SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF];
-			for (let handlerIdx = 0; handlerIdx < batchedHandlers.length; handlerIdx++) {
-				const [handler, plugin] = batchedHandlers[handlerIdx];
-				const handlerSymbol = handlerSymbols[handlerIdx];
-				if (symbolForCallerThatSkipSelf === handlerSymbol) {
-					continue;
-				}
-				const { handler: handlerFn } = normalizeHook(handler);
-				const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), source, importer, rawHookResolveIdOptions);
-				if (!isNullish(result)) {
-					return result;
-				}
-			}
-		};
-	}
-	(t(batchedHooks)).forEach((hookName) => {
-		switch (hookName) {
-			case "resolveId": {
-				break;
-			}
-			case "buildStart": {
-				if (batchedHooks.buildStart) {
-					const batchedHandlers = batchedHooks.buildStart;
-					composed.buildStart = async function(options) {
-						await Promise.all(batchedHandlers.map(([handler, plugin]) => {
-							const { handler: handlerFn } = normalizeHook(handler);
-							return handlerFn.call(applyFixedPluginResolveFn(this, plugin), options);
-						}));
-					};
-				}
-				break;
-			}
-			case "load": {
-				if (batchedHooks.load) {
-					const batchedHandlers = batchedHooks.load;
-					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);
-							if (!isNullish(result)) {
-								return result;
-							}
-						}
-					};
-				}
-				break;
-			}
-			case "transform": {
-				if (batchedHooks.transform) {
-					const batchedHandlers = batchedHooks.transform;
-					composed.transform = async function(initialCode, id, moduleType) {
-						let code = initialCode;
-						let moduleSideEffects = undefined;
-						function updateOutput(newCode, newModuleSideEffects) {
-							code = newCode;
-							moduleSideEffects = newModuleSideEffects ?? undefined;
-						}
-						for (const [handler, plugin] of batchedHandlers) {
-							const { handler: handlerFn } = normalizeHook(handler);
-							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), code, id, moduleType);
-							if (!isNullish(result)) {
-								if (typeof result === "string") {
-									updateOutput(result);
-								} else {
-									if (result.code) {
-										updateOutput(result.code, result.moduleSideEffects);
-									}
-								}
-							}
-						}
-						return {
-							code,
-							moduleSideEffects
-						};
-					};
-				}
-				break;
-			}
-			case "buildEnd": {
-				if (batchedHooks.buildEnd) {
-					const batchedHandlers = batchedHooks.buildEnd;
-					composed.buildEnd = async function(err) {
-						await Promise.all(batchedHandlers.map(([handler, plugin]) => {
-							const { handler: handlerFn } = normalizeHook(handler);
-							return handlerFn.call(applyFixedPluginResolveFn(this, plugin), err);
-						}));
-					};
-				}
-				break;
-			}
-			case "renderChunk": {
-				if (batchedHooks.renderChunk) {
-					const batchedHandlers = batchedHooks.renderChunk;
-					composed.renderChunk = async function(code, chunk, options) {
-						for (const [handler, plugin] of batchedHandlers) {
-							const { handler: handlerFn } = normalizeHook(handler);
-							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), code, chunk, options);
-							if (!isNullish(result)) {
-								return result;
-							}
-						}
-					};
-				}
-				break;
-			}
-			case "banner":
-			case "footer":
-			case "intro":
-			case "outro": {
-				const hooks = batchedHooks[hookName];
-				if (hooks?.length) {
-					composed[hookName] = async function(chunk) {
-						const ret = [];
-						for (const [hook, plugin] of hooks) {
-							{
-								const { handler: handler } = normalizeHook(hook);
-								ret.push(typeof handler === "string" ? handler : await handler.call(applyFixedPluginResolveFn(this, plugin), chunk));
-							}
-						}
-						return ret.join("\n");
-					};
-				}
-				break;
-			}
-			case "closeBundle": {
-				if (batchedHooks.closeBundle) {
-					const batchedHandlers = batchedHooks.closeBundle;
-					composed.closeBundle = async function() {
-						await Promise.all(batchedHandlers.map(([handler, plugin]) => {
-							const { handler: handlerFn } = normalizeHook(handler);
-							return handlerFn.call(applyFixedPluginResolveFn(this, plugin));
-						}));
-					};
-				}
-				break;
-			}
-			case "watchChange": {
-				if (batchedHooks.watchChange) {
-					const batchedHandlers = batchedHooks.watchChange;
-					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, event);
-						}));
-					};
-				}
-				break;
-			}
-			case "closeWatcher": {
-				if (batchedHooks.closeWatcher) {
-					const batchedHandlers = batchedHooks.closeWatcher;
-					composed.closeWatcher = async function() {
-						await Promise.all(batchedHandlers.map(([handler, plugin]) => {
-							const { handler: handlerFn } = normalizeHook(handler);
-							return handlerFn.call(applyFixedPluginResolveFn(this, plugin));
-						}));
-					};
-				}
-				break;
-			}
-			default: {}
-		}
-	});
-	return composed;
-}
-function isComposablePlugin(plugin) {
-	if (plugin instanceof BuiltinPlugin) {
-		return false;
-	}
-	if ("_parallel"in plugin) {
-		return false;
-	}
-	const hasNotComposablePattern = (t(plugin)).some((hookName) => {
-		if (!isPluginHookName(hookName)) {
-			return false;
-		}
-		const OK_TO_COMPOSE = false;
-		if (isUnsupportedHooks(hookName)) {
-			return !OK_TO_COMPOSE;
-		}
-		if (plugin[hookName]) {
-			const { meta: meta } = normalizeHook(plugin[hookName]);
-			if (meta.order === "pre" || meta.order === "post") {
-				return !OK_TO_COMPOSE;
-			}
-		}
-		return OK_TO_COMPOSE;
-	});
-	if (hasNotComposablePattern) {
-		return false;
-	}
-	return true;
-}
-function composeJsPlugins(plugins) {
-	const newPlugins = [];
-	const toBeComposed = [];
-	plugins.forEach((plugin) => {
-		if (isComposablePlugin(plugin)) {
-			toBeComposed.push(plugin);
-		} else {
-			if (toBeComposed.length > 0) {
-				if (toBeComposed.length > 1) {
-					newPlugins.push(createComposedPlugin(toBeComposed));
-				} else {
-					newPlugins.push(toBeComposed[0]);
-				}
-				toBeComposed.length = 0;
-			}
-			newPlugins.push(plugin);
-		}
-	});
-	if (toBeComposed.length > 0) {
-		if (toBeComposed.length > 1) {
-			newPlugins.push(createComposedPlugin(toBeComposed));
-		} else {
-			newPlugins.push(toBeComposed[0]);
-		}
-		toBeComposed.length = 0;
-	}
-	return newPlugins;
-}
-
-//#endregion
-//#region src/utils/normalize-input-options.ts
-async function normalizeInputOptions(config) {
-	const { input: input,...rest } = config;
-	let plugins = await normalizePluginOption(config.plugins);
-	if (rest.experimental?.enableComposingJsPlugins ?? false) {
-		plugins = composeJsPlugins(plugins);
-	}
-	const treeshake = normalizeTreeshakeOptions(config.treeshake);
-	const logLevel = config.logLevel || LOG_LEVEL_INFO;
-	const onLog = getLogger(getObjectPlugins(plugins), getOnLog(config, logLevel), logLevel);
-	return {
-		...rest,
-		input: input ? typeof input === "string" ? [input] : input : [],
-		plugins,
-		logLevel,
-		onLog,
-		treeshake
-	};
-}
-
-//#endregion
-//#region src/utils/normalize-output-options.ts
-function normalizeOutputOptions(opts) {
-	const { dir: dir, format: format, exports: exports, sourcemap: sourcemap, sourcemapIgnoreList: sourcemapIgnoreList, sourcemapPathTransform: sourcemapPathTransform, globals: globals, entryFileNames: entryFileNames, chunkFileNames: chunkFileNames, assetFileNames: assetFileNames, name: name, esModule: esModule, file: file } = opts;
-	return {
-		dir: dir,
-		file,
-		format: getFormat(format),
-		exports: exports ?? "auto",
-		sourcemap: sourcemap ?? false,
-		sourcemapIgnoreList: typeof sourcemapIgnoreList === "function" ? sourcemapIgnoreList : sourcemapIgnoreList === false ? () => false : (relativeSourcePath, _sourcemapPath) => relativeSourcePath.includes("node_modules"),
-		sourcemapPathTransform,
-		banner: getAddon(opts, "banner"),
-		footer: getAddon(opts, "footer"),
-		intro: getAddon(opts, "intro"),
-		outro: getAddon(opts, "outro"),
-		esModule: esModule ?? "if-default-prop",
-		globals: globals ?? {},
-		entryFileNames: entryFileNames ?? "[name].js",
-		chunkFileNames: chunkFileNames ?? "[name]-[hash].js",
-		assetFileNames: assetFileNames ?? "assets/[name]-[hash][extname]",
-		plugins: [],
-		minify: opts.minify,
-		extend: opts.extend,
-		name,
-		externalLiveBindings: opts.externalLiveBindings ?? true,
-		inlineDynamicImports: opts.inlineDynamicImports ?? false,
-		advancedChunks: opts.advancedChunks
-	};
-}
-function getFormat(format) {
-	switch (format) {
-		case undefined:
-		case "es":
-		case "esm":
-		case "module": {
-			return "es";
-		}
-		case "cjs":
-		case "commonjs": {
-			return "cjs";
-		}
-		case "iife": {
-			return "iife";
-		}
-		case "umd": {
-			return "umd";
-		}
-		default: unimplemented(`output.format: ${format}`);
-	}
-}
-const getAddon = (config, name) => {
-	return async (chunk) => {
-		const configAddon = config[name];
-		if (typeof configAddon === "function") {
-			return configAddon(chunk);
-		}
-		return configAddon || "";
-	};
-};
-
-//#endregion
-//#region src/options/bindingify-output-options.ts
-function bindingifyOutputOptions(outputOptions) {
-	const { dir: dir, format: format, exports: exports, sourcemap: sourcemap, sourcemapIgnoreList: sourcemapIgnoreList, sourcemapPathTransform: sourcemapPathTransform, name: name, entryFileNames: entryFileNames, chunkFileNames: chunkFileNames, assetFileNames: assetFileNames, banner: banner, footer: footer, intro: intro, outro: outro, esModule: esModule, globals: globals, file: file } = outputOptions;
-	return {
-		dir,
-		file: file == null ? undefined : file,
-		format: function() {
-			switch (format) {
-				case "es": return "es";
-				case "cjs": return "cjs";
-				case "iife": return "iife";
-				case "umd": return "umd";
-			}
-		}(),
-		exports,
-		sourcemap: bindingifySourcemap(sourcemap),
-		sourcemapIgnoreList,
-		sourcemapPathTransform,
-		banner,
-		footer,
-		intro,
-		outro,
-		extend: outputOptions.extend,
-		globals,
-		esModule: bindingifyEsModule(esModule),
-		name,
-		entryFileNames,
-		chunkFileNames,
-		assetFileNames,
-		plugins: [],
-		minify: outputOptions.minify,
-		externalLiveBindings: outputOptions.externalLiveBindings,
-		inlineDynamicImports: outputOptions.inlineDynamicImports,
-		advancedChunks: outputOptions.advancedChunks
-	};
-}
-function bindingifySourcemap(sourcemap) {
-	switch (sourcemap) {
-		case true: return "file";
-		case "inline": return "inline";
-		case false:
-		case undefined: return undefined;
-		case "hidden": return "hidden";
-		default: throw new Error(`unknown sourcemap: ${sourcemap}`);
-	}
-}
-function bindingifyEsModule(esModule) {
-	switch (esModule) {
-		case true:
-		case false:
-		case "if-default-prop": return esModule;
-		default: throw new Error(`unknown esModule: ${esModule}`);
-	}
-}
-
-//#endregion
-//#region src/utils/create-bundler.ts
-var import_binding$1 = __toESM(require_binding());
-async function createBundler(inputOptions, outputOptions) {
-	const pluginDriver = new PluginDriver();
-	inputOptions = await pluginDriver.callOptionsHook(inputOptions);
-	const normalizedInputOptions = await normalizeInputOptions(inputOptions);
-	const parallelPluginInitResult = await initializeParallelPlugins(normalizedInputOptions.plugins);
-	try {
-		outputOptions = pluginDriver.callOutputOptionsHook(normalizedInputOptions, outputOptions);
-		const normalizedOutputOptions = normalizeOutputOptions(outputOptions);
-		const bindingInputOptions = bindingifyInputOptions(normalizedInputOptions, normalizedOutputOptions);
-		return {
-			bundler: new import_binding$1.Bundler(bindingInputOptions, bindingifyOutputOptions(normalizedOutputOptions), parallelPluginInitResult?.registry),
-			stopWorkers: parallelPluginInitResult?.stopWorkers
-		};
-	} catch (e) {
-		await parallelPluginInitResult?.stopWorkers();
-		throw e;
-	}
-}
-
-//#endregion
-//#region src/rolldown-build.ts
-class RolldownBuild {
-	#inputOptions;
-	#bundler;
-	constructor(inputOptions) {
-		this.#inputOptions = inputOptions;
-	}
-	async #getBundlerWithStopWorker(outputOptions) {
-		if (this.#bundler) {
-			this.#bundler.stopWorkers?.();
-		}
-		return this.#bundler = await createBundler(this.#inputOptions, outputOptions);
-	}
-	async generate(outputOptions = {}) {
-		const { bundler: bundler } = await this.#getBundlerWithStopWorker(outputOptions);
-		const output = await bundler.generate();
-		return transformToRollupOutput(output);
-	}
-	async write(outputOptions = {}) {
-		const { bundler: bundler } = await this.#getBundlerWithStopWorker(outputOptions);
-		const output = await bundler.write();
-		return transformToRollupOutput(output);
-	}
-	async close() {
-		const { bundler: bundler, stopWorkers: stopWorkers } = await this.#getBundlerWithStopWorker({});
-		await stopWorkers?.();
-		await bundler.close();
-	}
-}
-
-//#endregion
-//#region src/watcher.ts
-var import_binding = __toESM(require_binding());
-class Watcher {
-	closed;
-	controller;
-	inner;
-	stopWorkers;
-	constructor(inner, stopWorkers) {
-		this.closed = false;
-		this.controller = new AbortController();
-		this.inner = inner;
-		this.stopWorkers = stopWorkers;
-	}
-	async close() {
-		this.closed = true;
-		await this.stopWorkers?.();
-		await this.inner.close();
-		this.controller.abort();
-	}
-	on(event, listener) {
-		switch (event) {
-			case "close":
-				this.inner.on(import_binding.BindingWatcherEvent.Close, async () => {
-					await listener();
-				});
-				break;
-			case "event":
-				this.inner.on(import_binding.BindingWatcherEvent.Event, async (data) => {
-					if (data.code === "BUNDLE_END") {
-						await listener({
-							code: "BUNDLE_END",
-							duration: Number(data.duration),
-							output: [data.output]
-						});
-					} else {
-						await listener(data);
-					}
-				});
-				break;
-			case "restart":
-				this.inner.on(import_binding.BindingWatcherEvent.ReStart, async () => {
-					await listener();
-				});
-				break;
-			case "change":
-				this.inner.on(import_binding.BindingWatcherEvent.Change, async (data) => {
-					await listener(data.id, {event: data.kind});
-				});
-				break;
-			default: throw new Error(`Unknown event: ${event}`);
-		}
-		return this;
-	}
-	watch() {
-		const watcherWorkerPath = require.resolve("rolldown/watcher-worker");
-		const child = spawn(process.argv[0], [watcherWorkerPath], {signal: this.controller.signal});
-		child.on("error", () => {});
-	}
-}
-
-//#endregion
-//#region src/rolldown.ts
-const rolldown = async (input) => {
-	return new RolldownBuild(input);
-};
-const watch = async (input) => {
-	const { bundler: bundler, stopWorkers: stopWorkers } = await createBundler(input, input.output || {});
-	const bindingWatcher = await bundler.watch();
-	const watcher = new Watcher(bindingWatcher, stopWorkers);
-	watcher.watch();
-	return watcher;
-};
-const experimental_scan = async (input) => {
-	const { bundler: bundler, stopWorkers: stopWorkers } = await createBundler(input, {});
-	await bundler.scan();
-	await stopWorkers?.();
-};
-
-//#endregion
-//#region package.json
-const version = "0.14.0";
-const description = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
-
-//#endregion
-//#region src/index.ts
-const VERSION = version;
-
-//#endregion
-exports.LogLevelOptionSchema = LogLevelOptionSchema;
-exports.LogLevelSchema = LogLevelSchema;
-exports.LogLevelWithErrorSchema = LogLevelWithErrorSchema;
-exports.PluginContextData = PluginContextData;
-exports.RollupLogSchema = RollupLogSchema;
-exports.RollupLogWithStringSchema = RollupLogWithStringSchema;
-exports.VERSION = VERSION;
-exports.aliasPlugin = aliasPlugin;
-exports.arraify = arraify;
-exports.bindingifyPlugin = bindingifyPlugin;
-exports.buildImportAnalysisPlugin = buildImportAnalysisPlugin;
-exports.composeJsPlugins = composeJsPlugins;
-exports.defineConfig = defineConfig;
-exports.description = description;
-exports.dynamicImportVarsPlugin = dynamicImportVarsPlugin;
-exports.experimental_scan = experimental_scan;
-exports.importGlobPlugin = importGlobPlugin;
-exports.jsonPlugin = jsonPlugin;
-exports.loadFallbackPlugin = loadFallbackPlugin;
-exports.manifestPlugin = manifestPlugin;
-exports.modulePreloadPolyfillPlugin = modulePreloadPolyfillPlugin;
-exports.replacePlugin = replacePlugin;
-exports.require_binding = require_binding;
-exports.rolldown = rolldown;
-exports.transformPlugin = transformPlugin;
-exports.version = version;
-exports.wasmFallbackPlugin = wasmFallbackPlugin;
-exports.wasmHelperPlugin = wasmHelperPlugin;
-exports.watch = watch;
-