rolldown 1.0.0-beta.36 → 1.0.0-beta.38

package/dist/shared/{src-WjgJWoNk.mjs → src-CWMXqoXE.mjs}

@@ -1,33 +1,234 @@
-import { BindingAttachDebugInfo, BindingBundler, BindingCallableBuiltinPlugin, BindingChunkModuleOrderBy, BindingJsx, BindingLogLevel, BindingPluginOrder, BindingPropertyReadSideEffects, BindingPropertyWriteSideEffects, BindingWatcher, ParallelJsPluginRegistry, augmentCodeLocation, error, logCycleLoading, logDuplicateJsxConfig, logInputHookInOutputPlugin, logInvalidLogPosition, logMultiplyNotifyOption, logPluginError, parseAst, shutdownAsyncRuntime, startAsyncRuntime } from "./parse-ast-index-CkDFQ-07.mjs";
+import { BindingAttachDebugInfo, BindingBundler, BindingCallableBuiltinPlugin, BindingChunkModuleOrderBy, BindingJsx, BindingLogLevel, BindingPluginOrder, BindingPropertyReadSideEffects, BindingPropertyWriteSideEffects, BindingWatcher, ParallelJsPluginRegistry, augmentCodeLocation, error, initTraceSubscriber, logCycleLoading, logDuplicateJsxConfig, logInputHookInOutputPlugin, logInvalidLogPosition, logMultiplyNotifyOption, logPluginError, parseAst, shutdownAsyncRuntime, startAsyncRuntime } from "./parse-ast-index-BL17IImH.mjs";
 import { arraify, noop, unimplemented, unreachable, unsupported } from "./misc-CQeo-AFx.mjs";
-import { Worker } from "node:worker_threads";
+import { Worker, isMainThread } from "node:worker_threads";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import colors from "ansis";
 import * as filter from "@rolldown/pluginutils";
 import fsp from "node:fs/promises";
 import os from "node:os";
 
