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

package/dist/browser.mjs

@@ -1,11 +1,9 @@
 import { BindingHookSideEffects, BindingLogLevel, BindingPluginOrder, BindingWatcher, Bundler, parseSync, shutdownAsyncRuntime, startAsyncRuntime } from "./rolldown-binding.wasi-browser.js";
 import path from "pathe";
-import "@valibot/to-json-schema";
 import colors from "ansis";
-import * as v from "valibot";
 
 //#region package.json
-var version = "1.0.0-beta.8-commit.852c603";
+var version = "1.0.0-beta.8-commit.a720367";
 
 //#endregion
 //#region src/builtin-plugin/utils.ts
@@ -33,9 +31,6 @@ function arraify(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");
@@ -424,11 +419,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$1) => v$1?.then));
-	return array;
+		array$1 = (await Promise.all(array$1)).flat(Infinity);
+	while (array$1.some((v) => v?.then));
+	return array$1;
 }
 
 //#endregion
@@ -543,201 +538,1170 @@ 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 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 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 src/utils/validator.ts
-const StringOrRegExpSchema = v.union([v.string(), v.instance(RegExp)]);
-const LogLevelSchema = v.union([
-	v.literal("debug"),
-	v.literal("info"),
-	v.literal("warn")
+const StringOrRegExpSchema = union([string(), instance(RegExp)]);
+const LogLevelSchema = union([
+	literal("debug"),
+	literal("info"),
+	literal("warn")
 ]);
-const LogLevelOptionSchema = v.union([LogLevelSchema, v.literal("silent")]);
-const LogLevelWithErrorSchema = v.union([LogLevelSchema, v.literal("error")]);
-const RollupLogSchema = v.any();
-const RollupLogWithStringSchema = v.union([RollupLogSchema, v.string()]);
-const InputOptionSchema = v.union([
-	v.string(),
-	v.array(v.string()),
-	v.record(v.string(), v.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 = v.union([
+const ExternalSchema = union([
 	StringOrRegExpSchema,
-	v.array(StringOrRegExpSchema),
-	v.pipe(v.function(), v.args(v.tuple([
-		v.string(),
-		v.optional(v.string()),
-		v.boolean()
-	])), v.returns(v.nullish(v.boolean())))
+	array(StringOrRegExpSchema),
+	pipe(function_(), args(tuple([
+		string(),
+		optional(string()),
+		boolean()
+	])), returns(nullish(boolean())))
 ]);
-const ModuleTypesSchema = v.record(v.string(), v.union([
-	v.literal("base64"),
-	v.literal("binary"),
-	v.literal("css"),
-	v.literal("dataurl"),
-	v.literal("empty"),
-	v.literal("js"),
-	v.literal("json"),
-	v.literal("jsx"),
-	v.literal("text"),
-	v.literal("ts"),
-	v.literal("tsx")
+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 = v.strictObject({
-	development: v.pipe(v.optional(v.boolean()), v.description("Development specific information")),
-	factory: v.pipe(v.optional(v.string()), v.description("Jsx element transformation")),
-	fragment: v.pipe(v.optional(v.string()), v.description("Jsx fragment transformation")),
-	importSource: v.pipe(v.optional(v.string()), v.description("Import the factory of element and fragment if mode is classic")),
-	jsxImportSource: v.pipe(v.optional(v.string()), v.description("Import the factory of element and fragment if mode is automatic")),
-	mode: v.pipe(v.optional(v.union([
-		v.literal("classic"),
-		v.literal("automatic"),
-		v.literal("preserve")
-	])), v.description("Jsx transformation mode")),
-	refresh: v.pipe(v.optional(v.boolean()), v.description("React refresh transformation"))
+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 = v.union([v.literal("Runtime"), v.literal("External")]);
-const DecoratorOptionSchema = v.object({
-	legacy: v.optional(v.boolean()),
-	emitDecoratorMetadata: v.optional(v.boolean())
+const HelperModeSchema = union([literal("Runtime"), literal("External")]);
+const DecoratorOptionSchema = object({
+	legacy: optional(boolean()),
+	emitDecoratorMetadata: optional(boolean())
 });
-const HelpersSchema = v.object({ mode: v.optional(HelperModeSchema) });
-const RewriteImportExtensionsSchema = v.union([
-	v.literal("rewrite"),
-	v.literal("remove"),
-	v.boolean()
+const HelpersSchema = object({ mode: optional(HelperModeSchema) });
+const RewriteImportExtensionsSchema = union([
+	literal("rewrite"),
+	literal("remove"),
+	boolean()
 ]);
-const TypescriptSchema = v.object({
-	jsxPragma: v.optional(v.string()),
-	jsxPragmaFrag: v.optional(v.string()),
-	onlyRemoveTypeImports: v.optional(v.boolean()),
-	allowNamespaces: v.optional(v.boolean()),
-	allowDeclareFields: v.optional(v.boolean()),
-	declaration: v.optional(v.object({
-		stripInternal: v.optional(v.boolean()),
-		sourcemap: v.optional(v.boolean())
+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: v.optional(RewriteImportExtensionsSchema)
+	rewriteImportExtensions: optional(RewriteImportExtensionsSchema)
 });
-const AssumptionsSchema = v.object({
-	ignoreFunctionLength: v.optional(v.boolean()),
-	noDocumentAll: v.optional(v.boolean()),
-	objectRestNoSymbols: v.optional(v.boolean()),
-	pureGetters: v.optional(v.boolean()),
-	setPublicClassFields: v.optional(v.boolean())
+const AssumptionsSchema = object({
+	ignoreFunctionLength: optional(boolean()),
+	noDocumentAll: optional(boolean()),
+	objectRestNoSymbols: optional(boolean()),
+	pureGetters: optional(boolean()),
+	setPublicClassFields: optional(boolean())
 });
-const TransformOptionsSchema = v.object({
-	assumptions: v.optional(AssumptionsSchema),
-	typescript: v.optional(TypescriptSchema),
-	helpers: v.optional(HelpersSchema),
-	decorators: v.optional(DecoratorOptionSchema)
+const TransformOptionsSchema = object({
+	assumptions: optional(AssumptionsSchema),
+	typescript: optional(TypescriptSchema),
+	helpers: optional(HelpersSchema),
+	decorators: optional(DecoratorOptionSchema)
 });
-const WatchOptionsSchema = v.strictObject({
-	chokidar: v.optional(v.never(`The "watch.chokidar" option is deprecated, please use "watch.notify" instead of it`)),
-	exclude: v.optional(v.union([StringOrRegExpSchema, v.array(StringOrRegExpSchema)])),
-	include: v.optional(v.union([StringOrRegExpSchema, v.array(StringOrRegExpSchema)])),
-	notify: v.pipe(v.optional(v.strictObject({
-		compareContents: v.optional(v.boolean()),
-		pollInterval: v.optional(v.number())
-	})), v.description("Notify options")),
-	skipWrite: v.pipe(v.optional(v.boolean()), v.description("Skip the bundle.write() step")),
-	buildDelay: v.pipe(v.optional(v.number()), v.description("Throttle watch rebuilds"))
+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 = v.strictObject({
-	circularDependency: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting circular dependency")),
-	eval: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting eval")),
-	missingGlobalName: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting missing global name")),
-	missingNameOptionForIifeExport: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting missing name option for iife export")),
-	mixedExport: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting mixed export")),
-	unresolvedEntry: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting unresolved entry")),
-	unresolvedImport: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting unresolved import")),
-	filenameConflict: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting filename conflict")),
-	commonJsVariableInEsm: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting common js variable in esm")),
-	importIsUndefined: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting import is undefined")),
-	configurationFieldConflict: v.pipe(v.optional(v.boolean()), v.description("Whether to emit warning when detecting configuration field conflict"))
+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 = v.strictObject({
-	mangle: v.optional(v.boolean()),
-	compress: v.optional(v.boolean()),
-	removeWhitespace: v.optional(v.boolean())
+const MinifyOptionsSchema = strictObject({
+	mangle: optional(boolean()),
+	compress: optional(boolean()),
+	removeWhitespace: optional(boolean())
 });
-const ResolveOptionsSchema = v.strictObject({
-	alias: v.optional(v.record(v.string(), v.union([v.string(), v.array(v.string())]))),
-	aliasFields: v.optional(v.array(v.array(v.string()))),
-	conditionNames: v.optional(v.array(v.string())),
-	extensionAlias: v.optional(v.record(v.string(), v.array(v.string()))),
-	exportsFields: v.optional(v.array(v.array(v.string()))),
-	extensions: v.optional(v.array(v.string())),
-	mainFields: v.optional(v.array(v.string())),
-	mainFiles: v.optional(v.array(v.string())),
-	modules: v.optional(v.array(v.string())),
-	symlinks: v.optional(v.boolean()),
-	tsconfigFilename: v.optional(v.string())
+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 = v.union([v.boolean(), v.looseObject({
-	annotations: v.optional(v.boolean()),
-	manualPureFunctions: v.optional(v.array(v.string())),
-	unknownGlobalSideEffects: v.optional(v.boolean())
+const TreeshakingOptionsSchema = union([boolean(), looseObject({
+	annotations: optional(boolean()),
+	manualPureFunctions: optional(array(string())),
+	unknownGlobalSideEffects: optional(boolean())
 })]);
-const OnLogSchema = v.pipe(v.function(), v.args(v.tuple([
+const OnLogSchema = pipe(function_(), args(tuple([
 	LogLevelSchema,
 	RollupLogSchema,
-	v.pipe(v.function(), v.args(v.tuple([LogLevelWithErrorSchema, RollupLogWithStringSchema])))
+	pipe(function_(), args(tuple([LogLevelWithErrorSchema, RollupLogWithStringSchema])))
 ])));
-const OnwarnSchema = v.pipe(v.function(), v.args(v.tuple([RollupLogSchema, v.pipe(v.function(), v.args(v.tuple([v.union([RollupLogWithStringSchema, v.pipe(v.function(), v.returns(RollupLogWithStringSchema))])])))])));
-const HmrSchema = v.union([v.boolean(), v.strictObject({
-	port: v.optional(v.number()),
-	host: v.optional(v.string()),
-	implement: v.optional(v.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 = v.strictObject({
-	input: v.optional(InputOptionSchema),
-	plugins: v.optional(v.custom(() => true)),
-	external: v.optional(ExternalSchema),
-	resolve: v.optional(ResolveOptionsSchema),
-	cwd: v.pipe(v.optional(v.string()), v.description("Current working directory")),
-	platform: v.pipe(v.optional(v.union([
-		v.literal("browser"),
-		v.literal("neutral"),
-		v.literal("node")
-	])), v.description(`Platform for which the code should be generated (node, ${colors.underline("browser")}, neutral)`)),
-	shimMissingExports: v.pipe(v.optional(v.boolean()), v.description("Create shim variables for missing exports")),
-	treeshake: v.optional(TreeshakingOptionsSchema),
-	logLevel: v.pipe(v.optional(LogLevelOptionSchema), v.description(`Log level (${colors.dim("silent")}, ${colors.underline(colors.gray("info"))}, debug, ${colors.yellow("warn")})`)),
-	onLog: v.optional(OnLogSchema),
-	onwarn: v.optional(OnwarnSchema),
-	moduleTypes: v.pipe(v.optional(ModuleTypesSchema), v.description("Module types for customized extensions")),
-	experimental: v.optional(v.strictObject({
-		disableLiveBindings: v.optional(v.boolean()),
-		enableComposingJsPlugins: v.optional(v.boolean()),
-		resolveNewUrlToAsset: v.optional(v.boolean()),
-		strictExecutionOrder: v.optional(v.boolean()),
-		hmr: v.optional(HmrSchema)
+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, ${colors.underline("browser")}, neutral)`)),
+	shimMissingExports: pipe(optional(boolean()), description("Create shim variables for missing exports")),
+	treeshake: optional(TreeshakingOptionsSchema),
+	logLevel: pipe(optional(LogLevelOptionSchema), description(`Log level (${colors.dim("silent")}, ${colors.underline(colors.gray("info"))}, debug, ${colors.yellow("warn")})`)),
+	onLog: optional(OnLogSchema),
+	onwarn: optional(OnwarnSchema),
+	moduleTypes: pipe(optional(ModuleTypesSchema), description("Module types for customized extensions")),
+	experimental: optional(strictObject({
+		disableLiveBindings: optional(boolean()),
+		enableComposingJsPlugins: optional(boolean()),
+		resolveNewUrlToAsset: optional(boolean()),
+		strictExecutionOrder: optional(boolean()),
+		hmr: optional(HmrSchema)
 	})),
-	define: v.pipe(v.optional(v.record(v.string(), v.string())), v.description("Define global variables")),
-	inject: v.optional(v.record(v.string(), v.union([v.string(), v.tuple([v.string(), v.string()])]))),
-	profilerNames: v.optional(v.boolean()),
-	jsx: v.optional(v.union([
-		v.boolean(),
+	define: pipe(optional(record(string(), string())), description("Define global variables")),
+	inject: optional(record(string(), union([string(), tuple([string(), string()])]))),
+	profilerNames: optional(boolean()),
+	jsx: optional(union([
+		boolean(),
 		JsxOptionsSchema,
-		v.string("react"),
-		v.string("react-jsx"),
-		v.string("preserve")
+		string("react"),
+		string("react-jsx"),
+		string("preserve")
 	])),
-	transform: v.optional(TransformOptionsSchema),
-	watch: v.optional(v.union([WatchOptionsSchema, v.literal(false)])),
-	dropLabels: v.pipe(v.optional(v.array(v.string())), v.description("Remove labeled statements with these label names")),
-	checks: v.optional(ChecksOptionsSchema),
-	keepNames: v.pipe(v.optional(v.boolean()), v.description("Keep function/class name")),
-	debug: v.pipe(v.optional(v.object({ sessionId: v.pipe(v.optional(v.string()), v.description("Used to name the build.")) })), v.description("Enable debug mode. Emit debug information to disk. This might slow down the build process significantly."))
+	transform: optional(TransformOptionsSchema),
+	watch: optional(union([WatchOptionsSchema, literal(false)])),
+	dropLabels: pipe(optional(array(string())), description("Remove labeled statements with these label names")),
+	checks: optional(ChecksOptionsSchema),
+	keepNames: pipe(optional(boolean()), description("Keep function/class name")),
+	debug: pipe(optional(object({ sessionId: pipe(optional(string()), description("Used to name the build.")) })), description("Enable debug mode. Emit debug information to disk. This might slow down the build process significantly."))
 });
-const InputCliOverrideSchema = v.strictObject({
-	input: v.pipe(v.optional(v.array(v.string())), v.description("Entry file")),
-	external: v.pipe(v.optional(v.array(v.string())), v.description("Comma-separated list of module ids to exclude from the bundle `<module-id>,...`")),
-	inject: v.pipe(v.optional(v.record(v.string(), v.string())), v.description("Inject import statements on demand")),
-	treeshake: v.pipe(v.optional(v.boolean()), v.description("enable treeshaking")),
-	jsx: v.pipe(v.optional(JsxOptionsSchema), v.description("enable jsx"))
+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 = v.omit(v.strictObject({
+const InputCliOptionsSchema = omit(strictObject({
 	...InputOptionsSchema.entries,
 	...InputCliOverrideSchema.entries
 }), [
@@ -764,87 +1728,87 @@ var ESTarget = /* @__PURE__ */ function(ESTarget$1) {
 	ESTarget$1["ESNext"] = "esnext";
 	return ESTarget$1;
 }(ESTarget || {});
-const ModuleFormatSchema = v.union([
-	v.literal("es"),
-	v.literal("cjs"),
-	v.literal("esm"),
-	v.literal("module"),
-	v.literal("commonjs"),
-	v.literal("iife"),
-	v.literal("umd")
+const ModuleFormatSchema = union([
+	literal("es"),
+	literal("cjs"),
+	literal("esm"),
+	literal("module"),
+	literal("commonjs"),
+	literal("iife"),
+	literal("umd")
 ]);
-const AddonFunctionSchema = v.pipe(v.function(), v.args(v.tuple([v.custom(() => true)])), v.returnsAsync(v.unionAsync([v.string(), v.pipeAsync(v.promise(), v.awaitAsync(), v.string())])));
-const ChunkFileNamesSchema = v.union([v.string(), v.pipe(v.function(), v.args(v.tuple([v.custom(() => true)])), v.returns(v.string()))]);
-const AssetFileNamesSchema = v.union([v.string(), v.pipe(v.function(), v.args(v.tuple([v.custom(() => true)])), v.returns(v.string()))]);
-const SanitizeFileNameSchema = v.union([v.boolean(), v.pipe(v.function(), v.args(v.tuple([v.string()])), v.returns(v.string()))]);
-const GlobalsFunctionSchema = v.pipe(v.function(), v.args(v.tuple([v.string()])), v.returns(v.string()));
-const AdvancedChunksSchema = v.strictObject({
-	minSize: v.optional(v.number()),
-	maxSize: v.optional(v.number()),
-	minModuleSize: v.optional(v.number()),
-	maxModuleSize: v.optional(v.number()),
-	minShareCount: v.optional(v.number()),
-	groups: v.optional(v.array(v.strictObject({
-		name: v.string(),
-		test: v.optional(v.union([v.string(), v.instance(RegExp)])),
-		priority: v.optional(v.number()),
-		minSize: v.optional(v.number()),
-		minShareCount: v.optional(v.number()),
-		maxSize: v.optional(v.number()),
-		minModuleSize: v.optional(v.number()),
-		maxModuleSize: v.optional(v.number())
+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 = v.strictObject({
-	dir: v.pipe(v.optional(v.string()), v.description("Output directory, defaults to `dist` if `file` is not set")),
-	file: v.pipe(v.optional(v.string()), v.description("Single output file")),
-	exports: v.pipe(v.optional(v.union([
-		v.literal("auto"),
-		v.literal("named"),
-		v.literal("default"),
-		v.literal("none")
-	])), v.description(`Specify a export mode (${colors.underline("auto")}, named, default, none)`)),
-	hashCharacters: v.pipe(v.optional(v.union([
-		v.literal("base64"),
-		v.literal("base36"),
-		v.literal("hex")
-	])), v.description("Use the specified character set for file hashes")),
-	format: v.pipe(v.optional(ModuleFormatSchema), v.description(`Output format of the generated bundle (supports ${colors.underline("esm")}, cjs, and iife)`)),
-	sourcemap: v.pipe(v.optional(v.union([
-		v.boolean(),
-		v.literal("inline"),
-		v.literal("hidden")
-	])), v.description(`Generate sourcemap (\`-s inline\` for inline, or ${colors.bold("pass the `-s` on the last argument if you want to generate `.map` file")})`)),
-	sourcemapDebugIds: v.pipe(v.optional(v.boolean()), v.description("Inject sourcemap debug IDs")),
-	sourcemapIgnoreList: v.optional(v.union([v.boolean(), v.custom(() => true)])),
-	sourcemapPathTransform: v.optional(v.custom(() => true)),
-	banner: v.optional(v.union([v.string(), AddonFunctionSchema])),
-	footer: v.optional(v.union([v.string(), AddonFunctionSchema])),
-	intro: v.optional(v.union([v.string(), AddonFunctionSchema])),
-	outro: v.optional(v.union([v.string(), AddonFunctionSchema])),
-	extend: v.pipe(v.optional(v.boolean()), v.description("Extend global variable defined by name in IIFE / UMD formats")),
-	esModule: v.optional(v.union([v.boolean(), v.literal("if-default-prop")])),
-	assetFileNames: v.optional(AssetFileNamesSchema),
-	entryFileNames: v.optional(ChunkFileNamesSchema),
-	chunkFileNames: v.optional(ChunkFileNamesSchema),
-	cssEntryFileNames: v.optional(ChunkFileNamesSchema),
-	cssChunkFileNames: v.optional(ChunkFileNamesSchema),
-	sanitizeFileName: v.optional(SanitizeFileNameSchema),
-	minify: v.pipe(v.optional(v.union([
-		v.boolean(),
-		v.string("dce-only"),
+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 (${colors.underline("auto")}, named, default, none)`)),
+	hashCharacters: pipe(optional(union([
+		literal("base64"),
+		literal("base36"),
+		literal("hex")
+	])), description("Use the specified character set for file hashes")),
+	format: pipe(optional(ModuleFormatSchema), description(`Output format of the generated bundle (supports ${colors.underline("esm")}, cjs, and iife)`)),
+	sourcemap: pipe(optional(union([
+		boolean(),
+		literal("inline"),
+		literal("hidden")
+	])), description(`Generate sourcemap (\`-s inline\` for inline, or ${colors.bold("pass the `-s` on the last argument if you want to generate `.map` file")})`)),
+	sourcemapDebugIds: pipe(optional(boolean()), description("Inject sourcemap debug IDs")),
+	sourcemapIgnoreList: optional(union([boolean(), custom(() => true)])),
+	sourcemapPathTransform: optional(custom(() => true)),
+	banner: optional(union([string(), AddonFunctionSchema])),
+	footer: optional(union([string(), AddonFunctionSchema])),
+	intro: optional(union([string(), AddonFunctionSchema])),
+	outro: optional(union([string(), AddonFunctionSchema])),
+	extend: pipe(optional(boolean()), description("Extend global variable defined by name in IIFE / UMD formats")),
+	esModule: optional(union([boolean(), literal("if-default-prop")])),
+	assetFileNames: optional(AssetFileNamesSchema),
+	entryFileNames: optional(ChunkFileNamesSchema),
+	chunkFileNames: optional(ChunkFileNamesSchema),
+	cssEntryFileNames: optional(ChunkFileNamesSchema),
+	cssChunkFileNames: optional(ChunkFileNamesSchema),
+	sanitizeFileName: optional(SanitizeFileNameSchema),
+	minify: pipe(optional(union([
+		boolean(),
+		string("dce-only"),
 		MinifyOptionsSchema
-	])), v.description("Minify the bundled file")),
-	name: v.pipe(v.optional(v.string()), v.description("Name for UMD / IIFE format outputs")),
-	globals: v.pipe(v.optional(v.union([v.record(v.string(), v.string()), GlobalsFunctionSchema])), v.description("Global variable of UMD / IIFE dependencies (syntax: `key=value`)")),
-	externalLiveBindings: v.pipe(v.optional(v.boolean()), v.description("external live bindings")),
-	inlineDynamicImports: v.pipe(v.optional(v.boolean()), v.description("Inline dynamic imports")),
-	advancedChunks: v.optional(AdvancedChunksSchema),
-	comments: v.pipe(v.optional(v.union([v.literal("none"), v.literal("preserve-legal")])), v.description("Control comments in the output")),
-	plugins: v.optional(v.custom(() => true)),
-	polyfillRequire: v.pipe(v.optional(v.boolean()), v.description("Disable require polyfill injection")),
-	target: v.pipe(v.optional(v.enum(ESTarget)), v.description("The JavaScript target environment")),
-	hoistTransitiveImports: v.optional(v.custom((input) => {
+	])), description("Minify the bundled file")),
+	name: pipe(optional(string()), description("Name for UMD / IIFE format outputs")),
+	globals: pipe(optional(union([record(string(), string()), GlobalsFunctionSchema])), description("Global variable of UMD / IIFE dependencies (syntax: `key=value`)")),
+	externalLiveBindings: pipe(optional(boolean()), description("external live bindings")),
+	inlineDynamicImports: pipe(optional(boolean()), description("Inline dynamic imports")),
+	advancedChunks: optional(AdvancedChunksSchema),
+	comments: pipe(optional(union([literal("none"), literal("preserve-legal")])), description("Control comments in the output")),
+	plugins: optional(custom(() => true)),
+	polyfillRequire: pipe(optional(boolean()), description("Disable require polyfill injection")),
+	target: pipe(optional(enum_(ESTarget)), description("The JavaScript target environment")),
+	hoistTransitiveImports: optional(custom((input) => {
 		if (input) return false;
 		return true;
 	}, () => `The 'true' value is not supported`))
@@ -852,26 +1816,26 @@ const OutputOptionsSchema = v.strictObject({
 const getAddonDescription = (placement, wrapper) => {
 	return `Code to insert the ${colors.bold(placement)} of the bundled file (${colors.bold(wrapper)} the wrapper function)`;
 };
-const OutputCliOverrideSchema = v.strictObject({
-	assetFileNames: v.pipe(v.optional(v.string()), v.description("Name pattern for asset files")),
-	entryFileNames: v.pipe(v.optional(v.string()), v.description("Name pattern for emitted entry chunks")),
-	chunkFileNames: v.pipe(v.optional(v.string()), v.description("Name pattern for emitted secondary chunks")),
-	cssEntryFileNames: v.pipe(v.optional(v.string()), v.description("Name pattern for emitted css entry chunks")),
-	cssChunkFileNames: v.pipe(v.optional(v.string()), v.description("Name pattern for emitted css secondary chunks")),
-	sanitizeFileName: v.pipe(v.optional(v.boolean()), v.description("Sanitize file name")),
-	banner: v.pipe(v.optional(v.string()), v.description(getAddonDescription("top", "outside"))),
-	footer: v.pipe(v.optional(v.string()), v.description(getAddonDescription("bottom", "outside"))),
-	intro: v.pipe(v.optional(v.string()), v.description(getAddonDescription("top", "inside"))),
-	outro: v.pipe(v.optional(v.string()), v.description(getAddonDescription("bottom", "inside"))),
-	esModule: v.pipe(v.optional(v.boolean()), v.description("Always generate `__esModule` marks in non-ESM formats, defaults to `if-default-prop` (use `--no-esModule` to always disable)")),
-	globals: v.pipe(v.optional(v.record(v.string(), v.string())), v.description("Global variable of UMD / IIFE dependencies (syntax: `key=value`)")),
-	advancedChunks: v.pipe(v.optional(v.strictObject({
-		minSize: v.pipe(v.optional(v.number()), v.description("Minimum size of the chunk")),
-		minShareCount: v.pipe(v.optional(v.number()), v.description("Minimum share count of the chunk"))
-	})), v.description("Global variable of UMD / IIFE dependencies (syntax: `key=value`)")),
-	minify: v.pipe(v.optional(v.boolean()), v.description("Minify the bundled file"))
+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 = v.omit(v.strictObject({
+const OutputCliOptionsSchema = omit(strictObject({
 	...OutputOptionsSchema.entries,
 	...OutputCliOverrideSchema.entries
 }), [
@@ -880,11 +1844,11 @@ const OutputCliOptionsSchema = v.omit(v.strictObject({
 	"plugins",
 	"hoistTransitiveImports"
 ]);
-const CliOptionsSchema = v.strictObject({
-	config: v.pipe(v.optional(v.union([v.string(), v.boolean()])), v.description("Path to the config file (default: `rolldown.config.js`)")),
-	help: v.pipe(v.optional(v.boolean()), v.description("Show help")),
-	version: v.pipe(v.optional(v.boolean()), v.description("Show version number")),
-	watch: v.pipe(v.optional(v.boolean()), v.description("Watch files in bundle and rebuild on changes")),
+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
 });
@@ -892,7 +1856,7 @@ const inputHelperMsgRecord = { output: { ignored: true } };
 const outputHelperMsgRecord = {};
 function validateOption(key, options) {
 	if (globalThis.process?.env?.ROLLDOWN_OPTIONS_VALIDATION === "loose") return;
-	let parsed = v.safeParse(key === "input" ? InputOptionsSchema : OutputOptionsSchema, options);
+	let parsed = safeParse(key === "input" ? InputOptionsSchema : OutputOptionsSchema, options);
 	if (!parsed.success) {
 		const errors = parsed.issues.map((issue) => {
 			const issuePaths = issue.path.map((path$1) => path$1.key);
@@ -1047,9 +2011,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) {
@@ -1097,68 +2061,104 @@ function t(...n) {
 }
 
 //#endregion
-//#region src/filter-expression-index.ts
-function and(left, right) {
-	return {
-		kind: "and",
-		left,
-		right
-	};
+//#region src/filter-index.ts
+var And = class {
+	kind;
+	args;
+	constructor(...args$1) {
+		if (args$1.length === 0) throw new Error("`And` expects at least one operand");
+		this.args = args$1;
+		this.kind = "and";
+	}
+};
+var Or = class {
+	kind;
+	args;
+	constructor(...args$1) {
+		if (args$1.length === 0) throw new Error("`Or` expects at least one operand");
+		this.args = args$1;
+		this.kind = "or";
+	}
+};
+var Id = class {
+	kind;
+	pattern;
+	constructor(pattern) {
+		this.pattern = pattern;
+		this.kind = "id";
+	}
+};
+var ModuleType = class {
+	kind;
+	pattern;
+	constructor(pattern) {
+		this.pattern = pattern;
+		this.kind = "moduleType";
+	}
+};
+var Code = class {
+	kind;
+	pattern;
+	constructor(expr) {
+		this.pattern = expr;
+		this.kind = "code";
+	}
+};
+var Include = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "include";
+	}
+};
+var Exclude = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "exclude";
+	}
+};
+function and(...args$1) {
+	return new And(...args$1);
 }
-function or(left, right) {
-	return {
-		kind: "or",
-		left,
-		right
-	};
+function or(...args$1) {
+	return new Or(...args$1);
 }
 function id(pattern) {
-	return {
-		kind: "id",
-		pattern
-	};
+	return new Id(pattern);
 }
 function moduleType(pattern) {
-	return {
-		kind: "moduleType",
-		pattern
-	};
+	return new ModuleType(pattern);
 }
 function code(pattern) {
-	return {
-		kind: "code",
-		pattern
-	};
+	return new Code(pattern);
 }
 function include(expr) {
-	return {
-		kind: "include",
-		expr
-	};
+	return new Include(expr);
 }
 function exclude(expr) {
-	return {
-		kind: "exclude",
-		expr
-	};
+	return new Exclude(expr);
 }
 
 //#endregion
 //#region src/plugin/bindingify-hook-filter.ts
 function generalHookFilterMatcherToFilterExprs(matcher, stringKind) {
-	if (typeof matcher === "string" || matcher instanceof RegExp) return [include(id(matcher))];
-	if (Array.isArray(matcher)) return matcher.map((m) => include(id(m)));
-	if (matcher.custom) return matcher.custom;
+	if (typeof matcher === "string" || matcher instanceof RegExp) return [include(generateAtomMatcher(stringKind, matcher))];
+	if (Array.isArray(matcher)) return matcher.map((m) => include(generateAtomMatcher(stringKind, m)));
 	let ret = [];
-	let isCode = stringKind === "code";
-	if (matcher.exclude) ret.push(...arraify(matcher.exclude).map((m) => exclude(isCode ? code(m) : id(m))));
-	if (matcher.include) ret.push(...arraify(matcher.include).map((m) => include(isCode ? code(m) : id(m))));
+	if (matcher.exclude) ret.push(...arraify(matcher.exclude).map((m) => exclude(generateAtomMatcher(stringKind, m))));
+	if (matcher.include) ret.push(...arraify(matcher.include).map((m) => include(generateAtomMatcher(stringKind, m))));
 	return ret;
 }
+function generateAtomMatcher(kind, matcher) {
+	return kind === "code" ? code(matcher) : 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 = [];
@@ -1168,33 +2168,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) => moduleType(m)));
+		andExprList.push(or(...moduleTypes.map((m) => moduleType(m))));
 	}
-	if (idIncludes.length) {
-		let joinedOrExpr = joinFilterExprsWithOr(idIncludes.map((item) => item.expr));
-		if (!cursor) cursor = joinedOrExpr;
-		else cursor = and(cursor, joinedOrExpr);
-	}
-	if (codeIncludes.length) {
-		let joinedOrExpr = joinFilterExprsWithOr(codeIncludes.map((item) => item.expr));
-		if (!cursor) cursor = joinedOrExpr;
-		else cursor = and(cursor, joinedOrExpr);
-	}
-	if (cursor) ret.push(include(cursor));
+	if (idIncludes.length) andExprList.push(or(...idIncludes.map((item) => item.expr)));
+	if (codeIncludes.length) andExprList.push(or(...codeIncludes.map((item) => item.expr)));
+	if (andExprList.length) ret.push(include(and(...andExprList)));
 	return ret;
 }
-function joinFilterExprsWithOr(filterExprs) {
-	if (filterExprs.length === 1) return filterExprs[0];
-	return 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 = [];
@@ -1204,9 +2192,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": {
@@ -1217,21 +2217,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;
 		}
@@ -1245,27 +2245,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
@@ -1392,10 +2395,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) {
@@ -1403,7 +2406,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);
@@ -1490,41 +2493,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,
@@ -1535,7 +2538,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
@@ -1551,13 +2554,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,
@@ -1569,7 +2572,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
@@ -1579,16 +2582,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
@@ -1604,16 +2607,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
@@ -1640,13 +2643,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)
 	};
@@ -2044,25 +3047,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 };
@@ -2075,30 +3078,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 {
@@ -2108,14 +3111,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 {
@@ -2125,67 +3128,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)
 	};
@@ -2193,24 +3196,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)
 	};
@@ -2280,7 +3283,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,
@@ -2290,26 +3293,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$1, 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$1, 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,
@@ -2385,13 +3388,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 error(logPluginError(e, plugin.name, {
 					hook: hookName,
-					id: hookName === "transform" ? args[2] : void 0
+					id: hookName === "transform" ? args$1[2] : void 0
 				}));
 			}
 		};
@@ -2445,13 +3448,13 @@ var PluginContextData = class {
 			get() {
 				return moduleSideEffects;
 			},
-			set: (v$1) => {
+			set: (v) => {
 				this.updateModuleOption(id$1, {
-					moduleSideEffects: v$1,
+					moduleSideEffects: v,
 					meta: info.meta,
 					invalidate: true
 				});
-				moduleSideEffects = v$1;
+				moduleSideEffects = v;
 			}
 		});
 		return info;
@@ -3098,6 +4101,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 ?? [];
 	}
@@ -3250,46 +4256,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) {
@@ -3301,4 +4267,4 @@ function defineConfig(config) {
 const VERSION = version;
 
 //#endregion
-export { VERSION, build, defineConfig, rolldown, watch, withFilter };
+export { VERSION, build, defineConfig, rolldown, watch };