@jixo/cli 0.24.1 → 0.25.0

package/assets/bundle/google-aistudio.browser.js

@@ -1,7 +1,7 @@
-const obj_assign_props = /* @__NO_SIDE_EFFECTS__ */ (a, b) => {
-	const b_props = Object.getOwnPropertyDescriptors(b);
-	Object.defineProperties(a, b_props);
-	return a;
+const obj_assign_props = /* @__NO_SIDE_EFFECTS__ */ (a$1, b$1) => {
+	const b_props = Object.getOwnPropertyDescriptors(b$1);
+	Object.defineProperties(a$1, b_props);
+	return a$1;
 };
 const isPromiseLike = (value) => value !== null && typeof value?.then === "function";
 const func_remember = /* @__NO_SIDE_EFFECTS__ */ (func, key) => {
@@ -218,17 +218,17 @@ const prepareDirHandle = async () => {
 		rootDirHandle = await window.showDirectoryPicker({ mode: "readwrite" });
 		console.log(`%c✅ 根文件夹已选择: %c${rootDirHandle.name}`, styles.success, styles.code);
 		return rootDirHandle;
-	} catch (e) {
+	} catch (e$1) {
 		clearTimeout(ti);
-		if (e instanceof Error) {
-			if (e.name === "SecurityError" || e.name === "NotAllowedError") {
+		if (e$1 instanceof Error) {
+			if (e$1.name === "SecurityError" || e$1.name === "NotAllowedError") {
 				console.log("%c请将鼠标聚焦到窗口视图中", styles.info);
 				await delay(1e3);
 				return prepareDirHandle();
 			}
-			if (e.name === "AbortError") throw new DOMException("用户取消了文件夹选择", "AbortError");
+			if (e$1.name === "AbortError") throw new DOMException("用户取消了文件夹选择", "AbortError");
 		}
-		throw e;
+		throw e$1;
 	}
 };
 const getEasyFs = /* @__PURE__ */ func_remember(async () => {
@@ -241,7 +241,7 @@ const getEasyFs = /* @__PURE__ */ func_remember(async () => {
 		let curr = dirHandle;
 		const parts = path.split("/").filter(Boolean);
 		const last = parts.at(-1);
-		for (let i = 0; i < parts.length - 1; i++) curr = await curr.getDirectoryHandle(parts[i], { create });
+		for (let i$1 = 0; i$1 < parts.length - 1; i$1++) curr = await curr.getDirectoryHandle(parts[i$1], { create });
 		return {
 			parent: curr,
 			name: last,
@@ -258,10 +258,10 @@ const getEasyFs = /* @__PURE__ */ func_remember(async () => {
 	const writeFile = async (filePath, data, opts) => {
 		const { getFile } = await getHandle(filePath, { create: true });
 		const handle = await getFile();
-		const w = await handle.createWritable();
-		if (!opts?.append) await w.truncate(0);
-		await w.write(data);
-		await w.close();
+		const w$1 = await handle.createWritable();
+		if (!opts?.append) await w$1.truncate(0);
+		await w$1.write(data);
+		await w$1.close();
 	};
 	const createWriteStream = async (filePath) => {
 		const { getFile } = await getHandle(filePath, { create: true });
@@ -307,12 +307,12 @@ const getEasyFs = /* @__PURE__ */ func_remember(async () => {
 	const stat = async (path) => {
 		const { getFile, getDir } = await getHandle(path);
 		try {
-			const h = await getFile();
-			const f = await h.getFile();
+			const h$1 = await getFile();
+			const f$1 = await h$1.getFile();
 			return {
 				isFile: true,
-				size: f.size,
-				lastModified: f.lastModified
+				size: f$1.size,
+				lastModified: f$1.lastModified
 			};
 		} catch {
 			await getDir();
@@ -410,17 +410,3170 @@ const syncInput = async (fps = 3) => {
 		}
 	})();
 };
+const t = Symbol.for("@ts-pattern/matcher"), e = Symbol.for("@ts-pattern/isVariadic"), n = "@ts-pattern/anonymous-select-key", r = (t$1) => Boolean(t$1 && "object" == typeof t$1), i = (e$1) => e$1 && !!e$1[t], o = (n$1, s$1, c$1) => {
+	if (i(n$1)) {
+		const e$1 = n$1[t](), { matched: r$1, selections: i$1 } = e$1.match(s$1);
+		return r$1 && i$1 && Object.keys(i$1).forEach((t$1) => c$1(t$1, i$1[t$1])), r$1;
+	}
+	if (r(n$1)) {
+		if (!r(s$1)) return !1;
+		if (Array.isArray(n$1)) {
+			if (!Array.isArray(s$1)) return !1;
+			let t$1 = [], r$1 = [], a$1 = [];
+			for (const o$1 of n$1.keys()) {
+				const s$2 = n$1[o$1];
+				i(s$2) && s$2[e] ? a$1.push(s$2) : a$1.length ? r$1.push(s$2) : t$1.push(s$2);
+			}
+			if (a$1.length) {
+				if (a$1.length > 1) throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");
+				if (s$1.length < t$1.length + r$1.length) return !1;
+				const e$1 = s$1.slice(0, t$1.length), n$2 = 0 === r$1.length ? [] : s$1.slice(-r$1.length), i$1 = s$1.slice(t$1.length, 0 === r$1.length ? Infinity : -r$1.length);
+				return t$1.every((t$2, n$3) => o(t$2, e$1[n$3], c$1)) && r$1.every((t$2, e$2) => o(t$2, n$2[e$2], c$1)) && (0 === a$1.length || o(a$1[0], i$1, c$1));
+			}
+			return n$1.length === s$1.length && n$1.every((t$2, e$1) => o(t$2, s$1[e$1], c$1));
+		}
+		return Reflect.ownKeys(n$1).every((e$1) => {
+			const r$1 = n$1[e$1];
+			return (e$1 in s$1 || i(a$1 = r$1) && "optional" === a$1[t]().matcherType) && o(r$1, s$1[e$1], c$1);
+			var a$1;
+		});
+	}
+	return Object.is(s$1, n$1);
+}, s = (e$1) => {
+	var n$1, o$1, a$1;
+	return r(e$1) ? i(e$1) ? null != (n$1 = null == (o$1 = (a$1 = e$1[t]()).getSelectionKeys) ? void 0 : o$1.call(a$1)) ? n$1 : [] : Array.isArray(e$1) ? c(e$1, s) : c(Object.values(e$1), s) : [];
+}, c = (t$1, e$1) => t$1.reduce((t$2, n$1) => t$2.concat(e$1(n$1)), []);
+function a(...t$1) {
+	if (1 === t$1.length) {
+		const [e$1] = t$1;
+		return (t$2) => o(e$1, t$2, () => {});
+	}
+	if (2 === t$1.length) {
+		const [e$1, n$1] = t$1;
+		return o(e$1, n$1, () => {});
+	}
+	throw new Error(`isMatching wasn't given the right number of arguments: expected 1 or 2, received ${t$1.length}.`);
+}
+function u(t$1) {
+	return Object.assign(t$1, {
+		optional: () => h(t$1),
+		and: (e$1) => m(t$1, e$1),
+		or: (e$1) => d(t$1, e$1),
+		select: (e$1) => void 0 === e$1 ? y(t$1) : y(e$1, t$1)
+	});
+}
+function l(t$1) {
+	return Object.assign(((t$2) => Object.assign(t$2, { [Symbol.iterator]() {
+		let n$1 = 0;
+		const r$1 = [{
+			value: Object.assign(t$2, { [e]: !0 }),
+			done: !1
+		}, {
+			done: !0,
+			value: void 0
+		}];
+		return { next: () => {
+			var t$3;
+			return null != (t$3 = r$1[n$1++]) ? t$3 : r$1.at(-1);
+		} };
+	} }))(t$1), {
+		optional: () => l(h(t$1)),
+		select: (e$1) => l(void 0 === e$1 ? y(t$1) : y(e$1, t$1))
+	});
+}
+function h(e$1) {
+	return u({ [t]: () => ({
+		match: (t$1) => {
+			let n$1 = {};
+			const r$1 = (t$2, e$2) => {
+				n$1[t$2] = e$2;
+			};
+			return void 0 === t$1 ? (s(e$1).forEach((t$2) => r$1(t$2, void 0)), {
+				matched: !0,
+				selections: n$1
+			}) : {
+				matched: o(e$1, t$1, r$1),
+				selections: n$1
+			};
+		},
+		getSelectionKeys: () => s(e$1),
+		matcherType: "optional"
+	}) });
+}
+const f = (t$1, e$1) => {
+	for (const n$1 of t$1) if (!e$1(n$1)) return !1;
+	return !0;
+}, g = (t$1, e$1) => {
+	for (const [n$1, r$1] of t$1.entries()) if (!e$1(r$1, n$1)) return !1;
+	return !0;
+};
+function m(...e$1) {
+	return u({ [t]: () => ({
+		match: (t$1) => {
+			let n$1 = {};
+			const r$1 = (t$2, e$2) => {
+				n$1[t$2] = e$2;
+			};
+			return {
+				matched: e$1.every((e$2) => o(e$2, t$1, r$1)),
+				selections: n$1
+			};
+		},
+		getSelectionKeys: () => c(e$1, s),
+		matcherType: "and"
+	}) });
+}
+function d(...e$1) {
+	return u({ [t]: () => ({
+		match: (t$1) => {
+			let n$1 = {};
+			const r$1 = (t$2, e$2) => {
+				n$1[t$2] = e$2;
+			};
+			return c(e$1, s).forEach((t$2) => r$1(t$2, void 0)), {
+				matched: e$1.some((e$2) => o(e$2, t$1, r$1)),
+				selections: n$1
+			};
+		},
+		getSelectionKeys: () => c(e$1, s),
+		matcherType: "or"
+	}) });
+}
+function p(e$1) {
+	return { [t]: () => ({ match: (t$1) => ({ matched: Boolean(e$1(t$1)) }) }) };
+}
+function y(...e$1) {
+	const r$1 = "string" == typeof e$1[0] ? e$1[0] : void 0, i$1 = 2 === e$1.length ? e$1[1] : "string" == typeof e$1[0] ? void 0 : e$1[0];
+	return u({ [t]: () => ({
+		match: (t$1) => {
+			let e$2 = { [null != r$1 ? r$1 : n]: t$1 };
+			return {
+				matched: void 0 === i$1 || o(i$1, t$1, (t$2, n$1) => {
+					e$2[t$2] = n$1;
+				}),
+				selections: e$2
+			};
+		},
+		getSelectionKeys: () => [null != r$1 ? r$1 : n].concat(void 0 === i$1 ? [] : s(i$1))
+	}) });
+}
+function v(t$1) {
+	return "number" == typeof t$1;
+}
+function b(t$1) {
+	return "string" == typeof t$1;
+}
+function w(t$1) {
+	return "bigint" == typeof t$1;
+}
+const S = u(p(function(t$1) {
+	return !0;
+})), O = S, j = (t$1) => Object.assign(u(t$1), {
+	startsWith: (e$1) => {
+		return j(m(t$1, (n$1 = e$1, p((t$2) => b(t$2) && t$2.startsWith(n$1)))));
+		var n$1;
+	},
+	endsWith: (e$1) => {
+		return j(m(t$1, (n$1 = e$1, p((t$2) => b(t$2) && t$2.endsWith(n$1)))));
+		var n$1;
+	},
+	minLength: (e$1) => j(m(t$1, ((t$2) => p((e$2) => b(e$2) && e$2.length >= t$2))(e$1))),
+	length: (e$1) => j(m(t$1, ((t$2) => p((e$2) => b(e$2) && e$2.length === t$2))(e$1))),
+	maxLength: (e$1) => j(m(t$1, ((t$2) => p((e$2) => b(e$2) && e$2.length <= t$2))(e$1))),
+	includes: (e$1) => {
+		return j(m(t$1, (n$1 = e$1, p((t$2) => b(t$2) && t$2.includes(n$1)))));
+		var n$1;
+	},
+	regex: (e$1) => {
+		return j(m(t$1, (n$1 = e$1, p((t$2) => b(t$2) && Boolean(t$2.match(n$1))))));
+		var n$1;
+	}
+}), K = j(p(b)), x = (t$1) => Object.assign(u(t$1), {
+	between: (e$1, n$1) => x(m(t$1, ((t$2, e$2) => p((n$2) => v(n$2) && t$2 <= n$2 && e$2 >= n$2))(e$1, n$1))),
+	lt: (e$1) => x(m(t$1, ((t$2) => p((e$2) => v(e$2) && e$2 < t$2))(e$1))),
+	gt: (e$1) => x(m(t$1, ((t$2) => p((e$2) => v(e$2) && e$2 > t$2))(e$1))),
+	lte: (e$1) => x(m(t$1, ((t$2) => p((e$2) => v(e$2) && e$2 <= t$2))(e$1))),
+	gte: (e$1) => x(m(t$1, ((t$2) => p((e$2) => v(e$2) && e$2 >= t$2))(e$1))),
+	int: () => x(m(t$1, p((t$2) => v(t$2) && Number.isInteger(t$2)))),
+	finite: () => x(m(t$1, p((t$2) => v(t$2) && Number.isFinite(t$2)))),
+	positive: () => x(m(t$1, p((t$2) => v(t$2) && t$2 > 0))),
+	negative: () => x(m(t$1, p((t$2) => v(t$2) && t$2 < 0)))
+}), E = x(p(v)), A = (t$1) => Object.assign(u(t$1), {
+	between: (e$1, n$1) => A(m(t$1, ((t$2, e$2) => p((n$2) => w(n$2) && t$2 <= n$2 && e$2 >= n$2))(e$1, n$1))),
+	lt: (e$1) => A(m(t$1, ((t$2) => p((e$2) => w(e$2) && e$2 < t$2))(e$1))),
+	gt: (e$1) => A(m(t$1, ((t$2) => p((e$2) => w(e$2) && e$2 > t$2))(e$1))),
+	lte: (e$1) => A(m(t$1, ((t$2) => p((e$2) => w(e$2) && e$2 <= t$2))(e$1))),
+	gte: (e$1) => A(m(t$1, ((t$2) => p((e$2) => w(e$2) && e$2 >= t$2))(e$1))),
+	positive: () => A(m(t$1, p((t$2) => w(t$2) && t$2 > 0))),
+	negative: () => A(m(t$1, p((t$2) => w(t$2) && t$2 < 0)))
+}), P = A(p(w)), T = u(p(function(t$1) {
+	return "boolean" == typeof t$1;
+})), B = u(p(function(t$1) {
+	return "symbol" == typeof t$1;
+})), _ = u(p(function(t$1) {
+	return null == t$1;
+})), k = u(p(function(t$1) {
+	return null != t$1;
+}));
+var N = {
+	__proto__: null,
+	matcher: t,
+	optional: h,
+	array: function(...e$1) {
+		return l({ [t]: () => ({
+			match: (t$1) => {
+				if (!Array.isArray(t$1)) return { matched: !1 };
+				if (0 === e$1.length) return { matched: !0 };
+				const n$1 = e$1[0];
+				let r$1 = {};
+				if (0 === t$1.length) return s(n$1).forEach((t$2) => {
+					r$1[t$2] = [];
+				}), {
+					matched: !0,
+					selections: r$1
+				};
+				const i$1 = (t$2, e$2) => {
+					r$1[t$2] = (r$1[t$2] || []).concat([e$2]);
+				};
+				return {
+					matched: t$1.every((t$2) => o(n$1, t$2, i$1)),
+					selections: r$1
+				};
+			},
+			getSelectionKeys: () => 0 === e$1.length ? [] : s(e$1[0])
+		}) });
+	},
+	set: function(...e$1) {
+		return u({ [t]: () => ({
+			match: (t$1) => {
+				if (!(t$1 instanceof Set)) return { matched: !1 };
+				let n$1 = {};
+				if (0 === t$1.size) return {
+					matched: !0,
+					selections: n$1
+				};
+				if (0 === e$1.length) return { matched: !0 };
+				const r$1 = (t$2, e$2) => {
+					n$1[t$2] = (n$1[t$2] || []).concat([e$2]);
+				}, i$1 = e$1[0];
+				return {
+					matched: f(t$1, (t$2) => o(i$1, t$2, r$1)),
+					selections: n$1
+				};
+			},
+			getSelectionKeys: () => 0 === e$1.length ? [] : s(e$1[0])
+		}) });
+	},
+	map: function(...e$1) {
+		return u({ [t]: () => ({
+			match: (t$1) => {
+				if (!(t$1 instanceof Map)) return { matched: !1 };
+				let n$1 = {};
+				if (0 === t$1.size) return {
+					matched: !0,
+					selections: n$1
+				};
+				const r$1 = (t$2, e$2) => {
+					n$1[t$2] = (n$1[t$2] || []).concat([e$2]);
+				};
+				if (0 === e$1.length) return { matched: !0 };
+				var i$1;
+				if (1 === e$1.length) throw new Error(`\`P.map\` wasn't given enough arguments. Expected (key, value), received ${null == (i$1 = e$1[0]) ? void 0 : i$1.toString()}`);
+				const [s$1, c$1] = e$1;
+				return {
+					matched: g(t$1, (t$2, e$2) => {
+						const n$2 = o(s$1, e$2, r$1), i$2 = o(c$1, t$2, r$1);
+						return n$2 && i$2;
+					}),
+					selections: n$1
+				};
+			},
+			getSelectionKeys: () => 0 === e$1.length ? [] : [...s(e$1[0]), ...s(e$1[1])]
+		}) });
+	},
+	intersection: m,
+	union: d,
+	not: function(e$1) {
+		return u({ [t]: () => ({
+			match: (t$1) => ({ matched: !o(e$1, t$1, () => {}) }),
+			getSelectionKeys: () => [],
+			matcherType: "not"
+		}) });
+	},
+	when: p,
+	select: y,
+	any: S,
+	_: O,
+	string: K,
+	number: E,
+	bigint: P,
+	boolean: T,
+	symbol: B,
+	nullish: _,
+	nonNullable: k,
+	instanceOf: function(t$1) {
+		return u(p(function(t$2) {
+			return (e$1) => e$1 instanceof t$2;
+		}(t$1)));
+	},
+	shape: function(t$1) {
+		return u(p(a(t$1)));
+	}
+};
+var W = class extends Error {
+	constructor(t$1) {
+		let e$1;
+		try {
+			e$1 = JSON.stringify(t$1);
+		} catch (n$1) {
+			e$1 = t$1;
+		}
+		super(`Pattern matching error: no pattern matches value ${e$1}`), this.input = void 0, this.input = t$1;
+	}
+};
+const $$1 = {
+	matched: !1,
+	value: void 0
+};
+function z(t$1) {
+	return new I(t$1, $$1);
+}
+var I = class I {
+	constructor(t$1, e$1) {
+		this.input = void 0, this.state = void 0, this.input = t$1, this.state = e$1;
+	}
+	with(...t$1) {
+		if (this.state.matched) return this;
+		const e$1 = t$1[t$1.length - 1], r$1 = [t$1[0]];
+		let i$1;
+		3 === t$1.length && "function" == typeof t$1[1] ? i$1 = t$1[1] : t$1.length > 2 && r$1.push(...t$1.slice(1, t$1.length - 1));
+		let s$1 = !1, c$1 = {};
+		const a$1 = (t$2, e$2) => {
+			s$1 = !0, c$1[t$2] = e$2;
+		}, u$1 = !r$1.some((t$2) => o(t$2, this.input, a$1)) || i$1 && !Boolean(i$1(this.input)) ? $$1 : {
+			matched: !0,
+			value: e$1(s$1 ? n in c$1 ? c$1[n] : c$1 : this.input, this.input)
+		};
+		return new I(this.input, u$1);
+	}
+	when(t$1, e$1) {
+		if (this.state.matched) return this;
+		const n$1 = Boolean(t$1(this.input));
+		return new I(this.input, n$1 ? {
+			matched: !0,
+			value: e$1(this.input, this.input)
+		} : $$1);
+	}
+	otherwise(t$1) {
+		return this.state.matched ? this.state.value : t$1(this.input);
+	}
+	exhaustive(t$1 = L) {
+		return this.state.matched ? this.state.value : t$1(this.input);
+	}
+	run() {
+		return this.exhaustive();
+	}
+	returnType() {
+		return this;
+	}
+};
+function L(t$1) {
+	throw new W(t$1);
+}
+const NEVER = Object.freeze({ status: "aborted" });
+function $constructor(name, initializer$2, params) {
+	function init(inst, def) {
+		var _a;
+		Object.defineProperty(inst, "_zod", {
+			value: inst._zod ?? {},
+			enumerable: false
+		});
+		(_a = inst._zod).traits ?? (_a.traits = /* @__PURE__ */ new Set());
+		inst._zod.traits.add(name);
+		initializer$2(inst, def);
+		for (const k$1 in _$1.prototype) if (!(k$1 in inst)) Object.defineProperty(inst, k$1, { value: _$1.prototype[k$1].bind(inst) });
+		inst._zod.constr = _$1;
+		inst._zod.def = def;
+	}
+	const Parent = params?.Parent ?? Object;
+	class Definition extends Parent {}
+	Object.defineProperty(Definition, "name", { value: name });
+	function _$1(def) {
+		var _a;
+		const inst = params?.Parent ? new Definition() : this;
+		init(inst, def);
+		(_a = inst._zod).deferred ?? (_a.deferred = []);
+		for (const fn of inst._zod.deferred) fn();
+		return inst;
+	}
+	Object.defineProperty(_$1, "init", { value: init });
+	Object.defineProperty(_$1, Symbol.hasInstance, { value: (inst) => {
+		if (params?.Parent && inst instanceof params.Parent) return true;
+		return inst?._zod?.traits?.has(name);
+	} });
+	Object.defineProperty(_$1, "name", { value: name });
+	return _$1;
+}
+const $brand = Symbol("zod_brand");
+var $ZodAsyncError = class extends Error {
+	constructor() {
+		super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+	}
+};
+const globalConfig = {};
+function config(newConfig) {
+	if (newConfig) Object.assign(globalConfig, newConfig);
+	return globalConfig;
+}
+function getEnumValues(entries) {
+	const numericValues = Object.values(entries).filter((v$1) => typeof v$1 === "number");
+	const values = Object.entries(entries).filter(([k$1, _$1]) => numericValues.indexOf(+k$1) === -1).map(([_$1, v$1]) => v$1);
+	return values;
+}
+function jsonStringifyReplacer(_$1, value) {
+	if (typeof value === "bigint") return value.toString();
+	return value;
+}
+function cached(getter) {
+	const set = false;
+	return { get value() {
+		{
+			const value = getter();
+			Object.defineProperty(this, "value", { value });
+			return value;
+		}
+	} };
+}
+function nullish(input) {
+	return input === null || input === void 0;
+}
+function cleanRegex(source) {
+	const start = source.startsWith("^") ? 1 : 0;
+	const end = source.endsWith("$") ? source.length - 1 : source.length;
+	return source.slice(start, end);
+}
+function defineLazy(object$1, key, getter) {
+	const set = false;
+	Object.defineProperty(object$1, key, {
+		get() {
+			{
+				const value = getter();
+				object$1[key] = value;
+				return value;
+			}
+		},
+		set(v$1) {
+			Object.defineProperty(object$1, key, { value: v$1 });
+		},
+		configurable: true
+	});
+}
+function assignProp(target, prop, value) {
+	Object.defineProperty(target, prop, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+}
+function mergeDefs(...defs) {
+	const mergedDescriptors = {};
+	for (const def of defs) {
+		const descriptors = Object.getOwnPropertyDescriptors(def);
+		Object.assign(mergedDescriptors, descriptors);
+	}
+	return Object.defineProperties({}, mergedDescriptors);
+}
+function esc(str) {
+	return JSON.stringify(str);
+}
+const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
+function isObject(data) {
+	return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+const allowsEval = cached(() => {
+	if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) return false;
+	try {
+		const F = Function;
+		new F("");
+		return true;
+	} catch (_$1) {
+		return false;
+	}
+});
+function isPlainObject(o$1) {
+	if (isObject(o$1) === false) return false;
+	const ctor = o$1.constructor;
+	if (ctor === void 0) return true;
+	const prot = ctor.prototype;
+	if (isObject(prot) === false) return false;
+	if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) return false;
+	return true;
+}
+const propertyKeyTypes = new Set([
+	"string",
+	"number",
+	"symbol"
+]);
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function clone(inst, def, params) {
+	const cl = new inst._zod.constr(def ?? inst._zod.def);
+	if (!def || params?.parent) cl._zod.parent = inst;
+	return cl;
+}
+function normalizeParams(_params) {
+	const params = _params;
+	if (!params) return {};
+	if (typeof params === "string") return { error: () => params };
+	if (params?.message !== void 0) {
+		if (params?.error !== void 0) throw new Error("Cannot specify both `message` and `error` params");
+		params.error = params.message;
+	}
+	delete params.message;
+	if (typeof params.error === "string") return {
+		...params,
+		error: () => params.error
+	};
+	return params;
+}
+function optionalKeys(shape) {
+	return Object.keys(shape).filter((k$1) => {
+		return shape[k$1]._zod.optin === "optional" && shape[k$1]._zod.optout === "optional";
+	});
+}
+const NUMBER_FORMAT_RANGES = {
+	safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+	int32: [-2147483648, 2147483647],
+	uint32: [0, 4294967295],
+	float32: [-34028234663852886e22, 34028234663852886e22],
+	float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+};
+function pick(schema, mask) {
+	const currDef = schema._zod.def;
+	const def = mergeDefs(schema._zod.def, {
+		get shape() {
+			const newShape = {};
+			for (const key in mask) {
+				if (!(key in currDef.shape)) throw new Error(`Unrecognized key: "${key}"`);
+				if (!mask[key]) continue;
+				newShape[key] = currDef.shape[key];
+			}
+			assignProp(this, "shape", newShape);
+			return newShape;
+		},
+		checks: []
+	});
+	return clone(schema, def);
+}
+function omit(schema, mask) {
+	const currDef = schema._zod.def;
+	const def = mergeDefs(schema._zod.def, {
+		get shape() {
+			const newShape = { ...schema._zod.def.shape };
+			for (const key in mask) {
+				if (!(key in currDef.shape)) throw new Error(`Unrecognized key: "${key}"`);
+				if (!mask[key]) continue;
+				delete newShape[key];
+			}
+			assignProp(this, "shape", newShape);
+			return newShape;
+		},
+		checks: []
+	});
+	return clone(schema, def);
+}
+function extend(schema, shape) {
+	if (!isPlainObject(shape)) throw new Error("Invalid input to extend: expected a plain object");
+	const def = mergeDefs(schema._zod.def, {
+		get shape() {
+			const _shape = {
+				...schema._zod.def.shape,
+				...shape
+			};
+			assignProp(this, "shape", _shape);
+			return _shape;
+		},
+		checks: []
+	});
+	return clone(schema, def);
+}
+function merge(a$1, b$1) {
+	const def = mergeDefs(a$1._zod.def, {
+		get shape() {
+			const _shape = {
+				...a$1._zod.def.shape,
+				...b$1._zod.def.shape
+			};
+			assignProp(this, "shape", _shape);
+			return _shape;
+		},
+		get catchall() {
+			return b$1._zod.def.catchall;
+		},
+		checks: []
+	});
+	return clone(a$1, def);
+}
+function partial(Class, schema, mask) {
+	const def = mergeDefs(schema._zod.def, {
+		get shape() {
+			const oldShape = schema._zod.def.shape;
+			const shape = { ...oldShape };
+			if (mask) for (const key in mask) {
+				if (!(key in oldShape)) throw new Error(`Unrecognized key: "${key}"`);
+				if (!mask[key]) continue;
+				shape[key] = Class ? new Class({
+					type: "optional",
+					innerType: oldShape[key]
+				}) : oldShape[key];
+			}
+			else for (const key in oldShape) shape[key] = Class ? new Class({
+				type: "optional",
+				innerType: oldShape[key]
+			}) : oldShape[key];
+			assignProp(this, "shape", shape);
+			return shape;
+		},
+		checks: []
+	});
+	return clone(schema, def);
+}
+function required(Class, schema, mask) {
+	const def = mergeDefs(schema._zod.def, {
+		get shape() {
+			const oldShape = schema._zod.def.shape;
+			const shape = { ...oldShape };
+			if (mask) for (const key in mask) {
+				if (!(key in shape)) throw new Error(`Unrecognized key: "${key}"`);
+				if (!mask[key]) continue;
+				shape[key] = new Class({
+					type: "nonoptional",
+					innerType: oldShape[key]
+				});
+			}
+			else for (const key in oldShape) shape[key] = new Class({
+				type: "nonoptional",
+				innerType: oldShape[key]
+			});
+			assignProp(this, "shape", shape);
+			return shape;
+		},
+		checks: []
+	});
+	return clone(schema, def);
+}
+function aborted(x$1, startIndex = 0) {
+	for (let i$1 = startIndex; i$1 < x$1.issues.length; i$1++) if (x$1.issues[i$1]?.continue !== true) return true;
+	return false;
+}
+function prefixIssues(path, issues) {
+	return issues.map((iss) => {
+		var _a;
+		(_a = iss).path ?? (_a.path = []);
+		iss.path.unshift(path);
+		return iss;
+	});
+}
+function unwrapMessage(message) {
+	return typeof message === "string" ? message : message?.message;
+}
+function finalizeIssue(iss, ctx, config$1) {
+	const full = {
+		...iss,
+		path: iss.path ?? []
+	};
+	if (!iss.message) {
+		const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config$1.customError?.(iss)) ?? unwrapMessage(config$1.localeError?.(iss)) ?? "Invalid input";
+		full.message = message;
+	}
+	delete full.inst;
+	delete full.continue;
+	if (!ctx?.reportInput) delete full.input;
+	return full;
+}
+function getLengthableOrigin(input) {
+	if (Array.isArray(input)) return "array";
+	if (typeof input === "string") return "string";
+	return "unknown";
+}
+function issue(...args) {
+	const [iss, input, inst] = args;
+	if (typeof iss === "string") return {
+		message: iss,
+		code: "custom",
+		input,
+		inst
+	};
+	return { ...iss };
+}
+const initializer$1 = (inst, def) => {
+	inst.name = "$ZodError";
+	Object.defineProperty(inst, "_zod", {
+		value: inst._zod,
+		enumerable: false
+	});
+	Object.defineProperty(inst, "issues", {
+		value: def,
+		enumerable: false
+	});
+	inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
+	Object.defineProperty(inst, "toString", {
+		value: () => inst.message,
+		enumerable: false
+	});
+};
+const $ZodError = $constructor("$ZodError", initializer$1);
+const $ZodRealError = $constructor("$ZodError", initializer$1, { Parent: Error });
+function flattenError(error, mapper = (issue$1) => issue$1.message) {
+	const fieldErrors = {};
+	const formErrors = [];
+	for (const sub of error.issues) if (sub.path.length > 0) {
+		fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+		fieldErrors[sub.path[0]].push(mapper(sub));
+	} else formErrors.push(mapper(sub));
+	return {
+		formErrors,
+		fieldErrors
+	};
+}
+function formatError(error, _mapper) {
+	const mapper = _mapper || function(issue$1) {
+		return issue$1.message;
+	};
+	const fieldErrors = { _errors: [] };
+	const processError = (error$1) => {
+		for (const issue$1 of error$1.issues) if (issue$1.code === "invalid_union" && issue$1.errors.length) issue$1.errors.map((issues) => processError({ issues }));
+		else if (issue$1.code === "invalid_key") processError({ issues: issue$1.issues });
+		else if (issue$1.code === "invalid_element") processError({ issues: issue$1.issues });
+		else if (issue$1.path.length === 0) fieldErrors._errors.push(mapper(issue$1));
+		else {
+			let curr = fieldErrors;
+			let i$1 = 0;
+			while (i$1 < issue$1.path.length) {
+				const el = issue$1.path[i$1];
+				const terminal = i$1 === issue$1.path.length - 1;
+				if (!terminal) curr[el] = curr[el] || { _errors: [] };
+				else {
+					curr[el] = curr[el] || { _errors: [] };
+					curr[el]._errors.push(mapper(issue$1));
+				}
+				curr = curr[el];
+				i$1++;
+			}
+		}
+	};
+	processError(error);
+	return fieldErrors;
+}
+const _parse = (_Err) => (schema, value, _ctx, _params) => {
+	const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
+	const result = schema._zod.run({
+		value,
+		issues: []
+	}, ctx);
+	if (result instanceof Promise) throw new $ZodAsyncError();
+	if (result.issues.length) {
+		const e$1 = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+		captureStackTrace(e$1, _params?.callee);
+		throw e$1;
+	}
+	return result.value;
+};
+const parse$1 = /* @__PURE__ */ _parse($ZodRealError);
+const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+	const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+	let result = schema._zod.run({
+		value,
+		issues: []
+	}, ctx);
+	if (result instanceof Promise) result = await result;
+	if (result.issues.length) {
+		const e$1 = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+		captureStackTrace(e$1, params?.callee);
+		throw e$1;
+	}
+	return result.value;
+};
+const parseAsync$1 = /* @__PURE__ */ _parseAsync($ZodRealError);
+const _safeParse = (_Err) => (schema, value, _ctx) => {
+	const ctx = _ctx ? {
+		..._ctx,
+		async: false
+	} : { async: false };
+	const result = schema._zod.run({
+		value,
+		issues: []
+	}, ctx);
+	if (result instanceof Promise) throw new $ZodAsyncError();
+	return result.issues.length ? {
+		success: false,
+		error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+	} : {
+		success: true,
+		data: result.value
+	};
+};
+const safeParse$1 = /* @__PURE__ */ _safeParse($ZodRealError);
+const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+	const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+	let result = schema._zod.run({
+		value,
+		issues: []
+	}, ctx);
+	if (result instanceof Promise) result = await result;
+	return result.issues.length ? {
+		success: false,
+		error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+	} : {
+		success: true,
+		data: result.value
+	};
+};
+const safeParseAsync$1 = /* @__PURE__ */ _safeParseAsync($ZodRealError);
+const cuid = /^[cC][^\s-]{8,}$/;
+const cuid2 = /^[0-9a-z]+$/;
+const ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
+const xid = /^[0-9a-vA-V]{20}$/;
+const ksuid = /^[A-Za-z0-9]{27}$/;
+const nanoid = /^[a-zA-Z0-9_-]{21}$/;
+const duration$1 = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
+const guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
+const uuid = (version$1) => {
+	if (!version$1) return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/;
+	return /* @__PURE__ */ new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version$1}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
+};
+const email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
+const _emoji$1 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
+function emoji() {
+	return new RegExp(_emoji$1, "u");
+}
+const ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
+const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})$/;
+const cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
+const cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
+const base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
+const base64url = /^[A-Za-z0-9_-]*$/;
+const hostname = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
+const e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
+const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
+const date$1 = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
+function timeSource(args) {
+	const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
+	const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+	return regex;
+}
+function time$1(args) {
+	return /* @__PURE__ */ new RegExp(`^${timeSource(args)}$`);
+}
+function datetime$1(args) {
+	const time$2 = timeSource({ precision: args.precision });
+	const opts = ["Z"];
+	if (args.local) opts.push("");
+	if (args.offset) opts.push(`([+-]\\d{2}:\\d{2})`);
+	const timeRegex = `${time$2}(?:${opts.join("|")})`;
+	return /* @__PURE__ */ new RegExp(`^${dateSource}T(?:${timeRegex})$`);
+}
+const string$1 = (params) => {
+	const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+	return /* @__PURE__ */ new RegExp(`^${regex}$`);
+};
+const lowercase = /^[^A-Z]*$/;
+const uppercase = /^[^a-z]*$/;
+const $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
+	var _a;
+	inst._zod ?? (inst._zod = {});
+	inst._zod.def = def;
+	(_a = inst._zod).onattach ?? (_a.onattach = []);
+});
+const $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
+	var _a;
+	$ZodCheck.init(inst, def);
+	(_a = inst._zod.def).when ?? (_a.when = (payload) => {
+		const val = payload.value;
+		return !nullish(val) && val.length !== void 0;
+	});
+	inst._zod.onattach.push((inst$1) => {
+		const curr = inst$1._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
+		if (def.maximum < curr) inst$1._zod.bag.maximum = def.maximum;
+	});
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		const length = input.length;
+		if (length <= def.maximum) return;
+		const origin = getLengthableOrigin(input);
+		payload.issues.push({
+			origin,
+			code: "too_big",
+			maximum: def.maximum,
+			inclusive: true,
+			input,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
+	var _a;
+	$ZodCheck.init(inst, def);
+	(_a = inst._zod.def).when ?? (_a.when = (payload) => {
+		const val = payload.value;
+		return !nullish(val) && val.length !== void 0;
+	});
+	inst._zod.onattach.push((inst$1) => {
+		const curr = inst$1._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
+		if (def.minimum > curr) inst$1._zod.bag.minimum = def.minimum;
+	});
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		const length = input.length;
+		if (length >= def.minimum) return;
+		const origin = getLengthableOrigin(input);
+		payload.issues.push({
+			origin,
+			code: "too_small",
+			minimum: def.minimum,
+			inclusive: true,
+			input,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
+	var _a;
+	$ZodCheck.init(inst, def);
+	(_a = inst._zod.def).when ?? (_a.when = (payload) => {
+		const val = payload.value;
+		return !nullish(val) && val.length !== void 0;
+	});
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.minimum = def.length;
+		bag.maximum = def.length;
+		bag.length = def.length;
+	});
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		const length = input.length;
+		if (length === def.length) return;
+		const origin = getLengthableOrigin(input);
+		const tooBig = length > def.length;
+		payload.issues.push({
+			origin,
+			...tooBig ? {
+				code: "too_big",
+				maximum: def.length
+			} : {
+				code: "too_small",
+				minimum: def.length
+			},
+			inclusive: true,
+			exact: true,
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
+	var _a, _b;
+	$ZodCheck.init(inst, def);
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.format = def.format;
+		if (def.pattern) {
+			bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
+			bag.patterns.add(def.pattern);
+		}
+	});
+	if (def.pattern) (_a = inst._zod).check ?? (_a.check = (payload) => {
+		def.pattern.lastIndex = 0;
+		if (def.pattern.test(payload.value)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: def.format,
+			input: payload.value,
+			...def.pattern ? { pattern: def.pattern.toString() } : {},
+			inst,
+			continue: !def.abort
+		});
+	});
+	else (_b = inst._zod).check ?? (_b.check = () => {});
+});
+const $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
+	$ZodCheckStringFormat.init(inst, def);
+	inst._zod.check = (payload) => {
+		def.pattern.lastIndex = 0;
+		if (def.pattern.test(payload.value)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "regex",
+			input: payload.value,
+			pattern: def.pattern.toString(),
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => {
+	def.pattern ?? (def.pattern = lowercase);
+	$ZodCheckStringFormat.init(inst, def);
+});
+const $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => {
+	def.pattern ?? (def.pattern = uppercase);
+	$ZodCheckStringFormat.init(inst, def);
+});
+const $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const escapedRegex = escapeRegex(def.includes);
+	const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
+	def.pattern = pattern;
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
+		bag.patterns.add(pattern);
+	});
+	inst._zod.check = (payload) => {
+		if (payload.value.includes(def.includes, def.position)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "includes",
+			includes: def.includes,
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const pattern = /* @__PURE__ */ new RegExp(`^${escapeRegex(def.prefix)}.*`);
+	def.pattern ?? (def.pattern = pattern);
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
+		bag.patterns.add(pattern);
+	});
+	inst._zod.check = (payload) => {
+		if (payload.value.startsWith(def.prefix)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "starts_with",
+			prefix: def.prefix,
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const pattern = /* @__PURE__ */ new RegExp(`.*${escapeRegex(def.suffix)}$`);
+	def.pattern ?? (def.pattern = pattern);
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
+		bag.patterns.add(pattern);
+	});
+	inst._zod.check = (payload) => {
+		if (payload.value.endsWith(def.suffix)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "ends_with",
+			suffix: def.suffix,
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	inst._zod.check = (payload) => {
+		payload.value = def.tx(payload.value);
+	};
+});
+var Doc = class {
+	constructor(args = []) {
+		this.content = [];
+		this.indent = 0;
+		if (this) this.args = args;
+	}
+	indented(fn) {
+		this.indent += 1;
+		fn(this);
+		this.indent -= 1;
+	}
+	write(arg) {
+		if (typeof arg === "function") {
+			arg(this, { execution: "sync" });
+			arg(this, { execution: "async" });
+			return;
+		}
+		const content = arg;
+		const lines = content.split("\n").filter((x$1) => x$1);
+		const minIndent = Math.min(...lines.map((x$1) => x$1.length - x$1.trimStart().length));
+		const dedented = lines.map((x$1) => x$1.slice(minIndent)).map((x$1) => " ".repeat(this.indent * 2) + x$1);
+		for (const line of dedented) this.content.push(line);
+	}
+	compile() {
+		const F = Function;
+		const args = this?.args;
+		const content = this?.content ?? [``];
+		const lines = [...content.map((x$1) => `  ${x$1}`)];
+		return new F(...args, lines.join("\n"));
+	}
+};
+const version = {
+	major: 4,
+	minor: 0,
+	patch: 10
+};
+const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
+	var _a;
+	inst ?? (inst = {});
+	inst._zod.def = def;
+	inst._zod.bag = inst._zod.bag || {};
+	inst._zod.version = version;
+	const checks = [...inst._zod.def.checks ?? []];
+	if (inst._zod.traits.has("$ZodCheck")) checks.unshift(inst);
+	for (const ch of checks) for (const fn of ch._zod.onattach) fn(inst);
+	if (checks.length === 0) {
+		(_a = inst._zod).deferred ?? (_a.deferred = []);
+		inst._zod.deferred?.push(() => {
+			inst._zod.run = inst._zod.parse;
+		});
+	} else {
+		const runChecks = (payload, checks$1, ctx) => {
+			let isAborted = aborted(payload);
+			let asyncResult;
+			for (const ch of checks$1) {
+				if (ch._zod.def.when) {
+					const shouldRun = ch._zod.def.when(payload);
+					if (!shouldRun) continue;
+				} else if (isAborted) continue;
+				const currLen = payload.issues.length;
+				const _$1 = ch._zod.check(payload);
+				if (_$1 instanceof Promise && ctx?.async === false) throw new $ZodAsyncError();
+				if (asyncResult || _$1 instanceof Promise) asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
+					await _$1;
+					const nextLen = payload.issues.length;
+					if (nextLen === currLen) return;
+					if (!isAborted) isAborted = aborted(payload, currLen);
+				});
+				else {
+					const nextLen = payload.issues.length;
+					if (nextLen === currLen) continue;
+					if (!isAborted) isAborted = aborted(payload, currLen);
+				}
+			}
+			if (asyncResult) return asyncResult.then(() => {
+				return payload;
+			});
+			return payload;
+		};
+		inst._zod.run = (payload, ctx) => {
+			const result = inst._zod.parse(payload, ctx);
+			if (result instanceof Promise) {
+				if (ctx.async === false) throw new $ZodAsyncError();
+				return result.then((result$1) => runChecks(result$1, checks, ctx));
+			}
+			return runChecks(result, checks, ctx);
+		};
+	}
+	inst["~standard"] = {
+		validate: (value) => {
+			try {
+				const r$1 = safeParse$1(inst, value);
+				return r$1.success ? { value: r$1.data } : { issues: r$1.error?.issues };
+			} catch (_$1) {
+				return safeParseAsync$1(inst, value).then((r$1) => r$1.success ? { value: r$1.data } : { issues: r$1.error?.issues });
+			}
+		},
+		vendor: "zod",
+		version: 1
+	};
+});
+const $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string$1(inst._zod.bag);
+	inst._zod.parse = (payload, _$1) => {
+		if (def.coerce) try {
+			payload.value = String(payload.value);
+		} catch (_$2) {}
+		if (typeof payload.value === "string") return payload;
+		payload.issues.push({
+			expected: "string",
+			code: "invalid_type",
+			input: payload.value,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => {
+	$ZodCheckStringFormat.init(inst, def);
+	$ZodString.init(inst, def);
+});
+const $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => {
+	def.pattern ?? (def.pattern = guid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
+	if (def.version) {
+		const versionMap = {
+			v1: 1,
+			v2: 2,
+			v3: 3,
+			v4: 4,
+			v5: 5,
+			v6: 6,
+			v7: 7,
+			v8: 8
+		};
+		const v$1 = versionMap[def.version];
+		if (v$1 === void 0) throw new Error(`Invalid UUID version: "${def.version}"`);
+		def.pattern ?? (def.pattern = uuid(v$1));
+	} else def.pattern ?? (def.pattern = uuid());
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => {
+	def.pattern ?? (def.pattern = email);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
+	$ZodStringFormat.init(inst, def);
+	inst._zod.check = (payload) => {
+		try {
+			const trimmed = payload.value.trim();
+			const url = new URL(trimmed);
+			if (def.hostname) {
+				def.hostname.lastIndex = 0;
+				if (!def.hostname.test(url.hostname)) payload.issues.push({
+					code: "invalid_format",
+					format: "url",
+					note: "Invalid hostname",
+					pattern: hostname.source,
+					input: payload.value,
+					inst,
+					continue: !def.abort
+				});
+			}
+			if (def.protocol) {
+				def.protocol.lastIndex = 0;
+				if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) payload.issues.push({
+					code: "invalid_format",
+					format: "url",
+					note: "Invalid protocol",
+					pattern: def.protocol.source,
+					input: payload.value,
+					inst,
+					continue: !def.abort
+				});
+			}
+			if (def.normalize) payload.value = url.href;
+			else payload.value = trimmed;
+			return;
+		} catch (_$1) {
+			payload.issues.push({
+				code: "invalid_format",
+				format: "url",
+				input: payload.value,
+				inst,
+				continue: !def.abort
+			});
+		}
+	};
+});
+const $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => {
+	def.pattern ?? (def.pattern = emoji());
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => {
+	def.pattern ?? (def.pattern = nanoid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => {
+	def.pattern ?? (def.pattern = cuid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => {
+	def.pattern ?? (def.pattern = cuid2);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => {
+	def.pattern ?? (def.pattern = ulid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => {
+	def.pattern ?? (def.pattern = xid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => {
+	def.pattern ?? (def.pattern = ksuid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => {
+	def.pattern ?? (def.pattern = datetime$1(def));
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => {
+	def.pattern ?? (def.pattern = date$1);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
+	def.pattern ?? (def.pattern = time$1(def));
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => {
+	def.pattern ?? (def.pattern = duration$1);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => {
+	def.pattern ?? (def.pattern = ipv4);
+	$ZodStringFormat.init(inst, def);
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.format = `ipv4`;
+	});
+});
+const $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => {
+	def.pattern ?? (def.pattern = ipv6);
+	$ZodStringFormat.init(inst, def);
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.format = `ipv6`;
+	});
+	inst._zod.check = (payload) => {
+		try {
+			new URL(`http://[${payload.value}]`);
+		} catch {
+			payload.issues.push({
+				code: "invalid_format",
+				format: "ipv6",
+				input: payload.value,
+				inst,
+				continue: !def.abort
+			});
+		}
+	};
+});
+const $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => {
+	def.pattern ?? (def.pattern = cidrv4);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
+	def.pattern ?? (def.pattern = cidrv6);
+	$ZodStringFormat.init(inst, def);
+	inst._zod.check = (payload) => {
+		const [address, prefix] = payload.value.split("/");
+		try {
+			if (!prefix) throw new Error();
+			const prefixNum = Number(prefix);
+			if (`${prefixNum}` !== prefix) throw new Error();
+			if (prefixNum < 0 || prefixNum > 128) throw new Error();
+			new URL(`http://[${address}]`);
+		} catch {
+			payload.issues.push({
+				code: "invalid_format",
+				format: "cidrv6",
+				input: payload.value,
+				inst,
+				continue: !def.abort
+			});
+		}
+	};
+});
+function isValidBase64(data) {
+	if (data === "") return true;
+	if (data.length % 4 !== 0) return false;
+	try {
+		atob(data);
+		return true;
+	} catch {
+		return false;
+	}
+}
+const $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => {
+	def.pattern ?? (def.pattern = base64);
+	$ZodStringFormat.init(inst, def);
+	inst._zod.onattach.push((inst$1) => {
+		inst$1._zod.bag.contentEncoding = "base64";
+	});
+	inst._zod.check = (payload) => {
+		if (isValidBase64(payload.value)) return;
+		payload.issues.push({
+			code: "invalid_format",
+			format: "base64",
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+function isValidBase64URL(data) {
+	if (!base64url.test(data)) return false;
+	const base64$1 = data.replace(/[-_]/g, (c$1) => c$1 === "-" ? "+" : "/");
+	const padded = base64$1.padEnd(Math.ceil(base64$1.length / 4) * 4, "=");
+	return isValidBase64(padded);
+}
+const $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => {
+	def.pattern ?? (def.pattern = base64url);
+	$ZodStringFormat.init(inst, def);
+	inst._zod.onattach.push((inst$1) => {
+		inst$1._zod.bag.contentEncoding = "base64url";
+	});
+	inst._zod.check = (payload) => {
+		if (isValidBase64URL(payload.value)) return;
+		payload.issues.push({
+			code: "invalid_format",
+			format: "base64url",
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => {
+	def.pattern ?? (def.pattern = e164);
+	$ZodStringFormat.init(inst, def);
+});
+function isValidJWT(token, algorithm = null) {
+	try {
+		const tokensParts = token.split(".");
+		if (tokensParts.length !== 3) return false;
+		const [header] = tokensParts;
+		if (!header) return false;
+		const parsedHeader = JSON.parse(atob(header));
+		if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") return false;
+		if (!parsedHeader.alg) return false;
+		if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm)) return false;
+		return true;
+	} catch {
+		return false;
+	}
+}
+const $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
+	$ZodStringFormat.init(inst, def);
+	inst._zod.check = (payload) => {
+		if (isValidJWT(payload.value, def.alg)) return;
+		payload.issues.push({
+			code: "invalid_format",
+			format: "jwt",
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload) => payload;
+});
+const $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload) => payload;
+});
+const $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, _ctx) => {
+		payload.issues.push({
+			expected: "never",
+			code: "invalid_type",
+			input: payload.value,
+			inst
+		});
+		return payload;
+	};
+});
+function handleArrayResult(result, final, index) {
+	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
+	final.value[index] = result.value;
+}
+const $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!Array.isArray(input)) {
+			payload.issues.push({
+				expected: "array",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		payload.value = Array(input.length);
+		const proms = [];
+		for (let i$1 = 0; i$1 < input.length; i$1++) {
+			const item = input[i$1];
+			const result = def.element._zod.run({
+				value: item,
+				issues: []
+			}, ctx);
+			if (result instanceof Promise) proms.push(result.then((result$1) => handleArrayResult(result$1, payload, i$1)));
+			else handleArrayResult(result, payload, i$1);
+		}
+		if (proms.length) return Promise.all(proms).then(() => payload);
+		return payload;
+	};
+});
+function handlePropertyResult(result, final, key, input) {
+	if (result.issues.length) final.issues.push(...prefixIssues(key, result.issues));
+	if (result.value === void 0) {
+		if (key in input) final.value[key] = void 0;
+	} else final.value[key] = result.value;
+}
+const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
+	$ZodType.init(inst, def);
+	const _normalized = cached(() => {
+		const keys = Object.keys(def.shape);
+		for (const k$1 of keys) if (!(def.shape[k$1] instanceof $ZodType)) throw new Error(`Invalid element at key "${k$1}": expected a Zod schema`);
+		const okeys = optionalKeys(def.shape);
+		return {
+			shape: def.shape,
+			keys,
+			keySet: new Set(keys),
+			numKeys: keys.length,
+			optionalKeys: new Set(okeys)
+		};
+	});
+	defineLazy(inst._zod, "propValues", () => {
+		const shape = def.shape;
+		const propValues = {};
+		for (const key in shape) {
+			const field = shape[key]._zod;
+			if (field.values) {
+				propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
+				for (const v$1 of field.values) propValues[key].add(v$1);
+			}
+		}
+		return propValues;
+	});
+	const generateFastpass = (shape) => {
+		const doc = new Doc([
+			"shape",
+			"payload",
+			"ctx"
+		]);
+		const normalized = _normalized.value;
+		const parseStr = (key) => {
+			const k$1 = esc(key);
+			return `shape[${k$1}]._zod.run({ value: input[${k$1}], issues: [] }, ctx)`;
+		};
+		doc.write(`const input = payload.value;`);
+		const ids = Object.create(null);
+		let counter = 0;
+		for (const key of normalized.keys) ids[key] = `key_${counter++}`;
+		doc.write(`const newResult = {}`);
+		for (const key of normalized.keys) {
+			const id = ids[key];
+			const k$1 = esc(key);
+			doc.write(`const ${id} = ${parseStr(key)};`);
+			doc.write(`
+        if (${id}.issues.length) {
+          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${k$1}, ...iss.path] : [${k$1}]
+          })));
+        }
+        
+        if (${id}.value === undefined) {
+          if (${k$1} in input) {
+            newResult[${k$1}] = undefined;
+          }
+        } else {
+          newResult[${k$1}] = ${id}.value;
+        }
+      `);
+		}
+		doc.write(`payload.value = newResult;`);
+		doc.write(`return payload;`);
+		const fn = doc.compile();
+		return (payload, ctx) => fn(shape, payload, ctx);
+	};
+	let fastpass;
+	const isObject$1 = isObject;
+	const jit = !globalConfig.jitless;
+	const allowsEval$1 = allowsEval;
+	const fastEnabled = jit && allowsEval$1.value;
+	const catchall = def.catchall;
+	let value;
+	inst._zod.parse = (payload, ctx) => {
+		value ?? (value = _normalized.value);
+		const input = payload.value;
+		if (!isObject$1(input)) {
+			payload.issues.push({
+				expected: "object",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const proms = [];
+		if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
+			if (!fastpass) fastpass = generateFastpass(def.shape);
+			payload = fastpass(payload, ctx);
+		} else {
+			payload.value = {};
+			const shape = value.shape;
+			for (const key of value.keys) {
+				const el = shape[key];
+				const r$1 = el._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (r$1 instanceof Promise) proms.push(r$1.then((r$2) => handlePropertyResult(r$2, payload, key, input)));
+				else handlePropertyResult(r$1, payload, key, input);
+			}
+		}
+		if (!catchall) return proms.length ? Promise.all(proms).then(() => payload) : payload;
+		const unrecognized = [];
+		const keySet = value.keySet;
+		const _catchall = catchall._zod;
+		const t$1 = _catchall.def.type;
+		for (const key of Object.keys(input)) {
+			if (keySet.has(key)) continue;
+			if (t$1 === "never") {
+				unrecognized.push(key);
+				continue;
+			}
+			const r$1 = _catchall.run({
+				value: input[key],
+				issues: []
+			}, ctx);
+			if (r$1 instanceof Promise) proms.push(r$1.then((r$2) => handlePropertyResult(r$2, payload, key, input)));
+			else handlePropertyResult(r$1, payload, key, input);
+		}
+		if (unrecognized.length) payload.issues.push({
+			code: "unrecognized_keys",
+			keys: unrecognized,
+			input,
+			inst
+		});
+		if (!proms.length) return payload;
+		return Promise.all(proms).then(() => {
+			return payload;
+		});
+	};
+});
+function handleUnionResults(results, final, inst, ctx) {
+	for (const result of results) if (result.issues.length === 0) {
+		final.value = result.value;
+		return final;
+	}
+	const nonaborted = results.filter((r$1) => !aborted(r$1));
+	if (nonaborted.length === 1) {
+		final.value = nonaborted[0].value;
+		return nonaborted[0];
+	}
+	final.issues.push({
+		code: "invalid_union",
+		input: final.value,
+		inst,
+		errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+	});
+	return final;
+}
+const $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "optin", () => def.options.some((o$1) => o$1._zod.optin === "optional") ? "optional" : void 0);
+	defineLazy(inst._zod, "optout", () => def.options.some((o$1) => o$1._zod.optout === "optional") ? "optional" : void 0);
+	defineLazy(inst._zod, "values", () => {
+		if (def.options.every((o$1) => o$1._zod.values)) return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
+		return void 0;
+	});
+	defineLazy(inst._zod, "pattern", () => {
+		if (def.options.every((o$1) => o$1._zod.pattern)) {
+			const patterns = def.options.map((o$1) => o$1._zod.pattern);
+			return /* @__PURE__ */ new RegExp(`^(${patterns.map((p$1) => cleanRegex(p$1.source)).join("|")})$`);
+		}
+		return void 0;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		let async = false;
+		const results = [];
+		for (const option of def.options) {
+			const result = option._zod.run({
+				value: payload.value,
+				issues: []
+			}, ctx);
+			if (result instanceof Promise) {
+				results.push(result);
+				async = true;
+			} else {
+				if (result.issues.length === 0) return result;
+				results.push(result);
+			}
+		}
+		if (!async) return handleUnionResults(results, payload, inst, ctx);
+		return Promise.all(results).then((results$1) => {
+			return handleUnionResults(results$1, payload, inst, ctx);
+		});
+	};
+});
+const $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		const left = def.left._zod.run({
+			value: input,
+			issues: []
+		}, ctx);
+		const right = def.right._zod.run({
+			value: input,
+			issues: []
+		}, ctx);
+		const async = left instanceof Promise || right instanceof Promise;
+		if (async) return Promise.all([left, right]).then(([left$1, right$1]) => {
+			return handleIntersectionResults(payload, left$1, right$1);
+		});
+		return handleIntersectionResults(payload, left, right);
+	};
+});
+function mergeValues(a$1, b$1) {
+	if (a$1 === b$1) return {
+		valid: true,
+		data: a$1
+	};
+	if (a$1 instanceof Date && b$1 instanceof Date && +a$1 === +b$1) return {
+		valid: true,
+		data: a$1
+	};
+	if (isPlainObject(a$1) && isPlainObject(b$1)) {
+		const bKeys = Object.keys(b$1);
+		const sharedKeys = Object.keys(a$1).filter((key) => bKeys.indexOf(key) !== -1);
+		const newObj = {
+			...a$1,
+			...b$1
+		};
+		for (const key of sharedKeys) {
+			const sharedValue = mergeValues(a$1[key], b$1[key]);
+			if (!sharedValue.valid) return {
+				valid: false,
+				mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
+			};
+			newObj[key] = sharedValue.data;
+		}
+		return {
+			valid: true,
+			data: newObj
+		};
+	}
+	if (Array.isArray(a$1) && Array.isArray(b$1)) {
+		if (a$1.length !== b$1.length) return {
+			valid: false,
+			mergeErrorPath: []
+		};
+		const newArray = [];
+		for (let index = 0; index < a$1.length; index++) {
+			const itemA = a$1[index];
+			const itemB = b$1[index];
+			const sharedValue = mergeValues(itemA, itemB);
+			if (!sharedValue.valid) return {
+				valid: false,
+				mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
+			};
+			newArray.push(sharedValue.data);
+		}
+		return {
+			valid: true,
+			data: newArray
+		};
+	}
+	return {
+		valid: false,
+		mergeErrorPath: []
+	};
+}
+function handleIntersectionResults(result, left, right) {
+	if (left.issues.length) result.issues.push(...left.issues);
+	if (right.issues.length) result.issues.push(...right.issues);
+	if (aborted(result)) return result;
+	const merged = mergeValues(left.value, right.value);
+	if (!merged.valid) throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
+	result.value = merged.data;
+	return result;
+}
+const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
+	$ZodType.init(inst, def);
+	const values = getEnumValues(def.entries);
+	const valuesSet = new Set(values);
+	inst._zod.values = valuesSet;
+	inst._zod.pattern = /* @__PURE__ */ new RegExp(`^(${values.filter((k$1) => propertyKeyTypes.has(typeof k$1)).map((o$1) => typeof o$1 === "string" ? escapeRegex(o$1) : o$1.toString()).join("|")})$`);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (valuesSet.has(input)) return payload;
+		payload.issues.push({
+			code: "invalid_value",
+			values,
+			input,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, _ctx) => {
+		const _out = def.transform(payload.value, payload);
+		if (_ctx.async) {
+			const output = _out instanceof Promise ? _out : Promise.resolve(_out);
+			return output.then((output$1) => {
+				payload.value = output$1;
+				return payload;
+			});
+		}
+		if (_out instanceof Promise) throw new $ZodAsyncError();
+		payload.value = _out;
+		return payload;
+	};
+});
+const $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.optin = "optional";
+	inst._zod.optout = "optional";
+	defineLazy(inst._zod, "values", () => {
+		return def.innerType._zod.values ? new Set([...def.innerType._zod.values, void 0]) : void 0;
+	});
+	defineLazy(inst._zod, "pattern", () => {
+		const pattern = def.innerType._zod.pattern;
+		return pattern ? /* @__PURE__ */ new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		if (def.innerType._zod.optin === "optional") return def.innerType._zod.run(payload, ctx);
+		if (payload.value === void 0) return payload;
+		return def.innerType._zod.run(payload, ctx);
+	};
+});
+const $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+	defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+	defineLazy(inst._zod, "pattern", () => {
+		const pattern = def.innerType._zod.pattern;
+		return pattern ? /* @__PURE__ */ new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
+	});
+	defineLazy(inst._zod, "values", () => {
+		return def.innerType._zod.values ? new Set([...def.innerType._zod.values, null]) : void 0;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		if (payload.value === null) return payload;
+		return def.innerType._zod.run(payload, ctx);
+	};
+});
+const $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.optin = "optional";
+	defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+	inst._zod.parse = (payload, ctx) => {
+		if (payload.value === void 0) {
+			payload.value = def.defaultValue;
+			return payload;
+		}
+		const result = def.innerType._zod.run(payload, ctx);
+		if (result instanceof Promise) return result.then((result$1) => handleDefaultResult(result$1, def));
+		return handleDefaultResult(result, def);
+	};
+});
+function handleDefaultResult(payload, def) {
+	if (payload.value === void 0) payload.value = def.defaultValue;
+	return payload;
+}
+const $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.optin = "optional";
+	defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+	inst._zod.parse = (payload, ctx) => {
+		if (payload.value === void 0) payload.value = def.defaultValue;
+		return def.innerType._zod.run(payload, ctx);
+	};
+});
+const $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "values", () => {
+		const v$1 = def.innerType._zod.values;
+		return v$1 ? new Set([...v$1].filter((x$1) => x$1 !== void 0)) : void 0;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		const result = def.innerType._zod.run(payload, ctx);
+		if (result instanceof Promise) return result.then((result$1) => handleNonOptionalResult(result$1, inst));
+		return handleNonOptionalResult(result, inst);
+	};
+});
+function handleNonOptionalResult(payload, inst) {
+	if (!payload.issues.length && payload.value === void 0) payload.issues.push({
+		code: "invalid_type",
+		expected: "nonoptional",
+		input: payload.value,
+		inst
+	});
+	return payload;
+}
+const $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+	defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+	defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+	inst._zod.parse = (payload, ctx) => {
+		const result = def.innerType._zod.run(payload, ctx);
+		if (result instanceof Promise) return result.then((result$1) => {
+			payload.value = result$1.value;
+			if (result$1.issues.length) {
+				payload.value = def.catchValue({
+					...payload,
+					error: { issues: result$1.issues.map((iss) => finalizeIssue(iss, ctx, config())) },
+					input: payload.value
+				});
+				payload.issues = [];
+			}
+			return payload;
+		});
+		payload.value = result.value;
+		if (result.issues.length) {
+			payload.value = def.catchValue({
+				...payload,
+				error: { issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config())) },
+				input: payload.value
+			});
+			payload.issues = [];
+		}
+		return payload;
+	};
+});
+const $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "values", () => def.in._zod.values);
+	defineLazy(inst._zod, "optin", () => def.in._zod.optin);
+	defineLazy(inst._zod, "optout", () => def.out._zod.optout);
+	defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
+	inst._zod.parse = (payload, ctx) => {
+		const left = def.in._zod.run(payload, ctx);
+		if (left instanceof Promise) return left.then((left$1) => handlePipeResult(left$1, def, ctx));
+		return handlePipeResult(left, def, ctx);
+	};
+});
+function handlePipeResult(left, def, ctx) {
+	if (left.issues.length) return left;
+	return def.out._zod.run({
+		value: left.value,
+		issues: left.issues
+	}, ctx);
+}
+const $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
+	defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+	defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+	defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+	inst._zod.parse = (payload, ctx) => {
+		const result = def.innerType._zod.run(payload, ctx);
+		if (result instanceof Promise) return result.then(handleReadonlyResult);
+		return handleReadonlyResult(result);
+	};
+});
+function handleReadonlyResult(payload) {
+	payload.value = Object.freeze(payload.value);
+	return payload;
+}
+const $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, _$1) => {
+		return payload;
+	};
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		const r$1 = def.fn(input);
+		if (r$1 instanceof Promise) return r$1.then((r$2) => handleRefineResult(r$2, payload, input, inst));
+		handleRefineResult(r$1, payload, input, inst);
+		return;
+	};
+});
+function handleRefineResult(result, payload, input, inst) {
+	if (!result) {
+		const _iss = {
+			code: "custom",
+			input,
+			inst,
+			path: [...inst._zod.def.path ?? []],
+			continue: !inst._zod.def.abort
+		};
+		if (inst._zod.def.params) _iss.params = inst._zod.def.params;
+		payload.issues.push(issue(_iss));
+	}
+}
+const $output = Symbol("ZodOutput");
+const $input = Symbol("ZodInput");
+var $ZodRegistry = class {
+	constructor() {
+		this._map = /* @__PURE__ */ new Map();
+		this._idmap = /* @__PURE__ */ new Map();
+	}
+	add(schema, ..._meta) {
+		const meta = _meta[0];
+		this._map.set(schema, meta);
+		if (meta && typeof meta === "object" && "id" in meta) {
+			if (this._idmap.has(meta.id)) throw new Error(`ID ${meta.id} already exists in the registry`);
+			this._idmap.set(meta.id, schema);
+		}
+		return this;
+	}
+	clear() {
+		this._map = /* @__PURE__ */ new Map();
+		this._idmap = /* @__PURE__ */ new Map();
+		return this;
+	}
+	remove(schema) {
+		const meta = this._map.get(schema);
+		if (meta && typeof meta === "object" && "id" in meta) this._idmap.delete(meta.id);
+		this._map.delete(schema);
+		return this;
+	}
+	get(schema) {
+		const p$1 = schema._zod.parent;
+		if (p$1) {
+			const pm = { ...this.get(p$1) ?? {} };
+			delete pm.id;
+			const f$1 = {
+				...pm,
+				...this._map.get(schema)
+			};
+			return Object.keys(f$1).length ? f$1 : void 0;
+		}
+		return this._map.get(schema);
+	}
+	has(schema) {
+		return this._map.has(schema);
+	}
+};
+function registry() {
+	return new $ZodRegistry();
+}
+const globalRegistry = /* @__PURE__ */ registry();
+function _string(Class, params) {
+	return new Class({
+		type: "string",
+		...normalizeParams(params)
+	});
+}
+function _email(Class, params) {
+	return new Class({
+		type: "string",
+		format: "email",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _guid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "guid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _uuid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _uuidv4(Class, params) {
+	return new Class({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: false,
+		version: "v4",
+		...normalizeParams(params)
+	});
+}
+function _uuidv6(Class, params) {
+	return new Class({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: false,
+		version: "v6",
+		...normalizeParams(params)
+	});
+}
+function _uuidv7(Class, params) {
+	return new Class({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: false,
+		version: "v7",
+		...normalizeParams(params)
+	});
+}
+function _url(Class, params) {
+	return new Class({
+		type: "string",
+		format: "url",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _emoji(Class, params) {
+	return new Class({
+		type: "string",
+		format: "emoji",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _nanoid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "nanoid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _cuid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "cuid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _cuid2(Class, params) {
+	return new Class({
+		type: "string",
+		format: "cuid2",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _ulid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "ulid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _xid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "xid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _ksuid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "ksuid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _ipv4(Class, params) {
+	return new Class({
+		type: "string",
+		format: "ipv4",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _ipv6(Class, params) {
+	return new Class({
+		type: "string",
+		format: "ipv6",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _cidrv4(Class, params) {
+	return new Class({
+		type: "string",
+		format: "cidrv4",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _cidrv6(Class, params) {
+	return new Class({
+		type: "string",
+		format: "cidrv6",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _base64(Class, params) {
+	return new Class({
+		type: "string",
+		format: "base64",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _base64url(Class, params) {
+	return new Class({
+		type: "string",
+		format: "base64url",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _e164(Class, params) {
+	return new Class({
+		type: "string",
+		format: "e164",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _jwt(Class, params) {
+	return new Class({
+		type: "string",
+		format: "jwt",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+function _isoDateTime(Class, params) {
+	return new Class({
+		type: "string",
+		format: "datetime",
+		check: "string_format",
+		offset: false,
+		local: false,
+		precision: null,
+		...normalizeParams(params)
+	});
+}
+function _isoDate(Class, params) {
+	return new Class({
+		type: "string",
+		format: "date",
+		check: "string_format",
+		...normalizeParams(params)
+	});
+}
+function _isoTime(Class, params) {
+	return new Class({
+		type: "string",
+		format: "time",
+		check: "string_format",
+		precision: null,
+		...normalizeParams(params)
+	});
+}
+function _isoDuration(Class, params) {
+	return new Class({
+		type: "string",
+		format: "duration",
+		check: "string_format",
+		...normalizeParams(params)
+	});
+}
+function _any(Class) {
+	return new Class({ type: "any" });
+}
+function _unknown(Class) {
+	return new Class({ type: "unknown" });
+}
+function _never(Class, params) {
+	return new Class({
+		type: "never",
+		...normalizeParams(params)
+	});
+}
+function _maxLength(maximum, params) {
+	const ch = new $ZodCheckMaxLength({
+		check: "max_length",
+		...normalizeParams(params),
+		maximum
+	});
+	return ch;
+}
+function _minLength(minimum, params) {
+	return new $ZodCheckMinLength({
+		check: "min_length",
+		...normalizeParams(params),
+		minimum
+	});
+}
+function _length(length, params) {
+	return new $ZodCheckLengthEquals({
+		check: "length_equals",
+		...normalizeParams(params),
+		length
+	});
+}
+function _regex(pattern, params) {
+	return new $ZodCheckRegex({
+		check: "string_format",
+		format: "regex",
+		...normalizeParams(params),
+		pattern
+	});
+}
+function _lowercase(params) {
+	return new $ZodCheckLowerCase({
+		check: "string_format",
+		format: "lowercase",
+		...normalizeParams(params)
+	});
+}
+function _uppercase(params) {
+	return new $ZodCheckUpperCase({
+		check: "string_format",
+		format: "uppercase",
+		...normalizeParams(params)
+	});
+}
+function _includes(includes, params) {
+	return new $ZodCheckIncludes({
+		check: "string_format",
+		format: "includes",
+		...normalizeParams(params),
+		includes
+	});
+}
+function _startsWith(prefix, params) {
+	return new $ZodCheckStartsWith({
+		check: "string_format",
+		format: "starts_with",
+		...normalizeParams(params),
+		prefix
+	});
+}
+function _endsWith(suffix, params) {
+	return new $ZodCheckEndsWith({
+		check: "string_format",
+		format: "ends_with",
+		...normalizeParams(params),
+		suffix
+	});
+}
+function _overwrite(tx) {
+	return new $ZodCheckOverwrite({
+		check: "overwrite",
+		tx
+	});
+}
+function _normalize(form) {
+	return _overwrite((input) => input.normalize(form));
+}
+function _trim() {
+	return _overwrite((input) => input.trim());
+}
+function _toLowerCase() {
+	return _overwrite((input) => input.toLowerCase());
+}
+function _toUpperCase() {
+	return _overwrite((input) => input.toUpperCase());
+}
+function _array(Class, element, params) {
+	return new Class({
+		type: "array",
+		element,
+		...normalizeParams(params)
+	});
+}
+function _refine(Class, fn, _params) {
+	const schema = new Class({
+		type: "custom",
+		check: "custom",
+		fn,
+		...normalizeParams(_params)
+	});
+	return schema;
+}
+const ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
+	$ZodISODateTime.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+function datetime(params) {
+	return _isoDateTime(ZodISODateTime, params);
+}
+const ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
+	$ZodISODate.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+function date(params) {
+	return _isoDate(ZodISODate, params);
+}
+const ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
+	$ZodISOTime.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+function time(params) {
+	return _isoTime(ZodISOTime, params);
+}
+const ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => {
+	$ZodISODuration.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+function duration(params) {
+	return _isoDuration(ZodISODuration, params);
+}
+const initializer = (inst, issues) => {
+	$ZodError.init(inst, issues);
+	inst.name = "ZodError";
+	Object.defineProperties(inst, {
+		format: { value: (mapper) => formatError(inst, mapper) },
+		flatten: { value: (mapper) => flattenError(inst, mapper) },
+		addIssue: { value: (issue$1) => {
+			inst.issues.push(issue$1);
+			inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+		} },
+		addIssues: { value: (issues$1) => {
+			inst.issues.push(...issues$1);
+			inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+		} },
+		isEmpty: { get() {
+			return inst.issues.length === 0;
+		} }
+	});
+};
+const ZodError = $constructor("ZodError", initializer);
+const ZodRealError = $constructor("ZodError", initializer, { Parent: Error });
+const parse = /* @__PURE__ */ _parse(ZodRealError);
+const parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
+const safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
+const safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
+const ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst.def = def;
+	Object.defineProperty(inst, "_def", { value: def });
+	inst.check = (...checks) => {
+		return inst.clone({
+			...def,
+			checks: [...def.checks ?? [], ...checks.map((ch) => typeof ch === "function" ? { _zod: {
+				check: ch,
+				def: { check: "custom" },
+				onattach: []
+			} } : ch)]
+		});
+	};
+	inst.clone = (def$1, params) => clone(inst, def$1, params);
+	inst.brand = () => inst;
+	inst.register = ((reg, meta) => {
+		reg.add(inst, meta);
+		return inst;
+	});
+	inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
+	inst.safeParse = (data, params) => safeParse(inst, data, params);
+	inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
+	inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
+	inst.spa = inst.safeParseAsync;
+	inst.refine = (check$1, params) => inst.check(refine(check$1, params));
+	inst.superRefine = (refinement) => inst.check(superRefine(refinement));
+	inst.overwrite = (fn) => inst.check(_overwrite(fn));
+	inst.optional = () => optional(inst);
+	inst.nullable = () => nullable(inst);
+	inst.nullish = () => optional(nullable(inst));
+	inst.nonoptional = (params) => nonoptional(inst, params);
+	inst.array = () => array(inst);
+	inst.or = (arg) => union([inst, arg]);
+	inst.and = (arg) => intersection(inst, arg);
+	inst.transform = (tx) => pipe(inst, transform(tx));
+	inst.default = (def$1) => _default(inst, def$1);
+	inst.prefault = (def$1) => prefault(inst, def$1);
+	inst.catch = (params) => _catch(inst, params);
+	inst.pipe = (target) => pipe(inst, target);
+	inst.readonly = () => readonly(inst);
+	inst.describe = (description) => {
+		const cl = inst.clone();
+		globalRegistry.add(cl, { description });
+		return cl;
+	};
+	Object.defineProperty(inst, "description", {
+		get() {
+			return globalRegistry.get(inst)?.description;
+		},
+		configurable: true
+	});
+	inst.meta = (...args) => {
+		if (args.length === 0) return globalRegistry.get(inst);
+		const cl = inst.clone();
+		globalRegistry.add(cl, args[0]);
+		return cl;
+	};
+	inst.isOptional = () => inst.safeParse(void 0).success;
+	inst.isNullable = () => inst.safeParse(null).success;
+	return inst;
+});
+const _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
+	$ZodString.init(inst, def);
+	ZodType.init(inst, def);
+	const bag = inst._zod.bag;
+	inst.format = bag.format ?? null;
+	inst.minLength = bag.minimum ?? null;
+	inst.maxLength = bag.maximum ?? null;
+	inst.regex = (...args) => inst.check(_regex(...args));
+	inst.includes = (...args) => inst.check(_includes(...args));
+	inst.startsWith = (...args) => inst.check(_startsWith(...args));
+	inst.endsWith = (...args) => inst.check(_endsWith(...args));
+	inst.min = (...args) => inst.check(_minLength(...args));
+	inst.max = (...args) => inst.check(_maxLength(...args));
+	inst.length = (...args) => inst.check(_length(...args));
+	inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
+	inst.lowercase = (params) => inst.check(_lowercase(params));
+	inst.uppercase = (params) => inst.check(_uppercase(params));
+	inst.trim = () => inst.check(_trim());
+	inst.normalize = (...args) => inst.check(_normalize(...args));
+	inst.toLowerCase = () => inst.check(_toLowerCase());
+	inst.toUpperCase = () => inst.check(_toUpperCase());
+});
+const ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
+	$ZodString.init(inst, def);
+	_ZodString.init(inst, def);
+	inst.email = (params) => inst.check(_email(ZodEmail, params));
+	inst.url = (params) => inst.check(_url(ZodURL, params));
+	inst.jwt = (params) => inst.check(_jwt(ZodJWT, params));
+	inst.emoji = (params) => inst.check(_emoji(ZodEmoji, params));
+	inst.guid = (params) => inst.check(_guid(ZodGUID, params));
+	inst.uuid = (params) => inst.check(_uuid(ZodUUID, params));
+	inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params));
+	inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params));
+	inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params));
+	inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params));
+	inst.guid = (params) => inst.check(_guid(ZodGUID, params));
+	inst.cuid = (params) => inst.check(_cuid(ZodCUID, params));
+	inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params));
+	inst.ulid = (params) => inst.check(_ulid(ZodULID, params));
+	inst.base64 = (params) => inst.check(_base64(ZodBase64, params));
+	inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params));
+	inst.xid = (params) => inst.check(_xid(ZodXID, params));
+	inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params));
+	inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params));
+	inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params));
+	inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params));
+	inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params));
+	inst.e164 = (params) => inst.check(_e164(ZodE164, params));
+	inst.datetime = (params) => inst.check(datetime(params));
+	inst.date = (params) => inst.check(date(params));
+	inst.time = (params) => inst.check(time(params));
+	inst.duration = (params) => inst.check(duration(params));
+});
+function string(params) {
+	return _string(ZodString, params);
+}
+const ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => {
+	$ZodStringFormat.init(inst, def);
+	_ZodString.init(inst, def);
+});
+const ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => {
+	$ZodEmail.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => {
+	$ZodGUID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => {
+	$ZodUUID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
+	$ZodURL.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
+	$ZodEmoji.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => {
+	$ZodNanoID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => {
+	$ZodCUID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => {
+	$ZodCUID2.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => {
+	$ZodULID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => {
+	$ZodXID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => {
+	$ZodKSUID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => {
+	$ZodIPv4.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => {
+	$ZodIPv6.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => {
+	$ZodCIDRv4.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => {
+	$ZodCIDRv6.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
+	$ZodBase64.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
+	$ZodBase64URL.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
+	$ZodE164.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
+	$ZodJWT.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
+	$ZodAny.init(inst, def);
+	ZodType.init(inst, def);
+});
+function any() {
+	return _any(ZodAny);
+}
+const ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
+	$ZodUnknown.init(inst, def);
+	ZodType.init(inst, def);
+});
+function unknown() {
+	return _unknown(ZodUnknown);
+}
+const ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
+	$ZodNever.init(inst, def);
+	ZodType.init(inst, def);
+});
+function never(params) {
+	return _never(ZodNever, params);
+}
+const ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
+	$ZodArray.init(inst, def);
+	ZodType.init(inst, def);
+	inst.element = def.element;
+	inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
+	inst.nonempty = (params) => inst.check(_minLength(1, params));
+	inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
+	inst.length = (len, params) => inst.check(_length(len, params));
+	inst.unwrap = () => inst.element;
+});
+function array(element, params) {
+	return _array(ZodArray, element, params);
+}
+const ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
+	$ZodObject.init(inst, def);
+	ZodType.init(inst, def);
+	defineLazy(inst, "shape", () => def.shape);
+	inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
+	inst.catchall = (catchall) => inst.clone({
+		...inst._zod.def,
+		catchall
+	});
+	inst.passthrough = () => inst.clone({
+		...inst._zod.def,
+		catchall: unknown()
+	});
+	inst.loose = () => inst.clone({
+		...inst._zod.def,
+		catchall: unknown()
+	});
+	inst.strict = () => inst.clone({
+		...inst._zod.def,
+		catchall: never()
+	});
+	inst.strip = () => inst.clone({
+		...inst._zod.def,
+		catchall: void 0
+	});
+	inst.extend = (incoming) => {
+		return extend(inst, incoming);
+	};
+	inst.merge = (other) => merge(inst, other);
+	inst.pick = (mask) => pick(inst, mask);
+	inst.omit = (mask) => omit(inst, mask);
+	inst.partial = (...args) => partial(ZodOptional, inst, args[0]);
+	inst.required = (...args) => required(ZodNonOptional, inst, args[0]);
+});
+function object(shape, params) {
+	const def = {
+		type: "object",
+		get shape() {
+			assignProp(this, "shape", { ...shape });
+			return this.shape;
+		},
+		...normalizeParams(params)
+	};
+	return new ZodObject(def);
+}
+const ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
+	$ZodUnion.init(inst, def);
+	ZodType.init(inst, def);
+	inst.options = def.options;
+});
+function union(options, params) {
+	return new ZodUnion({
+		type: "union",
+		options,
+		...normalizeParams(params)
+	});
+}
+const ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
+	$ZodIntersection.init(inst, def);
+	ZodType.init(inst, def);
+});
+function intersection(left, right) {
+	return new ZodIntersection({
+		type: "intersection",
+		left,
+		right
+	});
+}
+const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
+	$ZodEnum.init(inst, def);
+	ZodType.init(inst, def);
+	inst.enum = def.entries;
+	inst.options = Object.values(def.entries);
+	const keys = new Set(Object.keys(def.entries));
+	inst.extract = (values, params) => {
+		const newEntries = {};
+		for (const value of values) if (keys.has(value)) newEntries[value] = def.entries[value];
+		else throw new Error(`Key ${value} not found in enum`);
+		return new ZodEnum({
+			...def,
+			checks: [],
+			...normalizeParams(params),
+			entries: newEntries
+		});
+	};
+	inst.exclude = (values, params) => {
+		const newEntries = { ...def.entries };
+		for (const value of values) if (keys.has(value)) delete newEntries[value];
+		else throw new Error(`Key ${value} not found in enum`);
+		return new ZodEnum({
+			...def,
+			checks: [],
+			...normalizeParams(params),
+			entries: newEntries
+		});
+	};
+});
+function _enum(values, params) {
+	const entries = Array.isArray(values) ? Object.fromEntries(values.map((v$1) => [v$1, v$1])) : values;
+	return new ZodEnum({
+		type: "enum",
+		entries,
+		...normalizeParams(params)
+	});
+}
+const ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
+	$ZodTransform.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.parse = (payload, _ctx) => {
+		payload.addIssue = (issue$1) => {
+			if (typeof issue$1 === "string") payload.issues.push(issue(issue$1, payload.value, def));
+			else {
+				const _issue = issue$1;
+				if (_issue.fatal) _issue.continue = false;
+				_issue.code ?? (_issue.code = "custom");
+				_issue.input ?? (_issue.input = payload.value);
+				_issue.inst ?? (_issue.inst = inst);
+				payload.issues.push(issue(_issue));
+			}
+		};
+		const output = def.transform(payload.value, payload);
+		if (output instanceof Promise) return output.then((output$1) => {
+			payload.value = output$1;
+			return payload;
+		});
+		payload.value = output;
+		return payload;
+	};
+});
+function transform(fn) {
+	return new ZodTransform({
+		type: "transform",
+		transform: fn
+	});
+}
+const ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
+	$ZodOptional.init(inst, def);
+	ZodType.init(inst, def);
+	inst.unwrap = () => inst._zod.def.innerType;
+});
+function optional(innerType) {
+	return new ZodOptional({
+		type: "optional",
+		innerType
+	});
+}
+const ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
+	$ZodNullable.init(inst, def);
+	ZodType.init(inst, def);
+	inst.unwrap = () => inst._zod.def.innerType;
+});
+function nullable(innerType) {
+	return new ZodNullable({
+		type: "nullable",
+		innerType
+	});
+}
+const ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
+	$ZodDefault.init(inst, def);
+	ZodType.init(inst, def);
+	inst.unwrap = () => inst._zod.def.innerType;
+	inst.removeDefault = inst.unwrap;
+});
+function _default(innerType, defaultValue) {
+	return new ZodDefault({
+		type: "default",
+		innerType,
+		get defaultValue() {
+			return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+		}
+	});
+}
+const ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
+	$ZodPrefault.init(inst, def);
+	ZodType.init(inst, def);
+	inst.unwrap = () => inst._zod.def.innerType;
+});
+function prefault(innerType, defaultValue) {
+	return new ZodPrefault({
+		type: "prefault",
+		innerType,
+		get defaultValue() {
+			return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+		}
+	});
+}
+const ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
+	$ZodNonOptional.init(inst, def);
+	ZodType.init(inst, def);
+	inst.unwrap = () => inst._zod.def.innerType;
+});
+function nonoptional(innerType, params) {
+	return new ZodNonOptional({
+		type: "nonoptional",
+		innerType,
+		...normalizeParams(params)
+	});
+}
+const ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
+	$ZodCatch.init(inst, def);
+	ZodType.init(inst, def);
+	inst.unwrap = () => inst._zod.def.innerType;
+	inst.removeCatch = inst.unwrap;
+});
+function _catch(innerType, catchValue) {
+	return new ZodCatch({
+		type: "catch",
+		innerType,
+		catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
+	});
+}
+const ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
+	$ZodPipe.init(inst, def);
+	ZodType.init(inst, def);
+	inst.in = def.in;
+	inst.out = def.out;
+});
+function pipe(in_, out) {
+	return new ZodPipe({
+		type: "pipe",
+		in: in_,
+		out
+	});
+}
+const ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
+	$ZodReadonly.init(inst, def);
+	ZodType.init(inst, def);
+	inst.unwrap = () => inst._zod.def.innerType;
+});
+function readonly(innerType) {
+	return new ZodReadonly({
+		type: "readonly",
+		innerType
+	});
+}
+const ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
+	$ZodCustom.init(inst, def);
+	ZodType.init(inst, def);
+});
+function check(fn) {
+	const ch = new $ZodCheck({ check: "custom" });
+	ch._zod.check = fn;
+	return ch;
+}
+function refine(fn, _params = {}) {
+	return _refine(ZodCustom, fn, _params);
+}
+function superRefine(fn) {
+	const ch = check((payload) => {
+		payload.addIssue = (issue$1) => {
+			if (typeof issue$1 === "string") payload.issues.push(issue(issue$1, payload.value, ch._zod.def));
+			else {
+				const _issue = issue$1;
+				if (_issue.fatal) _issue.continue = false;
+				_issue.code ?? (_issue.code = "custom");
+				_issue.input ?? (_issue.input = payload.value);
+				_issue.inst ?? (_issue.inst = ch);
+				_issue.continue ?? (_issue.continue = !ch._zod.def.abort);
+				payload.issues.push(issue(_issue));
+			}
+		};
+		return fn(payload.value, payload);
+	});
+	return ch;
+}
+const TargetPartSchema = union([
+	object({ text: string() }),
+	object({ inlineData: object({
+		mimeType: string(),
+		data: string()
+	}) }),
+	object({ function_call: object({
+		name: string(),
+		args: any()
+	}) }),
+	object({ function_response: object({
+		name: string(),
+		response: any()
+	}) })
+]);
+const TargetMessageSchema = object({
+	role: string(),
+	parts: array(TargetPartSchema)
+});
+const FinalOutputSchema = array(TargetMessageSchema);
+const blobUrlToBase64 = (blobUrl) => {
+	return new Promise(async (resolve, reject) => {
+		try {
+			const response = await fetch(blobUrl);
+			if (!response.ok) throw new Error(`Failed to fetch blob: ${response.statusText}`);
+			const blob = await response.blob();
+			const reader = new FileReader();
+			reader.onloadend = () => {
+				const base64Data = reader.result.split(",")[1];
+				resolve(base64Data);
+			};
+			reader.onerror = (error) => {
+				reject(error);
+			};
+			reader.readAsDataURL(blob);
+		} catch (error) {
+			reject(error);
+		}
+	});
+};
+let normalizeNcMapToCanonicalArray;
+const normalizeNcValue = (ncWrapper) => {
+	const ncArray = ncWrapper.Nc;
+	return z(ncArray).with([
+		N.any,
+		N.any,
+		N.any,
+		N.any,
+		{ Nc: [N.select(N.instanceOf(Map))] }
+	], (innerMap) => {
+		const processedMapArray = normalizeNcMapToCanonicalArray(innerMap);
+		return [
+			null,
+			null,
+			null,
+			null,
+			[processedMapArray]
+		];
+	}).otherwise(() => ncArray);
+};
+normalizeNcMapToCanonicalArray = (map) => {
+	return Array.from(map.entries()).map(([key, valueWrapper]) => {
+		const canonicalValueArray = normalizeNcValue(valueWrapper);
+		return [key, canonicalValueArray];
+	});
+};
+const getCanonicalFunctionCall = (msg) => {
+	return z(msg.parts[0]).with(N.array(), (part) => ({
+		name: part[10][0],
+		argsArray: part[10][1][0]
+	})).with({ Nc: N.array() }, (part) => {
+		const functionCallData = part.Nc[10].Nc;
+		const name = functionCallData[0];
+		const argsMap = functionCallData[1].Nc[0];
+		return {
+			name,
+			argsArray: normalizeNcMapToCanonicalArray(argsMap)
+		};
+	}).otherwise(() => {
+		throw new Error("Unknown function_call structure encountered.");
+	});
+};
+const parseArgValue = (arg) => {
+	if (!Array.isArray(arg)) return arg;
+	return z(arg).with([
+		N.any,
+		N.any,
+		N.any,
+		N.any,
+		N.select(N.array())
+	], (nestedPairs) => parseFunctionArgs(nestedPairs[0])).with([
+		N.any,
+		N.any,
+		N.any,
+		1
+	], () => true).with([
+		N.any,
+		N.any,
+		N.any,
+		0
+	], () => false).with([
+		N.any,
+		N.any,
+		N.select(N.string)
+	], (val) => val).with([N.any, N.select(N.number)], (val) => val).otherwise(() => null);
+};
+const parseFunctionArgs = (argList) => {
+	if (!Array.isArray(argList)) return {};
+	return Object.fromEntries(argList.map(([key, value]) => [key, parseArgValue(value)]));
+};
+const convertMessages = async (sourceMessages) => {
+	const groupedMessages = sourceMessages.reduce((acc, msg) => {
+		const lastGroup = acc[acc.length - 1];
+		const prevMessage = lastGroup?.items[lastGroup.items.length - 1];
+		if (lastGroup && lastGroup.role === msg.role && prevMessage?.Ua !== "function_call") lastGroup.items.push(msg);
+		else acc.push({
+			role: msg.role,
+			items: [msg]
+		});
+		return acc;
+	}, []);
+	const finalMessages = [];
+	for (const group of groupedMessages) {
+		let functionResponseData = null;
+		const partsPromises = group.items.map(async (item) => {
+			return z(item).with({
+				Ua: "text",
+				text: N.string
+			}, (msg) => {
+				return msg.text.length > 0 ? { text: msg.text } : null;
+			}).with({
+				Ua: "image",
+				Wd: N.not(void 0).select()
+			}, (wd) => {
+				return { inlineData: {
+					mimeType: wd.mimeType,
+					data: wd.Dc
+				} };
+			}).with({
+				Ua: "image",
+				Ta: N.not(void 0).select("ta"),
+				zd: N.not(void 0).select("zd")
+			}, async ({ ta, zd }) => {
+				try {
+					const data = await blobUrlToBase64(zd);
+					return { inlineData: {
+						mimeType: ta.mimeType,
+						data
+					} };
+				} catch (error) {
+					console.error(`Failed to process blob URL ${zd}:`, error);
+					return null;
+				}
+			}).with({ Ua: "function_call" }, (msg) => {
+				try {
+					const { name, argsArray } = getCanonicalFunctionCall(msg);
+					const args = parseFunctionArgs(argsArray);
+					if (msg.Qg?.response) functionResponseData = {
+						name,
+						response: msg.Qg.response
+					};
+					return { function_call: {
+						name,
+						args
+					} };
+				} catch (error) {
+					console.error("Failed to parse function call:", error, item);
+					return null;
+				}
+			}).otherwise(() => null);
+		});
+		const parts = (await Promise.all(partsPromises)).filter((p$1) => p$1 !== null);
+		if (parts.length > 0) finalMessages.push({
+			role: group.role,
+			parts
+		});
+		if (functionResponseData) finalMessages.push({
+			role: "user",
+			parts: [{ function_response: {
+				name: functionResponseData.name,
+				response: { output: functionResponseData.response }
+			} }]
+		});
+	}
+	finalMessages.push({
+		role: "user",
+		parts: [{ text: "INSERT_INPUT_HERE" }]
+	});
+	return finalMessages;
+};
 const syncOutput = async () => {
-	const onChange = func_throttle(runFileCreation, 200, {
+	const onChange = func_throttle(async (raw) => {
+		await runFileCreation(await convertMessages(raw));
+	}, 200, {
 		before: true,
 		waitPromise: true
 	});
 	const arr_push = Array.prototype[Symbol.for("arr_push")] || Array.prototype.push;
 	Array.prototype[Symbol.for("arr_push")] = arr_push;
 	Array.prototype.push = function push(...args) {
-		const a = args[0];
-		if (a && Object.getPrototypeOf(a) === Object.prototype && a.role && a.id && typeof a.text === "string") onChange(this);
-		return arr_push.apply(this, args);
+		const a$1 = args[0];
+		let isMatched = false;
+		if (this.length > 1 && a$1 && Object.getPrototypeOf(a$1) === Object.prototype && a$1.role && a$1.id && typeof a$1.text === "string") isMatched = true;
+		const res = arr_push.apply(this, args);
+		if (isMatched) try {
+			onChange(structuredClone(this));
+		} catch {}
+		return res;
 	};
 	const findInput = () => $(`textarea[aria-label="Start typing a prompt"]`);
 	while (!started) {
@@ -434,7 +3587,7 @@ const syncOutput = async () => {
 };
 let started = false;
 let writting = false;
-async function runFileCreation(b, targetFilename = getTargetNamespace() + ".contents.json") {
+async function runFileCreation(b$1, targetFilename = getTargetNamespace() + ".contents.json") {
 	started = true;
 	if (writting) return;
 	writting = true;
@@ -444,7 +3597,7 @@ async function runFileCreation(b, targetFilename = getTargetNamespace() + ".cont
 		const fileHandle = await rootDirHandle$1.getFileHandle(targetFilename, { create: true });
 		const writable = await fileHandle.createWritable();
 		console.log("%c   - 创建可写流成功。", styles.info);
-		await writable.write(JSON.stringify(b));
+		await writable.write(JSON.stringify(b$1));
 		console.log("%c   - 数据写入中...", styles.info);
 		await writable.close();
 		console.log(`%c   - ✅ 文件写入并关闭成功: %c${targetFilename}`, styles.success, styles.code);
@@ -456,10 +3609,10 @@ async function runFileCreation(b, targetFilename = getTargetNamespace() + ".cont
 	}
 }
 (async () => {
-	const aborted = await prepareDirHandle().then(() => false, (e) => {
-		if (e instanceof Error && e.name === "AbortError") return true;
+	const aborted$1 = await prepareDirHandle().then(() => false, (e$1) => {
+		if (e$1 instanceof Error && e$1.name === "AbortError") return true;
 	});
-	if (aborted) {
+	if (aborted$1) {
 		console.warn("用户取消了脚本运行");
 		return;
 	}