+//#region ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
+/**
+* This is not the set of all possible signals.
+*
+* It IS, however, the set of all signals that trigger
+* an exit on either Linux or BSD systems.  Linux is a
+* superset of the signal names supported on BSD, and
+* the unknown signals just fail to register, so we can
+* catch that easily enough.
+*
+* Windows signals are a different set, since there are
+* signals that terminate Windows processes, but don't
+* terminate (or don't even exist) on Posix systems.
+*
+* Don't bother with SIGKILL.  It's uncatchable, which
+* means that we can't fire any callbacks anyway.
+*
+* If a user does happen to register a handler on a non-
+* fatal signal like SIGWINCH or something, and then
+* exit, it'll end up firing `process.emit('exit')`, so
+* the handler will be fired anyway.
+*
+* SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+* artificially, inherently leave the process in a
+* state from which it is not safe to try and enter JS
+* listeners.
+*/
+const signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+if (process.platform === "linux") signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+
+//#endregion
+//#region ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
+const processOk = (process$2) => !!process$2 && typeof process$2 === "object" && typeof process$2.removeListener === "function" && typeof process$2.emit === "function" && typeof process$2.reallyExit === "function" && typeof process$2.listeners === "function" && typeof process$2.kill === "function" && typeof process$2.pid === "number" && typeof process$2.on === "function";
+const kExitEmitter = Symbol.for("signal-exit emitter");
+const global = globalThis;
+const ObjectDefineProperty = Object.defineProperty.bind(Object);
+var Emitter = class {
+	emitted = {
+		afterExit: false,
+		exit: false
+	};
+	listeners = {
+		afterExit: [],
+		exit: []
+	};
+	count = 0;
+	id = Math.random();
+	constructor() {
+		if (global[kExitEmitter]) return global[kExitEmitter];
+		ObjectDefineProperty(global, kExitEmitter, {
+			value: this,
+			writable: false,
+			enumerable: false,
+			configurable: false
+		});
+	}
+	on(ev, fn) {
+		this.listeners[ev].push(fn);
+	}
+	removeListener(ev, fn) {
+		const list = this.listeners[ev];
+		const i = list.indexOf(fn);
+		/* c8 ignore start */
+		if (i === -1) return;
+		/* c8 ignore stop */
+		if (i === 0 && list.length === 1) list.length = 0;
+		else list.splice(i, 1);
+	}
+	emit(ev, code, signal) {
+		if (this.emitted[ev]) return false;
+		this.emitted[ev] = true;
+		let ret = false;
+		for (const fn of this.listeners[ev]) ret = fn(code, signal) === true || ret;
+		if (ev === "exit") ret = this.emit("afterExit", code, signal) || ret;
+		return ret;
+	}
+};
+var SignalExitBase = class {};
+const signalExitWrap = (handler) => {
+	return {
+		onExit(cb, opts) {
+			return handler.onExit(cb, opts);
+		},
+		load() {
+			return handler.load();
+		},
+		unload() {
+			return handler.unload();
+		}
+	};
+};
+var SignalExitFallback = class extends SignalExitBase {
+	onExit() {
+		return () => {};
+	}
+	load() {}
+	unload() {}
+};
+var SignalExit = class extends SignalExitBase {
+	/* c8 ignore start */
+	#hupSig = process$1.platform === "win32" ? "SIGINT" : "SIGHUP";
+	/* c8 ignore stop */
+	#emitter = new Emitter();
+	#process;
+	#originalProcessEmit;
+	#originalProcessReallyExit;
+	#sigListeners = {};
+	#loaded = false;
+	constructor(process$2) {
+		super();
+		this.#process = process$2;
+		this.#sigListeners = {};
+		for (const sig of signals) this.#sigListeners[sig] = () => {
+			const listeners = this.#process.listeners(sig);
+			let { count } = this.#emitter;
+			/* c8 ignore start */
+			const p = process$2;
+			if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") count += p.__signal_exit_emitter__.count;
+			/* c8 ignore stop */
+			if (listeners.length === count) {
+				this.unload();
+				const ret = this.#emitter.emit("exit", null, sig);
+				/* c8 ignore start */
+				const s = sig === "SIGHUP" ? this.#hupSig : sig;
+				if (!ret) process$2.kill(process$2.pid, s);
+			}
+		};
+		this.#originalProcessReallyExit = process$2.reallyExit;
+		this.#originalProcessEmit = process$2.emit;
+	}
+	onExit(cb, opts) {
+		/* c8 ignore start */
+		if (!processOk(this.#process)) return () => {};
+		/* c8 ignore stop */
+		if (this.#loaded === false) this.load();
+		const ev = opts?.alwaysLast ? "afterExit" : "exit";
+		this.#emitter.on(ev, cb);
+		return () => {
+			this.#emitter.removeListener(ev, cb);
+			if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) this.unload();
+		};
+	}
+	load() {
+		if (this.#loaded) return;
+		this.#loaded = true;
+		this.#emitter.count += 1;
+		for (const sig of signals) try {
+			const fn = this.#sigListeners[sig];
+			if (fn) this.#process.on(sig, fn);
+		} catch (_) {}
+		this.#process.emit = (ev, ...a) => {
+			return this.#processEmit(ev, ...a);
+		};
+		this.#process.reallyExit = (code) => {
+			return this.#processReallyExit(code);
+		};
+	}
+	unload() {
+		if (!this.#loaded) return;
+		this.#loaded = false;
+		signals.forEach((sig) => {
+			const listener = this.#sigListeners[sig];
+			/* c8 ignore start */
+			if (!listener) throw new Error("Listener not defined for signal: " + sig);
+			/* c8 ignore stop */
+			try {
+				this.#process.removeListener(sig, listener);
+			} catch (_) {}
+			/* c8 ignore stop */
+		});
+		this.#process.emit = this.#originalProcessEmit;
+		this.#process.reallyExit = this.#originalProcessReallyExit;
+		this.#emitter.count -= 1;
+	}
+	#processReallyExit(code) {
+		/* c8 ignore start */
+		if (!processOk(this.#process)) return 0;
+		this.#process.exitCode = code || 0;
+		/* c8 ignore stop */
+		this.#emitter.emit("exit", this.#process.exitCode, null);
+		return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+	}
+	#processEmit(ev, ...args$1) {
+		const og = this.#originalProcessEmit;
+		if (ev === "exit" && processOk(this.#process)) {
+			if (typeof args$1[0] === "number") this.#process.exitCode = args$1[0];
+			/* c8 ignore start */
+			const ret = og.call(this.#process, ev, ...args$1);
+			/* c8 ignore start */
+			this.#emitter.emit("exit", this.#process.exitCode, null);
+			/* c8 ignore stop */
+			return ret;
+		} else return og.call(this.#process, ev, ...args$1);
+	}
+};
+const process$1 = globalThis.process;
+const { onExit, load, unload } = signalExitWrap(processOk(process$1) ? new SignalExit(process$1) : new SignalExitFallback());
+
+//#endregion
+//#region src/setup.ts
+if (isMainThread) {
+	const subscriberGuard = initTraceSubscriber();
+	onExit(() => {
+		subscriberGuard?.close();
+	});
+}
+
+//#endregion
 //#region package.json
-var version = "1.0.0-beta.36";
+var version = "1.0.0-beta.38";
 var description$1 = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
 
 //#endregion
 //#region src/builtin-plugin/utils.ts
-const BuiltinClassSymbol = Symbol.for("__RolldownBuiltinPlugin__");
 var BuiltinPlugin = class {
 	constructor(name, _options) {
 		this.name = name;
 		this._options = _options;
-		this[BuiltinClassSymbol] = true;
 	}
 };
-function isBuiltinPlugin(obj) {
-	return obj && obj[BuiltinClassSymbol] === true;
-}
-function createBuiltinPlugin(name, options) {
-	return new BuiltinPlugin(name, options);
-}
 function makeBuiltinPluginCallable(plugin) {
 	let callablePlugin = new BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
 	const wrappedPlugin = plugin;
@@ -173,75 +374,6 @@ function normalizeHook(hook) {
 	unreachable("Invalid hook type");
 }
 
-//#endregion
-//#region src/utils/normalize-string-or-regex.ts
-function normalizedStringOrRegex(pattern) {
-	if (!pattern) return;
-	if (!isReadonlyArray(pattern)) return [pattern];
-	return pattern;
-}
-function isReadonlyArray(input) {
-	return Array.isArray(input);
-}
-
-//#endregion
-//#region src/builtin-plugin/constructors.ts
-function modulePreloadPolyfillPlugin(config) {
-	return createBuiltinPlugin("builtin:module-preload-polyfill", config);
-}
-function dynamicImportVarsPlugin(config) {
-	if (config) {
-		config.include = normalizedStringOrRegex(config.include);
-		config.exclude = normalizedStringOrRegex(config.exclude);
-	}
-	return createBuiltinPlugin("builtin:dynamic-import-vars", config);
-}
-function importGlobPlugin(config) {
-	return createBuiltinPlugin("builtin:import-glob", config);
-}
-function reporterPlugin(config) {
-	return createBuiltinPlugin("builtin:reporter", config);
-}
-function manifestPlugin(config) {
-	return createBuiltinPlugin("builtin:manifest", config);
-}
-function wasmHelperPlugin(config) {
-	return createBuiltinPlugin("builtin:wasm-helper", config);
-}
-function wasmFallbackPlugin() {
-	const builtinPlugin = createBuiltinPlugin("builtin:wasm-fallback");
-	return makeBuiltinPluginCallable(builtinPlugin);
-}
-function loadFallbackPlugin() {
-	return createBuiltinPlugin("builtin:load-fallback");
-}
-function jsonPlugin(config) {
-	const builtinPlugin = createBuiltinPlugin("builtin:json", config);
-	return makeBuiltinPluginCallable(builtinPlugin);
-}
-function buildImportAnalysisPlugin(config) {
-	return createBuiltinPlugin("builtin:build-import-analysis", config);
-}
-function viteResolvePlugin(config) {
-	const builtinPlugin = createBuiltinPlugin("builtin:vite-resolve", config);
-	return makeBuiltinPluginCallable(builtinPlugin);
-}
-function isolatedDeclarationPlugin(config) {
-	return createBuiltinPlugin("builtin:isolated-declaration", config);
-}
-function assetPlugin(config) {
-	return createBuiltinPlugin("builtin:asset", config);
-}
-function webWorkerPostPlugin() {
-	return createBuiltinPlugin("builtin:web-worker-post");
-}
-function oxcRuntimePlugin(config) {
-	return createBuiltinPlugin("builtin:oxc-runtime", config);
-}
-function esmExternalRequirePlugin(config) {
-	return createBuiltinPlugin("builtin:esm-external-require", config);
-}
-
 //#endregion
 //#region src/constants/plugin.ts
 const ENUMERATED_INPUT_PLUGIN_HOOK_NAMES = [
@@ -333,14 +465,13 @@ function checkOutputPluginOption(plugins, onLog) {
 function normalizePlugins(plugins, anonymousPrefix) {
 	for (const [index, plugin] of plugins.entries()) {
 		if ("_parallel" in plugin) continue;
-		if (isBuiltinPlugin(plugin)) continue;
+		if (plugin instanceof BuiltinPlugin) continue;
 		if (!plugin.name) plugin.name = `${anonymousPrefix}${index + 1}`;
 	}
 	return plugins;
 }
 const ANONYMOUS_PLUGIN_PREFIX = "at position ";
 const ANONYMOUS_OUTPUT_PLUGIN_PREFIX = "at output position ";
-const BUILTIN_PLUGINS = [oxcRuntimePlugin({ resolveBase: fileURLToPath(import.meta.url) })];
 
 //#endregion
 //#region src/plugin/minimal-plugin-context.ts
@@ -402,7 +533,7 @@ function getObjectPlugins(plugins) {
 	return plugins.filter((plugin) => {
 		if (!plugin) return;
 		if ("_parallel" in plugin) return;
-		if (isBuiltinPlugin(plugin)) return;
+		if (plugin instanceof BuiltinPlugin) return;
 		return plugin;
 	});
 }
@@ -435,14 +566,14 @@ function getSortedPlugins(hookName, plugins) {
 
 //#endregion
 //#region ../../node_modules/.pnpm/valibot@1.1.0_typescript@5.9.2/node_modules/valibot/dist/index.js
-var store$1;
+var store;
 /* @__NO_SIDE_EFFECTS__ */
 function getGlobalConfig(config2) {
 	return {
-		lang: config2?.lang ?? store$1?.lang,
+		lang: config2?.lang ?? store?.lang,
 		message: config2?.message,
-		abortEarly: config2?.abortEarly ?? store$1?.abortEarly,
-		abortPipeEarly: config2?.abortPipeEarly ?? store$1?.abortPipeEarly
+		abortEarly: config2?.abortEarly ?? store?.abortEarly,
+		abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
 	};
 }
 var store2;
@@ -1423,395 +1554,68 @@ function safeParse(schema, input, config2) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@valibot+to-json-schema@1.3.0_valibot@1.1.0_typescript@5.9.2_/node_modules/@valibot/to-json-schema/dist/index.js
-/**
-* Adds an error message to the errors array.
-*
-* @param errors The array of error messages.
-* @param message The error message to add.
-*
-* @returns The new errors.
-*/
-function addError(errors, message) {
-	if (errors) {
-		errors.push(message);
-		return errors;
-	}
-	return [message];
-}
-/**
-* Throws an error or logs a warning based on the configuration.
-*
-* @param message The message to throw or log.
-* @param config The conversion configuration.
-*/
-function handleError(message, config) {
-	switch (config?.errorMode) {
-		case "ignore": break;
-		case "warn":
-			console.warn(message);
-			break;
-		default: throw new Error(message);
-	}
-}
-/**
-* Converts any supported Valibot action to the JSON Schema format.
-*
-* @param jsonSchema The JSON Schema object.
-* @param valibotAction The Valibot action object.
-* @param config The conversion configuration.
-*
-* @returns The converted JSON Schema.
-*/
-function convertAction(jsonSchema, valibotAction, config) {
-	if (config?.ignoreActions?.includes(valibotAction.type)) return jsonSchema;
-	let errors;
-	switch (valibotAction.type) {
-		case "base64":
-			jsonSchema.contentEncoding = "base64";
-			break;
-		case "bic":
-		case "cuid2":
-		case "decimal":
-		case "digits":
-		case "emoji":
-		case "hexadecimal":
-		case "hex_color":
-		case "nanoid":
-		case "octal":
-		case "ulid":
-			jsonSchema.pattern = valibotAction.requirement.source;
-			break;
-		case "description":
-			jsonSchema.description = valibotAction.description;
-			break;
-		case "email":
-			jsonSchema.format = "email";
-			break;
-		case "empty":
-			if (jsonSchema.type === "array") jsonSchema.maxItems = 0;
-			else {
-				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
-				jsonSchema.maxLength = 0;
-			}
-			break;
-		case "entries":
-			jsonSchema.minProperties = valibotAction.requirement;
-			jsonSchema.maxProperties = valibotAction.requirement;
-			break;
-		case "integer":
-			jsonSchema.type = "integer";
-			break;
-		case "ipv4":
-			jsonSchema.format = "ipv4";
-			break;
-		case "ipv6":
-			jsonSchema.format = "ipv6";
-			break;
-		case "iso_date":
-			jsonSchema.format = "date";
-			break;
-		case "iso_date_time":
-		case "iso_timestamp":
-			jsonSchema.format = "date-time";
-			break;
-		case "iso_time":
-			jsonSchema.format = "time";
-			break;
-		case "length":
-			if (jsonSchema.type === "array") {
-				jsonSchema.minItems = valibotAction.requirement;
-				jsonSchema.maxItems = valibotAction.requirement;
-			} else {
-				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
-				jsonSchema.minLength = valibotAction.requirement;
-				jsonSchema.maxLength = valibotAction.requirement;
-			}
-			break;
-		case "max_entries":
-			jsonSchema.maxProperties = valibotAction.requirement;
-			break;
-		case "max_length":
-			if (jsonSchema.type === "array") jsonSchema.maxItems = valibotAction.requirement;
-			else {
-				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
-				jsonSchema.maxLength = valibotAction.requirement;
-			}
-			break;
-		case "max_value":
-			if (jsonSchema.type !== "number") errors = addError(errors, `The "max_value" action is not supported on type "${jsonSchema.type}".`);
-			jsonSchema.maximum = valibotAction.requirement;
-			break;
-		case "metadata":
-			if (typeof valibotAction.metadata.title === "string") jsonSchema.title = valibotAction.metadata.title;
-			if (typeof valibotAction.metadata.description === "string") jsonSchema.description = valibotAction.metadata.description;
-			if (Array.isArray(valibotAction.metadata.examples)) jsonSchema.examples = valibotAction.metadata.examples;
-			break;
-		case "min_entries":
-			jsonSchema.minProperties = valibotAction.requirement;
-			break;
-		case "min_length":
-			if (jsonSchema.type === "array") jsonSchema.minItems = valibotAction.requirement;
-			else {
-				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
-				jsonSchema.minLength = valibotAction.requirement;
-			}
-			break;
-		case "min_value":
-			if (jsonSchema.type !== "number") errors = addError(errors, `The "min_value" action is not supported on type "${jsonSchema.type}".`);
-			jsonSchema.minimum = valibotAction.requirement;
-			break;
-		case "multiple_of":
-			jsonSchema.multipleOf = valibotAction.requirement;
-			break;
-		case "non_empty":
-			if (jsonSchema.type === "array") jsonSchema.minItems = 1;
-			else {
-				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
-				jsonSchema.minLength = 1;
-			}
-			break;
-		case "regex":
-			if (valibotAction.requirement.flags) errors = addError(errors, "RegExp flags are not supported by JSON Schema.");
-			jsonSchema.pattern = valibotAction.requirement.source;
-			break;
-		case "title":
-			jsonSchema.title = valibotAction.title;
-			break;
-		case "url":
-			jsonSchema.format = "uri";
-			break;
-		case "uuid":
-			jsonSchema.format = "uuid";
-			break;
-		case "value":
-			jsonSchema.const = valibotAction.requirement;
-			break;
-		default: errors = addError(errors, `The "${valibotAction.type}" action cannot be converted to JSON Schema.`);
-	}
-	if (config?.overrideAction) {
-		const actionOverride = config.overrideAction({
-			valibotAction,
-			jsonSchema,
-			errors
-		});
-		if (actionOverride) return { ...actionOverride };
-	}
-	if (errors) for (const message of errors) handleError(message, config);
-	return jsonSchema;
-}
-/**
-* Flattens a Valibot pipe by recursively expanding nested pipes.
-*
-* @param pipe The pipeline to flatten.
-*
-* @returns A flat pipeline.
-*/
-function flattenPipe(pipe$1) {
-	return pipe$1.flatMap((item) => "pipe" in item ? flattenPipe(item.pipe) : item);
-}
-let refCount = 0;
-/**
-* Converts any supported Valibot schema to the JSON Schema format.
-*
-* @param jsonSchema The JSON Schema object.
-* @param valibotSchema The Valibot schema object.
-* @param config The conversion configuration.
-* @param context The conversion context.
-* @param skipRef Whether to skip using a reference.
-*
-* @returns The converted JSON Schema.
-*/
-function convertSchema(jsonSchema, valibotSchema, config, context, skipRef = false) {
-	if (!skipRef) {
-		const referenceId = context.referenceMap.get(valibotSchema);
-		if (referenceId) {
-			jsonSchema.$ref = `#/$defs/${referenceId}`;
-			if (config?.overrideRef) {
-				const refOverride = config.overrideRef({
-					...context,
-					referenceId,
-					valibotSchema,
-					jsonSchema
-				});
-				if (refOverride) jsonSchema.$ref = refOverride;
-			}
-			return jsonSchema;
-		}
-	}
-	if ("pipe" in valibotSchema) {
-		const flatPipe = flattenPipe(valibotSchema.pipe);
-		let startIndex = 0;
-		let stopIndex = flatPipe.length - 1;
-		if (config?.typeMode === "input") {
-			const inputStopIndex = flatPipe.slice(1).findIndex((item) => item.kind === "schema" || item.kind === "transformation" && (item.type === "find_item" || item.type === "parse_json" || item.type === "raw_transform" || item.type === "reduce_items" || item.type === "stringify_json" || item.type === "transform"));
-			if (inputStopIndex !== -1) stopIndex = inputStopIndex;
-		} else if (config?.typeMode === "output") {
-			const outputStartIndex = flatPipe.findLastIndex((item) => item.kind === "schema");
-			if (outputStartIndex !== -1) startIndex = outputStartIndex;
-		}
-		for (let index = startIndex; index <= stopIndex; index++) {
-			const valibotPipeItem = flatPipe[index];
-			if (valibotPipeItem.kind === "schema") {
-				if (index > startIndex) handleError("Set the \"typeMode\" config to \"input\" or \"output\" to convert pipelines with multiple schemas.", config);
-				jsonSchema = convertSchema(jsonSchema, valibotPipeItem, config, context, true);
-			} else jsonSchema = convertAction(jsonSchema, valibotPipeItem, config);
-		}
-		return jsonSchema;
-	}
-	let errors;
-	switch (valibotSchema.type) {
-		case "boolean":
-			jsonSchema.type = "boolean";
-			break;
-		case "null":
-			jsonSchema.type = "null";
-			break;
-		case "number":
-			jsonSchema.type = "number";
-			break;
-		case "string":
-			jsonSchema.type = "string";
-			break;
-		case "array":
-			jsonSchema.type = "array";
-			jsonSchema.items = convertSchema({}, valibotSchema.item, config, context);
-			break;
-		case "tuple":
-		case "tuple_with_rest":
-		case "loose_tuple":
-		case "strict_tuple":
-			jsonSchema.type = "array";
-			jsonSchema.items = [];
-			jsonSchema.minItems = valibotSchema.items.length;
-			for (const item of valibotSchema.items) jsonSchema.items.push(convertSchema({}, item, config, context));
-			if (valibotSchema.type === "tuple_with_rest") jsonSchema.additionalItems = convertSchema({}, valibotSchema.rest, config, context);
-			else if (valibotSchema.type === "strict_tuple") jsonSchema.additionalItems = false;
-			break;
+//#region src/utils/flatten-valibot-schema.ts
+function unwrapSchema(schema) {
+	if (!schema) return schema;
+	if (schema.type === "optional" && schema.wrapped) return unwrapSchema(schema.wrapped);
+	if (schema.type === "nullable" && schema.wrapped) return unwrapSchema(schema.wrapped);
+	if (schema.type === "nullish" && schema.wrapped) return unwrapSchema(schema.wrapped);
+	return schema;
+}
+function getValibotSchemaType(schema) {
+	if (!schema) return "any";
+	if (schema.type) switch (schema.type) {
+		case "string": return "string";
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "array": return "array";
 		case "object":
-		case "object_with_rest":
-		case "loose_object":
 		case "strict_object":
-			jsonSchema.type = "object";
-			jsonSchema.properties = {};
-			jsonSchema.required = [];
-			for (const key in valibotSchema.entries) {
-				const entry = valibotSchema.entries[key];
-				jsonSchema.properties[key] = convertSchema({}, entry, config, context);
-				if (entry.type !== "nullish" && entry.type !== "optional") jsonSchema.required.push(key);
-			}
-			if (valibotSchema.type === "object_with_rest") jsonSchema.additionalProperties = convertSchema({}, valibotSchema.rest, config, context);
-			else if (valibotSchema.type === "strict_object") jsonSchema.additionalProperties = false;
-			break;
-		case "record":
-			if ("pipe" in valibotSchema.key) errors = addError(errors, "The \"record\" schema with a schema for the key that contains a \"pipe\" cannot be converted to JSON Schema.");
-			if (valibotSchema.key.type !== "string") errors = addError(errors, `The "record" schema with the "${valibotSchema.key.type}" schema for the key cannot be converted to JSON Schema.`);
-			jsonSchema.type = "object";
-			jsonSchema.additionalProperties = convertSchema({}, valibotSchema.value, config, context);
-			break;
-		case "any":
-		case "unknown": break;
-		case "nullable":
-		case "nullish":
-			jsonSchema.anyOf = [convertSchema({}, valibotSchema.wrapped, config, context), { type: "null" }];
-			if (valibotSchema.default !== void 0) jsonSchema.default = getDefault(valibotSchema);
-			break;
-		case "exact_optional":
-		case "optional":
-		case "undefinedable":
-			jsonSchema = convertSchema(jsonSchema, valibotSchema.wrapped, config, context);
-			if (valibotSchema.default !== void 0) jsonSchema.default = getDefault(valibotSchema);
-			break;
-		case "literal":
-			if (typeof valibotSchema.literal !== "boolean" && typeof valibotSchema.literal !== "number" && typeof valibotSchema.literal !== "string") errors = addError(errors, "The value of the \"literal\" schema is not JSON compatible.");
-			jsonSchema.const = valibotSchema.literal;
-			break;
-		case "enum":
-			jsonSchema.enum = valibotSchema.options;
-			break;
-		case "picklist":
-			if (valibotSchema.options.some((option) => typeof option !== "number" && typeof option !== "string")) errors = addError(errors, "An option of the \"picklist\" schema is not JSON compatible.");
-			jsonSchema.enum = valibotSchema.options;
-			break;
-		case "union":
-		case "variant":
-			jsonSchema.anyOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
-			break;
-		case "intersect":
-			jsonSchema.allOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
-			break;
-		case "lazy": {
-			let wrappedValibotSchema = context.getterMap.get(valibotSchema.getter);
-			if (!wrappedValibotSchema) {
-				wrappedValibotSchema = valibotSchema.getter(void 0);
-				context.getterMap.set(valibotSchema.getter, wrappedValibotSchema);
-			}
-			let referenceId = context.referenceMap.get(wrappedValibotSchema);
-			if (!referenceId) {
-				referenceId = `${refCount++}`;
-				context.referenceMap.set(wrappedValibotSchema, referenceId);
-				context.definitions[referenceId] = convertSchema({}, wrappedValibotSchema, config, context, true);
-			}
-			jsonSchema.$ref = `#/$defs/${referenceId}`;
-			if (config?.overrideRef) {
-				const refOverride = config.overrideRef({
-					...context,
-					referenceId,
-					valibotSchema: wrappedValibotSchema,
-					jsonSchema
-				});
-				if (refOverride) jsonSchema.$ref = refOverride;
-			}
-			break;
+		case "loose_object": return "object";
+		case "union": return "union";
+		case "literal": return typeof schema.literal;
+		case "record": return "object";
+		case "optional": return getValibotSchemaType(schema.wrapped);
+		case "nullable": return getValibotSchemaType(schema.wrapped);
+		case "nullish": return getValibotSchemaType(schema.wrapped);
+		case "never": return "never";
+		case "any": return "any";
+		case "custom": return "any";
+		case "function": return "never";
+		case "instance": return "object";
+		default: return "any";
+	}
+	return "any";
+}
+function getValibotDescription(schema) {
+	if (!schema) return void 0;
+	if (schema.pipe && Array.isArray(schema.pipe)) {
+		for (const action of schema.pipe) if (action.type === "description" && action.description) return action.description;
+	}
+	if (schema.type === "optional" && schema.wrapped) return getValibotDescription(schema.wrapped);
+}
+function flattenValibotSchema(schema, result = {}, prefix = "") {
+	if (!schema || typeof schema !== "object") return result;
+	if (schema.type === "strict_object" || schema.type === "object" || schema.type === "loose_object") {
+		if (schema.entries && typeof schema.entries === "object") for (const [key, value] of Object.entries(schema.entries)) {
+			const fullKey = prefix ? `${prefix}.${key}` : key;
+			const valueSchema = value;
+			const type = getValibotSchemaType(valueSchema);
+			const description$2 = getValibotDescription(valueSchema);
+			if (type === "object") {
+				const unwrappedSchema = unwrapSchema(valueSchema);
+				if (unwrappedSchema && unwrappedSchema.entries) flattenValibotSchema(unwrappedSchema, result, fullKey);
+				else result[fullKey] = {
+					type,
+					description: description$2
+				};
+			} else result[fullKey] = {
+				type,
+				description: description$2
+			};
 		}
-		default: errors = addError(errors, `The "${valibotSchema.type}" schema cannot be converted to JSON Schema.`);
-	}
-	if (config?.overrideSchema) {
-		const schemaOverride = config.overrideSchema({
-			...context,
-			referenceId: context.referenceMap.get(valibotSchema),
-			valibotSchema,
-			jsonSchema,
-			errors
-		});
-		if (schemaOverride) return { ...schemaOverride };
 	}
-	if (errors) for (const message of errors) handleError(message, config);
-	return jsonSchema;
-}
-let store;
-/**
-* Returns the current global schema definitions.
-*
-* @returns The schema definitions.
-*
-* @beta
-*/
-function getGlobalDefs() {
-	return store;
-}
-/**
-* Converts a Valibot schema to the JSON Schema format.
-*
-* @param schema The Valibot schema object.
-* @param config The JSON Schema configuration.
-*
-* @returns The converted JSON Schema.
-*/
-function toJsonSchema(schema, config) {
-	const context = {
-		definitions: {},
-		referenceMap: /* @__PURE__ */ new Map(),
-		getterMap: /* @__PURE__ */ new Map()
-	};
-	const definitions = config?.definitions ?? getGlobalDefs();
-	if (definitions) {
-		for (const key in definitions) context.referenceMap.set(definitions[key], key);
-		for (const key in definitions) context.definitions[key] = convertSchema({}, definitions[key], config, context, true);
-	}
-	const jsonSchema = convertSchema({ $schema: "http://json-schema.org/draft-07/schema#" }, schema, config, context);
-	if (context.referenceMap.size) jsonSchema.$defs = context.definitions;
-	return jsonSchema;
+	return result;
 }
 
 //#endregion
@@ -1860,7 +1664,7 @@ const JsxOptionsSchema = strictObject({
 	throwIfNamespace: pipe(optional(string()), description("Toggles whether to throw an error when a tag name uses an XML namespace")),
 	importSource: pipe(optional(string()), description("Import the factory of element and fragment if mode is classic")),
 	pragma: pipe(optional(string()), description("Jsx element transformation")),
-	pragmaFlag: pipe(optional(string()), description("Jsx fragment transformation")),
+	pragmaFrag: pipe(optional(string()), description("Jsx fragment transformation")),
 	refresh: pipe(optional(boolean()), description("Enable react fast refresh"))
 });
 const RollupJsxOptionsSchema = strictObject({
@@ -1979,7 +1783,11 @@ const MinifyOptionsSchema = strictObject({
 	codegen: optional(union([boolean(), CodegenOptionsSchema]))
 });
 const ResolveOptionsSchema = strictObject({
-	alias: optional(record(string(), union([string(), array(string())]))),
+	alias: optional(record(string(), union([
+		literal(false),
+		string(),
+		array(string())
+	]))),
 	aliasFields: optional(array(array(string()))),
 	conditionNames: optional(array(string())),
 	extensionAlias: optional(record(string(), array(string()))),
@@ -2097,7 +1905,7 @@ const InputCliOverrideSchema = strictObject({
 		literal("react-jsx"),
 		literal("preserve")
 	])), description("Jsx options preset")),
-	preserveEntrySignatures: pipe(optional(union([literal(false)])), description("Avoid facade chunks for entry points")),
+	preserveEntrySignatures: pipe(optional(literal(false)), description("Avoid facade chunks for entry points")),
 	context: pipe(optional(string()), description("The entity top-level `this` represents."))
 });
 const InputCliOptionsSchema = omit(strictObject({
@@ -2287,8 +2095,8 @@ function getInputCliKeys() {
 function getOutputCliKeys() {
 	return keyof(OutputCliOptionsSchema).options;
 }
-function getJsonSchema() {
-	return toJsonSchema(CliOptionsSchema, { errorMode: "ignore" });
+function getCliSchemaInfo() {
+	return flattenValibotSchema(CliOptionsSchema);
 }
 
 //#endregion
@@ -2398,7 +2206,7 @@ function normalizeTransformHookSourcemap(id, originalCode, rawMap) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/remeda@2.30.0/node_modules/remeda/dist/lazyDataLastImpl-BDhrIOwR.js
+//#region ../../node_modules/.pnpm/remeda@2.31.1/node_modules/remeda/dist/lazyDataLastImpl-BDhrIOwR.js
 function e(e$1, t$2, n$1) {
 	let r = (n$2) => e$1(n$2, ...t$2);
 	return n$1 === void 0 ? r : Object.assign(r, {
@@ -2408,7 +2216,7 @@ function e(e$1, t$2, n$1) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/remeda@2.30.0/node_modules/remeda/dist/purry-DH9cw9sy.js
+//#region ../../node_modules/.pnpm/remeda@2.31.1/node_modules/remeda/dist/purry-DH9cw9sy.js
 function t(t$2, n$1, r) {
 	let i = t$2.length - n$1.length;
 	if (i === 0) return t$2(...n$1);
@@ -2417,7 +2225,7 @@ function t(t$2, n$1, r) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/remeda@2.30.0/node_modules/remeda/dist/partition-BJYkp-a7.js
+//#region ../../node_modules/.pnpm/remeda@2.31.1/node_modules/remeda/dist/partition-DAu403JQ.js
 function t$1(...t$2) {
 	return t(n, t$2);
 }
@@ -3381,7 +3189,7 @@ function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, nor
 	const { plugin: buildEnd, meta: buildEndMeta } = bindingifyBuildEnd(args$1);
 	const { plugin: transform, meta: transformMeta, filter: transformFilter } = bindingifyTransform(args$1);
 	const { plugin: moduleParsed, meta: moduleParsedMeta } = bindingifyModuleParsed(args$1);
-	const { plugin: load, meta: loadMeta, filter: loadFilter } = bindingifyLoad(args$1);
+	const { plugin: load$1, meta: loadMeta, filter: loadFilter } = bindingifyLoad(args$1);
 	const { plugin: renderChunk, meta: renderChunkMeta, filter: renderChunkFilter } = bindingifyRenderChunk(args$1);
 	const { plugin: augmentChunkHash, meta: augmentChunkHashMeta } = bindingifyAugmentChunkHash(args$1);
 	const { plugin: renderStart, meta: renderStartMeta } = bindingifyRenderStart(args$1);
@@ -3412,7 +3220,7 @@ function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, nor
 		transformFilter,
 		moduleParsed,
 		moduleParsedMeta,
-		load,
+		load: load$1,
 		loadMeta,
 		loadFilter,
 		renderChunk,
@@ -3861,13 +3669,24 @@ var PluginContextData = class {
 	}
 };
 
+//#endregion
+//#region src/utils/normalize-string-or-regex.ts
+function normalizedStringOrRegex(pattern) {
+	if (!pattern) return;
+	if (!isReadonlyArray(pattern)) return [pattern];
+	return pattern;
+}
+function isReadonlyArray(input) {
+	return Array.isArray(input);
+}
+
 //#endregion
 //#region src/utils/bindingify-input-options.ts
 function bindingifyInputOptions(rawPlugins, inputOptions, outputOptions, normalizedOutputPlugins, onLog, logLevel, watchMode) {
 	const pluginContextData = new PluginContextData(onLog, outputOptions, normalizedOutputPlugins);
 	const plugins = rawPlugins.map((plugin) => {
 		if ("_parallel" in plugin) return;
-		if (isBuiltinPlugin(plugin)) return bindingifyBuiltInPlugin(plugin);
+		if (plugin instanceof BuiltinPlugin) return bindingifyBuiltInPlugin(plugin);
 		return bindingifyPlugin(plugin, inputOptions, outputOptions, pluginContextData, normalizedOutputPlugins, onLog, logLevel, watchMode);
 	});
 	const { jsx, transform } = bindingifyJsx(onLog, inputOptions.jsx, inputOptions.transform);
@@ -3933,13 +3752,7 @@ function bindingifyExternal(external) {
 			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;
-			});
-		};
+		return arraify(external);
 	}
 }
 function bindingifyExperimental(experimental) {
@@ -3973,7 +3786,7 @@ function bindingifyResolve(resolve) {
 		return {
 			alias: alias ? Object.entries(alias).map(([name, replacement]) => ({
 				find: name,
-				replacements: arraify(replacement)
+				replacements: replacement === false ? [void 0] : arraify(replacement)
 			})) : void 0,
 			extensionAlias: extensionAlias ? Object.entries(extensionAlias).map(([name, value]) => ({
 				target: name,
@@ -4204,11 +4017,7 @@ async function createBundlerOptions(inputOptions, outputOptions, watchMode) {
 	const onLog = getLogger(getObjectPlugins(inputPlugins), getOnLog(inputOptions, logLevel), logLevel, watchMode);
 	outputOptions = PluginDriver.callOutputOptionsHook([...inputPlugins, ...outputPlugins], outputOptions, onLog, logLevel, watchMode);
 	const normalizedOutputPlugins = await normalizePluginOption(outputOptions.plugins);
-	let plugins = [
-		...BUILTIN_PLUGINS,
-		...normalizePlugins(inputPlugins, ANONYMOUS_PLUGIN_PREFIX),
-		...checkOutputPluginOption(normalizePlugins(normalizedOutputPlugins, ANONYMOUS_OUTPUT_PLUGIN_PREFIX), onLog)
-	];
+	let plugins = [...normalizePlugins(inputPlugins, ANONYMOUS_PLUGIN_PREFIX), ...checkOutputPluginOption(normalizePlugins(normalizedOutputPlugins, ANONYMOUS_OUTPUT_PLUGIN_PREFIX), onLog)];
 	const parallelPluginInitResult = await initializeParallelPlugins(plugins);
 	try {
 		const bindingInputOptions = bindingifyInputOptions(plugins, inputOptions, outputOptions, normalizedOutputPlugins, onLog, logLevel, watchMode);
@@ -4229,27 +4038,6 @@ async function createBundlerOptions(inputOptions, outputOptions, watchMode) {
 	}
 }
 
-//#endregion
-//#region src/utils/create-bundler.ts
-let asyncRuntimeShutdown = false;
-async function createBundlerImpl(bundler, inputOptions, outputOptions) {
-	const option = await createBundlerOptions(inputOptions, outputOptions, false);
-	if (asyncRuntimeShutdown) startAsyncRuntime();
-	try {
-		return {
-			impl: bundler.createImpl(option.bundlerOptions),
-			stopWorkers: option.stopWorkers,
-			shutdown: () => {
-				shutdownAsyncRuntime();
-				asyncRuntimeShutdown = true;
-			}
-		};
-	} catch (e$1) {
-		await option.stopWorkers?.();
-		throw e$1;
-	}
-}
-
 //#endregion
 //#region src/utils/transform-hmr-patch-output.ts
 function transformHmrPatchOutput(output) {
@@ -4265,10 +4053,11 @@ function handleHmrPatchOutputErrors(output) {
 //#endregion
 //#region src/api/rolldown/rolldown-build.ts
 Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose");
-var RolldownBuild = class {
+var RolldownBuild = class RolldownBuild {
 	#inputOptions;
 	#bundler;
 	#bundlerImpl;
+	static asyncRuntimeShutdown = false;
 	constructor(inputOptions) {
 		this.#inputOptions = inputOptions;
 		this.#bundler = new BindingBundler();
@@ -4278,7 +4067,26 @@ var RolldownBuild = class {
 	}
 	async #getBundlerWithStopWorker(outputOptions) {
 		if (this.#bundlerImpl) await this.#bundlerImpl.stopWorkers?.();
-		return this.#bundlerImpl = await createBundlerImpl(this.#bundler, this.#inputOptions, outputOptions);
+		const option = await createBundlerOptions(this.#inputOptions, outputOptions, false);
+		if (RolldownBuild.asyncRuntimeShutdown) startAsyncRuntime();
+		try {
+			return this.#bundlerImpl = {
+				impl: this.#bundler.createImpl(option.bundlerOptions),
+				stopWorkers: option.stopWorkers,
+				shutdown: () => {
+					shutdownAsyncRuntime();
+					RolldownBuild.asyncRuntimeShutdown = true;
+				}
+			};
+		} catch (e$1) {
+			await option.stopWorkers?.();
+			throw e$1;
+		}
+	}
+	async scan() {
+		const { impl } = await this.#getBundlerWithStopWorker({});
+		const output = await impl.scan();
+		return handleOutputErrors(output);
 	}
 	async generate(outputOptions = {}) {
 		validateOption("output", outputOptions);
@@ -4486,4 +4294,4 @@ function defineConfig(config) {
 const VERSION = version;
 
 //#endregion
-export { PluginContextData, PluginDriver, VERSION, assetPlugin, bindingifyPlugin, build, buildImportAnalysisPlugin, createBuiltinPlugin, createBundlerImpl, createBundlerOptions, defineConfig, description$1 as description, dynamicImportVarsPlugin, esmExternalRequirePlugin, getInputCliKeys, getJsonSchema, getOutputCliKeys, handleOutputErrors, importGlobPlugin, isolatedDeclarationPlugin, jsonPlugin, loadFallbackPlugin, manifestPlugin, modulePreloadPolyfillPlugin, normalizedStringOrRegex, reporterPlugin, rolldown, validateCliOptions, version, viteResolvePlugin, wasmFallbackPlugin, wasmHelperPlugin, watch, webWorkerPostPlugin };
+export { BuiltinPlugin, PluginContextData, PluginDriver, RolldownBuild, VERSION, bindingifyPlugin, build, createBundlerOptions, defineConfig, description$1 as description, getCliSchemaInfo, getInputCliKeys, getOutputCliKeys, makeBuiltinPluginCallable, normalizedStringOrRegex, onExit, rolldown, validateCliOptions, version, watch };