@rolldown/browser 1.0.0-beta.8-commit.852c603 → 1.0.0-beta.8-commit.a720367

package/dist/shared/{src-DbbYa-_8.cjs → src-zKH-Bkca.cjs}

@@ -1,26 +1,24 @@
 "use strict";
 const require_chunk = require('./chunk-qZFfknuJ.cjs');
-const require_parse_ast_index = require('./parse-ast-index-B9pj8J1q.cjs');
-const require_filter_expression_index = require('./filter-expression-index-CRtoeipP.cjs');
+const require_filter_index = require('./filter-index-ChddWdsi.cjs');
+const require_parse_ast_index = require('./parse-ast-index-DTWvag1h.cjs');
 const src_rolldown_binding_wasi_cjs = require_chunk.__toESM(require("../rolldown-binding.wasi.cjs"));
 const node_path = require_chunk.__toESM(require("node:path"));
-const __valibot_to_json_schema = require_chunk.__toESM(require("@valibot/to-json-schema"));
 const ansis = require_chunk.__toESM(require("ansis"));
-const valibot = require_chunk.__toESM(require("valibot"));
 const node_os = require_chunk.__toESM(require("node:os"));
 const node_worker_threads = require_chunk.__toESM(require("node:worker_threads"));
 
 //#region package.json
-var version = "1.0.0-beta.8-commit.852c603";
-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 src_rolldown_binding_wasi_cjs.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;
 }
@@ -98,30 +96,6 @@ function isolatedDeclarationPlugin(config) {
 	return new BuiltinPlugin("builtin:isolated-declaration", config);
 }
 
-//#endregion
-//#region src/utils/misc.ts
-function arraify(value) {
-	return Array.isArray(value) ? value : [value];
-}
-function isNullish(value) {
-	return value === null || value === void 0;
-}
-function isPromiseLike(value) {
-	return value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
-}
-function unimplemented(info) {
-	if (info) throw new Error(`unimplemented: ${info}`);
-	throw new Error("unimplemented");
-}
-function unreachable(info) {
-	if (info) throw new Error(`unreachable: ${info}`);
-	throw new Error("unreachable");
-}
-function unsupported(info) {
-	throw new Error(`UNSUPPORTED: ${info}`);
-}
-function noop(..._args) {}
-
 //#endregion
 //#region src/log/logging.ts
 const LOG_LEVEL_SILENT = "silent";
@@ -140,7 +114,7 @@ const logLevelPriority = {
 //#region src/log/log-handler.ts
 const normalizeLog = (log) => typeof log === "string" ? { message: log } : typeof log === "function" ? normalizeLog(log()) : log;
 function getLogHandler(level, code$1, logger, pluginName, logLevel) {
-	if (logLevelPriority[level] < logLevelPriority[logLevel]) return noop;
+	if (logLevelPriority[level] < logLevelPriority[logLevel]) return require_filter_index.noop;
 	return (log, pos) => {
 		if (pos != null) logger(LOG_LEVEL_WARN, require_parse_ast_index.logInvalidLogPosition(pluginName));
 		log = normalizeLog(log);
@@ -243,7 +217,7 @@ function normalizeHook(hook) {
 			meta: { order }
 		};
 	}
-	unreachable("Invalid hook type");
+	require_filter_index.unreachable("Invalid hook type");
 }
 
 //#endregion
@@ -317,11 +291,11 @@ const DEFINED_HOOK_NAMES = {
 
 //#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) => v?.then));
-	return array;
+		array$1 = (await Promise.all(array$1)).flat(Infinity);
+	while (array$1.some((v) => v?.then));
+	return array$1;
 }
 
 //#endregion
@@ -436,201 +410,1509 @@ function getSortedPlugins(hookName, plugins) {
 	];
 }
 
