rolldown 0.10.5 → 0.11.0

package/dist/shared/utils_index-PYoHCZRc.cjs

@@ -0,0 +1,1507 @@
+const { __commonJSMin, __toESM } = require("./chunk-IY9XHjk1.cjs");
+const { default: nodePath, 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/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/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,
+		get source() {
+			return transformAssetSource(asset.source);
+		},
+		set source(source) {
+			asset.source = bindingAssetSource(source);
+		}
+	};
+}
+function transformToRollupOutput(output) {
+	const { chunks, assets } = output;
+	const [firstChunk, ...restChunks] = chunks;
+	return {output: [transformToRollupOutputChunk(firstChunk), ...restChunks.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/utils/normalize-plugin-option.ts
+const normalizePluginOption = async (plugins) => (await asyncFlatten([plugins])).filter(Boolean);
+
+//#endregion
+//#region src/binding.js
+var require_binding = __commonJSMin((exports, module) => {
+	const { 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) {
+				console.error(err);
+			}
+		}
+		if (!nativeBinding) {
+			try {
+				nativeBinding = require('@rolldown/binding-wasm32-wasi');
+			} catch (err) {
+				if (process.env.NAPI_RS_FORCE_WASI) {
+					console.error(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.isolatedDeclaration = nativeBinding.isolatedDeclaration;
+	module.exports.registerPlugins = nativeBinding.registerPlugins;
+	module.exports.transform = nativeBinding.transform;
+});
+
+//#endregion
+//#region src/utils/normalize-hook.ts
+function normalizeHook(hook) {
+	if (typeof hook === 'function') {
+		return [hook, {}];
+	}
+	const { handler,...options } = hook;
+	return [handler, options];
+}
+
+//#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/misc.ts
+function arraify(value) {
+	return Array.isArray(value) ? value : [value];
+}
+function unimplemented(info) {
+	if (info) {
+		throw new Error(`unimplemented: ${info}`);
+	}
+	throw new Error('unimplemented');
+}
+function unsupported(info) {
+	return () => {
+		throw new Error(`UNSUPPORTED: ${info}`);
+	};
+}
+function noop(..._args) {}
+
+//#endregion
+//#region src/utils/transform-module-info.ts
+function transformModuleInfo(info) {
+	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
+	};
+}
+
+//#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/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 = 0, 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, 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, column } = pos;
+		properties.loc = {
+			column,
+			file: id,
+			line
+		};
+	} else {
+		properties.pos = pos;
+		const location = locate(source, pos, {offsetLine: 1});
+		if (!location) {
+			return;
+		}
+		const { line, column } = location;
+		properties.loc = {
+			column,
+			file: id,
+			line
+		};
+	}
+	if (properties.frame === undefined) {
+		const { line, 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;
+	parse;
+	modules = new Map();
+	moduleIds = null;
+	constructor(options, context, 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.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 = context.resolve.bind(context);
+		this.emitFile = (file) => {
+			if (file.type !== 'asset') {
+				return unimplemented('PluginContext.emitFile: only asset type is supported');
+			}
+			return context.emitFile({
+				...file,
+				source: bindingAssetSource(file.source)
+			});
+		};
+		this.getFileName = context.getFileName.bind(context);
+		this.getModuleInfo = (id) => {
+			if (this.modules.has(id)) {
+				return this.modules.get(id) ?? null;
+			}
+			const bindingInfo = context.getModuleInfo(id);
+			if (bindingInfo) {
+				const info = transformModuleInfo(bindingInfo);
+				this.modules.set(id, info);
+				return info;
+			}
+			return null;
+		};
+		this.getModuleIds = () => {
+			if (this.moduleIds) {
+				return this.moduleIds.values();
+			}
+			const moduleIds = context.getModuleIds();
+			if (moduleIds) {
+				this.moduleIds = moduleIds;
+				return moduleIds.values();
+			}
+			return [].values();
+		};
+		this.parse = unsupported('`PluginContext#parse` is not supported by rolldown.');
+	}
+}
+
+//#endregion
+//#region src/plugin/transfrom-plugin-context.ts
+class TransformPluginContext {
+	debug;
+	info;
+	warn;
+	error;
+	resolve;
+	emitFile;
+	getFileName;
+	parse;
+	constructor(inner, context, moduleId, moduleSource) {
+		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(context.debug);
+		this.warn = getLogHandler$1(context.warn);
+		this.info = getLogHandler$1(context.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 context.error(error$1);
+		};
+		this.resolve = context.resolve;
+		this.parse = context.parse;
+		this.emitFile = context.emitFile;
+		this.getFileName = context.getFileName;
+	}
+}
+
+//#endregion
+//#region src/utils/transform-side-effects.ts
+var import_binding$4 = __toESM(require_binding());
+function bindingifySideEffects(sideEffects) {
+	switch (sideEffects) {
+		case true: return import_binding$4.BindingHookSideEffects.True;
+		case false: return import_binding$4.BindingHookSideEffects.False;
+		case 'no-treeshake': return import_binding$4.BindingHookSideEffects.NoTreeshake;
+		case null:
+		case undefined: return undefined;
+		default: throw new Error(`Unexpected side effects: ${sideEffects}`);
+	}
+}
+
+//#endregion
+//#region src/plugin/bindingify-build-hooks.ts
+function bindingifyBuildStart(plugin, options) {
+	const hook = plugin.buildStart;
+	if (!hook) {
+		return undefined;
+	}
+	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
+	return async (ctx) => {
+		await handler.call(new PluginContext(options, ctx, plugin), options);
+	};
+}
+function bindingifyBuildEnd(plugin, options) {
+	const hook = plugin.buildEnd;
+	if (!hook) {
+		return undefined;
+	}
+	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
+	return async (ctx, err) => {
+		await handler.call(new PluginContext(options, ctx, plugin), err ? new Error(err) : undefined);
+	};
+}
+function bindingifyResolveId(plugin, options) {
+	const hook = plugin.resolveId;
+	if (!hook) {
+		return undefined;
+	}
+	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
+	return async (ctx, specifier, importer, extraOptions) => {
+		const ret = await handler.call(new PluginContext(options, ctx, plugin), specifier, importer ?? undefined, extraOptions);
+		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);
+		}
+		return result;
+	};
+}
+function bindingifyResolveDynamicImport(plugin, options) {
+	const hook = plugin.resolveDynamicImport;
+	if (!hook) {
+		return undefined;
+	}
+	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
+	return async (ctx, specifier, importer) => {
+		const ret = await handler.call(new PluginContext(options, ctx, plugin), 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);
+		}
+		return result;
+	};
+}
+function bindingifyTransform(plugin, options) {
+	const hook = plugin.transform;
+	if (!hook) {
+		return undefined;
+	}
+	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
+	return async (ctx, code, id) => {
+		const ret = await handler.call(new TransformPluginContext(ctx, new PluginContext(options, ctx.inner(), plugin), id, code), code, id);
+		if (ret == null) {
+			return undefined;
+		}
+		if (typeof ret === 'string') {
+			return {code: ret};
+		}
+		return {
+			code: ret.code,
+			map: bindingifySourcemap$1(ret.map),
+			sideEffects: bindingifySideEffects(ret.moduleSideEffects)
+		};
+	};
+}
+function bindingifyLoad(plugin, options) {
+	const hook = plugin.load;
+	if (!hook) {
+		return undefined;
+	}
+	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
+	return async (ctx, id) => {
+		const ret = await handler.call(new PluginContext(options, ctx, plugin), id);
+		if (ret == null) {
+			return;
+		}
+		if (typeof ret === 'string') {
+			return {code: ret};
+		}
+		if (!ret.map) {
+			return {code: ret.code};
+		}
+		let map = typeof ret.map === 'object' ? ret.map : JSON.parse(ret.map);
+		if (!isEmptySourcemapFiled(map.sources)) {
+			const directory = path$1.dirname(id) || '.';
+			const sourceRoot = map.sourceRoot || '.';
+			map.sources = map.sources.map((source) => path$1.resolve(directory, sourceRoot, source));
+		}
+		const result = {
+			code: ret.code,
+			map: bindingifySourcemap$1(map)
+		};
+		if (ret.moduleSideEffects !== null) {
+			result.sideEffects = bindingifySideEffects(ret.moduleSideEffects);
+		}
+		return result;
+	};
+}
+function bindingifyModuleParsed(plugin, options) {
+	const hook = plugin.moduleParsed;
+	if (!hook) {
+		return undefined;
+	}
+	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
+	return async (ctx, moduleInfo) => {
+		await handler.call(new PluginContext(options, ctx, plugin), transformModuleInfo(moduleInfo));
+	};
+}
+
+//#endregion
+//#region src/plugin/bindingify-output-hooks.ts
+function bindingifyRenderStart(plugin, options, outputOptions) {
+	const hook = plugin.renderStart;
+	if (!hook) {
+		return undefined;
+	}
+	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
+	return async (ctx) => {
+		handler.call(new PluginContext(options, ctx, plugin), outputOptions, options);
+	};
+}
+function bindingifyRenderChunk(plugin, options, outputOptions) {
+	const hook = plugin.renderChunk;
+	if (!hook) {
+		return undefined;
+	}
+	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
+	return async (ctx, code, chunk) => {
+		const ret = await handler.call(new PluginContext(options, ctx, plugin), 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)
+		};
+	};
+}
+function bindingifyAugmentChunkHash(plugin, options) {
+	const hook = plugin.augmentChunkHash;
+	if (!hook) {
+		return undefined;
+	}
+	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
+	return async (ctx, chunk) => {
+		return await handler.call(new PluginContext(options, ctx, plugin), chunk);
+	};
+}
+function bindingifyRenderError(plugin, options) {
+	const hook = plugin.renderError;
+	if (!hook) {
+		return undefined;
+	}
+	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
+	return async (ctx, err) => {
+		handler.call(new PluginContext(options, ctx, plugin), new Error(err));
+	};
+}
+function bindingifyGenerateBundle(plugin, options, outputOptions) {
+	const hook = plugin.generateBundle;
+	if (!hook) {
+		return undefined;
+	}
+	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
+	return async (ctx, bundle, isWrite) => {
+		handler.call(new PluginContext(options, ctx, plugin), outputOptions, transformToOutputBundle(bundle), isWrite);
+	};
+}
+function bindingifyWriteBundle(plugin, options, outputOptions) {
+	const hook = plugin.writeBundle;
+	if (!hook) {
+		return undefined;
+	}
+	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
+	return async (ctx, bundle) => {
+		handler.call(new PluginContext(options, ctx, plugin), outputOptions, transformToOutputBundle(bundle));
+	};
+}
+
+//#endregion
+//#region src/plugin/bindingify-plugin.ts
+function bindingifyPlugin(plugin, options, outputOptions) {
+	return {
+		name: plugin.name ?? 'unknown',
+		buildStart: bindingifyBuildStart(plugin, options),
+		resolveId: bindingifyResolveId(plugin, options),
+		resolveDynamicImport: bindingifyResolveDynamicImport(plugin, options),
+		buildEnd: bindingifyBuildEnd(plugin, options),
+		transform: bindingifyTransform(plugin, options),
+		moduleParsed: bindingifyModuleParsed(plugin, options),
+		load: bindingifyLoad(plugin, options),
+		renderChunk: bindingifyRenderChunk(plugin, options, outputOptions),
+		augmentChunkHash: bindingifyAugmentChunkHash(plugin, options),
+		renderStart: bindingifyRenderStart(plugin, options, outputOptions),
+		renderError: bindingifyRenderError(plugin, options),
+		generateBundle: bindingifyGenerateBundle(plugin, options, outputOptions),
+		writeBundle: bindingifyWriteBundle(plugin, options, outputOptions)
+	};
+}
+
+//#endregion
+//#region src/plugin/bindingify-builtin-plugin.ts
+var import_binding$3 = __toESM(require_binding());
+class BuiltinPlugin {
+	constructor(name, options) {
+		this.name = name;
+		this.options = options;
+		this.name = name;
+		this.options = options;
+	}
+}
+class BuiltinWasmPlugin extends BuiltinPlugin {
+	constructor(options) {
+		super(import_binding$3.BindingBuiltinPluginName.WasmPlugin, options);
+	}
+}
+class BuiltinGlobImportPlugin extends BuiltinPlugin {
+	constructor(options) {
+		super(import_binding$3.BindingBuiltinPluginName.GlobImportPlugin, options);
+	}
+}
+function bindingifyBuiltInPlugin(plugin) {
+	return {
+		name: plugin.name,
+		options: plugin.options
+	};
+}
+
+//#endregion
+//#region src/options/bindingify-input-options.ts
+var import_binding$2 = __toESM(require_binding());
+function bindingifyInputOptions(options, outputOptions) {
+	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);
+		}),
+		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,...rest } = options.resolve;
+			return {
+				alias: alias ? Object.entries(alias).map(([name, replacement]) => ({
+					find: name,
+					replacements: [replacement]
+				})) : 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
+	};
+}
+function bindingifyLogLevel(logLevel) {
+	switch (logLevel) {
+		case 'silent': return import_binding$2.BindingLogLevel.Silent;
+		case 'warn': return import_binding$2.BindingLogLevel.Warn;
+		case 'info': return import_binding$2.BindingLogLevel.Info;
+		case 'debug': return import_binding$2.BindingLogLevel.Debug;
+		default: throw new Error(`Unexpected log level: ${logLevel}`);
+	}
+}
+function bindingifyInput(input) {
+	if (Array.isArray(input)) {
+		return input.map((src) => {
+			const name = nodePath.parse(src).name;
+			return {
+				name,
+				import: src
+			};
+		});
+	} else {
+		return Object.entries(input).map((value) => {
+			return {
+				name: value[0],
+				import: value[1]
+			};
+		});
+	}
+}
+
+//#endregion
+//#region src/utils/initialize-parallel-plugins.ts
+var import_binding$1 = __toESM(require_binding());
+async function initializeParallelPlugins(plugins) {
+	const pluginInfos = [];
+	for (const [index, plugin] of plugins.entries()) {
+		if ('_parallel'in plugin) {
+			const { fileUrl, 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$1.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/log/logger.ts
+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 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),
+					warn: getLogHandler$1(LOG_LEVEL_WARN)
+				}, level, log) === false) {
+					return;
+				}
+			}
+		}
+		onLog(level, log);
+	};
+	return logger;
+}
+const getOnLog = (config, logLevel, printLog = defaultPrintLog) => {
+	const { onwarn, 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.isAbsolute(id)) return id;
+	return path.relative(path.resolve(), id);
+}
+
+//#endregion
+//#region src/plugin/plugin-driver.ts
+class PluginDriver {
+	async callOptionsHook(inputOptions) {
+		const logLevel = inputOptions.logLevel || LOG_LEVEL_INFO;
+		const plugins = 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, _optionsIgnoredSofar] = 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),
+					warn: getLogHandler(LOG_LEVEL_WARN, 'PLUGIN_WARNING', logger, name, logLevel)
+				}, inputOptions);
+				if (result) {
+					inputOptions = result;
+				}
+			}
+		}
+		return inputOptions;
+	}
+	async callOutputOptionsHook(inputOptions, outputOptions) {
+		const plugins = getObjectPlugins(inputOptions.plugins);
+		for (const plugin of plugins) {
+			const options = plugin.outputOptions;
+			if (options) {
+				const [handler, _optionsIgnoredSofar] = normalizeHook(options);
+				const result = await 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;
+	});
+}
+
+//#endregion
+//#region src/utils/normalize-tree-shake.ts
+function normalizeTreeshakeOptions(config) {
+	if (config === false) {
+		return undefined;
+	}
+	if (config === true || config === undefined) {
+		return {moduleSideEffects: 'true'};
+	}
+	if (config.moduleSideEffects === undefined) {
+		config.moduleSideEffects = 'true';
+	} else if (isRegExp(config.moduleSideEffects)) {
+		config.moduleSideEffects = config.moduleSideEffects.source;
+	} else {
+		config.moduleSideEffects = config.moduleSideEffects.toString();
+	}
+	return config;
+}
+
+//#endregion
+//#region src/utils/normalize-input-options.ts
+async function normalizeInputOptions(config) {
+	const { input,...rest } = config;
+	const plugins = await normalizePluginOption(config.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, format, exports, sourcemap, sourcemapIgnoreList, sourcemapPathTransform, entryFileNames, chunkFileNames, assetFileNames } = opts;
+	return {
+		dir: dir,
+		format: getFormat(format),
+		exports: exports ?? 'named',
+		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'),
+		entryFileNames: entryFileNames ?? '[name].js',
+		chunkFileNames: chunkFileNames ?? '[name]-[hash].js',
+		assetFileNames: assetFileNames ?? 'assets/[name]-[hash][extname]',
+		plugins: []
+	};
+}
+function getFormat(format) {
+	switch (format) {
+		case undefined:
+		case 'es':
+		case 'esm':
+		case 'module': {
+			return 'es';
+		}
+		case 'cjs':
+		case 'commonjs': {
+			return 'cjs';
+		}
+		default: unimplemented(`output.format: ${format}`);
+	}
+}
+const getAddon = (config, name) => {
+	const configAddon = config[name];
+	if (typeof configAddon === 'function') {
+		return configAddon;
+	}
+	return async () => configAddon || '';
+};
+
+//#endregion
+//#region src/options/bindingify-output-options.ts
+function bindingifyOutputOptions(outputOptions) {
+	const { dir, format, exports, sourcemap, sourcemapIgnoreList, sourcemapPathTransform, entryFileNames, chunkFileNames, assetFileNames, banner, footer } = outputOptions;
+	return {
+		dir,
+		format: function() {
+			switch (format) {
+				case 'es': return 'es';
+				case 'cjs': return 'cjs';
+			}
+		}(),
+		exports,
+		sourcemap: bindingifySourcemap(sourcemap),
+		sourcemapIgnoreList,
+		sourcemapPathTransform,
+		banner,
+		footer,
+		entryFileNames,
+		chunkFileNames,
+		assetFileNames,
+		plugins: []
+	};
+}
+function bindingifySourcemap(sourcemap) {
+	switch (sourcemap) {
+		case true: return 'file';
+		case 'inline': return 'inline';
+		case false:
+		case undefined:
+		case 'hidden': return 'hidden';
+		default: throw new Error(`unknown sourcemap: ${sourcemap}`);
+	}
+}
+
+//#endregion
+//#region src/utils/create-bundler.ts
+var import_binding = __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 = await pluginDriver.callOutputOptionsHook(normalizedInputOptions, outputOptions);
+		const normalizedOutputOptions = normalizeOutputOptions(outputOptions);
+		const bindingInputOptions = bindingifyInputOptions(normalizedInputOptions, normalizedOutputOptions);
+		return {
+			bundler: new import_binding.Bundler(bindingInputOptions, bindingifyOutputOptions(normalizedOutputOptions), parallelPluginInitResult?.registry),
+			stopWorkers: parallelPluginInitResult?.stopWorkers
+		};
+	} catch (e) {
+		await parallelPluginInitResult?.stopWorkers();
+		throw e;
+	}
+}
+
+//#endregion
+exports.BuiltinGlobImportPlugin = BuiltinGlobImportPlugin;
+exports.BuiltinWasmPlugin = BuiltinWasmPlugin;
+exports.arraify = arraify;
+exports.bindingifyPlugin = bindingifyPlugin;
+exports.createBundler = createBundler;
+exports.require_binding = require_binding;
+exports.transformToRollupOutput = transformToRollupOutput;