rolldown 0.13.2 → 0.14.0

package/dist/shared/plugin-context-data-F1I9ytXp.cjs

@@ -1,1435 +0,0 @@
-const { __commonJSMin, __toESM } = require("./chunk-gQ4GMlVi.cjs");
-const { default: path } = __toESM(require("node:path"));
-const { z } = __toESM(require("zod"));
-const { isRegExp } = __toESM(require("node:util/types"));
-
-//#region src/utils/asset-source.ts
-function transformAssetSource(bindingAssetSource$1) {
-	return bindingAssetSource$1.inner;
-}
-function bindingAssetSource(source) {
-	return {inner: source};
-}
-
-//#endregion
-//#region src/utils/transform-to-rollup-output.ts
-function transformToRollupOutputChunk(chunk) {
-	return {
-		type: "chunk",
-		get code() {
-			return chunk.code;
-		},
-		set code(code) {
-			chunk.code = code;
-		},
-		fileName: chunk.fileName,
-		name: chunk.name,
-		get modules() {
-			return Object.fromEntries((Object.entries(chunk.modules)).map(([key, _]) => [key, {}]));
-		},
-		get imports() {
-			return chunk.imports;
-		},
-		set imports(imports) {
-			chunk.imports = imports;
-		},
-		get dynamicImports() {
-			return chunk.dynamicImports;
-		},
-		exports: chunk.exports,
-		isEntry: chunk.isEntry,
-		facadeModuleId: chunk.facadeModuleId || null,
-		isDynamicEntry: chunk.isDynamicEntry,
-		get moduleIds() {
-			return chunk.moduleIds;
-		},
-		get map() {
-			return chunk.map ? JSON.parse(chunk.map) : null;
-		},
-		set map(map) {
-			chunk.map = JSON.stringify(map);
-		},
-		sourcemapFileName: chunk.sourcemapFileName || null,
-		preliminaryFileName: chunk.preliminaryFileName
-	};
-}
-function transformToRollupOutputAsset(asset) {
-	return {
-		type: "asset",
-		fileName: asset.fileName,
-		originalFileName: asset.originalFileName || null,
-		get source() {
-			return transformAssetSource(asset.source);
-		},
-		set source(source) {
-			asset.source = bindingAssetSource(source);
-		},
-		name: asset.name ?? undefined
-	};
-}
-function transformToRollupOutput(output) {
-	const { chunks: chunks, assets: assets } = output;
-	return {output: [...chunks.map(transformToRollupOutputChunk), ...assets.map(transformToRollupOutputAsset),]};
-}
-function transformToOutputBundle(output) {
-	const bundle = Object.fromEntries((transformToRollupOutput(output)).output.map((item) => [item.fileName, item]));
-	return new Proxy(bundle, {deleteProperty(target, property) {
-		if (typeof property === "string") {
-			output.delete(property);
-		}
-		return true;
-	}});
-}
-
-//#endregion
-//#region src/binding.js
-var require_binding = __commonJSMin((exports, module) => {
-	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.Bundler = nativeBinding.Bundler;
-	module.exports.FinalBindingOutputs = nativeBinding.FinalBindingOutputs;
-	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.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/types/sourcemap.ts
-function bindingifySourcemap(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/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/plugin/plugin-context.ts
-class PluginContext {
-	debug;
-	info;
-	warn;
-	error;
-	resolve;
-	emitFile;
-	getFileName;
-	getModuleInfo;
-	getModuleIds;
-	addWatchFile;
-	parse;
-	constructor(options, context, plugin, data) {
-		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.warn = getLogHandler(LOG_LEVEL_WARN, "PLUGIN_WARNING", onLog, pluginName, logLevel);
-		this.info = getLogHandler(LOG_LEVEL_INFO, "PLUGIN_LOG", onLog, pluginName, logLevel);
-		this.error = (e) => {
-			return error(logPluginError(normalizeLog(e), pluginName));
-		};
-		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 = () => {};
-	}
-}
-
-//#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 = (error$1, pos) => {
-			if (typeof error$1 === "string") error$1 = {message: error$1};
-			if (pos) augmentCodeLocation(error$1, pos, moduleSource, moduleId);
-			error$1.id = moduleId;
-			error$1.hook = "transform";
-			return this.error(error$1);
-		};
-	}
-}
-
-//#endregion
-//#region src/utils/transform-side-effects.ts
-var import_binding$1 = __toESM(require_binding());
-function bindingifySideEffects(sideEffects) {
-	switch (sideEffects) {
-		case true: return import_binding$1.BindingHookSideEffects.True;
-		case false: return import_binding$1.BindingHookSideEffects.False;
-		case "no-treeshake": return import_binding$1.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 = __toESM(require_binding());
-function bindingifyPluginHookMeta(options) {
-	return {order: bindingPluginOrder(options.order)};
-}
-function bindingPluginOrder(order) {
-	switch (order) {
-		case "post": return import_binding.BindingPluginOrder.Post;
-		case "pre": return import_binding.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/options/utils.ts
-function normalizedStringOrRegex(pattern) {
-	if (!pattern) {
-		return undefined;
-	}
-	if (isRegExp(pattern) || typeof pattern === "string") {
-		pattern = [pattern];
-	}
-	let ret = [];
-	for (let p of pattern) {
-		if (isRegExp(p)) {
-			ret.push({
-				value: p.source,
-				flag: p.flags
-			});
-		} else {
-			ret.push({value: p});
-		}
-	}
-	return ret;
-}
-
-//#endregion
-//#region src/plugin/bindingify-hook-filter.ts
-function bindingifyResolveIdFilter(filterOption) {
-	if (!filterOption) {
-		return undefined;
-	}
-	const { id: id } = filterOption;
-	if (!id) {
-		return undefined;
-	}
-	let include;
-	let exclude;
-	if (id.include) {
-		include = normalizedStringOrRegex(id.include);
-	}
-	if (id.exclude) {
-		exclude = normalizedStringOrRegex(id.exclude);
-	}
-	return {
-		include,
-		exclude
-	};
-}
-function bindingifyLoadFilter(filterOption) {
-	if (!filterOption) {
-		return undefined;
-	}
-	const { id: id } = filterOption;
-	if (!id) {
-		return undefined;
-	}
-	let include;
-	let exclude;
-	if (id.include) {
-		include = normalizedStringOrRegex(id.include);
-	}
-	if (id.exclude) {
-		exclude = normalizedStringOrRegex(id.exclude);
-	}
-	let ret = {
-		include,
-		exclude
-	};
-	return ret;
-}
-function bindingifyTransformFilter(filterOption) {
-	if (!filterOption) {
-		return undefined;
-	}
-	const { id: id, moduleType: moduleType, code: code } = filterOption;
-	let idRet;
-	let moduleTypeRet;
-	let codeRet;
-	if (id) {
-		let include;
-		let exclude;
-		if (id.include) {
-			include = normalizedStringOrRegex(id.include);
-		}
-		if (id.exclude) {
-			exclude = normalizedStringOrRegex(id.exclude);
-		}
-		idRet = {
-			include,
-			exclude
-		};
-	}
-	if (code) {
-		let include;
-		let exclude;
-		if (code.include) {
-			include = normalizedStringOrRegex(code.include);
-		}
-		if (code.exclude) {
-			exclude = normalizedStringOrRegex(code.exclude);
-		}
-		codeRet = {
-			include,
-			exclude
-		};
-	}
-	if (moduleType) {
-		if (Array.isArray(moduleType)) {
-			moduleTypeRet = moduleType;
-		} else {
-			moduleTypeRet = moduleType.include;
-		}
-	}
-	return {
-		id: idRet,
-		moduleType: moduleTypeRet,
-		code: codeRet
-	};
-}
-
-//#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 == false || ret == null) {
-				return;
-			}
-			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 == false || ret == null) {
-				return;
-			}
-			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(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(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(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) => {
-			await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), outputOptions, transformToOutputBundle(bundle), isWrite);
-		},
-		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) => {
-			await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), outputOptions, transformToOutputBundle(bundle));
-		},
-		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-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: 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);
-	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,
-		banner,
-		bannerMeta,
-		footer,
-		footerMeta,
-		intro,
-		introMeta,
-		outro,
-		outroMeta
-	};
-}
-
-//#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
-exports.LOG_LEVEL_DEBUG = LOG_LEVEL_DEBUG;
-exports.LOG_LEVEL_ERROR = LOG_LEVEL_ERROR;
-exports.LOG_LEVEL_INFO = LOG_LEVEL_INFO;
-exports.LOG_LEVEL_WARN = LOG_LEVEL_WARN;
-exports.LogLevelOptionSchema = LogLevelOptionSchema;
-exports.LogLevelSchema = LogLevelSchema;
-exports.LogLevelWithErrorSchema = LogLevelWithErrorSchema;
-exports.PluginContextData = PluginContextData;
-exports.RollupLogSchema = RollupLogSchema;
-exports.RollupLogWithStringSchema = RollupLogWithStringSchema;
-exports.SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF = SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF;
-exports.arraify = arraify;
-exports.bindingifyPlugin = bindingifyPlugin;
-exports.error = error;
-exports.getLogHandler = getLogHandler;
-exports.isNullish = isNullish;
-exports.logLevelPriority = logLevelPriority;
-exports.logPluginError = logPluginError;
-exports.normalizeHook = normalizeHook;
-exports.normalizeLog = normalizeLog;
-exports.normalizedStringOrRegex = normalizedStringOrRegex;
-exports.require_binding = require_binding;
-exports.transformToRollupOutput = transformToRollupOutput;
-exports.unimplemented = unimplemented;
-