+//#endregion
+//#region ../../node_modules/.pnpm/valibot@1.0.0_typescript@5.8.3/node_modules/valibot/dist/index.js
+var store;
+/* @__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
+	};
+}
+var store2;
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalMessage(lang) {
+	return store2?.get(lang);
+}
+var store3;
+/* @__NO_SIDE_EFFECTS__ */
+function getSchemaMessage(lang) {
+	return store3?.get(lang);
+}
+var store4;
+/* @__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";
+}
+var 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;
+	}
+};
+/* @__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
+	};
+}
+
+//#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;
+}
+var refCount = 0;
+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;
+}
+
 //#endregion
 //#region src/utils/validator.ts
-const StringOrRegExpSchema = valibot.union([valibot.string(), valibot.instance(RegExp)]);
-const LogLevelSchema = valibot.union([
-	valibot.literal("debug"),
-	valibot.literal("info"),
-	valibot.literal("warn")
+const StringOrRegExpSchema = union([string(), instance(RegExp)]);
+const LogLevelSchema = union([
+	literal("debug"),
+	literal("info"),
+	literal("warn")
 ]);
-const LogLevelOptionSchema = valibot.union([LogLevelSchema, valibot.literal("silent")]);
-const LogLevelWithErrorSchema = valibot.union([LogLevelSchema, valibot.literal("error")]);
-const RollupLogSchema = valibot.any();
-const RollupLogWithStringSchema = valibot.union([RollupLogSchema, valibot.string()]);
-const InputOptionSchema = valibot.union([
-	valibot.string(),
-	valibot.array(valibot.string()),
-	valibot.record(valibot.string(), valibot.string())
+const LogLevelOptionSchema = union([LogLevelSchema, literal("silent")]);
+const LogLevelWithErrorSchema = union([LogLevelSchema, literal("error")]);
+const RollupLogSchema = any();
+const RollupLogWithStringSchema = union([RollupLogSchema, string()]);
+const InputOptionSchema = union([
+	string(),
+	array(string()),
+	record(string(), string())
 ]);
-const ExternalSchema = valibot.union([
+const ExternalSchema = union([
 	StringOrRegExpSchema,
-	valibot.array(StringOrRegExpSchema),
-	valibot.pipe(valibot.function(), valibot.args(valibot.tuple([
-		valibot.string(),
-		valibot.optional(valibot.string()),
-		valibot.boolean()
-	])), valibot.returns(valibot.nullish(valibot.boolean())))
+	array(StringOrRegExpSchema),
+	pipe(function_(), args(tuple([
+		string(),
+		optional(string()),
+		boolean()
+	])), returns(nullish(boolean())))
 ]);
-const ModuleTypesSchema = valibot.record(valibot.string(), valibot.union([
-	valibot.literal("base64"),
-	valibot.literal("binary"),
-	valibot.literal("css"),
-	valibot.literal("dataurl"),
-	valibot.literal("empty"),
-	valibot.literal("js"),
-	valibot.literal("json"),
-	valibot.literal("jsx"),
-	valibot.literal("text"),
-	valibot.literal("ts"),
-	valibot.literal("tsx")
+const 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")
 ]));
-const JsxOptionsSchema = valibot.strictObject({
-	development: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Development specific information")),
-	factory: valibot.pipe(valibot.optional(valibot.string()), valibot.description("Jsx element transformation")),
-	fragment: valibot.pipe(valibot.optional(valibot.string()), valibot.description("Jsx fragment transformation")),
-	importSource: valibot.pipe(valibot.optional(valibot.string()), valibot.description("Import the factory of element and fragment if mode is classic")),
-	jsxImportSource: valibot.pipe(valibot.optional(valibot.string()), valibot.description("Import the factory of element and fragment if mode is automatic")),
-	mode: valibot.pipe(valibot.optional(valibot.union([
-		valibot.literal("classic"),
-		valibot.literal("automatic"),
-		valibot.literal("preserve")
-	])), valibot.description("Jsx transformation mode")),
-	refresh: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("React refresh transformation"))
+const 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"))
 });
-const HelperModeSchema = valibot.union([valibot.literal("Runtime"), valibot.literal("External")]);
-const DecoratorOptionSchema = valibot.object({
-	legacy: valibot.optional(valibot.boolean()),
-	emitDecoratorMetadata: valibot.optional(valibot.boolean())
+const HelperModeSchema = union([literal("Runtime"), literal("External")]);
+const DecoratorOptionSchema = object({
+	legacy: optional(boolean()),
+	emitDecoratorMetadata: optional(boolean())
 });
-const HelpersSchema = valibot.object({ mode: valibot.optional(HelperModeSchema) });
-const RewriteImportExtensionsSchema = valibot.union([
-	valibot.literal("rewrite"),
-	valibot.literal("remove"),
-	valibot.boolean()
+const HelpersSchema = object({ mode: optional(HelperModeSchema) });
+const RewriteImportExtensionsSchema = union([
+	literal("rewrite"),
+	literal("remove"),
+	boolean()
 ]);
-const TypescriptSchema = valibot.object({
-	jsxPragma: valibot.optional(valibot.string()),
-	jsxPragmaFrag: valibot.optional(valibot.string()),
-	onlyRemoveTypeImports: valibot.optional(valibot.boolean()),
-	allowNamespaces: valibot.optional(valibot.boolean()),
-	allowDeclareFields: valibot.optional(valibot.boolean()),
-	declaration: valibot.optional(valibot.object({
-		stripInternal: valibot.optional(valibot.boolean()),
-		sourcemap: valibot.optional(valibot.boolean())
+const 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: valibot.optional(RewriteImportExtensionsSchema)
+	rewriteImportExtensions: optional(RewriteImportExtensionsSchema)
 });
-const AssumptionsSchema = valibot.object({
-	ignoreFunctionLength: valibot.optional(valibot.boolean()),
-	noDocumentAll: valibot.optional(valibot.boolean()),
-	objectRestNoSymbols: valibot.optional(valibot.boolean()),
-	pureGetters: valibot.optional(valibot.boolean()),
-	setPublicClassFields: valibot.optional(valibot.boolean())
+const AssumptionsSchema = object({
+	ignoreFunctionLength: optional(boolean()),
+	noDocumentAll: optional(boolean()),
+	objectRestNoSymbols: optional(boolean()),
+	pureGetters: optional(boolean()),
+	setPublicClassFields: optional(boolean())
 });
-const TransformOptionsSchema = valibot.object({
-	assumptions: valibot.optional(AssumptionsSchema),
-	typescript: valibot.optional(TypescriptSchema),
-	helpers: valibot.optional(HelpersSchema),
-	decorators: valibot.optional(DecoratorOptionSchema)
+const TransformOptionsSchema = object({
+	assumptions: optional(AssumptionsSchema),
+	typescript: optional(TypescriptSchema),
+	helpers: optional(HelpersSchema),
+	decorators: optional(DecoratorOptionSchema)
 });
-const WatchOptionsSchema = valibot.strictObject({
-	chokidar: valibot.optional(valibot.never(`The "watch.chokidar" option is deprecated, please use "watch.notify" instead of it`)),
-	exclude: valibot.optional(valibot.union([StringOrRegExpSchema, valibot.array(StringOrRegExpSchema)])),
-	include: valibot.optional(valibot.union([StringOrRegExpSchema, valibot.array(StringOrRegExpSchema)])),
-	notify: valibot.pipe(valibot.optional(valibot.strictObject({
-		compareContents: valibot.optional(valibot.boolean()),
-		pollInterval: valibot.optional(valibot.number())
-	})), valibot.description("Notify options")),
-	skipWrite: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Skip the bundle.write() step")),
-	buildDelay: valibot.pipe(valibot.optional(valibot.number()), valibot.description("Throttle watch rebuilds"))
+const 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"))
 });
-const ChecksOptionsSchema = valibot.strictObject({
-	circularDependency: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Whether to emit warning when detecting circular dependency")),
-	eval: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Whether to emit warning when detecting eval")),
-	missingGlobalName: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Whether to emit warning when detecting missing global name")),
-	missingNameOptionForIifeExport: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Whether to emit warning when detecting missing name option for iife export")),
-	mixedExport: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Whether to emit warning when detecting mixed export")),
-	unresolvedEntry: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Whether to emit warning when detecting unresolved entry")),
-	unresolvedImport: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Whether to emit warning when detecting unresolved import")),
-	filenameConflict: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Whether to emit warning when detecting filename conflict")),
-	commonJsVariableInEsm: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Whether to emit warning when detecting common js variable in esm")),
-	importIsUndefined: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Whether to emit warning when detecting import is undefined")),
-	configurationFieldConflict: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Whether to emit warning when detecting configuration field conflict"))
+const 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"))
 });
-const MinifyOptionsSchema = valibot.strictObject({
-	mangle: valibot.optional(valibot.boolean()),
-	compress: valibot.optional(valibot.boolean()),
-	removeWhitespace: valibot.optional(valibot.boolean())
+const MinifyOptionsSchema = strictObject({
+	mangle: optional(boolean()),
+	compress: optional(boolean()),
+	removeWhitespace: optional(boolean())
 });
-const ResolveOptionsSchema = valibot.strictObject({
-	alias: valibot.optional(valibot.record(valibot.string(), valibot.union([valibot.string(), valibot.array(valibot.string())]))),
-	aliasFields: valibot.optional(valibot.array(valibot.array(valibot.string()))),
-	conditionNames: valibot.optional(valibot.array(valibot.string())),
-	extensionAlias: valibot.optional(valibot.record(valibot.string(), valibot.array(valibot.string()))),
-	exportsFields: valibot.optional(valibot.array(valibot.array(valibot.string()))),
-	extensions: valibot.optional(valibot.array(valibot.string())),
-	mainFields: valibot.optional(valibot.array(valibot.string())),
-	mainFiles: valibot.optional(valibot.array(valibot.string())),
-	modules: valibot.optional(valibot.array(valibot.string())),
-	symlinks: valibot.optional(valibot.boolean()),
-	tsconfigFilename: valibot.optional(valibot.string())
+const 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())
 });
-const TreeshakingOptionsSchema = valibot.union([valibot.boolean(), valibot.looseObject({
-	annotations: valibot.optional(valibot.boolean()),
-	manualPureFunctions: valibot.optional(valibot.array(valibot.string())),
-	unknownGlobalSideEffects: valibot.optional(valibot.boolean())
+const TreeshakingOptionsSchema = union([boolean(), looseObject({
+	annotations: optional(boolean()),
+	manualPureFunctions: optional(array(string())),
+	unknownGlobalSideEffects: optional(boolean())
 })]);
-const OnLogSchema = valibot.pipe(valibot.function(), valibot.args(valibot.tuple([
+const OnLogSchema = pipe(function_(), args(tuple([
 	LogLevelSchema,
 	RollupLogSchema,
-	valibot.pipe(valibot.function(), valibot.args(valibot.tuple([LogLevelWithErrorSchema, RollupLogWithStringSchema])))
+	pipe(function_(), args(tuple([LogLevelWithErrorSchema, RollupLogWithStringSchema])))
 ])));
-const OnwarnSchema = valibot.pipe(valibot.function(), valibot.args(valibot.tuple([RollupLogSchema, valibot.pipe(valibot.function(), valibot.args(valibot.tuple([valibot.union([RollupLogWithStringSchema, valibot.pipe(valibot.function(), valibot.returns(RollupLogWithStringSchema))])])))])));
-const HmrSchema = valibot.union([valibot.boolean(), valibot.strictObject({
-	port: valibot.optional(valibot.number()),
-	host: valibot.optional(valibot.string()),
-	implement: valibot.optional(valibot.string())
+const OnwarnSchema = pipe(function_(), args(tuple([RollupLogSchema, pipe(function_(), args(tuple([union([RollupLogWithStringSchema, pipe(function_(), returns(RollupLogWithStringSchema))])])))])));
+const HmrSchema = union([boolean(), strictObject({
+	port: optional(number()),
+	host: optional(string()),
+	implement: optional(string())
 })]);
-const InputOptionsSchema = valibot.strictObject({
-	input: valibot.optional(InputOptionSchema),
-	plugins: valibot.optional(valibot.custom(() => true)),
-	external: valibot.optional(ExternalSchema),
-	resolve: valibot.optional(ResolveOptionsSchema),
-	cwd: valibot.pipe(valibot.optional(valibot.string()), valibot.description("Current working directory")),
-	platform: valibot.pipe(valibot.optional(valibot.union([
-		valibot.literal("browser"),
-		valibot.literal("neutral"),
-		valibot.literal("node")
-	])), valibot.description(`Platform for which the code should be generated (node, ${ansis.default.underline("browser")}, neutral)`)),
-	shimMissingExports: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Create shim variables for missing exports")),
-	treeshake: valibot.optional(TreeshakingOptionsSchema),
-	logLevel: valibot.pipe(valibot.optional(LogLevelOptionSchema), valibot.description(`Log level (${ansis.default.dim("silent")}, ${ansis.default.underline(ansis.default.gray("info"))}, debug, ${ansis.default.yellow("warn")})`)),
-	onLog: valibot.optional(OnLogSchema),
-	onwarn: valibot.optional(OnwarnSchema),
-	moduleTypes: valibot.pipe(valibot.optional(ModuleTypesSchema), valibot.description("Module types for customized extensions")),
-	experimental: valibot.optional(valibot.strictObject({
-		disableLiveBindings: valibot.optional(valibot.boolean()),
-		enableComposingJsPlugins: valibot.optional(valibot.boolean()),
-		resolveNewUrlToAsset: valibot.optional(valibot.boolean()),
-		strictExecutionOrder: valibot.optional(valibot.boolean()),
-		hmr: valibot.optional(HmrSchema)
+const 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, ${ansis.default.underline("browser")}, neutral)`)),
+	shimMissingExports: pipe(optional(boolean()), description("Create shim variables for missing exports")),
+	treeshake: optional(TreeshakingOptionsSchema),
+	logLevel: pipe(optional(LogLevelOptionSchema), description(`Log level (${ansis.default.dim("silent")}, ${ansis.default.underline(ansis.default.gray("info"))}, debug, ${ansis.default.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: valibot.pipe(valibot.optional(valibot.record(valibot.string(), valibot.string())), valibot.description("Define global variables")),
-	inject: valibot.optional(valibot.record(valibot.string(), valibot.union([valibot.string(), valibot.tuple([valibot.string(), valibot.string()])]))),
-	profilerNames: valibot.optional(valibot.boolean()),
-	jsx: valibot.optional(valibot.union([
-		valibot.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,
-		valibot.string("react"),
-		valibot.string("react-jsx"),
-		valibot.string("preserve")
+		string("react"),
+		string("react-jsx"),
+		string("preserve")
 	])),
-	transform: valibot.optional(TransformOptionsSchema),
-	watch: valibot.optional(valibot.union([WatchOptionsSchema, valibot.literal(false)])),
-	dropLabels: valibot.pipe(valibot.optional(valibot.array(valibot.string())), valibot.description("Remove labeled statements with these label names")),
-	checks: valibot.optional(ChecksOptionsSchema),
-	keepNames: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Keep function/class name")),
-	debug: valibot.pipe(valibot.optional(valibot.object({ sessionId: valibot.pipe(valibot.optional(valibot.string()), valibot.description("Used to name the build.")) })), valibot.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."))
 });
-const InputCliOverrideSchema = valibot.strictObject({
-	input: valibot.pipe(valibot.optional(valibot.array(valibot.string())), valibot.description("Entry file")),
-	external: valibot.pipe(valibot.optional(valibot.array(valibot.string())), valibot.description("Comma-separated list of module ids to exclude from the bundle `<module-id>,...`")),
-	inject: valibot.pipe(valibot.optional(valibot.record(valibot.string(), valibot.string())), valibot.description("Inject import statements on demand")),
-	treeshake: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("enable treeshaking")),
-	jsx: valibot.pipe(valibot.optional(JsxOptionsSchema), valibot.description("enable jsx"))
+const 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"))
 });
-const InputCliOptionsSchema = valibot.omit(valibot.strictObject({
+const InputCliOptionsSchema = omit(strictObject({
 	...InputOptionsSchema.entries,
 	...InputCliOverrideSchema.entries
 }), [
@@ -657,87 +1939,87 @@ var ESTarget = /* @__PURE__ */ function(ESTarget$1) {
 	ESTarget$1["ESNext"] = "esnext";
 	return ESTarget$1;
 }(ESTarget || {});
