rolldown 1.0.0-beta.8-commit.baf6ca1 → 1.0.0-beta.8-commit.a720367

package/dist/shared/{src-gyFaNJxP.mjs → src-B7fgzJrI.mjs}

@@ -2,23 +2,21 @@ import { __esm } from "./chunk-DUYDk_2O.mjs";
 import { augmentCodeLocation, error, import_binding, init_logs, init_parse_ast_index, logCycleLoading, logInputHookInOutputPlugin, logInvalidLogPosition, logMultiplyNotifyOption, logPluginError, parseAst } from "./parse-ast-index-D0SmlXT6.mjs";
 import { and, arraify, code, exclude, id, include, init_filter_index, init_misc, isNullish, moduleType, noop, or, unimplemented, unreachable, unsupported } from "./filter-index-hnEzlqRW.mjs";
 import path from "node:path";
-import { toJsonSchema } from "@valibot/to-json-schema";
 import colors from "ansis";
-import * as v from "valibot";
 import { availableParallelism } from "node:os";
 import { Worker } from "node:worker_threads";
 
 //#region package.json
-var version = "1.0.0-beta.8-commit.baf6ca1";
-var description = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
+var version = "1.0.0-beta.8-commit.a720367";
+var description$1 = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
 
 //#endregion
 //#region src/builtin-plugin/utils.ts
 function makeBuiltinPluginCallable(plugin) {
 	let callablePlugin = new import_binding.BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
 	const wrappedPlugin = plugin;
-	for (const key in callablePlugin) wrappedPlugin[key] = function(...args) {
-		return callablePlugin[key](...args);
+	for (const key in callablePlugin) wrappedPlugin[key] = function(...args$1) {
+		return callablePlugin[key](...args$1);
 	};
 	return wrappedPlugin;
 }
@@ -309,11 +307,11 @@ var init_plugin$1 = __esm({ "src/constants/plugin.ts"() {
 
 //#endregion
 //#region src/utils/async-flatten.ts
-async function asyncFlatten(array) {
+async function asyncFlatten(array$1) {
 	do
-		array = (await Promise.all(array)).flat(Infinity);
-	while (array.some((v$1) => v$1?.then));
-	return array;
+		array$1 = (await Promise.all(array$1)).flat(Infinity);
+	while (array$1.some((v) => v?.then));
+	return array$1;
 }
 var init_async_flatten = __esm({ "src/utils/async-flatten.ts"() {} });
 
@@ -453,10 +451,1321 @@ var init_plugin_driver = __esm({ "src/plugin/plugin-driver.ts"() {
 	};
 } });
 
+//#endregion
+//#region ../../node_modules/.pnpm/valibot@1.0.0_typescript@5.8.3/node_modules/valibot/dist/index.js
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalConfig(config2) {
+	return {
+		lang: config2?.lang ?? store?.lang,
+		message: config2?.message,
+		abortEarly: config2?.abortEarly ?? store?.abortEarly,
+		abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalMessage(lang) {
+	return store2?.get(lang);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getSchemaMessage(lang) {
+	return store3?.get(lang);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getSpecificMessage(reference, lang) {
+	return store4?.get(reference)?.get(lang);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _stringify(input) {
+	const type = typeof input;
+	if (type === "string") return `"${input}"`;
+	if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+	if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+	return type;
+}
+function _addIssue(context, label, dataset, config2, other) {
+	const input = other && "input" in other ? other.input : dataset.value;
+	const expected = other?.expected ?? context.expects ?? null;
+	const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+	const issue = {
+		kind: context.kind,
+		type: context.type,
+		input,
+		expected,
+		received,
+		message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+		requirement: context.requirement,
+		path: other?.path,
+		issues: other?.issues,
+		lang: config2.lang,
+		abortEarly: config2.abortEarly,
+		abortPipeEarly: config2.abortPipeEarly
+	};
+	const isSchema = context.kind === "schema";
+	const message = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config2.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+	if (message !== void 0) issue.message = typeof message === "function" ? message(issue) : message;
+	if (isSchema) dataset.typed = false;
+	if (dataset.issues) dataset.issues.push(issue);
+	else dataset.issues = [issue];
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _getStandardProps(context) {
+	return {
+		version: 1,
+		vendor: "valibot",
+		validate(value2) {
+			return context["~run"]({ value: value2 }, /* @__PURE__ */ getGlobalConfig());
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isValidObjectKey(object2, key) {
+	return Object.hasOwn(object2, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _joinExpects(values2, separator) {
+	const list = [...new Set(values2)];
+	if (list.length > 1) return `(${list.join(` ${separator} `)})`;
+	return list[0] ?? "never";
+}
+/* @__NO_SIDE_EFFECTS__ */
+function args(schema) {
+	return {
+		kind: "transformation",
+		type: "args",
+		reference: args,
+		async: false,
+		schema,
+		"~run"(dataset, config2) {
+			const func = dataset.value;
+			dataset.value = (...args_) => {
+				const argsDataset = this.schema["~run"]({ value: args_ }, config2);
+				if (argsDataset.issues) throw new ValiError(argsDataset.issues);
+				return func(...argsDataset.value);
+			};
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function awaitAsync() {
+	return {
+		kind: "transformation",
+		type: "await",
+		reference: awaitAsync,
+		async: true,
+		async "~run"(dataset) {
+			dataset.value = await dataset.value;
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function description(description_) {
+	return {
+		kind: "metadata",
+		type: "description",
+		reference: description,
+		description: description_
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function returns(schema) {
+	return {
+		kind: "transformation",
+		type: "returns",
+		reference: returns,
+		async: false,
+		schema,
+		"~run"(dataset, config2) {
+			const func = dataset.value;
+			dataset.value = (...args_) => {
+				const returnsDataset = this.schema["~run"]({ value: func(...args_) }, config2);
+				if (returnsDataset.issues) throw new ValiError(returnsDataset.issues);
+				return returnsDataset.value;
+			};
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function returnsAsync(schema) {
+	return {
+		kind: "transformation",
+		type: "returns",
+		reference: returnsAsync,
+		async: false,
+		schema,
+		"~run"(dataset, config2) {
+			const func = dataset.value;
+			dataset.value = async (...args_) => {
+				const returnsDataset = await this.schema["~run"]({ value: await func(...args_) }, config2);
+				if (returnsDataset.issues) throw new ValiError(returnsDataset.issues);
+				return returnsDataset.value;
+			};
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getFallback(schema, dataset, config2) {
+	return typeof schema.fallback === "function" ? schema.fallback(dataset, config2) : schema.fallback;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getDefault(schema, dataset, config2) {
+	return typeof schema.default === "function" ? schema.default(dataset, config2) : schema.default;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function any() {
+	return {
+		kind: "schema",
+		type: "any",
+		reference: any,
+		expects: "any",
+		async: false,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset) {
+			dataset.typed = true;
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function array(item, message) {
+	return {
+		kind: "schema",
+		type: "array",
+		reference: array,
+		expects: "Array",
+		async: false,
+		item,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			const input = dataset.value;
+			if (Array.isArray(input)) {
+				dataset.typed = true;
+				dataset.value = [];
+				for (let key = 0; key < input.length; key++) {
+					const value2 = input[key];
+					const itemDataset = this.item["~run"]({ value: value2 }, config2);
+					if (itemDataset.issues) {
+						const pathItem = {
+							type: "array",
+							origin: "value",
+							input,
+							key,
+							value: value2
+						};
+						for (const issue of itemDataset.issues) {
+							if (issue.path) issue.path.unshift(pathItem);
+							else issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = itemDataset.issues;
+						if (config2.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					if (!itemDataset.typed) dataset.typed = false;
+					dataset.value.push(itemDataset.value);
+				}
+			} else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function boolean(message) {
+	return {
+		kind: "schema",
+		type: "boolean",
+		reference: boolean,
+		expects: "boolean",
+		async: false,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (typeof dataset.value === "boolean") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function custom(check2, message) {
+	return {
+		kind: "schema",
+		type: "custom",
+		reference: custom,
+		expects: "unknown",
+		async: false,
+		check: check2,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (this.check(dataset.value)) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function enum_(enum__, message) {
+	const options = [];
+	for (const key in enum__) if (`${+key}` !== key || typeof enum__[key] !== "string" || !Object.is(enum__[enum__[key]], +key)) options.push(enum__[key]);
+	return {
+		kind: "schema",
+		type: "enum",
+		reference: enum_,
+		expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+		async: false,
+		enum: enum__,
+		options,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (this.options.includes(dataset.value)) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function function_(message) {
+	return {
+		kind: "schema",
+		type: "function",
+		reference: function_,
+		expects: "Function",
+		async: false,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (typeof dataset.value === "function") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function instance(class_, message) {
+	return {
+		kind: "schema",
+		type: "instance",
+		reference: instance,
+		expects: class_.name,
+		async: false,
+		class: class_,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (dataset.value instanceof this.class) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function literal(literal_, message) {
+	return {
+		kind: "schema",
+		type: "literal",
+		reference: literal,
+		expects: /* @__PURE__ */ _stringify(literal_),
+		async: false,
+		literal: literal_,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (dataset.value === this.literal) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function looseObject(entries, message) {
+	return {
+		kind: "schema",
+		type: "loose_object",
+		reference: looseObject,
+		expects: "Object",
+		async: false,
+		entries,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const key in this.entries) {
+					const valueSchema = this.entries[key];
+					if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+						const value2 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+						const valueDataset = valueSchema["~run"]({ value: value2 }, config2);
+						if (valueDataset.issues) {
+							const pathItem = {
+								type: "object",
+								origin: "value",
+								input,
+								key,
+								value: value2
+							};
+							for (const issue of valueDataset.issues) {
+								if (issue.path) issue.path.unshift(pathItem);
+								else issue.path = [pathItem];
+								dataset.issues?.push(issue);
+							}
+							if (!dataset.issues) dataset.issues = valueDataset.issues;
+							if (config2.abortEarly) {
+								dataset.typed = false;
+								break;
+							}
+						}
+						if (!valueDataset.typed) dataset.typed = false;
+						dataset.value[key] = valueDataset.value;
+					} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+					else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+						_addIssue(this, "key", dataset, config2, {
+							input: void 0,
+							expected: `"${key}"`,
+							path: [{
+								type: "object",
+								origin: "key",
+								input,
+								key,
+								value: input[key]
+							}]
+						});
+						if (config2.abortEarly) break;
+					}
+				}
+				if (!dataset.issues || !config2.abortEarly) {
+					for (const key in input) if (/* @__PURE__ */ _isValidObjectKey(input, key) && !(key in this.entries)) dataset.value[key] = input[key];
+				}
+			} else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function never(message) {
+	return {
+		kind: "schema",
+		type: "never",
+		reference: never,
+		expects: "never",
+		async: false,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			_addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function nullish(wrapped, default_) {
+	return {
+		kind: "schema",
+		type: "nullish",
+		reference: nullish,
+		expects: `(${wrapped.expects} | null | undefined)`,
+		async: false,
+		wrapped,
+		default: default_,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (dataset.value === null || dataset.value === void 0) {
+				if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config2);
+				if (dataset.value === null || dataset.value === void 0) {
+					dataset.typed = true;
+					return dataset;
+				}
+			}
+			return this.wrapped["~run"](dataset, config2);
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function number(message) {
+	return {
+		kind: "schema",
+		type: "number",
+		reference: number,
+		expects: "number",
+		async: false,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function object(entries, message) {
+	return {
+		kind: "schema",
+		type: "object",
+		reference: object,
+		expects: "Object",
+		async: false,
+		entries,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const key in this.entries) {
+					const valueSchema = this.entries[key];
+					if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+						const value2 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+						const valueDataset = valueSchema["~run"]({ value: value2 }, config2);
+						if (valueDataset.issues) {
+							const pathItem = {
+								type: "object",
+								origin: "value",
+								input,
+								key,
+								value: value2
+							};
+							for (const issue of valueDataset.issues) {
+								if (issue.path) issue.path.unshift(pathItem);
+								else issue.path = [pathItem];
+								dataset.issues?.push(issue);
+							}
+							if (!dataset.issues) dataset.issues = valueDataset.issues;
+							if (config2.abortEarly) {
+								dataset.typed = false;
+								break;
+							}
+						}
+						if (!valueDataset.typed) dataset.typed = false;
+						dataset.value[key] = valueDataset.value;
+					} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+					else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+						_addIssue(this, "key", dataset, config2, {
+							input: void 0,
+							expected: `"${key}"`,
+							path: [{
+								type: "object",
+								origin: "key",
+								input,
+								key,
+								value: input[key]
+							}]
+						});
+						if (config2.abortEarly) break;
+					}
+				}
+			} else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function optional(wrapped, default_) {
+	return {
+		kind: "schema",
+		type: "optional",
+		reference: optional,
+		expects: `(${wrapped.expects} | undefined)`,
+		async: false,
+		wrapped,
+		default: default_,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (dataset.value === void 0) {
+				if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config2);
+				if (dataset.value === void 0) {
+					dataset.typed = true;
+					return dataset;
+				}
+			}
+			return this.wrapped["~run"](dataset, config2);
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function picklist(options, message) {
+	return {
+		kind: "schema",
+		type: "picklist",
+		reference: picklist,
+		expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+		async: false,
+		options,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (this.options.includes(dataset.value)) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function promise(message) {
+	return {
+		kind: "schema",
+		type: "promise",
+		reference: promise,
+		expects: "Promise",
+		async: false,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (dataset.value instanceof Promise) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function record(key, value2, message) {
+	return {
+		kind: "schema",
+		type: "record",
+		reference: record,
+		expects: "Object",
+		async: false,
+		key,
+		value: value2,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const entryKey in input) if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
+					const entryValue = input[entryKey];
+					const keyDataset = this.key["~run"]({ value: entryKey }, config2);
+					if (keyDataset.issues) {
+						const pathItem = {
+							type: "object",
+							origin: "key",
+							input,
+							key: entryKey,
+							value: entryValue
+						};
+						for (const issue of keyDataset.issues) {
+							issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = keyDataset.issues;
+						if (config2.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					const valueDataset = this.value["~run"]({ value: entryValue }, config2);
+					if (valueDataset.issues) {
+						const pathItem = {
+							type: "object",
+							origin: "value",
+							input,
+							key: entryKey,
+							value: entryValue
+						};
+						for (const issue of valueDataset.issues) {
+							if (issue.path) issue.path.unshift(pathItem);
+							else issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = valueDataset.issues;
+						if (config2.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					if (!keyDataset.typed || !valueDataset.typed) dataset.typed = false;
+					if (keyDataset.typed) dataset.value[keyDataset.value] = valueDataset.value;
+				}
+			} else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function strictObject(entries, message) {
+	return {
+		kind: "schema",
+		type: "strict_object",
+		reference: strictObject,
+		expects: "Object",
+		async: false,
+		entries,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const key in this.entries) {
+					const valueSchema = this.entries[key];
+					if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+						const value2 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+						const valueDataset = valueSchema["~run"]({ value: value2 }, config2);
+						if (valueDataset.issues) {
+							const pathItem = {
+								type: "object",
+								origin: "value",
+								input,
+								key,
+								value: value2
+							};
+							for (const issue of valueDataset.issues) {
+								if (issue.path) issue.path.unshift(pathItem);
+								else issue.path = [pathItem];
+								dataset.issues?.push(issue);
+							}
+							if (!dataset.issues) dataset.issues = valueDataset.issues;
+							if (config2.abortEarly) {
+								dataset.typed = false;
+								break;
+							}
+						}
+						if (!valueDataset.typed) dataset.typed = false;
+						dataset.value[key] = valueDataset.value;
+					} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+					else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+						_addIssue(this, "key", dataset, config2, {
+							input: void 0,
+							expected: `"${key}"`,
+							path: [{
+								type: "object",
+								origin: "key",
+								input,
+								key,
+								value: input[key]
+							}]
+						});
+						if (config2.abortEarly) break;
+					}
+				}
+				if (!dataset.issues || !config2.abortEarly) {
+					for (const key in input) if (!(key in this.entries)) {
+						_addIssue(this, "key", dataset, config2, {
+							input: key,
+							expected: "never",
+							path: [{
+								type: "object",
+								origin: "key",
+								input,
+								key,
+								value: input[key]
+							}]
+						});
+						break;
+					}
+				}
+			} else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function string(message) {
+	return {
+		kind: "schema",
+		type: "string",
+		reference: string,
+		expects: "string",
+		async: false,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (typeof dataset.value === "string") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function tuple(items, message) {
+	return {
+		kind: "schema",
+		type: "tuple",
+		reference: tuple,
+		expects: "Array",
+		async: false,
+		items,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			const input = dataset.value;
+			if (Array.isArray(input)) {
+				dataset.typed = true;
+				dataset.value = [];
+				for (let key = 0; key < this.items.length; key++) {
+					const value2 = input[key];
+					const itemDataset = this.items[key]["~run"]({ value: value2 }, config2);
+					if (itemDataset.issues) {
+						const pathItem = {
+							type: "array",
+							origin: "value",
+							input,
+							key,
+							value: value2
+						};
+						for (const issue of itemDataset.issues) {
+							if (issue.path) issue.path.unshift(pathItem);
+							else issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = itemDataset.issues;
+						if (config2.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					if (!itemDataset.typed) dataset.typed = false;
+					dataset.value.push(itemDataset.value);
+				}
+			} else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _subIssues(datasets) {
+	let issues;
+	if (datasets) for (const dataset of datasets) if (issues) issues.push(...dataset.issues);
+	else issues = dataset.issues;
+	return issues;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function union(options, message) {
+	return {
+		kind: "schema",
+		type: "union",
+		reference: union,
+		expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
+		async: false,
+		options,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			let validDataset;
+			let typedDatasets;
+			let untypedDatasets;
+			for (const schema of this.options) {
+				const optionDataset = schema["~run"]({ value: dataset.value }, config2);
+				if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
+				else typedDatasets = [optionDataset];
+				else {
+					validDataset = optionDataset;
+					break;
+				}
+				else if (untypedDatasets) untypedDatasets.push(optionDataset);
+				else untypedDatasets = [optionDataset];
+			}
+			if (validDataset) return validDataset;
+			if (typedDatasets) {
+				if (typedDatasets.length === 1) return typedDatasets[0];
+				_addIssue(this, "type", dataset, config2, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
+				dataset.typed = true;
+			} else if (untypedDatasets?.length === 1) return untypedDatasets[0];
+			else _addIssue(this, "type", dataset, config2, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function unionAsync(options, message) {
+	return {
+		kind: "schema",
+		type: "union",
+		reference: unionAsync,
+		expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
+		async: true,
+		options,
+		message,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		async "~run"(dataset, config2) {
+			let validDataset;
+			let typedDatasets;
+			let untypedDatasets;
+			for (const schema of this.options) {
+				const optionDataset = await schema["~run"]({ value: dataset.value }, config2);
+				if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
+				else typedDatasets = [optionDataset];
+				else {
+					validDataset = optionDataset;
+					break;
+				}
+				else if (untypedDatasets) untypedDatasets.push(optionDataset);
+				else untypedDatasets = [optionDataset];
+			}
+			if (validDataset) return validDataset;
+			if (typedDatasets) {
+				if (typedDatasets.length === 1) return typedDatasets[0];
+				_addIssue(this, "type", dataset, config2, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
+				dataset.typed = true;
+			} else if (untypedDatasets?.length === 1) return untypedDatasets[0];
+			else _addIssue(this, "type", dataset, config2, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function keyof(schema, message) {
+	return /* @__PURE__ */ picklist(Object.keys(schema.entries), message);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function omit(schema, keys) {
+	const entries = { ...schema.entries };
+	for (const key of keys) delete entries[key];
+	return {
+		...schema,
+		entries,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function pipe(...pipe2) {
+	return {
+		...pipe2[0],
+		pipe: pipe2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			for (const item of pipe2) if (item.kind !== "metadata") {
+				if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+					dataset.typed = false;
+					break;
+				}
+				if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) dataset = item["~run"](dataset, config2);
+			}
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function pipeAsync(...pipe2) {
+	return {
+		...pipe2[0],
+		pipe: pipe2,
+		async: true,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		async "~run"(dataset, config2) {
+			for (const item of pipe2) if (item.kind !== "metadata") {
+				if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+					dataset.typed = false;
+					break;
+				}
+				if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) dataset = await item["~run"](dataset, config2);
+			}
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function safeParse(schema, input, config2) {
+	const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config2));
+	return {
+		typed: dataset.typed,
+		success: !dataset.issues,
+		output: dataset.value,
+		issues: dataset.issues
+	};
+}
+var store, store2, store3, store4, ValiError;
+var init_dist$2 = __esm({ "../../node_modules/.pnpm/valibot@1.0.0_typescript@5.8.3/node_modules/valibot/dist/index.js"() {
+	ValiError = class extends Error {
+		/**
+		* Creates a Valibot error with useful information.
+		*
+		* @param issues The error issues.
+		*/
+		constructor(issues) {
+			super(issues[0].message);
+			this.name = "ValiError";
+			this.issues = issues;
+		}
+	};
+} });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@valibot+to-json-schema@1.0.0_valibot@1.0.0_typescript@5.8.3_/node_modules/@valibot/to-json-schema/dist/index.js
+function handleError(message, config) {
+	switch (config?.errorMode) {
+		case "ignore": break;
+		case "warn": {
+			console.warn(message);
+			break;
+		}
+		default: throw new Error(message);
+	}
+}
+function convertAction(jsonSchema, valibotAction, config) {
+	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") handleError(`The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`, config);
+				jsonSchema.maxLength = 0;
+			}
+			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") handleError(`The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`, config);
+				jsonSchema.minLength = valibotAction.requirement;
+				jsonSchema.maxLength = valibotAction.requirement;
+			}
+			break;
+		}
+		case "max_length": {
+			if (jsonSchema.type === "array") jsonSchema.maxItems = valibotAction.requirement;
+			else {
+				if (jsonSchema.type !== "string") handleError(`The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`, config);
+				jsonSchema.maxLength = valibotAction.requirement;
+			}
+			break;
+		}
+		case "max_value": {
+			if (jsonSchema.type !== "number") handleError(`The "max_value" action is not supported on type "${jsonSchema.type}".`, config);
+			jsonSchema.maximum = valibotAction.requirement;
+			break;
+		}
+		case "min_length": {
+			if (jsonSchema.type === "array") jsonSchema.minItems = valibotAction.requirement;
+			else {
+				if (jsonSchema.type !== "string") handleError(`The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`, config);
+				jsonSchema.minLength = valibotAction.requirement;
+			}
+			break;
+		}
+		case "min_value": {
+			if (jsonSchema.type !== "number") handleError(`The "min_value" action is not supported on type "${jsonSchema.type}".`, config);
+			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") handleError(`The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`, config);
+				jsonSchema.minLength = 1;
+			}
+			break;
+		}
+		case "regex": {
+			if (valibotAction.requirement.flags) handleError("RegExp flags are not supported by JSON Schema.", config);
+			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: handleError(
+			// @ts-expect-error
+			`The "${valibotAction.type}" action cannot be converted to JSON Schema.`,
+			config
+);
+	}
+	return jsonSchema;
+}
+function convertSchema(jsonSchema, valibotSchema, config, context) {
+	const referenceId = context.referenceMap.get(valibotSchema);
+	if (referenceId && referenceId in context.definitions) {
+		jsonSchema.$ref = `#/$defs/${referenceId}`;
+		return jsonSchema;
+	}
+	if ("pipe" in valibotSchema) {
+		for (let index = 0; index < valibotSchema.pipe.length; index++) {
+			const valibotPipeItem = valibotSchema.pipe[index];
+			if (valibotPipeItem.kind === "schema") {
+				if (index > 0) handleError("A \"pipe\" with multiple schemas cannot be converted to JSON Schema.", config);
+				const tempJsonSchema = convertSchema({}, valibotPipeItem, config, context);
+				if (tempJsonSchema.$ref) {
+					const referenceId2 = tempJsonSchema.$ref.split("/")[2];
+					Object.assign(jsonSchema, context.definitions[referenceId2]);
+				} else Object.assign(jsonSchema, tempJsonSchema);
+			} else jsonSchema = convertAction(jsonSchema, valibotPipeItem, config);
+		}
+		return jsonSchema;
+	}
+	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 = [];
+			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 jsonSchema.additionalItems = valibotSchema.type === "loose_tuple";
+			break;
+		}
+		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) handleError("The \"record\" schema with a schema for the key that contains a \"pipe\" cannot be converted to JSON Schema.", config);
+			if (valibotSchema.key.type !== "string") handleError(`The "record" schema with the "${valibotSchema.key.type}" schema for the key cannot be converted to JSON Schema.`, config);
+			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") handleError("The value of the \"literal\" schema is not JSON compatible.", config);
+			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")) handleError("An option of the \"picklist\" schema is not JSON compatible.", config);
+			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 referenceId2 = context.referenceMap.get(wrappedValibotSchema);
+			if (!referenceId2) {
+				referenceId2 = `${refCount++}`;
+				context.referenceMap.set(wrappedValibotSchema, referenceId2);
+				context.definitions[referenceId2] = convertSchema({}, wrappedValibotSchema, config, context);
+			}
+			jsonSchema.$ref = `#/$defs/${referenceId2}`;
+			break;
+		}
+		default: handleError(
+			// @ts-expect-error
+			`The "${valibotSchema.type}" schema cannot be converted to JSON Schema.`,
+			config
+);
+	}
+	return jsonSchema;
+}
+function toJsonSchema(schema, config) {
+	const context = {
+		definitions: {},
+		referenceMap: /* @__PURE__ */ new Map(),
+		getterMap: /* @__PURE__ */ new Map()
+	};
+	if (config?.definitions) {
+		for (const key in config.definitions) context.referenceMap.set(config.definitions[key], key);
+		for (const key in config.definitions) context.definitions[key] = convertSchema(
+			{},
+			// @ts-expect-error
+			config.definitions[key],
+			config,
+			context
+);
+	}
+	const jsonSchema = convertSchema(
+		{ $schema: "http://json-schema.org/draft-07/schema#" },
+		// @ts-expect-error
+		schema,
+		config,
+		context
+);
+	if (context.referenceMap.size) jsonSchema.$defs = context.definitions;
+	return jsonSchema;
+}
+var refCount;
+var init_dist$1 = __esm({ "../../node_modules/.pnpm/@valibot+to-json-schema@1.0.0_valibot@1.0.0_typescript@5.8.3_/node_modules/@valibot/to-json-schema/dist/index.js"() {
+	init_dist$2();
+	refCount = 0;
+} });
+
 //#endregion
 //#region src/utils/validator.ts
 function validateCliOptions(options) {
-	let parsed = v.safeParse(CliOptionsSchema, options);
+	let parsed = safeParse(CliOptionsSchema, options);
 	return [parsed.output, parsed.issues?.map((issue) => {
 		const option = issue.path?.map((pathItem) => pathItem.key).join(" ");
 		return `Invalid value for option ${option}: ${issue.message}`;
@@ -464,7 +1773,7 @@ function validateCliOptions(options) {
 }
 function validateOption(key, options) {
 	if (globalThis.process?.env?.ROLLDOWN_OPTIONS_VALIDATION === "loose") return;
-	let parsed = v.safeParse(key === "input" ? InputOptionsSchema : OutputOptionsSchema, options);
+	let parsed = safeParse(key === "input" ? InputOptionsSchema : OutputOptionsSchema, options);
 	if (!parsed.success) {
 		const errors = parsed.issues.map((issue) => {
 			const issuePaths = issue.path.map((path$1) => path$1.key);
@@ -485,209 +1794,211 @@ function validateOption(key, options) {
 	}
 }
 function getInputCliKeys() {
-	return v.keyof(InputCliOptionsSchema).options;
+	return keyof(InputCliOptionsSchema).options;
 }
 function getOutputCliKeys() {
-	return v.keyof(OutputCliOptionsSchema).options;
+	return keyof(OutputCliOptionsSchema).options;
 }
 function getJsonSchema() {
 	return toJsonSchema(CliOptionsSchema);
 }
 var StringOrRegExpSchema, LogLevelSchema, LogLevelOptionSchema, LogLevelWithErrorSchema, RollupLogSchema, RollupLogWithStringSchema, InputOptionSchema, ExternalSchema, ModuleTypesSchema, JsxOptionsSchema, HelperModeSchema, DecoratorOptionSchema, HelpersSchema, RewriteImportExtensionsSchema, TypescriptSchema, AssumptionsSchema, TransformOptionsSchema, WatchOptionsSchema, ChecksOptionsSchema, MinifyOptionsSchema, ResolveOptionsSchema, TreeshakingOptionsSchema, OnLogSchema, OnwarnSchema, HmrSchema, InputOptionsSchema, InputCliOverrideSchema, InputCliOptionsSchema, ESTarget, ModuleFormatSchema, AddonFunctionSchema, ChunkFileNamesSchema, AssetFileNamesSchema, SanitizeFileNameSchema, GlobalsFunctionSchema, AdvancedChunksSchema, OutputOptionsSchema, getAddonDescription, OutputCliOverrideSchema, OutputCliOptionsSchema, CliOptionsSchema, inputHelperMsgRecord, outputHelperMsgRecord;
 var init_validator = __esm({ "src/utils/validator.ts"() {
-	StringOrRegExpSchema = v.union([v.string(), v.instance(RegExp)]);
-	LogLevelSchema = v.union([
-		v.literal("debug"),
-		v.literal("info"),
-		v.literal("warn")
+	init_dist$1();
+	init_dist$2();
+	StringOrRegExpSchema = union([string(), instance(RegExp)]);
+	LogLevelSchema = union([
+		literal("debug"),
+		literal("info"),
+		literal("warn")
 	]);
-	LogLevelOptionSchema = v.union([LogLevelSchema, v.literal("silent")]);
-	LogLevelWithErrorSchema = v.union([LogLevelSchema, v.literal("error")]);
-	RollupLogSchema = v.any();
-	RollupLogWithStringSchema = v.union([RollupLogSchema, v.string()]);
-	InputOptionSchema = v.union([
-		v.string(),
-		v.array(v.string()),
-		v.record(v.string(), v.string())
+	LogLevelOptionSchema = union([LogLevelSchema, literal("silent")]);
+	LogLevelWithErrorSchema = union([LogLevelSchema, literal("error")]);
+	RollupLogSchema = any();
+	RollupLogWithStringSchema = union([RollupLogSchema, string()]);
+	InputOptionSchema = union([
+		string(),
+		array(string()),
+		record(string(), string())
 	]);
-	ExternalSchema = v.union([
+	ExternalSchema = union([
 		StringOrRegExpSchema,
-		v.array(StringOrRegExpSchema),
-		v.pipe(v.function(), v.args(v.tuple([
-			v.string(),
-			v.optional(v.string()),
-			v.boolean()
-		])), v.returns(v.nullish(v.boolean())))
+		array(StringOrRegExpSchema),
+		pipe(function_(), args(tuple([
+			string(),
+			optional(string()),
+			boolean()
+		])), returns(nullish(boolean())))
 	]);
-	ModuleTypesSchema = v.record(v.string(), v.union([
-		v.literal("base64"),
-		v.literal("binary"),
-		v.literal("css"),
-		v.literal("dataurl"),
-		v.literal("empty"),
-		v.literal("js"),
-		v.literal("json"),
-		v.literal("jsx"),
-		v.literal("text"),
-		v.literal("ts"),
-		v.literal("tsx")
+	ModuleTypesSchema = record(string(), union([
+		literal("base64"),
+		literal("binary"),
+		literal("css"),
+		literal("dataurl"),
+		literal("empty"),
+		literal("js"),
+		literal("json"),
+		literal("jsx"),
+		literal("text"),
+		literal("ts"),
+		literal("tsx")
 	]));
-	JsxOptionsSchema = v.strictObject({
-		development: v.pipe(v.optional(v.boolean()), v.description("Development specific information")),
-		factory: v.pipe(v.optional(v.string()), v.description("Jsx element transformation")),
-		fragment: v.pipe(v.optional(v.string()), v.description("Jsx fragment transformation")),
-		importSource: v.pipe(v.optional(v.string()), v.description("Import the factory of element and fragment if mode is classic")),
-		jsxImportSource: v.pipe(v.optional(v.string()), v.description("Import the factory of element and fragment if mode is automatic")),
-		mode: v.pipe(v.optional(v.union([
-			v.literal("classic"),
-			v.literal("automatic"),
-			v.literal("preserve")
-		])), v.description("Jsx transformation mode")),
-		refresh: v.pipe(v.optional(v.boolean()), v.description("React refresh transformation"))
+	JsxOptionsSchema = strictObject({
+		development: pipe(optional(boolean()), description("Development specific information")),
+		factory: pipe(optional(string()), description("Jsx element transformation")),
+		fragment: pipe(optional(string()), description("Jsx fragment transformation")),
+		importSource: pipe(optional(string()), description("Import the factory of element and fragment if mode is classic")),
+		jsxImportSource: pipe(optional(string()), description("Import the factory of element and fragment if mode is automatic")),
+		mode: pipe(optional(union([
+			literal("classic"),
+			literal("automatic"),
+			literal("preserve")
+		])), description("Jsx transformation mode")),
+		refresh: pipe(optional(boolean()), description("React refresh transformation"))
 	});
-	HelperModeSchema = v.union([v.literal("Runtime"), v.literal("External")]);
-	DecoratorOptionSchema = v.object({
-		legacy: v.optional(v.boolean()),
-		emitDecoratorMetadata: v.optional(v.boolean())
+	HelperModeSchema = union([literal("Runtime"), literal("External")]);
+	DecoratorOptionSchema = object({
+		legacy: optional(boolean()),
+		emitDecoratorMetadata: optional(boolean())
 	});
-	HelpersSchema = v.object({ mode: v.optional(HelperModeSchema) });
-	RewriteImportExtensionsSchema = v.union([
-		v.literal("rewrite"),
-		v.literal("remove"),
-		v.boolean()
+	HelpersSchema = object({ mode: optional(HelperModeSchema) });
+	RewriteImportExtensionsSchema = union([
+		literal("rewrite"),
+		literal("remove"),
+		boolean()
 	]);
-	TypescriptSchema = v.object({
-		jsxPragma: v.optional(v.string()),
-		jsxPragmaFrag: v.optional(v.string()),
-		onlyRemoveTypeImports: v.optional(v.boolean()),
-		allowNamespaces: v.optional(v.boolean()),
-		allowDeclareFields: v.optional(v.boolean()),
-		declaration: v.optional(v.object({
-			stripInternal: v.optional(v.boolean()),
-			sourcemap: v.optional(v.boolean())
+	TypescriptSchema = object({
+		jsxPragma: optional(string()),
+		jsxPragmaFrag: optional(string()),
+		onlyRemoveTypeImports: optional(boolean()),
+		allowNamespaces: optional(boolean()),
+		allowDeclareFields: optional(boolean()),
+		declaration: optional(object({
+			stripInternal: optional(boolean()),
+			sourcemap: optional(boolean())
 		})),
-		rewriteImportExtensions: v.optional(RewriteImportExtensionsSchema)
+		rewriteImportExtensions: optional(RewriteImportExtensionsSchema)
 	});
-	AssumptionsSchema = v.object({
-		ignoreFunctionLength: v.optional(v.boolean()),
-		noDocumentAll: v.optional(v.boolean()),
-		objectRestNoSymbols: v.optional(v.boolean()),
-		pureGetters: v.optional(v.boolean()),
-		setPublicClassFields: v.optional(v.boolean())
+	AssumptionsSchema = object({
+		ignoreFunctionLength: optional(boolean()),
+		noDocumentAll: optional(boolean()),
+		objectRestNoSymbols: optional(boolean()),
+		pureGetters: optional(boolean()),
+		setPublicClassFields: optional(boolean())
 	});
-	TransformOptionsSchema = v.object({
-		assumptions: v.optional(AssumptionsSchema),
-		typescript: v.optional(TypescriptSchema),
-		helpers: v.optional(HelpersSchema),
-		decorators: v.optional(DecoratorOptionSchema)
+	TransformOptionsSchema = object({
+		assumptions: optional(AssumptionsSchema),
+		typescript: optional(TypescriptSchema),
+		helpers: optional(HelpersSchema),
+		decorators: optional(DecoratorOptionSchema)
 	});
-	WatchOptionsSchema = v.strictObject({
-		chokidar: v.optional(v.never(`The "watch.chokidar" option is deprecated, please use "watch.notify" instead of it`)),
-		exclude: v.optional(v.union([StringOrRegExpSchema, v.array(StringOrRegExpSchema)])),
-		include: v.optional(v.union([StringOrRegExpSchema, v.array(StringOrRegExpSchema)])),
-		notify: v.pipe(v.optional(v.strictObject({
-			compareContents: v.optional(v.boolean()),
-			pollInterval: v.optional(v.number())
-		})), v.description("Notify options")),
-		skipWrite: v.pipe(v.optional(v.boolean()), v.description("Skip the bundle.write() step")),
-		buildDelay: v.pipe(v.optional(v.number()), v.description("Throttle watch rebuilds"))
+	WatchOptionsSchema = strictObject({
+		chokidar: optional(never(`The "watch.chokidar" option is deprecated, please use "watch.notify" instead of it`)),
+		exclude: optional(union([StringOrRegExpSchema, array(StringOrRegExpSchema)])),
+		include: optional(union([StringOrRegExpSchema, array(StringOrRegExpSchema)])),
+		notify: pipe(optional(strictObject({
+			compareContents: optional(boolean()),
+			pollInterval: optional(number())
+		})), description("Notify options")),
+		skipWrite: pipe(optional(boolean()), description("Skip the bundle.write() step")),
+		buildDelay: pipe(optional(number()), description("Throttle watch rebuilds"))
 	});
-	ChecksOptionsSchema = v.strictObject({
-		circularDependency: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting circular dependency")),
-		eval: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting eval")),
-		missingGlobalName: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting missing global name")),
-		missingNameOptionForIifeExport: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting missing name option for iife export")),
-		mixedExport: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting mixed export")),
-		unresolvedEntry: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting unresolved entry")),
-		unresolvedImport: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting unresolved import")),
-		filenameConflict: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting filename conflict")),
-		commonJsVariableInEsm: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting common js variable in esm")),
-		importIsUndefined: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting import is undefined")),
-		configurationFieldConflict: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting configuration field conflict"))
+	ChecksOptionsSchema = strictObject({
+		circularDependency: pipe(optional(boolean()), description("Whether to emit warning when detecting circular dependency")),
+		eval: pipe(optional(boolean()), description("Whether to emit warning when detecting eval")),
+		missingGlobalName: pipe(optional(boolean()), description("Whether to emit warning when detecting missing global name")),
+		missingNameOptionForIifeExport: pipe(optional(boolean()), description("Whether to emit warning when detecting missing name option for iife export")),
+		mixedExport: pipe(optional(boolean()), description("Whether to emit warning when detecting mixed export")),
+		unresolvedEntry: pipe(optional(boolean()), description("Whether to emit warning when detecting unresolved entry")),
+		unresolvedImport: pipe(optional(boolean()), description("Whether to emit warning when detecting unresolved import")),
+		filenameConflict: pipe(optional(boolean()), description("Whether to emit warning when detecting filename conflict")),
+		commonJsVariableInEsm: pipe(optional(boolean()), description("Whether to emit warning when detecting common js variable in esm")),
+		importIsUndefined: pipe(optional(boolean()), description("Whether to emit warning when detecting import is undefined")),
+		configurationFieldConflict: pipe(optional(boolean()), description("Whether to emit warning when detecting configuration field conflict"))
 	});
-	MinifyOptionsSchema = v.strictObject({
-		mangle: v.optional(v.boolean()),
-		compress: v.optional(v.boolean()),
-		removeWhitespace: v.optional(v.boolean())
+	MinifyOptionsSchema = strictObject({
+		mangle: optional(boolean()),
+		compress: optional(boolean()),
+		removeWhitespace: optional(boolean())
 	});
-	ResolveOptionsSchema = v.strictObject({
-		alias: v.optional(v.record(v.string(), v.union([v.string(), v.array(v.string())]))),
-		aliasFields: v.optional(v.array(v.array(v.string()))),
-		conditionNames: v.optional(v.array(v.string())),
-		extensionAlias: v.optional(v.record(v.string(), v.array(v.string()))),
-		exportsFields: v.optional(v.array(v.array(v.string()))),
-		extensions: v.optional(v.array(v.string())),
-		mainFields: v.optional(v.array(v.string())),
-		mainFiles: v.optional(v.array(v.string())),
-		modules: v.optional(v.array(v.string())),
-		symlinks: v.optional(v.boolean()),
-		tsconfigFilename: v.optional(v.string())
+	ResolveOptionsSchema = strictObject({
+		alias: optional(record(string(), union([string(), array(string())]))),
+		aliasFields: optional(array(array(string()))),
+		conditionNames: optional(array(string())),
+		extensionAlias: optional(record(string(), array(string()))),
+		exportsFields: optional(array(array(string()))),
+		extensions: optional(array(string())),
+		mainFields: optional(array(string())),
+		mainFiles: optional(array(string())),
+		modules: optional(array(string())),
+		symlinks: optional(boolean()),
+		tsconfigFilename: optional(string())
 	});
-	TreeshakingOptionsSchema = v.union([v.boolean(), v.looseObject({
-		annotations: v.optional(v.boolean()),
-		manualPureFunctions: v.optional(v.array(v.string())),
-		unknownGlobalSideEffects: v.optional(v.boolean())
+	TreeshakingOptionsSchema = union([boolean(), looseObject({
+		annotations: optional(boolean()),
+		manualPureFunctions: optional(array(string())),
+		unknownGlobalSideEffects: optional(boolean())
 	})]);
-	OnLogSchema = v.pipe(v.function(), v.args(v.tuple([
+	OnLogSchema = pipe(function_(), args(tuple([
 		LogLevelSchema,
 		RollupLogSchema,
-		v.pipe(v.function(), v.args(v.tuple([LogLevelWithErrorSchema, RollupLogWithStringSchema])))
+		pipe(function_(), args(tuple([LogLevelWithErrorSchema, RollupLogWithStringSchema])))
 	])));
-	OnwarnSchema = v.pipe(v.function(), v.args(v.tuple([RollupLogSchema, v.pipe(v.function(), v.args(v.tuple([v.union([RollupLogWithStringSchema, v.pipe(v.function(), v.returns(RollupLogWithStringSchema))])])))])));
-	HmrSchema = v.union([v.boolean(), v.strictObject({
-		port: v.optional(v.number()),
-		host: v.optional(v.string()),
-		implement: v.optional(v.string())
+	OnwarnSchema = pipe(function_(), args(tuple([RollupLogSchema, pipe(function_(), args(tuple([union([RollupLogWithStringSchema, pipe(function_(), returns(RollupLogWithStringSchema))])])))])));
+	HmrSchema = union([boolean(), strictObject({
+		port: optional(number()),
+		host: optional(string()),
+		implement: optional(string())
 	})]);
-	InputOptionsSchema = v.strictObject({
-		input: v.optional(InputOptionSchema),
-		plugins: v.optional(v.custom(() => true)),
-		external: v.optional(ExternalSchema),
-		resolve: v.optional(ResolveOptionsSchema),
-		cwd: v.pipe(v.optional(v.string()), v.description("Current working directory")),
-		platform: v.pipe(v.optional(v.union([
-			v.literal("browser"),
-			v.literal("neutral"),
-			v.literal("node")
-		])), v.description(`Platform for which the code should be generated (node, ${colors.underline("browser")}, neutral)`)),
-		shimMissingExports: v.pipe(v.optional(v.boolean()), v.description("Create shim variables for missing exports")),
-		treeshake: v.optional(TreeshakingOptionsSchema),
-		logLevel: v.pipe(v.optional(LogLevelOptionSchema), v.description(`Log level (${colors.dim("silent")}, ${colors.underline(colors.gray("info"))}, debug, ${colors.yellow("warn")})`)),
-		onLog: v.optional(OnLogSchema),
-		onwarn: v.optional(OnwarnSchema),
-		moduleTypes: v.pipe(v.optional(ModuleTypesSchema), v.description("Module types for customized extensions")),
-		experimental: v.optional(v.strictObject({
-			disableLiveBindings: v.optional(v.boolean()),
-			enableComposingJsPlugins: v.optional(v.boolean()),
-			resolveNewUrlToAsset: v.optional(v.boolean()),
-			strictExecutionOrder: v.optional(v.boolean()),
-			hmr: v.optional(HmrSchema)
+	InputOptionsSchema = strictObject({
+		input: optional(InputOptionSchema),
+		plugins: optional(custom(() => true)),
+		external: optional(ExternalSchema),
+		resolve: optional(ResolveOptionsSchema),
+		cwd: pipe(optional(string()), description("Current working directory")),
+		platform: pipe(optional(union([
+			literal("browser"),
+			literal("neutral"),
+			literal("node")
+		])), description(`Platform for which the code should be generated (node, ${colors.underline("browser")}, neutral)`)),
+		shimMissingExports: pipe(optional(boolean()), description("Create shim variables for missing exports")),
+		treeshake: optional(TreeshakingOptionsSchema),
+		logLevel: pipe(optional(LogLevelOptionSchema), description(`Log level (${colors.dim("silent")}, ${colors.underline(colors.gray("info"))}, debug, ${colors.yellow("warn")})`)),
+		onLog: optional(OnLogSchema),
+		onwarn: optional(OnwarnSchema),
+		moduleTypes: pipe(optional(ModuleTypesSchema), description("Module types for customized extensions")),
+		experimental: optional(strictObject({
+			disableLiveBindings: optional(boolean()),
+			enableComposingJsPlugins: optional(boolean()),
+			resolveNewUrlToAsset: optional(boolean()),
+			strictExecutionOrder: optional(boolean()),
+			hmr: optional(HmrSchema)
 		})),
-		define: v.pipe(v.optional(v.record(v.string(), v.string())), v.description("Define global variables")),
-		inject: v.optional(v.record(v.string(), v.union([v.string(), v.tuple([v.string(), v.string()])]))),
-		profilerNames: v.optional(v.boolean()),
-		jsx: v.optional(v.union([
-			v.boolean(),
+		define: pipe(optional(record(string(), string())), description("Define global variables")),
+		inject: optional(record(string(), union([string(), tuple([string(), string()])]))),
+		profilerNames: optional(boolean()),
+		jsx: optional(union([
+			boolean(),
 			JsxOptionsSchema,
-			v.string("react"),
-			v.string("react-jsx"),
-			v.string("preserve")
+			string("react"),
+			string("react-jsx"),
+			string("preserve")
 		])),
-		transform: v.optional(TransformOptionsSchema),
-		watch: v.optional(v.union([WatchOptionsSchema, v.literal(false)])),
-		dropLabels: v.pipe(v.optional(v.array(v.string())), v.description("Remove labeled statements with these label names")),
-		checks: v.optional(ChecksOptionsSchema),
-		keepNames: v.pipe(v.optional(v.boolean()), v.description("Keep function/class name")),
-		debug: v.pipe(v.optional(v.object({ sessionId: v.pipe(v.optional(v.string()), v.description("Used to name the build.")) })), v.description("Enable debug mode. Emit debug information to disk. This might slow down the build process significantly."))
+		transform: optional(TransformOptionsSchema),
+		watch: optional(union([WatchOptionsSchema, literal(false)])),
+		dropLabels: pipe(optional(array(string())), description("Remove labeled statements with these label names")),
+		checks: optional(ChecksOptionsSchema),
+		keepNames: pipe(optional(boolean()), description("Keep function/class name")),
+		debug: pipe(optional(object({ sessionId: pipe(optional(string()), description("Used to name the build.")) })), description("Enable debug mode. Emit debug information to disk. This might slow down the build process significantly."))
 	});
-	InputCliOverrideSchema = v.strictObject({
-		input: v.pipe(v.optional(v.array(v.string())), v.description("Entry file")),
-		external: v.pipe(v.optional(v.array(v.string())), v.description("Comma-separated list of module ids to exclude from the bundle `<module-id>,...`")),
-		inject: v.pipe(v.optional(v.record(v.string(), v.string())), v.description("Inject import statements on demand")),
-		treeshake: v.pipe(v.optional(v.boolean()), v.description("enable treeshaking")),
-		jsx: v.pipe(v.optional(JsxOptionsSchema), v.description("enable jsx"))
+	InputCliOverrideSchema = strictObject({
+		input: pipe(optional(array(string())), description("Entry file")),
+		external: pipe(optional(array(string())), description("Comma-separated list of module ids to exclude from the bundle `<module-id>,...`")),
+		inject: pipe(optional(record(string(), string())), description("Inject import statements on demand")),
+		treeshake: pipe(optional(boolean()), description("enable treeshaking")),
+		jsx: pipe(optional(JsxOptionsSchema), description("enable jsx"))
 	});
-	InputCliOptionsSchema = v.omit(v.strictObject({
+	InputCliOptionsSchema = omit(strictObject({
 		...InputOptionsSchema.entries,
 		...InputCliOverrideSchema.entries
 	}), [
@@ -714,87 +2025,87 @@ var init_validator = __esm({ "src/utils/validator.ts"() {
 		ESTarget$1["ESNext"] = "esnext";
 		return ESTarget$1;
 	}(ESTarget || {});
-	ModuleFormatSchema = v.union([
-		v.literal("es"),
-		v.literal("cjs"),
-		v.literal("esm"),
-		v.literal("module"),
-		v.literal("commonjs"),
-		v.literal("iife"),
-		v.literal("umd")
+	ModuleFormatSchema = union([
+		literal("es"),
+		literal("cjs"),
+		literal("esm"),
+		literal("module"),
+		literal("commonjs"),
+		literal("iife"),
+		literal("umd")
 	]);
-	AddonFunctionSchema = v.pipe(v.function(), v.args(v.tuple([v.custom(() => true)])), v.returnsAsync(v.unionAsync([v.string(), v.pipeAsync(v.promise(), v.awaitAsync(), v.string())])));
-	ChunkFileNamesSchema = v.union([v.string(), v.pipe(v.function(), v.args(v.tuple([v.custom(() => true)])), v.returns(v.string()))]);
-	AssetFileNamesSchema = v.union([v.string(), v.pipe(v.function(), v.args(v.tuple([v.custom(() => true)])), v.returns(v.string()))]);
-	SanitizeFileNameSchema = v.union([v.boolean(), v.pipe(v.function(), v.args(v.tuple([v.string()])), v.returns(v.string()))]);
-	GlobalsFunctionSchema = v.pipe(v.function(), v.args(v.tuple([v.string()])), v.returns(v.string()));
-	AdvancedChunksSchema = v.strictObject({
-		minSize: v.optional(v.number()),
-		maxSize: v.optional(v.number()),
-		minModuleSize: v.optional(v.number()),
-		maxModuleSize: v.optional(v.number()),
-		minShareCount: v.optional(v.number()),
-		groups: v.optional(v.array(v.strictObject({
-			name: v.string(),
-			test: v.optional(v.union([v.string(), v.instance(RegExp)])),
-			priority: v.optional(v.number()),
-			minSize: v.optional(v.number()),
-			minShareCount: v.optional(v.number()),
-			maxSize: v.optional(v.number()),
-			minModuleSize: v.optional(v.number()),
-			maxModuleSize: v.optional(v.number())
+	AddonFunctionSchema = pipe(function_(), args(tuple([custom(() => true)])), returnsAsync(unionAsync([string(), pipeAsync(promise(), awaitAsync(), string())])));
+	ChunkFileNamesSchema = union([string(), pipe(function_(), args(tuple([custom(() => true)])), returns(string()))]);
+	AssetFileNamesSchema = union([string(), pipe(function_(), args(tuple([custom(() => true)])), returns(string()))]);
+	SanitizeFileNameSchema = union([boolean(), pipe(function_(), args(tuple([string()])), returns(string()))]);
+	GlobalsFunctionSchema = pipe(function_(), args(tuple([string()])), returns(string()));
+	AdvancedChunksSchema = strictObject({
+		minSize: optional(number()),
+		maxSize: optional(number()),
+		minModuleSize: optional(number()),
+		maxModuleSize: optional(number()),
+		minShareCount: optional(number()),
+		groups: optional(array(strictObject({
+			name: string(),
+			test: optional(union([string(), instance(RegExp)])),
+			priority: optional(number()),
+			minSize: optional(number()),
+			minShareCount: optional(number()),
+			maxSize: optional(number()),
+			minModuleSize: optional(number()),
+			maxModuleSize: optional(number())
 		})))
 	});
-	OutputOptionsSchema = v.strictObject({
-		dir: v.pipe(v.optional(v.string()), v.description("Output directory, defaults to `dist` if `file` is not set")),
-		file: v.pipe(v.optional(v.string()), v.description("Single output file")),
-		exports: v.pipe(v.optional(v.union([
-			v.literal("auto"),
-			v.literal("named"),
-			v.literal("default"),
-			v.literal("none")
-		])), v.description(`Specify a export mode (${colors.underline("auto")}, named, default, none)`)),
-		hashCharacters: v.pipe(v.optional(v.union([
-			v.literal("base64"),
-			v.literal("base36"),
-			v.literal("hex")
-		])), v.description("Use the specified character set for file hashes")),
-		format: v.pipe(v.optional(ModuleFormatSchema), v.description(`Output format of the generated bundle (supports ${colors.underline("esm")}, cjs, and iife)`)),
-		sourcemap: v.pipe(v.optional(v.union([
-			v.boolean(),
-			v.literal("inline"),
-			v.literal("hidden")
-		])), v.description(`Generate sourcemap (\`-s inline\` for inline, or ${colors.bold("pass the `-s` on the last argument if you want to generate `.map` file")})`)),
-		sourcemapDebugIds: v.pipe(v.optional(v.boolean()), v.description("Inject sourcemap debug IDs")),
-		sourcemapIgnoreList: v.optional(v.union([v.boolean(), v.custom(() => true)])),
-		sourcemapPathTransform: v.optional(v.custom(() => true)),
-		banner: v.optional(v.union([v.string(), AddonFunctionSchema])),
-		footer: v.optional(v.union([v.string(), AddonFunctionSchema])),
-		intro: v.optional(v.union([v.string(), AddonFunctionSchema])),
-		outro: v.optional(v.union([v.string(), AddonFunctionSchema])),
-		extend: v.pipe(v.optional(v.boolean()), v.description("Extend global variable defined by name in IIFE / UMD formats")),
-		esModule: v.optional(v.union([v.boolean(), v.literal("if-default-prop")])),
-		assetFileNames: v.optional(AssetFileNamesSchema),
-		entryFileNames: v.optional(ChunkFileNamesSchema),
-		chunkFileNames: v.optional(ChunkFileNamesSchema),
-		cssEntryFileNames: v.optional(ChunkFileNamesSchema),
-		cssChunkFileNames: v.optional(ChunkFileNamesSchema),
-		sanitizeFileName: v.optional(SanitizeFileNameSchema),
-		minify: v.pipe(v.optional(v.union([
-			v.boolean(),
-			v.string("dce-only"),
+	OutputOptionsSchema = strictObject({
+		dir: pipe(optional(string()), description("Output directory, defaults to `dist` if `file` is not set")),
+		file: pipe(optional(string()), description("Single output file")),
+		exports: pipe(optional(union([
+			literal("auto"),
+			literal("named"),
+			literal("default"),
+			literal("none")
+		])), description(`Specify a export mode (${colors.underline("auto")}, named, default, none)`)),
+		hashCharacters: pipe(optional(union([
+			literal("base64"),
+			literal("base36"),
+			literal("hex")
+		])), description("Use the specified character set for file hashes")),
+		format: pipe(optional(ModuleFormatSchema), description(`Output format of the generated bundle (supports ${colors.underline("esm")}, cjs, and iife)`)),
+		sourcemap: pipe(optional(union([
+			boolean(),
+			literal("inline"),
+			literal("hidden")
+		])), description(`Generate sourcemap (\`-s inline\` for inline, or ${colors.bold("pass the `-s` on the last argument if you want to generate `.map` file")})`)),
+		sourcemapDebugIds: pipe(optional(boolean()), description("Inject sourcemap debug IDs")),
+		sourcemapIgnoreList: optional(union([boolean(), custom(() => true)])),
+		sourcemapPathTransform: optional(custom(() => true)),
+		banner: optional(union([string(), AddonFunctionSchema])),
+		footer: optional(union([string(), AddonFunctionSchema])),
+		intro: optional(union([string(), AddonFunctionSchema])),
+		outro: optional(union([string(), AddonFunctionSchema])),
+		extend: pipe(optional(boolean()), description("Extend global variable defined by name in IIFE / UMD formats")),
+		esModule: optional(union([boolean(), literal("if-default-prop")])),
+		assetFileNames: optional(AssetFileNamesSchema),
+		entryFileNames: optional(ChunkFileNamesSchema),
+		chunkFileNames: optional(ChunkFileNamesSchema),
+		cssEntryFileNames: optional(ChunkFileNamesSchema),
+		cssChunkFileNames: optional(ChunkFileNamesSchema),
+		sanitizeFileName: optional(SanitizeFileNameSchema),
+		minify: pipe(optional(union([
+			boolean(),
+			string("dce-only"),
 			MinifyOptionsSchema
-		])), v.description("Minify the bundled file")),
-		name: v.pipe(v.optional(v.string()), v.description("Name for UMD / IIFE format outputs")),
-		globals: v.pipe(v.optional(v.union([v.record(v.string(), v.string()), GlobalsFunctionSchema])), v.description("Global variable of UMD / IIFE dependencies (syntax: `key=value`)")),
-		externalLiveBindings: v.pipe(v.optional(v.boolean()), v.description("external live bindings")),
-		inlineDynamicImports: v.pipe(v.optional(v.boolean()), v.description("Inline dynamic imports")),
-		advancedChunks: v.optional(AdvancedChunksSchema),
-		comments: v.pipe(v.optional(v.union([v.literal("none"), v.literal("preserve-legal")])), v.description("Control comments in the output")),
-		plugins: v.optional(v.custom(() => true)),
-		polyfillRequire: v.pipe(v.optional(v.boolean()), v.description("Disable require polyfill injection")),
-		target: v.pipe(v.optional(v.enum(ESTarget)), v.description("The JavaScript target environment")),
-		hoistTransitiveImports: v.optional(v.custom((input) => {
+		])), description("Minify the bundled file")),
+		name: pipe(optional(string()), description("Name for UMD / IIFE format outputs")),
+		globals: pipe(optional(union([record(string(), string()), GlobalsFunctionSchema])), description("Global variable of UMD / IIFE dependencies (syntax: `key=value`)")),
+		externalLiveBindings: pipe(optional(boolean()), description("external live bindings")),
+		inlineDynamicImports: pipe(optional(boolean()), description("Inline dynamic imports")),
+		advancedChunks: optional(AdvancedChunksSchema),
+		comments: pipe(optional(union([literal("none"), literal("preserve-legal")])), description("Control comments in the output")),
+		plugins: optional(custom(() => true)),
+		polyfillRequire: pipe(optional(boolean()), description("Disable require polyfill injection")),
+		target: pipe(optional(enum_(ESTarget)), description("The JavaScript target environment")),
+		hoistTransitiveImports: optional(custom((input) => {
 			if (input) return false;
 			return true;
 		}, () => `The 'true' value is not supported`))
@@ -802,26 +2113,26 @@ var init_validator = __esm({ "src/utils/validator.ts"() {
 	getAddonDescription = (placement, wrapper) => {
 		return `Code to insert the ${colors.bold(placement)} of the bundled file (${colors.bold(wrapper)} the wrapper function)`;
 	};
-	OutputCliOverrideSchema = v.strictObject({
-		assetFileNames: v.pipe(v.optional(v.string()), v.description("Name pattern for asset files")),
-		entryFileNames: v.pipe(v.optional(v.string()), v.description("Name pattern for emitted entry chunks")),
-		chunkFileNames: v.pipe(v.optional(v.string()), v.description("Name pattern for emitted secondary chunks")),
-		cssEntryFileNames: v.pipe(v.optional(v.string()), v.description("Name pattern for emitted css entry chunks")),
-		cssChunkFileNames: v.pipe(v.optional(v.string()), v.description("Name pattern for emitted css secondary chunks")),
-		sanitizeFileName: v.pipe(v.optional(v.boolean()), v.description("Sanitize file name")),
-		banner: v.pipe(v.optional(v.string()), v.description(getAddonDescription("top", "outside"))),
-		footer: v.pipe(v.optional(v.string()), v.description(getAddonDescription("bottom", "outside"))),
-		intro: v.pipe(v.optional(v.string()), v.description(getAddonDescription("top", "inside"))),
-		outro: v.pipe(v.optional(v.string()), v.description(getAddonDescription("bottom", "inside"))),
-		esModule: v.pipe(v.optional(v.boolean()), v.description("Always generate `__esModule` marks in non-ESM formats, defaults to `if-default-prop` (use `--no-esModule` to always disable)")),
-		globals: v.pipe(v.optional(v.record(v.string(), v.string())), v.description("Global variable of UMD / IIFE dependencies (syntax: `key=value`)")),
-		advancedChunks: v.pipe(v.optional(v.strictObject({
-			minSize: v.pipe(v.optional(v.number()), v.description("Minimum size of the chunk")),
-			minShareCount: v.pipe(v.optional(v.number()), v.description("Minimum share count of the chunk"))
-		})), v.description("Global variable of UMD / IIFE dependencies (syntax: `key=value`)")),
-		minify: v.pipe(v.optional(v.boolean()), v.description("Minify the bundled file"))
+	OutputCliOverrideSchema = strictObject({
+		assetFileNames: pipe(optional(string()), description("Name pattern for asset files")),
+		entryFileNames: pipe(optional(string()), description("Name pattern for emitted entry chunks")),
+		chunkFileNames: pipe(optional(string()), description("Name pattern for emitted secondary chunks")),
+		cssEntryFileNames: pipe(optional(string()), description("Name pattern for emitted css entry chunks")),
+		cssChunkFileNames: pipe(optional(string()), description("Name pattern for emitted css secondary chunks")),
+		sanitizeFileName: pipe(optional(boolean()), description("Sanitize file name")),
+		banner: pipe(optional(string()), description(getAddonDescription("top", "outside"))),
+		footer: pipe(optional(string()), description(getAddonDescription("bottom", "outside"))),
+		intro: pipe(optional(string()), description(getAddonDescription("top", "inside"))),
+		outro: pipe(optional(string()), description(getAddonDescription("bottom", "inside"))),
+		esModule: pipe(optional(boolean()), description("Always generate `__esModule` marks in non-ESM formats, defaults to `if-default-prop` (use `--no-esModule` to always disable)")),
+		globals: pipe(optional(record(string(), string())), description("Global variable of UMD / IIFE dependencies (syntax: `key=value`)")),
+		advancedChunks: pipe(optional(strictObject({
+			minSize: pipe(optional(number()), description("Minimum size of the chunk")),
+			minShareCount: pipe(optional(number()), description("Minimum share count of the chunk"))
+		})), description("Global variable of UMD / IIFE dependencies (syntax: `key=value`)")),
+		minify: pipe(optional(boolean()), description("Minify the bundled file"))
 	});
-	OutputCliOptionsSchema = v.omit(v.strictObject({
+	OutputCliOptionsSchema = omit(strictObject({
 		...OutputOptionsSchema.entries,
 		...OutputCliOverrideSchema.entries
 	}), [
@@ -830,11 +2141,11 @@ var init_validator = __esm({ "src/utils/validator.ts"() {
 		"plugins",
 		"hoistTransitiveImports"
 	]);
-	CliOptionsSchema = v.strictObject({
-		config: v.pipe(v.optional(v.union([v.string(), v.boolean()])), v.description("Path to the config file (default: `rolldown.config.js`)")),
-		help: v.pipe(v.optional(v.boolean()), v.description("Show help")),
-		version: v.pipe(v.optional(v.boolean()), v.description("Show version number")),
-		watch: v.pipe(v.optional(v.boolean()), v.description("Watch files in bundle and rebuild on changes")),
+	CliOptionsSchema = strictObject({
+		config: pipe(optional(union([string(), boolean()])), description("Path to the config file (default: `rolldown.config.js`)")),
+		help: pipe(optional(boolean()), description("Show help")),
+		version: pipe(optional(boolean()), description("Show version number")),
+		watch: pipe(optional(boolean()), description("Watch files in bundle and rebuild on changes")),
 		...InputCliOptionsSchema.entries,
 		...OutputCliOptionsSchema.entries
 	});
@@ -982,9 +2293,9 @@ var init_transform_side_effects = __esm({ "src/utils/transform-side-effects.ts"(
 
 //#endregion
 //#region src/utils/transform-sourcemap.ts
-function isEmptySourcemapFiled(array) {
-	if (!array) return true;
-	if (array.length === 0 || !array[0]) return true;
+function isEmptySourcemapFiled(array$1) {
+	if (!array$1) return true;
+	if (array$1.length === 0 || !array$1[0]) return true;
 	return false;
 }
 function normalizeTransformHookSourcemap(id$1, originalCode, rawMap) {
@@ -2209,14 +3520,16 @@ var init_dist = __esm({ "../../node_modules/.pnpm/remeda@2.21.2/node_modules/rem
 //#endregion
 //#region src/plugin/bindingify-hook-filter.ts
 function generalHookFilterMatcherToFilterExprs(matcher, stringKind) {
-	if (typeof matcher === "string" || matcher instanceof RegExp) return [include(id(matcher))];
-	if (Array.isArray(matcher)) return matcher.map((m$10) => include(id(m$10)));
+	if (typeof matcher === "string" || matcher instanceof RegExp) return [include(generateAtomMatcher(stringKind, matcher))];
+	if (Array.isArray(matcher)) return matcher.map((m$10) => include(generateAtomMatcher(stringKind, m$10)));
 	let ret = [];
-	let isCode = stringKind === "code";
-	if (matcher.exclude) ret.push(...arraify(matcher.exclude).map((m$10) => exclude(isCode ? code(m$10) : id(m$10))));
-	if (matcher.include) ret.push(...arraify(matcher.include).map((m$10) => include(isCode ? code(m$10) : id(m$10))));
+	if (matcher.exclude) ret.push(...arraify(matcher.exclude).map((m$10) => exclude(generateAtomMatcher(stringKind, m$10))));
+	if (matcher.include) ret.push(...arraify(matcher.include).map((m$10) => include(generateAtomMatcher(stringKind, m$10))));
 	return ret;
 }
+function generateAtomMatcher(kind, matcher) {
+	return kind === "code" ? code(matcher) : id(matcher);
+}
 function transformFilterMatcherToFilterExprs(filterOption) {
 	if (!filterOption) return void 0;
 	if (Array.isArray(filterOption)) return filterOption;
@@ -2254,20 +3567,20 @@ function bindingifyFilterExpr(expr) {
 function bindingifyFilterExprImpl(expr, list) {
 	switch (expr.kind) {
 		case "and": {
-			let args = expr.args;
-			for (let i$22 = args.length - 1; i$22 >= 0; i$22--) bindingifyFilterExprImpl(args[i$22], list);
+			let args$1 = expr.args;
+			for (let i$22 = args$1.length - 1; i$22 >= 0; i$22--) bindingifyFilterExprImpl(args$1[i$22], list);
 			list.push({
 				kind: "And",
-				payload: args.length
+				payload: args$1.length
 			});
 			break;
 		}
 		case "or": {
-			let args = expr.args;
-			for (let i$22 = args.length - 1; i$22 >= 0; i$22--) bindingifyFilterExprImpl(args[i$22], list);
+			let args$1 = expr.args;
+			for (let i$22 = args$1.length - 1; i$22 >= 0; i$22--) bindingifyFilterExprImpl(args$1[i$22], list);
 			list.push({
 				kind: "Or",
-				payload: args.length
+				payload: args$1.length
 			});
 			break;
 		}
@@ -2400,10 +3713,10 @@ var init_plugin_context = __esm({ "src/plugin/plugin-context.ts"() {
 			async function createLoadModulePromise(context, data) {
 				const loadPromise = data.loadModulePromiseMap.get(id$1);
 				if (loadPromise) return loadPromise;
-				const promise = new Promise((resolve, _) => {
+				const promise$1 = new Promise((resolve, _) => {
 					data.loadModulePromiseResolveFnMap.set(id$1, resolve);
 				});
-				data.loadModulePromiseMap.set(id$1, promise);
+				data.loadModulePromiseMap.set(id$1, promise$1);
 				try {
 					await context.load(id$1, bindingifySideEffects(options.moduleSideEffects));
 				} catch (e$5) {
@@ -2411,7 +3724,7 @@ var init_plugin_context = __esm({ "src/plugin/plugin-context.ts"() {
 					data.loadModulePromiseResolveFnMap.delete(id$1);
 					throw e$5;
 				}
-				return promise;
+				return promise$1;
 			}
 			await createLoadModulePromise(this.context, this.data);
 			return this.data.getModuleInfo(id$1, this.context);
@@ -2505,41 +3818,41 @@ var init_transform_plugin_context = __esm({ "src/plugin/transform-plugin-context
 
 //#endregion
 //#region src/plugin/bindingify-build-hooks.ts
-function bindingifyBuildStart(args) {
-	const hook = args.plugin.buildStart;
+function bindingifyBuildStart(args$1) {
+	const hook = args$1.plugin.buildStart;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, opts) => {
-			await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), new NormalizedInputOptionsImpl(opts, args.onLog));
+			await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), new NormalizedInputOptionsImpl(opts, args$1.onLog));
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
 }
-function bindingifyBuildEnd(args) {
-	const hook = args.plugin.buildEnd;
+function bindingifyBuildEnd(args$1) {
+	const hook = args$1.plugin.buildEnd;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, err) => {
-			await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), err ? normalizeErrors(err) : void 0);
+			await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), err ? normalizeErrors(err) : void 0);
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
 }
-function bindingifyResolveId(args) {
-	const hook = args.plugin.resolveId;
+function bindingifyResolveId(args$1) {
+	const hook = args$1.plugin.resolveId;
 	if (!hook) return {};
 	const { handler, meta, options } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, specifier, importer, extraOptions) => {
-			const contextResolveOptions = extraOptions.custom != null ? args.pluginContextData.getSavedResolveOptions(extraOptions.custom) : void 0;
+			const contextResolveOptions = extraOptions.custom != null ? args$1.pluginContextData.getSavedResolveOptions(extraOptions.custom) : void 0;
 			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 PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), specifier, importer ?? void 0, newExtraOptions);
+			const ret = await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), specifier, importer ?? void 0, newExtraOptions);
 			if (ret == null) return;
 			if (ret === false) return {
 				id: specifier,
@@ -2550,7 +3863,7 @@ function bindingifyResolveId(args) {
 				id: ret,
 				normalizeExternalId: true
 			};
-			let exist = args.pluginContextData.updateModuleOption(ret.id, {
+			let exist = args$1.pluginContextData.updateModuleOption(ret.id, {
 				meta: ret.meta || {},
 				moduleSideEffects: ret.moduleSideEffects ?? null,
 				invalidate: false
@@ -2566,13 +3879,13 @@ function bindingifyResolveId(args) {
 		filter: bindingifyResolveIdFilter(options.filter)
 	};
 }
-function bindingifyResolveDynamicImport(args) {
-	const hook = args.plugin.resolveDynamicImport;
+function bindingifyResolveDynamicImport(args$1) {
+	const hook = args$1.plugin.resolveDynamicImport;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, specifier, importer) => {
-			const ret = await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), specifier, importer ?? void 0);
+			const ret = await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), specifier, importer ?? void 0);
 			if (ret == null) return;
 			if (ret === false) return {
 				id: specifier,
@@ -2584,7 +3897,7 @@ function bindingifyResolveDynamicImport(args) {
 				external: ret.external
 			};
 			if (ret.moduleSideEffects !== null) result.sideEffects = bindingifySideEffects(ret.moduleSideEffects);
-			args.pluginContextData.updateModuleOption(ret.id, {
+			args$1.pluginContextData.updateModuleOption(ret.id, {
 				meta: ret.meta || {},
 				moduleSideEffects: ret.moduleSideEffects || null,
 				invalidate: false
@@ -2594,16 +3907,16 @@ function bindingifyResolveDynamicImport(args) {
 		meta: bindingifyPluginHookMeta(meta)
 	};
 }
-function bindingifyTransform(args) {
-	const hook = args.plugin.transform;
+function bindingifyTransform(args$1) {
+	const hook = args$1.plugin.transform;
 	if (!hook) return {};
 	const { handler, meta, options } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, code$1, id$1, meta$1) => {
-			const ret = await handler.call(new TransformPluginContextImpl(args.outputOptions, ctx.inner(), args.plugin, args.pluginContextData, ctx, id$1, code$1, args.onLog, args.logLevel, args.watchMode), code$1, id$1, meta$1);
+			const ret = await handler.call(new TransformPluginContextImpl(args$1.outputOptions, ctx.inner(), args$1.plugin, args$1.pluginContextData, ctx, id$1, code$1, args$1.onLog, args$1.logLevel, args$1.watchMode), code$1, id$1, meta$1);
 			if (ret == null) return void 0;
 			if (typeof ret === "string") return { code: ret };
-			let moduleOption = args.pluginContextData.updateModuleOption(id$1, {
+			let moduleOption = args$1.pluginContextData.updateModuleOption(id$1, {
 				meta: ret.meta ?? {},
 				moduleSideEffects: ret.moduleSideEffects ?? null,
 				invalidate: false
@@ -2619,16 +3932,16 @@ function bindingifyTransform(args) {
 		filter: bindingifyTransformFilter(options.filter)
 	};
 }
-function bindingifyLoad(args) {
-	const hook = args.plugin.load;
+function bindingifyLoad(args$1) {
+	const hook = args$1.plugin.load;
 	if (!hook) return {};
 	const { handler, meta, options } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, id$1) => {
-			const ret = await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode, id$1), id$1);
+			const ret = await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode, id$1), id$1);
 			if (ret == null) return;
 			if (typeof ret === "string") return { code: ret };
-			let moduleOption = args.pluginContextData.updateModuleOption(id$1, {
+			let moduleOption = args$1.pluginContextData.updateModuleOption(id$1, {
 				meta: ret.meta || {},
 				moduleSideEffects: ret.moduleSideEffects ?? null,
 				invalidate: false
@@ -2655,13 +3968,13 @@ function preProcessSourceMap(ret, id$1) {
 	}
 	return map;
 }
-function bindingifyModuleParsed(args) {
-	const hook = args.plugin.moduleParsed;
+function bindingifyModuleParsed(args$1) {
+	const hook = args$1.plugin.moduleParsed;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, moduleInfo) => {
-			await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformModuleInfo(moduleInfo, args.pluginContextData.getModuleOption(moduleInfo.id)));
+			await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), transformModuleInfo(moduleInfo, args$1.pluginContextData.getModuleOption(moduleInfo.id)));
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
@@ -3092,25 +4405,25 @@ var init_transform_to_rollup_output = __esm({ "src/utils/transform-to-rollup-out
 
 //#endregion
 //#region src/plugin/bindingify-output-hooks.ts
-function bindingifyRenderStart(args) {
-	const hook = args.plugin.renderStart;
+function bindingifyRenderStart(args$1) {
+	const hook = args$1.plugin.renderStart;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, opts) => {
-			handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), new NormalizedOutputOptionsImpl(opts, args.outputOptions, args.normalizedOutputPlugins), new NormalizedInputOptionsImpl(opts, args.onLog));
+			handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), new NormalizedOutputOptionsImpl(opts, args$1.outputOptions, args$1.normalizedOutputPlugins), new NormalizedInputOptionsImpl(opts, args$1.onLog));
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
 }
-function bindingifyRenderChunk(args) {
-	const hook = args.plugin.renderChunk;
+function bindingifyRenderChunk(args$1) {
+	const hook = args$1.plugin.renderChunk;
 	if (!hook) return {};
 	const { handler, meta, options } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, code$1, chunk, opts, meta$1) => {
-			if (args.pluginContextData.getRenderChunkMeta() == null) args.pluginContextData.setRenderChunkMeta({ chunks: Object.fromEntries(Object.entries(meta$1.chunks).map(([key, value]) => [key, transformRenderedChunk(value)])) });
-			const ret = await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), code$1, transformRenderedChunk(chunk), new NormalizedOutputOptionsImpl(opts, args.outputOptions, args.normalizedOutputPlugins), args.pluginContextData.getRenderChunkMeta());
+			if (args$1.pluginContextData.getRenderChunkMeta() == null) args$1.pluginContextData.setRenderChunkMeta({ chunks: Object.fromEntries(Object.entries(meta$1.chunks).map(([key, value]) => [key, transformRenderedChunk(value)])) });
+			const ret = await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), code$1, transformRenderedChunk(chunk), new NormalizedOutputOptionsImpl(opts, args$1.outputOptions, args$1.normalizedOutputPlugins), args$1.pluginContextData.getRenderChunkMeta());
 			if (ret == null) return;
 			if (typeof ret === "string") return { code: ret };
 			if (!ret.map) return { code: ret.code };
@@ -3123,30 +4436,30 @@ function bindingifyRenderChunk(args) {
 		filter: bindingifyRenderChunkFilter(options.filter)
 	};
 }
-function bindingifyAugmentChunkHash(args) {
-	const hook = args.plugin.augmentChunkHash;
+function bindingifyAugmentChunkHash(args$1) {
+	const hook = args$1.plugin.augmentChunkHash;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, chunk) => {
-			return await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformRenderedChunk(chunk));
+			return await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), transformRenderedChunk(chunk));
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
 }
-function bindingifyRenderError(args) {
-	const hook = args.plugin.renderError;
+function bindingifyRenderError(args$1) {
+	const hook = args$1.plugin.renderError;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, err) => {
-			handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), normalizeErrors(err));
+			handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), normalizeErrors(err));
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
 }
-function bindingifyGenerateBundle(args) {
-	const hook = args.plugin.generateBundle;
+function bindingifyGenerateBundle(args$1) {
+	const hook = args$1.plugin.generateBundle;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
@@ -3156,14 +4469,14 @@ function bindingifyGenerateBundle(args) {
 				deleted: new Set()
 			};
 			const output = transformToOutputBundle(bundle, changed);
-			await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), new NormalizedOutputOptionsImpl(opts, args.outputOptions, args.normalizedOutputPlugins), output, isWrite);
+			await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), new NormalizedOutputOptionsImpl(opts, args$1.outputOptions, args$1.normalizedOutputPlugins), output, isWrite);
 			return collectChangedBundle(changed, output);
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
 }
-function bindingifyWriteBundle(args) {
-	const hook = args.plugin.writeBundle;
+function bindingifyWriteBundle(args$1) {
+	const hook = args$1.plugin.writeBundle;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
@@ -3173,67 +4486,67 @@ function bindingifyWriteBundle(args) {
 				deleted: new Set()
 			};
 			const output = transformToOutputBundle(bundle, changed);
-			await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), new NormalizedOutputOptionsImpl(opts, args.outputOptions, args.normalizedOutputPlugins), output);
+			await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), new NormalizedOutputOptionsImpl(opts, args$1.outputOptions, args$1.normalizedOutputPlugins), output);
 			return collectChangedBundle(changed, output);
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
 }
-function bindingifyCloseBundle(args) {
-	const hook = args.plugin.closeBundle;
+function bindingifyCloseBundle(args$1) {
+	const hook = args$1.plugin.closeBundle;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx) => {
-			await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode));
+			await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode));
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
 }
-function bindingifyBanner(args) {
-	const hook = args.plugin.banner;
+function bindingifyBanner(args$1) {
+	const hook = args$1.plugin.banner;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, chunk) => {
 			if (typeof handler === "string") return handler;
-			return handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformRenderedChunk(chunk));
+			return handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), transformRenderedChunk(chunk));
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
 }
-function bindingifyFooter(args) {
-	const hook = args.plugin.footer;
+function bindingifyFooter(args$1) {
+	const hook = args$1.plugin.footer;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, chunk) => {
 			if (typeof handler === "string") return handler;
-			return handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformRenderedChunk(chunk));
+			return handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), transformRenderedChunk(chunk));
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
 }
-function bindingifyIntro(args) {
-	const hook = args.plugin.intro;
+function bindingifyIntro(args$1) {
+	const hook = args$1.plugin.intro;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, chunk) => {
 			if (typeof handler === "string") return handler;
-			return handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformRenderedChunk(chunk));
+			return handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), transformRenderedChunk(chunk));
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
 }
-function bindingifyOutro(args) {
-	const hook = args.plugin.outro;
+function bindingifyOutro(args$1) {
+	const hook = args$1.plugin.outro;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, chunk) => {
 			if (typeof handler === "string") return handler;
-			return handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformRenderedChunk(chunk));
+			return handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), transformRenderedChunk(chunk));
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
@@ -3253,24 +4566,24 @@ var init_bindingify_output_hooks = __esm({ "src/plugin/bindingify-output-hooks.t
 
 //#endregion
 //#region src/plugin/bindingify-watch-hooks.ts
-function bindingifyWatchChange(args) {
-	const hook = args.plugin.watchChange;
+function bindingifyWatchChange(args$1) {
+	const hook = args$1.plugin.watchChange;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, id$1, event) => {
-			await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), id$1, { event });
+			await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), id$1, { event });
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
 }
-function bindingifyCloseWatcher(args) {
-	const hook = args.plugin.closeWatcher;
+function bindingifyCloseWatcher(args$1) {
+	const hook = args$1.plugin.closeWatcher;
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx) => {
-			await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode));
+			await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode));
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
@@ -3348,7 +4661,7 @@ var init_hook_usage = __esm({ "src/plugin/generated/hook-usage.ts"() {
 //#endregion
 //#region src/plugin/bindingify-plugin.ts
 function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, normalizedOutputPlugins, onLog, logLevel, watchMode) {
-	const args = {
+	const args$1 = {
 		plugin,
 		options,
 		outputOptions,
@@ -3358,26 +4671,26 @@ function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, nor
 		watchMode,
 		normalizedOutputPlugins
 	};
-	const { plugin: buildStart, meta: buildStartMeta } = bindingifyBuildStart(args);
-	const { plugin: resolveId, meta: resolveIdMeta, filter: resolveIdFilter } = bindingifyResolveId(args);
-	const { plugin: resolveDynamicImport, meta: resolveDynamicImportMeta } = bindingifyResolveDynamicImport(args);
-	const { plugin: buildEnd, meta: buildEndMeta } = bindingifyBuildEnd(args);
-	const { plugin: transform, meta: transformMeta, filter: transformFilter } = bindingifyTransform(args);
-	const { plugin: moduleParsed, meta: moduleParsedMeta } = bindingifyModuleParsed(args);
-	const { plugin: load, meta: loadMeta, filter: loadFilter } = bindingifyLoad(args);
-	const { plugin: renderChunk, meta: renderChunkMeta, filter: renderChunkFilter } = bindingifyRenderChunk(args);
-	const { plugin: augmentChunkHash, meta: augmentChunkHashMeta } = bindingifyAugmentChunkHash(args);
-	const { plugin: renderStart, meta: renderStartMeta } = bindingifyRenderStart(args);
-	const { plugin: renderError, meta: renderErrorMeta } = bindingifyRenderError(args);
-	const { plugin: generateBundle, meta: generateBundleMeta } = bindingifyGenerateBundle(args);
-	const { plugin: writeBundle, meta: writeBundleMeta } = bindingifyWriteBundle(args);
-	const { plugin: closeBundle, meta: closeBundleMeta } = bindingifyCloseBundle(args);
-	const { plugin: banner, meta: bannerMeta } = bindingifyBanner(args);
-	const { plugin: footer, meta: footerMeta } = bindingifyFooter(args);
-	const { plugin: intro, meta: introMeta } = bindingifyIntro(args);
-	const { plugin: outro, meta: outroMeta } = bindingifyOutro(args);
-	const { plugin: watchChange, meta: watchChangeMeta } = bindingifyWatchChange(args);
-	const { plugin: closeWatcher, meta: closeWatcherMeta } = bindingifyCloseWatcher(args);
+	const { plugin: buildStart, meta: buildStartMeta } = bindingifyBuildStart(args$1);
+	const { plugin: resolveId, meta: resolveIdMeta, filter: resolveIdFilter } = bindingifyResolveId(args$1);
+	const { plugin: resolveDynamicImport, meta: resolveDynamicImportMeta } = bindingifyResolveDynamicImport(args$1);
+	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: renderChunk, meta: renderChunkMeta, filter: renderChunkFilter } = bindingifyRenderChunk(args$1);
+	const { plugin: augmentChunkHash, meta: augmentChunkHashMeta } = bindingifyAugmentChunkHash(args$1);
+	const { plugin: renderStart, meta: renderStartMeta } = bindingifyRenderStart(args$1);
+	const { plugin: renderError, meta: renderErrorMeta } = bindingifyRenderError(args$1);
+	const { plugin: generateBundle, meta: generateBundleMeta } = bindingifyGenerateBundle(args$1);
+	const { plugin: writeBundle, meta: writeBundleMeta } = bindingifyWriteBundle(args$1);
+	const { plugin: closeBundle, meta: closeBundleMeta } = bindingifyCloseBundle(args$1);
+	const { plugin: banner, meta: bannerMeta } = bindingifyBanner(args$1);
+	const { plugin: footer, meta: footerMeta } = bindingifyFooter(args$1);
+	const { plugin: intro, meta: introMeta } = bindingifyIntro(args$1);
+	const { plugin: outro, meta: outroMeta } = bindingifyOutro(args$1);
+	const { plugin: watchChange, meta: watchChangeMeta } = bindingifyWatchChange(args$1);
+	const { plugin: closeWatcher, meta: closeWatcherMeta } = bindingifyCloseWatcher(args$1);
 	let hookUsage = extractHookUsage(plugin).inner();
 	const result = {
 		name: plugin.name,
@@ -3453,13 +4766,13 @@ function wrapHandlers(plugin) {
 		"closeWatcher"
 	]) {
 		const handler = plugin[hookName];
-		if (handler) plugin[hookName] = async (...args) => {
+		if (handler) plugin[hookName] = async (...args$1) => {
 			try {
-				return await handler(...args);
+				return await handler(...args$1);
 			} catch (e$5) {
 				return error(logPluginError(e$5, plugin.name, {
 					hook: hookName,
-					id: hookName === "transform" ? args[2] : void 0
+					id: hookName === "transform" ? args$1[2] : void 0
 				}));
 			}
 		};
@@ -3523,13 +4836,13 @@ var init_plugin_context_data = __esm({ "src/plugin/plugin-context-data.ts"() {
 				get() {
 					return moduleSideEffects;
 				},
-				set: (v$1) => {
+				set: (v) => {
 					this.updateModuleOption(id$1, {
-						moduleSideEffects: v$1,
+						moduleSideEffects: v,
 						meta: info.meta,
 						invalidate: true
 					});
-					moduleSideEffects = v$1;
+					moduleSideEffects = v;
 				}
 			});
 			return info;
@@ -4272,6 +5585,9 @@ var init_rolldown_build = __esm({ "src/api/rolldown/rolldown-build.ts"() {
 		async generateHmrPatch(changedFiles) {
 			return this.#bundler?.bundler.generateHmrPatch(changedFiles);
 		}
+		async hmrInvalidate(file, firstInvalidatedBy) {
+			return this.#bundler?.bundler.hmrInvalidate(file, firstInvalidatedBy);
+		}
 		get watchFiles() {
 			return this.#bundler?.bundler.watchFiles ?? [];
 		}
@@ -4470,4 +5786,4 @@ var init_src = __esm({ "src/index.ts"() {
 } });
 
 //#endregion
-export { BuiltinPlugin, PluginContextData, VERSION, bindingifyPlugin, build, buildImportAnalysisPlugin, composeJsPlugins, createBundler, defineConfig, description, dynamicImportVarsPlugin, getInputCliKeys, getJsonSchema, getOutputCliKeys, handleOutputErrors, importGlobPlugin, init_bindingify_plugin, init_compose_js_plugins, init_constructors, init_create_bundler, init_normalize_string_or_regex, init_plugin_context_data, init_rolldown, init_src, init_transform_to_rollup_output, init_validator, init_watch, isolatedDeclarationPlugin, jsonPlugin, loadFallbackPlugin, manifestPlugin, moduleFederationPlugin, modulePreloadPolyfillPlugin, normalizedStringOrRegex, reportPlugin, rolldown, validateCliOptions, version, viteResolvePlugin, wasmFallbackPlugin, wasmHelperPlugin, watch };
+export { BuiltinPlugin, PluginContextData, VERSION, bindingifyPlugin, build, buildImportAnalysisPlugin, composeJsPlugins, createBundler, defineConfig, description$1 as description, dynamicImportVarsPlugin, getInputCliKeys, getJsonSchema, getOutputCliKeys, handleOutputErrors, importGlobPlugin, init_bindingify_plugin, init_compose_js_plugins, init_constructors, init_create_bundler, init_normalize_string_or_regex, init_plugin_context_data, init_rolldown, init_src, init_transform_to_rollup_output, init_validator, init_watch, isolatedDeclarationPlugin, jsonPlugin, loadFallbackPlugin, manifestPlugin, moduleFederationPlugin, modulePreloadPolyfillPlugin, normalizedStringOrRegex, reportPlugin, rolldown, validateCliOptions, version, viteResolvePlugin, wasmFallbackPlugin, wasmHelperPlugin, watch };