-const ModuleFormatSchema = valibot.union([
-	valibot.literal("es"),
-	valibot.literal("cjs"),
-	valibot.literal("esm"),
-	valibot.literal("module"),
-	valibot.literal("commonjs"),
-	valibot.literal("iife"),
-	valibot.literal("umd")
+const ModuleFormatSchema = union([
+	literal("es"),
+	literal("cjs"),
+	literal("esm"),
+	literal("module"),
+	literal("commonjs"),
+	literal("iife"),
+	literal("umd")
 ]);
-const AddonFunctionSchema = valibot.pipe(valibot.function(), valibot.args(valibot.tuple([valibot.custom(() => true)])), valibot.returnsAsync(valibot.unionAsync([valibot.string(), valibot.pipeAsync(valibot.promise(), valibot.awaitAsync(), valibot.string())])));
-const ChunkFileNamesSchema = valibot.union([valibot.string(), valibot.pipe(valibot.function(), valibot.args(valibot.tuple([valibot.custom(() => true)])), valibot.returns(valibot.string()))]);
-const AssetFileNamesSchema = valibot.union([valibot.string(), valibot.pipe(valibot.function(), valibot.args(valibot.tuple([valibot.custom(() => true)])), valibot.returns(valibot.string()))]);
-const SanitizeFileNameSchema = valibot.union([valibot.boolean(), valibot.pipe(valibot.function(), valibot.args(valibot.tuple([valibot.string()])), valibot.returns(valibot.string()))]);
-const GlobalsFunctionSchema = valibot.pipe(valibot.function(), valibot.args(valibot.tuple([valibot.string()])), valibot.returns(valibot.string()));
-const AdvancedChunksSchema = valibot.strictObject({
-	minSize: valibot.optional(valibot.number()),
-	maxSize: valibot.optional(valibot.number()),
-	minModuleSize: valibot.optional(valibot.number()),
-	maxModuleSize: valibot.optional(valibot.number()),
-	minShareCount: valibot.optional(valibot.number()),
-	groups: valibot.optional(valibot.array(valibot.strictObject({
-		name: valibot.string(),
-		test: valibot.optional(valibot.union([valibot.string(), valibot.instance(RegExp)])),
-		priority: valibot.optional(valibot.number()),
-		minSize: valibot.optional(valibot.number()),
-		minShareCount: valibot.optional(valibot.number()),
-		maxSize: valibot.optional(valibot.number()),
-		minModuleSize: valibot.optional(valibot.number()),
-		maxModuleSize: valibot.optional(valibot.number())
+const AddonFunctionSchema = pipe(function_(), args(tuple([custom(() => true)])), returnsAsync(unionAsync([string(), pipeAsync(promise(), awaitAsync(), string())])));
+const ChunkFileNamesSchema = union([string(), pipe(function_(), args(tuple([custom(() => true)])), returns(string()))]);
+const AssetFileNamesSchema = union([string(), pipe(function_(), args(tuple([custom(() => true)])), returns(string()))]);
+const SanitizeFileNameSchema = union([boolean(), pipe(function_(), args(tuple([string()])), returns(string()))]);
+const GlobalsFunctionSchema = pipe(function_(), args(tuple([string()])), returns(string()));
+const 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())
 	})))
 });
-const OutputOptionsSchema = valibot.strictObject({
-	dir: valibot.pipe(valibot.optional(valibot.string()), valibot.description("Output directory, defaults to `dist` if `file` is not set")),
-	file: valibot.pipe(valibot.optional(valibot.string()), valibot.description("Single output file")),
-	exports: valibot.pipe(valibot.optional(valibot.union([
-		valibot.literal("auto"),
-		valibot.literal("named"),
-		valibot.literal("default"),
-		valibot.literal("none")
-	])), valibot.description(`Specify a export mode (${ansis.default.underline("auto")}, named, default, none)`)),
-	hashCharacters: valibot.pipe(valibot.optional(valibot.union([
-		valibot.literal("base64"),
-		valibot.literal("base36"),
-		valibot.literal("hex")
-	])), valibot.description("Use the specified character set for file hashes")),
-	format: valibot.pipe(valibot.optional(ModuleFormatSchema), valibot.description(`Output format of the generated bundle (supports ${ansis.default.underline("esm")}, cjs, and iife)`)),
-	sourcemap: valibot.pipe(valibot.optional(valibot.union([
-		valibot.boolean(),
-		valibot.literal("inline"),
-		valibot.literal("hidden")
-	])), valibot.description(`Generate sourcemap (\`-s inline\` for inline, or ${ansis.default.bold("pass the `-s` on the last argument if you want to generate `.map` file")})`)),
-	sourcemapDebugIds: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Inject sourcemap debug IDs")),
-	sourcemapIgnoreList: valibot.optional(valibot.union([valibot.boolean(), valibot.custom(() => true)])),
-	sourcemapPathTransform: valibot.optional(valibot.custom(() => true)),
-	banner: valibot.optional(valibot.union([valibot.string(), AddonFunctionSchema])),
-	footer: valibot.optional(valibot.union([valibot.string(), AddonFunctionSchema])),
-	intro: valibot.optional(valibot.union([valibot.string(), AddonFunctionSchema])),
-	outro: valibot.optional(valibot.union([valibot.string(), AddonFunctionSchema])),
-	extend: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Extend global variable defined by name in IIFE / UMD formats")),
-	esModule: valibot.optional(valibot.union([valibot.boolean(), valibot.literal("if-default-prop")])),
-	assetFileNames: valibot.optional(AssetFileNamesSchema),
-	entryFileNames: valibot.optional(ChunkFileNamesSchema),
-	chunkFileNames: valibot.optional(ChunkFileNamesSchema),
-	cssEntryFileNames: valibot.optional(ChunkFileNamesSchema),
-	cssChunkFileNames: valibot.optional(ChunkFileNamesSchema),
-	sanitizeFileName: valibot.optional(SanitizeFileNameSchema),
-	minify: valibot.pipe(valibot.optional(valibot.union([
-		valibot.boolean(),
-		valibot.string("dce-only"),
+const 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 (${ansis.default.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 ${ansis.default.underline("esm")}, cjs, and iife)`)),
+	sourcemap: pipe(optional(union([
+		boolean(),
+		literal("inline"),
+		literal("hidden")
+	])), description(`Generate sourcemap (\`-s inline\` for inline, or ${ansis.default.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
-	])), valibot.description("Minify the bundled file")),
-	name: valibot.pipe(valibot.optional(valibot.string()), valibot.description("Name for UMD / IIFE format outputs")),
-	globals: valibot.pipe(valibot.optional(valibot.union([valibot.record(valibot.string(), valibot.string()), GlobalsFunctionSchema])), valibot.description("Global variable of UMD / IIFE dependencies (syntax: `key=value`)")),
-	externalLiveBindings: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("external live bindings")),
-	inlineDynamicImports: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Inline dynamic imports")),
-	advancedChunks: valibot.optional(AdvancedChunksSchema),
-	comments: valibot.pipe(valibot.optional(valibot.union([valibot.literal("none"), valibot.literal("preserve-legal")])), valibot.description("Control comments in the output")),
-	plugins: valibot.optional(valibot.custom(() => true)),
-	polyfillRequire: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Disable require polyfill injection")),
-	target: valibot.pipe(valibot.optional(valibot.enum(ESTarget)), valibot.description("The JavaScript target environment")),
-	hoistTransitiveImports: valibot.optional(valibot.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`))
@@ -745,26 +2027,26 @@ const OutputOptionsSchema = valibot.strictObject({
 const getAddonDescription = (placement, wrapper) => {
 	return `Code to insert the ${ansis.default.bold(placement)} of the bundled file (${ansis.default.bold(wrapper)} the wrapper function)`;
 };
-const OutputCliOverrideSchema = valibot.strictObject({
-	assetFileNames: valibot.pipe(valibot.optional(valibot.string()), valibot.description("Name pattern for asset files")),
-	entryFileNames: valibot.pipe(valibot.optional(valibot.string()), valibot.description("Name pattern for emitted entry chunks")),
-	chunkFileNames: valibot.pipe(valibot.optional(valibot.string()), valibot.description("Name pattern for emitted secondary chunks")),
-	cssEntryFileNames: valibot.pipe(valibot.optional(valibot.string()), valibot.description("Name pattern for emitted css entry chunks")),
-	cssChunkFileNames: valibot.pipe(valibot.optional(valibot.string()), valibot.description("Name pattern for emitted css secondary chunks")),
-	sanitizeFileName: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Sanitize file name")),
-	banner: valibot.pipe(valibot.optional(valibot.string()), valibot.description(getAddonDescription("top", "outside"))),
-	footer: valibot.pipe(valibot.optional(valibot.string()), valibot.description(getAddonDescription("bottom", "outside"))),
-	intro: valibot.pipe(valibot.optional(valibot.string()), valibot.description(getAddonDescription("top", "inside"))),
-	outro: valibot.pipe(valibot.optional(valibot.string()), valibot.description(getAddonDescription("bottom", "inside"))),
-	esModule: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Always generate `__esModule` marks in non-ESM formats, defaults to `if-default-prop` (use `--no-esModule` to always disable)")),
-	globals: valibot.pipe(valibot.optional(valibot.record(valibot.string(), valibot.string())), valibot.description("Global variable of UMD / IIFE dependencies (syntax: `key=value`)")),
-	advancedChunks: valibot.pipe(valibot.optional(valibot.strictObject({
-		minSize: valibot.pipe(valibot.optional(valibot.number()), valibot.description("Minimum size of the chunk")),
-		minShareCount: valibot.pipe(valibot.optional(valibot.number()), valibot.description("Minimum share count of the chunk"))
-	})), valibot.description("Global variable of UMD / IIFE dependencies (syntax: `key=value`)")),
-	minify: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Minify the bundled file"))
+const 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"))
 });
-const OutputCliOptionsSchema = valibot.omit(valibot.strictObject({
+const OutputCliOptionsSchema = omit(strictObject({
 	...OutputOptionsSchema.entries,
 	...OutputCliOverrideSchema.entries
 }), [
@@ -773,16 +2055,16 @@ const OutputCliOptionsSchema = valibot.omit(valibot.strictObject({
 	"plugins",
 	"hoistTransitiveImports"
 ]);
-const CliOptionsSchema = valibot.strictObject({
-	config: valibot.pipe(valibot.optional(valibot.union([valibot.string(), valibot.boolean()])), valibot.description("Path to the config file (default: `rolldown.config.js`)")),
-	help: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Show help")),
-	version: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Show version number")),
-	watch: valibot.pipe(valibot.optional(valibot.boolean()), valibot.description("Watch files in bundle and rebuild on changes")),
+const 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
 });
 function validateCliOptions(options) {
-	let parsed = valibot.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}`;
@@ -792,7 +2074,7 @@ const inputHelperMsgRecord = { output: { ignored: true } };
 const outputHelperMsgRecord = {};
 function validateOption(key, options) {
 	if (globalThis.process?.env?.ROLLDOWN_OPTIONS_VALIDATION === "loose") return;
-	let parsed = valibot.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$2) => path$2.key);
@@ -813,13 +2095,13 @@ function validateOption(key, options) {
 	}
 }
 function getInputCliKeys() {
-	return valibot.keyof(InputCliOptionsSchema).options;
+	return keyof(InputCliOptionsSchema).options;
 }
 function getOutputCliKeys() {
-	return valibot.keyof(OutputCliOptionsSchema).options;
+	return keyof(OutputCliOptionsSchema).options;
 }
 function getJsonSchema() {
-	return (0, __valibot_to_json_schema.toJsonSchema)(CliOptionsSchema);
+	return toJsonSchema(CliOptionsSchema);
 }
 
 //#endregion
@@ -925,7 +2207,7 @@ function joinNewLine(s1, s2) {
 function transformModuleInfo(info, option) {
 	return {
 		get ast() {
-			return unsupported("ModuleInfo#ast");
+			return require_filter_index.unsupported("ModuleInfo#ast");
 		},
 		get code() {
 			return info.code;
@@ -956,9 +2238,9 @@ function bindingifySideEffects(sideEffects) {
 
 //#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) {
@@ -1008,19 +2290,20 @@ function t(...n) {
 //#endregion
 //#region src/plugin/bindingify-hook-filter.ts
 function generalHookFilterMatcherToFilterExprs(matcher, stringKind) {
-	if (typeof matcher === "string" || matcher instanceof RegExp) return [require_filter_expression_index.include(require_filter_expression_index.id(matcher))];
-	if (Array.isArray(matcher)) return matcher.map((m) => require_filter_expression_index.include(require_filter_expression_index.id(m)));
-	if (matcher.custom) return matcher.custom;
+	if (typeof matcher === "string" || matcher instanceof RegExp) return [require_filter_index.include(generateAtomMatcher(stringKind, matcher))];
+	if (Array.isArray(matcher)) return matcher.map((m) => require_filter_index.include(generateAtomMatcher(stringKind, m)));
 	let ret = [];
-	let isCode = stringKind === "code";
-	if (matcher.exclude) ret.push(...arraify(matcher.exclude).map((m) => require_filter_expression_index.exclude(isCode ? require_filter_expression_index.code(m) : require_filter_expression_index.id(m))));
-	if (matcher.include) ret.push(...arraify(matcher.include).map((m) => require_filter_expression_index.include(isCode ? require_filter_expression_index.code(m) : require_filter_expression_index.id(m))));
+	if (matcher.exclude) ret.push(...require_filter_index.arraify(matcher.exclude).map((m) => require_filter_index.exclude(generateAtomMatcher(stringKind, m))));
+	if (matcher.include) ret.push(...require_filter_index.arraify(matcher.include).map((m) => require_filter_index.include(generateAtomMatcher(stringKind, m))));
 	return ret;
 }
+function generateAtomMatcher(kind, matcher) {
+	return kind === "code" ? require_filter_index.code(matcher) : require_filter_index.id(matcher);
+}
 function transformFilterMatcherToFilterExprs(filterOption) {
 	if (!filterOption) return void 0;
-	const { id: id$1, code: code$1, moduleType: moduleType$1, custom } = filterOption;
-	if (custom) return custom;
+	if (Array.isArray(filterOption)) return filterOption;
+	const { id: id$1, code: code$1, moduleType: moduleType$1 } = filterOption;
 	let ret = [];
 	let idIncludes = [];
 	let idExcludes = [];
@@ -1030,33 +2313,21 @@ function transformFilterMatcherToFilterExprs(filterOption) {
 	if (code$1) [codeIncludes, codeExcludes] = d(generalHookFilterMatcherToFilterExprs(code$1, "code") ?? [], (m) => m.kind === "include");
 	ret.push(...idExcludes);
 	ret.push(...codeExcludes);
-	let cursor;
+	let andExprList = [];
 	if (moduleType$1) {
 		let moduleTypes = Array.isArray(moduleType$1) ? moduleType$1 : moduleType$1.include ?? [];
-		cursor = joinFilterExprsWithOr(moduleTypes.map((m) => require_filter_expression_index.moduleType(m)));
-	}
-	if (idIncludes.length) {
-		let joinedOrExpr = joinFilterExprsWithOr(idIncludes.map((item) => item.expr));
-		if (!cursor) cursor = joinedOrExpr;
-		else cursor = require_filter_expression_index.and(cursor, joinedOrExpr);
-	}
-	if (codeIncludes.length) {
-		let joinedOrExpr = joinFilterExprsWithOr(codeIncludes.map((item) => item.expr));
-		if (!cursor) cursor = joinedOrExpr;
-		else cursor = require_filter_expression_index.and(cursor, joinedOrExpr);
+		andExprList.push(require_filter_index.or(...moduleTypes.map((m) => require_filter_index.moduleType(m))));
 	}
-	if (cursor) ret.push(require_filter_expression_index.include(cursor));
+	if (idIncludes.length) andExprList.push(require_filter_index.or(...idIncludes.map((item) => item.expr)));
+	if (codeIncludes.length) andExprList.push(require_filter_index.or(...codeIncludes.map((item) => item.expr)));
+	if (andExprList.length) ret.push(require_filter_index.include(require_filter_index.and(...andExprList)));
 	return ret;
 }
-function joinFilterExprsWithOr(filterExprs) {
-	if (filterExprs.length === 1) return filterExprs[0];
-	return require_filter_expression_index.or(filterExprs[0], joinFilterExprsWithOr(filterExprs.slice(1)));
-}
-function bindingifyGeneralHookFilter(matcher, stringKind) {
-	let filterExprs = generalHookFilterMatcherToFilterExprs(matcher, stringKind);
-	let custom = [];
-	if (filterExprs) custom = filterExprs.map(bindingifyFilterExpr);
-	return { custom: custom.length > 0 ? custom : void 0 };
+function bindingifyGeneralHookFilter(stringKind, pattern) {
+	let filterExprs = generalHookFilterMatcherToFilterExprs(pattern, stringKind);
+	let ret = [];
+	if (filterExprs) ret = filterExprs.map(bindingifyFilterExpr);
+	return ret.length > 0 ? { value: ret } : void 0;
 }
 function bindingifyFilterExpr(expr) {
 	let list = [];
@@ -1066,9 +2337,21 @@ function bindingifyFilterExpr(expr) {
 function bindingifyFilterExprImpl(expr, list) {
 	switch (expr.kind) {
 		case "and": {
-			bindingifyFilterExprImpl(expr.right, list);
-			bindingifyFilterExprImpl(expr.left, list);
-			list.push({ kind: "And" });
+			let args$1 = expr.args;
+			for (let i$1 = args$1.length - 1; i$1 >= 0; i$1--) bindingifyFilterExprImpl(args$1[i$1], list);
+			list.push({
+				kind: "And",
+				payload: args$1.length
+			});
+			break;
+		}
+		case "or": {
+			let args$1 = expr.args;
+			for (let i$1 = args$1.length - 1; i$1 >= 0; i$1--) bindingifyFilterExprImpl(args$1[i$1], list);
+			list.push({
+				kind: "Or",
+				payload: args$1.length
+			});
 			break;
 		}
 		case "not": {
@@ -1079,21 +2362,21 @@ function bindingifyFilterExprImpl(expr, list) {
 		case "id": {
 			list.push({
 				kind: "Id",
-				value: expr.pattern
+				payload: expr.pattern
 			});
 			break;
 		}
 		case "moduleType": {
 			list.push({
 				kind: "ModuleType",
-				value: expr.pattern
+				payload: expr.pattern
 			});
 			break;
 		}
 		case "code": {
 			list.push({
 				kind: "Code",
-				value: expr.pattern
+				payload: expr.pattern
 			});
 			break;
 		}
@@ -1107,27 +2390,30 @@ function bindingifyFilterExprImpl(expr, list) {
 			list.push({ kind: "Exclude" });
 			break;
 		}
-		default: throw new Error(`Unknown filter expression kind: ${expr.kind}`);
+		default: throw new Error(`Unknown filter expression: ${expr}`);
 	}
 }
 function bindingifyResolveIdFilter(filterOption) {
-	return filterOption?.id ? bindingifyGeneralHookFilter(filterOption.id, "id") : void 0;
+	if (!filterOption) return void 0;
+	if (Array.isArray(filterOption)) return { value: filterOption.map(bindingifyFilterExpr) };
+	return filterOption.id ? bindingifyGeneralHookFilter("id", filterOption.id) : void 0;
 }
 function bindingifyLoadFilter(filterOption) {
-	return filterOption?.id ? bindingifyGeneralHookFilter(filterOption.id, "id") : void 0;
+	if (!filterOption) return void 0;
+	if (Array.isArray(filterOption)) return { value: filterOption.map(bindingifyFilterExpr) };
+	return filterOption.id ? bindingifyGeneralHookFilter("id", filterOption.id) : void 0;
 }
 function bindingifyTransformFilter(filterOption) {
 	if (!filterOption) return void 0;
-	let custom = transformFilterMatcherToFilterExprs(filterOption);
+	let filterExprs = transformFilterMatcherToFilterExprs(filterOption);
 	let ret = [];
-	if (custom) ret = custom.map(bindingifyFilterExpr);
-	return { custom: ret.length > 0 ? ret : void 0 };
+	if (filterExprs) ret = filterExprs.map(bindingifyFilterExpr);
+	return { value: ret.length > 0 ? ret : void 0 };
 }
 function bindingifyRenderChunkFilter(filterOption) {
-	if (filterOption) {
-		const { code: code$1 } = filterOption;
-		return { custom: code$1 ? bindingifyGeneralHookFilter(code$1, "code").custom : void 0 };
-	}
+	if (!filterOption) return void 0;
+	if (Array.isArray(filterOption)) return { value: filterOption.map(bindingifyFilterExpr) };
+	return filterOption.code ? bindingifyGeneralHookFilter("code", filterOption.code) : void 0;
 }
 
 //#endregion
@@ -1181,10 +2467,10 @@ var PluginContextImpl = class extends MinimalPluginContextImpl {
 		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) {
@@ -1192,7 +2478,7 @@ var PluginContextImpl = class extends MinimalPluginContextImpl {
 				data.loadModulePromiseResolveFnMap.delete(id$1);
 				throw e;
 			}
-			return promise;
+			return promise$1;
 		}
 		await createLoadModulePromise(this.context, this.data);
 		return this.data.getModuleInfo(id$1, this.context);
@@ -1209,12 +2495,12 @@ var PluginContextImpl = class extends MinimalPluginContextImpl {
 		const info = this.data.getModuleOption(res.id) || {};
 		return {
 			...res,
-			external: res.external === "relative" ? unreachable(`The PluginContext resolve result external couldn't be 'relative'`) : res.external,
+			external: res.external === "relative" ? require_filter_index.unreachable(`The PluginContext resolve result external couldn't be 'relative'`) : res.external,
 			...info
 		};
 	}
 	emitFile = (file) => {
-		if (file.type === "prebuilt-chunk") return unimplemented("PluginContext.emitFile with type prebuilt-chunk");
+		if (file.type === "prebuilt-chunk") return require_filter_index.unimplemented("PluginContext.emitFile with type prebuilt-chunk");
 		if (file.type === "chunk") return this.context.emitChunk(file);
 		const fnSanitizedFileName = file.fileName || typeof this.outputOptions.sanitizeFileName !== "function" ? void 0 : this.outputOptions.sanitizeFileName(file.name || "asset");
 		const filename = file.fileName ? void 0 : this.getAssetFileNames(file);
@@ -1279,41 +2565,41 @@ var TransformPluginContextImpl = class extends PluginContextImpl {
 
 //#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,
@@ -1324,7 +2610,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
@@ -1340,13 +2626,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,
@@ -1358,7 +2644,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
@@ -1368,16 +2654,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
@@ -1393,16 +2679,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
@@ -1429,13 +2715,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)
 	};
@@ -1559,7 +2845,7 @@ function bindingifyFormat(format) {
 		case "iife": return "iife";
 		case "umd": return "umd";
 		case "experimental-app": return "app";
-		default: unimplemented(`output.format: ${format}`);
+		default: require_filter_index.unimplemented(`output.format: ${format}`);
 	}
 }
 function bindingifySourcemap(sourcemap) {
@@ -1833,25 +3119,25 @@ function collectChangedBundle(changed, bundle) {
 
 //#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 };
@@ -1864,30 +3150,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 {
@@ -1897,14 +3183,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 {
@@ -1914,67 +3200,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)
 	};
@@ -1982,24 +3268,24 @@ function bindingifyOutro(args) {
 
 //#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)
 	};
@@ -2069,7 +3355,7 @@ function extractHookUsage(plugin) {
 //#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,
@@ -2079,26 +3365,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,
@@ -2174,13 +3460,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) {
 				return require_parse_ast_index.error(require_parse_ast_index.logPluginError(e, plugin.name, {
 					hook: hookName,
-					id: hookName === "transform" ? args[2] : void 0
+					id: hookName === "transform" ? args$1[2] : void 0
 				}));
 			}
 		};
@@ -2353,7 +3639,7 @@ function bindingifyExternal(external) {
 			if (id$1.startsWith("\0")) return false;
 			return external(id$1, importer, isResolved) ?? false;
 		};
-		const externalArr = arraify(external);
+		const externalArr = require_filter_index.arraify(external);
 		return (id$1, _importer, _isResolved) => {
 			return externalArr.some((pat) => {
 				if (pat instanceof RegExp) return pat.test(id$1);
@@ -2368,7 +3654,7 @@ function bindingifyResolve(resolve) {
 		return {
 			alias: alias ? Object.entries(alias).map(([name, replacement]) => ({
 				find: name,
-				replacements: arraify(replacement)
+				replacements: require_filter_index.arraify(replacement)
 			})) : void 0,
 			extensionAlias: extensionAlias ? Object.entries(extensionAlias).map(([name, value]) => ({
 				target: name,
@@ -2615,7 +3901,7 @@ function createComposedPlugin(plugins) {
 				if (symbolForCallerThatSkipSelf === handlerSymbol) continue;
 				const { handler: handlerFn } = normalizeHook(handler);
 				const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), source, importer, rawHookResolveIdOptions);
-				if (!isNullish(result)) return result;
+				if (!require_filter_index.isNullish(result)) return result;
 			}
 		};
 	}
@@ -2641,7 +3927,7 @@ function createComposedPlugin(plugins) {
 						for (const [handler, plugin] of batchedHandlers) {
 							const { handler: handlerFn } = normalizeHook(handler);
 							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), id$1);
-							if (!isNullish(result)) return result;
+							if (!require_filter_index.isNullish(result)) return result;
 						}
 					};
 				}
@@ -2663,7 +3949,7 @@ function createComposedPlugin(plugins) {
 								throw new Error(`The getCombinedSourcemap is not implement in transform hook at composedJsPlugins`);
 							};
 							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), code$1, id$1, moduleType$1);
-							if (!isNullish(result)) {
+							if (!require_filter_index.isNullish(result)) {
 								if (typeof result === "string") updateOutput(result);
 								else if (result.code) updateOutput(result.code, result.moduleSideEffects);
 							}
@@ -2695,7 +3981,7 @@ function createComposedPlugin(plugins) {
 						for (const [handler, plugin] of batchedHandlers) {
 							const { handler: handlerFn } = normalizeHook(handler);
 							const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), code$1, chunk, options, meta);
-							if (!isNullish(result)) return result;
+							if (!require_filter_index.isNullish(result)) return result;
 						}
 					};
 				}
@@ -2939,6 +4225,9 @@ var RolldownBuild = class {
 	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 ?? [];
 	}
@@ -3062,8 +4351,8 @@ var Watcher = class {
 	}
 };
 async function createWatcher(emitter, input) {
-	const options = arraify(input);
-	const bundlerOptions = await Promise.all(options.map((option) => arraify(option.output || {}).map(async (output) => {
+	const options = require_filter_index.arraify(input);
+	const bundlerOptions = await Promise.all(options.map((option) => require_filter_index.arraify(option.output || {}).map(async (output) => {
 		const inputOptions = await PluginDriver.callOptionsHook(option, true);
 		return createBundlerOptions(inputOptions, output, true);
 	})).flat());
@@ -3091,46 +4380,6 @@ const watch = (input) => {
 	return emitter;
 };
 
-//#endregion
-//#region src/plugin/with-filter.ts
-function withFilterImpl(pluginOption, filterObjectList) {
-	if (isPromiseLike(pluginOption)) return pluginOption.then((p) => withFilter(p, filterObjectList));
-	if (pluginOption == false || pluginOption == null) return pluginOption;
-	if (Array.isArray(pluginOption)) return pluginOption.map((p) => withFilter(p, filterObjectList));
-	let plugin = pluginOption;
-	let filterObjectIndex = findMatchedFilterObject(plugin.name, filterObjectList);
-	if (filterObjectIndex === -1) return plugin;
-	let filterObject = filterObjectList[filterObjectIndex];
-	Object.keys(plugin).forEach((key) => {
-		switch (key) {
-			case "transform":
-			case "resolveId":
-			case "load":
-				if (!plugin[key]) return;
-				if (typeof plugin[key] === "object") plugin[key].filter = filterObject[key] ?? plugin[key].filter;
-				else plugin[key] = {
-					handler: plugin[key],
-					filter: filterObject[key]
-				};
-				break;
-			default: break;
-		}
-	});
-	return plugin;
-}
-function withFilter(pluginOption, filterObject) {
-	return withFilterImpl(pluginOption, arraify(filterObject));
-}
-function findMatchedFilterObject(pluginName, overrideFilterObjectList) {
-	if (overrideFilterObjectList.length === 1 && overrideFilterObjectList[0].pluginNamePattern === void 0) return 0;
-	for (let i$1 = 0; i$1 < overrideFilterObjectList.length; i$1++) for (let j = 0; j < (overrideFilterObjectList[i$1].pluginNamePattern ?? []).length; j++) {
-		let pattern = overrideFilterObjectList[i$1].pluginNamePattern[j];
-		if (typeof pattern === "string" && pattern === pluginName) return i$1;
-		else if (pattern instanceof RegExp && pattern.test(pluginName)) return i$1;
-	}
-	return -1;
-}
-
 //#endregion
 //#region src/utils/define-config.ts
 function defineConfig(config) {
@@ -3160,12 +4409,6 @@ Object.defineProperty(exports, 'VERSION', {
     return VERSION;
   }
 });
-Object.defineProperty(exports, 'arraify', {
-  enumerable: true,
-  get: function () {
-    return arraify;
-  }
-});
 Object.defineProperty(exports, 'bindingifyPlugin', {
   enumerable: true,
   get: function () {
@@ -3205,7 +4448,7 @@ Object.defineProperty(exports, 'defineConfig', {
 Object.defineProperty(exports, 'description', {
   enumerable: true,
   get: function () {
-    return description;
+    return description$1;
   }
 });
 Object.defineProperty(exports, 'dynamicImportVarsPlugin', {
@@ -3333,10 +4576,4 @@ Object.defineProperty(exports, 'watch', {
   get: function () {
     return watch;
   }
-});
-Object.defineProperty(exports, 'withFilter', {
-  enumerable: true,
-  get: function () {
-    return withFilter;
-  }
 });