@jixo/cli 0.24.1 → 0.26.0

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

@@ -1,20 +1,36 @@
-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) => {
+const func_remember = /* @__NO_SIDE_EFFECTS__ */ (func, key, cacheAwaited) => {
 	let result;
 	const once_fn = function(...args) {
 		const newKey = key?.apply(this, args);
-		if (result === void 0 || newKey !== result.key) result = {
-			key: newKey,
-			res: func.apply(this, args)
-		};
+		if (result === void 0 || newKey !== result.key) {
+			const res = func.apply(this, args);
+			result = {
+				key: newKey,
+				res,
+				awaitedRes: void 0
+			};
+			if (cacheAwaited) if (typeof res === "object" && res && "then" in res && typeof res.then === "function") res.then((r$1) => {
+				if (result && res === result.res) result.awaitedRes = {
+					type: "resolved",
+					result: r$1
+				};
+			}, (e$1) => {
+				if (result && res === result.res) result.awaitedRes = {
+					type: "rejected",
+					error: e$1
+				};
+			});
+			else result.awaitedRes = res;
+		}
 		return result.res;
 	};
-	const once_fn_mix = Object.assign(once_fn, {
+	const once_fn_mix = /* @__PURE__ */ obj_assign_props(once_fn, {
 		get source() {
 			return func;
 		},
@@ -27,6 +43,9 @@ const func_remember = /* @__NO_SIDE_EFFECTS__ */ (func, key) => {
 		get returnValue() {
 			return result?.res;
 		},
+		get awaitedReturnValue() {
+			return result?.awaitedRes;
+		},
 		reset() {
 			result = void 0;
 		},
@@ -35,29 +54,6 @@ const func_remember = /* @__NO_SIDE_EFFECTS__ */ (func, key) => {
 			return once_fn_mix(...args);
 		}
 	});
-	Object.defineProperties(once_fn_mix, {
-		source: {
-			value: func,
-			writable: false,
-			configurable: true,
-			enumerable: true
-		},
-		key: {
-			get: () => result?.key,
-			configurable: true,
-			enumerable: true
-		},
-		runned: {
-			get: () => result != null,
-			configurable: true,
-			enumerable: true
-		},
-		returnValue: {
-			get: () => result?.res,
-			configurable: true,
-			enumerable: true
-		}
-	});
 	return once_fn_mix;
 };
 const wrapSuccess = (result) => {
@@ -121,7 +117,6 @@ const func_catch = /* @__PURE__ */ Object.assign((fn, errorParser) => {
 	wrapSuccess,
 	wrapError
 });
-const effect_symbol = Symbol.for("effect");
 const timmers = {
 	timeout: (ms) => {
 		return (cb) => {
@@ -165,6 +160,19 @@ const timmers = {
 		return typeof ms === "number" ? ms <= 0 ? timmers.microtask : timmers.timeout(ms) : ms;
 	}
 };
+const abort_signal_merge = (..._signals) => {
+	const signals = _signals.filter((s$1) => s$1 != null);
+	if (signals.length === 0) return;
+	if (signals.length === 1) return signals[0];
+	const aborted_signals = signals.filter((signal) => signal.aborted);
+	if (aborted_signals.length === 1) return aborted_signals[0];
+	if (aborted_signals.length > 1) return AbortSignal.abort(new AggregateError(aborted_signals.map((signal) => signal.reason), "multi-signals are aborted"));
+	const aborter = new AbortController();
+	for (const signal of signals) signal.addEventListener("abort", (reason) => {
+		aborter.abort(reason);
+	});
+	return aborter.signal;
+};
 const func_throttle = (fn, wait = 0, options = {}) => {
 	const timmer = timmers.from(wait);
 	let clear;
@@ -208,261 +216,1535 @@ const func_throttle = (fn, wait = 0, options = {}) => {
 		}
 	});
 };
-let rootDirHandle;
-const prepareDirHandle = async () => {
-	if (rootDirHandle) return rootDirHandle;
+let restoredDirHandle;
+const pickDirHandle = async () => {
 	const ti = setTimeout(() => {
-		console.log("%c等待用户动作: 请选择一个文件夹，用来作为内容导入导出的协作目录.", styles.info);
+		console.log("%c等待用户动作: 请选择一个文件夹", styles.info);
 	}, 100);
 	try {
-		rootDirHandle = await window.showDirectoryPicker({ mode: "readwrite" });
-		console.log(`%c✅ 根文件夹已选择: %c${rootDirHandle.name}`, styles.success, styles.code);
-		return rootDirHandle;
-	} catch (e) {
+		return await window.showDirectoryPicker({ mode: "readwrite" });
+	} 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();
+				return pickDirHandle();
 			}
-			if (e.name === "AbortError") throw new DOMException("用户取消了文件夹选择", "AbortError");
+			if (e$1.name === "AbortError") throw new DOMException("用户取消了文件夹选择", "AbortError");
 		}
-		throw e;
+		throw e$1;
+	} finally {
+		clearTimeout(ti);
 	}
 };
-const getEasyFs = /* @__PURE__ */ func_remember(async () => {
-	const [error, dirHandle] = await func_catch(prepareDirHandle)();
-	if (!dirHandle) {
-		getEasyFs.reset();
-		throw error;
+const prepareDirHandle = /* @__PURE__ */ func_remember(async () => {
+	const rootDirHandle = restoredDirHandle ?? await pickDirHandle();
+	console.log(`%c✅ 根文件夹已选择，用来作为内容导入导出的协作目录: %c${rootDirHandle.name}`, styles.success, styles.code);
+	return rootDirHandle;
+});
+const styles = {
+	header: "color: #4CAF50; font-size: 18px; font-weight: bold; border-bottom: 2px solid #4CAF50; padding-bottom: 5px;",
+	info: "color: #2196F3; font-style: italic;",
+	success: "color: #8BC34A; font-weight: bold;",
+	error: "color: #F44336; font-weight: bold;",
+	code: "background-color: #f0f0f0; color: #333; padding: 2px 4px; border-radius: 3px; font-family: monospace;",
+	warn: "color: #FFC107;"
+};
+const getTargetNamespace = () => location.pathname.split("/").at(-1);
+const delay = (ms, { signal } = {}) => new Promise((resolve, reject) => {
+	const ti = setTimeout(resolve, ms);
+	signal?.addEventListener("abort", () => {
+		clearTimeout(ti);
+		reject(signal.reason);
+	});
+});
+const raf = () => new Promise((cb) => requestAnimationFrame(cb));
+const untilRaf = async (condition, { timeout = 3e3, signal } = {}) => {
+	const timeoutSignal = createTimeoutSignal(timeout, signal, `untilRaf(${condition.toString()})`);
+	while (!await condition()) {
+		await raf();
+		timeoutSignal?.throwIfAborted();
 	}
-	const getHandle = async (path, { create = false } = {}) => {
-		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 });
-		return {
-			parent: curr,
-			name: last,
-			async getFile() {
-				if (!last) throw new Error("No file name");
-				return curr.getFileHandle(last, { create });
-			},
-			async getDir() {
-				if (!last) return curr;
-				return curr.getDirectoryHandle(last, { create });
+};
+const $ = (selectors) => document.querySelector(selectors);
+const createTimeoutSignal = (timeout, signal, reason) => {
+	return abort_signal_merge(signal, timeout > 0 ? (() => {
+		const abortController = new AbortController();
+		const ti = setTimeout(() => {
+			abortController.abort(new Error(reason));
+		}, timeout);
+		signal?.addEventListener("abort", () => clearTimeout(ti));
+		return abortController.signal;
+	})() : null);
+};
+const while$ = async (selectors, options = {}) => {
+	const { timeout = 3e3, signal } = options;
+	const timeoutSignal = createTimeoutSignal(timeout, signal, `while$(${selectors})`);
+	while (true) {
+		const ele = $(selectors);
+		if (ele != null) return ele;
+		await raf();
+		timeoutSignal?.throwIfAborted();
+	}
+};
+const $$ = (selectors) => document.querySelectorAll(selectors);
+const fillFunctionCall = async (signal) => {
+	if (signal?.aborted) return;
+	const rootDirHandle = await prepareDirHandle();
+	const targetName = getTargetNamespace();
+	const keys = await arrayFromAsync(rootDirHandle.keys());
+	for (const callTaskname of keys.filter((key) => key.endsWith(".function_call.json") && key.startsWith(targetName))) {
+		if (signal?.aborted) return;
+		const taskFile = await (await rootDirHandle.getFileHandle(callTaskname)).getFile();
+		const taskResponse = JSON.parse(await taskFile.text());
+		if (!taskResponse.output) return;
+		const lastBtn = [...(await while$("ms-prompt-scrollbar", { signal })).querySelectorAll("button")].at(-1);
+		if (lastBtn) {
+			lastBtn.click();
+			await untilRaf(() => lastBtn.classList.contains("ms-button-active"));
+		}
+		const functionCallEles = [...$$("ms-function-call-chunk")];
+		if (functionCallEles.length === 0) {
+			console.error("找不到任何可以进行function-call的输入");
+			return;
+		}
+		const functionCallEle = functionCallEles.find((ele) => ele.querySelector("mat-panel-title")?.textContent?.trim() === `function ${taskResponse.name}` && JSON.stringify(JSON.parse(ele.querySelector("code")?.textContent ?? "{}")) === taskResponse.parameters);
+		if (null == functionCallEle) {
+			console.warn(`找不到指定的可以进行function-call-ele: ${taskResponse.name}(${taskResponse.parameters})`);
+			return;
+		}
+		const responseTextEle = functionCallEle.querySelector("input[placeholder=\"Enter function response\"]");
+		if (!responseTextEle || responseTextEle.disabled) return;
+		responseTextEle.value = typeof taskResponse.output === "string" ? taskResponse.output : JSON.stringify(taskResponse.output, null, 2);
+		responseTextEle.dispatchEvent(new Event("input"));
+		const buttonEle = functionCallEle.querySelector("form button");
+		if (!buttonEle) return;
+		await untilRaf(() => buttonEle.ariaDisabled === "false");
+		buttonEle.click();
+		await rootDirHandle.removeEntry(callTaskname);
+	}
+};
+const syncInput = async (signal, fps = 3) => {
+	if (signal?.aborted) {
+		console.log("JIXO BROWSER: syncOutput aborted before starting.");
+		return;
+	}
+	signal?.addEventListener("abort", () => {
+		console.log("JIXO BROWSER: syncInput aborted.");
+	});
+	while (!signal?.aborted) {
+		await fillFunctionCall(signal);
+		await delay(1e3 / fps);
+	}
+};
+async function arrayFromAsync(iter) {
+	const arr = [];
+	for await (const i$1 of iter) arr.push(i$1);
+	return arr;
+}
+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: () => l(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 h(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: () => h(l(t$1)),
+		select: (e$1) => h(void 0 === e$1 ? y(t$1) : y(e$1, t$1))
+	});
+}
+function l(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: l,
+	array: function(...e$1) {
+		return h({ [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;
+	}
+	narrow() {
+		return this;
+	}
+};
+function L(t$1) {
+	throw new W(t$1);
+}
+Object.freeze({ status: "aborted" });
+function $constructor(name, initializer$1, 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$1(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;
+}
+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 jsonStringifyReplacer(_$1, value) {
+	if (typeof value === "bigint") return value.toString();
+	return value;
+}
+function cached(getter) {
+	return { get value() {
+		{
+			const value = getter();
+			Object.defineProperty(this, "value", { value });
+			return value;
+		}
+		throw new Error("cached value already set");
+	} };
+}
+function cleanRegex(source) {
+	const start = source.startsWith("^") ? 1 : 0;
+	const end = source.endsWith("$") ? source.length - 1 : source.length;
+	return source.slice(start, end);
+}
+const EVALUATING = Symbol("evaluating");
+function defineLazy(object$1, key, getter) {
+	let value = void 0;
+	Object.defineProperty(object$1, key, {
+		get() {
+			if (value === EVALUATING) return;
+			if (value === void 0) {
+				value = EVALUATING;
+				value = getter();
+			}
+			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
+	});
+}
+const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
+function isObject(data) {
+	return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+cached(() => {
+	if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) return false;
+	try {
+		new Function("");
+		return true;
+	} catch (_$1) {
+		return false;
+	}
+});
+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
 	};
-	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 createWriteStream = async (filePath) => {
-		const { getFile } = await getHandle(filePath, { create: true });
-		const handle = await getFile();
-		return handle.createWritable();
+	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";
+	});
+}
+Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER, -Number.MAX_VALUE, Number.MAX_VALUE;
+function aborted(x$1, startIndex = 0) {
+	if (x$1.aborted === true) return true;
+	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 ?? []
 	};
-	const readFileText = async (filePath) => {
-		const { getFile } = await getHandle(filePath);
-		const file = await (await getFile()).getFile();
-		return file.text();
+	if (!iss.message) full.message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config$1.customError?.(iss)) ?? unwrapMessage(config$1.localeError?.(iss)) ?? "Invalid input";
+	delete full.inst;
+	delete full.continue;
+	if (!ctx?.reportInput) delete full.input;
+	return full;
+}
+const initializer = (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);
+const $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
+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 = /* @__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 = /* @__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 readFileBinary = async (filePath) => {
-		const { getFile } = await getHandle(filePath);
-		const file = await (await getFile()).getFile();
-		return file.bytes();
+};
+const safeParse = /* @__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 createReadStream = async (filePath) => {
-		const { getFile } = await getHandle(filePath);
-		const file = await (await getFile()).getFile();
-		return file.stream();
+};
+const safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
+const string$1 = (params) => {
+	const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+	return /* @__PURE__ */ new RegExp(`^${regex}$`);
+};
+const version = {
+	major: 4,
+	minor: 1,
+	patch: 5
+};
+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) {
+					if (!ch._zod.def.when(payload)) 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;
+					if (payload.issues.length === currLen) return;
+					if (!isAborted) isAborted = aborted(payload, currLen);
+				});
+				else {
+					if (payload.issues.length === currLen) continue;
+					if (!isAborted) isAborted = aborted(payload, currLen);
+				}
+			}
+			if (asyncResult) return asyncResult.then(() => {
+				return payload;
+			});
+			return payload;
+		};
+		const handleCanaryResult = (canary, payload, ctx) => {
+			if (aborted(canary)) {
+				canary.aborted = true;
+				return canary;
+			}
+			const checkResult = runChecks(payload, checks, ctx);
+			if (checkResult instanceof Promise) {
+				if (ctx.async === false) throw new $ZodAsyncError();
+				return checkResult.then((checkResult$1) => inst._zod.parse(checkResult$1, ctx));
+			}
+			return inst._zod.parse(checkResult, ctx);
+		};
+		inst._zod.run = (payload, ctx) => {
+			if (ctx.skipChecks) return inst._zod.parse(payload, ctx);
+			if (ctx.direction === "backward") {
+				const canary = inst._zod.parse({
+					value: payload.value,
+					issues: []
+				}, {
+					...ctx,
+					skipChecks: true
+				});
+				if (canary instanceof Promise) return canary.then((canary$1) => {
+					return handleCanaryResult(canary$1, payload, ctx);
+				});
+				return handleCanaryResult(canary, 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(inst, value);
+				return r$1.success ? { value: r$1.data } : { issues: r$1.error?.issues };
+			} catch (_$1) {
+				return safeParseAsync(inst, value).then((r$1) => r$1.success ? { value: r$1.data } : { issues: r$1.error?.issues });
+			}
+		},
+		vendor: "zod",
+		version: 1
 	};
-	const readdir = async (dirPath) => {
-		const { getDir } = await getHandle(dirPath);
-		const dir = await getDir();
-		return Array.fromAsync(dir.keys());
+});
+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 mkdir = async (dirPath, opts) => {
-		const parts = dirPath.split("/").filter(Boolean);
-		let curr = dirHandle;
-		for (const segment of parts) {
-			curr = await curr.getDirectoryHandle(segment, { create: true });
-			if (!opts?.recursive) break;
+});
+const $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload) => 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;
 		}
-	};
-	const exists = async (path) => {
-		try {
-			await getHandle(path);
-			return true;
-		} catch {
-			return false;
+		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;
 	};
-	const stat = async (path) => {
-		const { getFile, getDir } = await getHandle(path);
-		try {
-			const h = await getFile();
-			const f = await h.getFile();
-			return {
-				isFile: true,
-				size: f.size,
-				lastModified: f.lastModified
-			};
-		} catch {
-			await getDir();
-			return { isFile: false };
+});
+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;
+}
+function normalizeDef(def) {
+	const keys = Object.keys(def.shape);
+	for (const k$1 of keys) if (!def.shape[k$1]._zod.traits.has("$ZodType")) throw new Error(`Invalid element at key "${k$1}": expected a Zod schema`);
+	const okeys = optionalKeys(def.shape);
+	return {
+		...def,
+		keys,
+		keySet: new Set(keys),
+		numKeys: keys.length,
+		optionalKeys: new Set(okeys)
+	};
+}
+function handleCatchall(proms, input, payload, ctx, def, inst) {
+	const unrecognized = [];
+	const keySet = def.keySet;
+	const _catchall = def.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;
+	});
+}
+const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
+	$ZodType.init(inst, def);
+	const _normalized = cached(() => normalizeDef(def));
+	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 isObject$1 = isObject;
+	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;
+		}
+		payload.value = {};
+		const proms = [];
+		const shape = value.shape;
+		for (const key of value.keys) {
+			const r$1 = shape[key]._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;
+		return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
 	};
-	const rm = async (path, opts) => {
-		try {
-			const { parent, name } = await getHandle(path);
-			if (!name) throw new Error("Invalid path");
-			await parent.removeEntry(name, { recursive: opts?.recursive });
-			return true;
-		} catch {
-			return false;
+});
+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)));
+	});
+	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("|")})$`);
 		}
+	});
+	const single = def.options.length === 1;
+	const first = def.options[0]._zod.run;
+	inst._zod.parse = (payload, ctx) => {
+		if (single) return first(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);
+		});
 	};
-	return {
-		writeFile,
-		createWriteStream,
-		readFileText,
-		readFileBinary,
-		createReadStream,
-		readdir,
-		mkdir,
-		exists,
-		stat,
-		rm
+});
+function handleOptionalResult(result, input) {
+	if (result.issues.length && input === void 0) return {
+		issues: [],
+		value: void 0
+	};
+	return result;
+}
+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") {
+			const result = def.innerType._zod.run(payload, ctx);
+			if (result instanceof Promise) return result.then((r$1) => handleOptionalResult(r$1, payload.value));
+			return handleOptionalResult(result, payload.value);
+		}
+		if (payload.value === void 0) return payload;
+		return def.innerType._zod.run(payload, ctx);
 	};
 });
-const styles = {
-	header: "color: #4CAF50; font-size: 18px; font-weight: bold; border-bottom: 2px solid #4CAF50; padding-bottom: 5px;",
-	info: "color: #2196F3; font-style: italic;",
-	success: "color: #8BC34A; font-weight: bold;",
-	error: "color: #F44336; font-weight: bold;",
-	code: "background-color: #f0f0f0; color: #333; padding: 2px 4px; border-radius: 3px; font-family: monospace;",
-	warn: "color: #FFC107;"
-};
-const arrayFromAsync = async (iter) => {
-	const arr = [];
-	for await (const item of iter) arr.push(item);
-	return arr;
-};
-const getTargetNamespace = () => location.pathname.split("/").at(-1);
-const delay = (ms) => new Promise((cb) => setTimeout(cb, ms));
-const $ = document.querySelector.bind(document);
-const $$ = document.querySelectorAll.bind(document);
-const fillFunctionCall = async () => {
-	const rootDirHandle$1 = await prepareDirHandle();
-	const targetName = getTargetNamespace();
-	const keys = await arrayFromAsync(rootDirHandle$1.keys());
-	const callTaskname = keys.find((key) => key.endsWith(".function_call.json") && key.startsWith(targetName));
-	if (!callTaskname) return;
-	const taskFileHandle = await rootDirHandle$1.getFileHandle(callTaskname);
-	const taskFile = await taskFileHandle.getFile();
-	const taskResponse = JSON.parse(await taskFile.text());
-	if (!taskResponse.output) return;
-	const scrollToBottom = async () => {
-		const chatContainerEle = document.querySelector("ms-autoscroll-container");
-		if (chatContainerEle) chatContainerEle.scrollTo({
-			top: chatContainerEle.scrollHeight - chatContainerEle.clientHeight,
-			behavior: "smooth"
+function _string(Class, params) {
+	return new Class({
+		type: "string",
+		...normalizeParams(params)
+	});
+}
+function _any(Class) {
+	return new Class({ type: "any" });
+}
+const ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
+	if (!inst._zod) throw new Error("Uninitialized schema in ZodMiniType.");
+	$ZodType.init(inst, def);
+	inst.def = def;
+	inst.type = def.type;
+	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.check = (...checks) => {
+		return inst.clone({
+			...def,
+			checks: [...def.checks ?? [], ...checks.map((ch) => typeof ch === "function" ? { _zod: {
+				check: ch,
+				def: { check: "custom" },
+				onattach: []
+			} } : ch)]
 		});
-		await delay(1e3);
 	};
-	const findFunctionCallResponseTextareaEle = () => document.querySelector("textarea[placeholder=\"Enter function response\"]");
-	const waitFunctionCallResponseTextareaEle = async () => {
-		while (true) {
-			const ele = findFunctionCallResponseTextareaEle();
-			if (ele) return ele;
-			await scrollToBottom();
-		}
+	inst.clone = (_def, params) => clone(inst, _def, params);
+	inst.brand = () => inst;
+	inst.register = ((reg, meta) => {
+		reg.add(inst, meta);
+		return inst;
+	});
+});
+const ZodMiniString = /* @__PURE__ */ $constructor("ZodMiniString", (inst, def) => {
+	$ZodString.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function string(params) {
+	return _string(ZodMiniString, params);
+}
+const ZodMiniAny = /* @__PURE__ */ $constructor("ZodMiniAny", (inst, def) => {
+	$ZodAny.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function any() {
+	return _any(ZodMiniAny);
+}
+const ZodMiniArray = /* @__PURE__ */ $constructor("ZodMiniArray", (inst, def) => {
+	$ZodArray.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function array(element, params) {
+	return new ZodMiniArray({
+		type: "array",
+		element,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
+	$ZodObject.init(inst, def);
+	ZodMiniType.init(inst, def);
+	defineLazy(inst, "shape", () => def.shape);
+});
+function object(shape, params) {
+	const def = {
+		type: "object",
+		get shape() {
+			assignProp(this, "shape", { ...shape });
+			return this.shape;
+		},
+		...normalizeParams(params)
 	};
-	const textareaEle = await waitFunctionCallResponseTextareaEle();
-	if (textareaEle.disabled) return;
-	textareaEle.value = JSON.stringify(taskResponse.output, null, 2);
-	textareaEle.dispatchEvent(new Event("input"));
-	await delay(150);
-	const findFunctionCallResponseButtonEle = () => document.querySelector(`button[mattooltip="Send response"]`);
-	const waitFunctionCallResponseButtonEle = async () => {
-		while (true) {
-			const ele = findFunctionCallResponseButtonEle();
-			if (ele) return ele;
-			await scrollToBottom();
+	return new ZodMiniObject(def);
+}
+const ZodMiniUnion = /* @__PURE__ */ $constructor("ZodMiniUnion", (inst, def) => {
+	$ZodUnion.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function union(options, params) {
+	return new ZodMiniUnion({
+		type: "union",
+		options,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniOptional = /* @__PURE__ */ $constructor("ZodMiniOptional", (inst, def) => {
+	$ZodOptional.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function optional(innerType) {
+	return new ZodMiniOptional({
+		type: "optional",
+		innerType
+	});
+}
+let __TYPE_KEY = "__TYPE_KEY__";
+let __CONTENT_KEY = "__CONTENT_KEY__";
+let __BLOB_URL_KEY = "__BLOB_URL_KEY__";
+let __IMAGE_CONTENT_KEY = "__IMAGE_CONTENT_KEY__";
+let __IMAGE_INLINE_CONTENT_KEY = "__IMAGE_INLINE_CONTENT_KEY__";
+let __FILE_CONTENT_KEY = "__FILE_CONTENT_KEY__";
+let __FC_RESPONSE_KEY = "__FC_RESPONSE_KEY__";
+let sm = [];
+const KEYS = {
+	get TYPE_KEY() {
+		if (__TYPE_KEY === "__TYPE_KEY__") {
+			const msg = sm.at(-1);
+			for (const key in msg) {
+				if (/^(role|text|grounding|id|isJson|parts|tokenCount)$/.test(key)) continue;
+				const val = msg[key];
+				if (/^(text|image|function_call|file)$/.test(val)) {
+					__TYPE_KEY = key;
+					break;
+				}
+			}
 		}
-	};
-	const buttonEle = await waitFunctionCallResponseButtonEle();
-	buttonEle.click();
-	await rootDirHandle$1.removeEntry(callTaskname);
-};
-const syncInput = async (fps = 3) => {
-	(async () => {
-		while (true) {
-			await fillFunctionCall();
-			await delay(1e3 / fps);
+		return __TYPE_KEY;
+	},
+	get CONTENT_KEY() {
+		if (__CONTENT_KEY === "__CONTENT_KEY__") msgLabel: for (const msg of sm) {
+			const parts = msg.parts;
+			if (Array.isArray(parts) && parts.length > 0) {
+				const part = parts[0];
+				for (const key in part) {
+					const val = part[key];
+					if (Array.isArray(val)) {
+						__CONTENT_KEY = key;
+						break msgLabel;
+					}
+					break;
+				}
+			}
+		}
+		return __CONTENT_KEY;
+	},
+	get BLOB_URL_KEY() {
+		prepareImageKeys();
+		return __BLOB_URL_KEY;
+	},
+	get IMAGE_CONTENT_KEY() {
+		prepareImageKeys();
+		return __IMAGE_CONTENT_KEY;
+	},
+	get IMAGE_INLINE_CONTENT_KEY() {
+		prepareImageKeys();
+		return __IMAGE_INLINE_CONTENT_KEY;
+	},
+	get FILE_CONTENT_KEY() {
+		if (__FILE_CONTENT_KEY === "__FILE_CONTENT_KEY__") {
+			for (const msg of sm) if ("file" === msg[KEYS.TYPE_KEY]) for (const key in msg) {
+				if (/^(role|text|grounding|id|isJson|parts|tokenCount)$/.test(key)) continue;
+				const val = msg[key];
+				if (typeof val === "object" && val && "mimeType" in val) __FILE_CONTENT_KEY = key;
+			}
+		}
+		return __FILE_CONTENT_KEY;
+	},
+	get FC_RESPONSE_KEY() {
+		if (__FC_RESPONSE_KEY === "__FC_RESPONSE_KEY__") {
+			for (const msg of sm) if ("function_call" === msg[KEYS.TYPE_KEY]) for (const key in msg) {
+				if (/^(role|text|grounding|id|isJson|parts|tokenCount)$/.test(key)) continue;
+				const val = msg[key];
+				if (typeof val === "object" && val && "response" in val) __FC_RESPONSE_KEY = key;
+			}
+		}
+		return __FC_RESPONSE_KEY;
+	}
+};
+const prepareImageKeys = () => {
+	if (__BLOB_URL_KEY === "__BLOB_URL_KEY__" || __IMAGE_CONTENT_KEY === "__IMAGE_CONTENT_KEY__" || __IMAGE_INLINE_CONTENT_KEY === "__IMAGE_INLINE_CONTENT_KEY__") {
+		for (const msg of sm) if ("image" === msg[KEYS.TYPE_KEY]) for (const key in msg) {
+			if (/^(role|text|grounding|id|isJson|parts|tokenCount)$/.test(key)) continue;
+			const val = msg[key];
+			if (typeof val === "object" && val && "mimeType" in val) if ("id" in val) __IMAGE_CONTENT_KEY = key;
+			else __IMAGE_INLINE_CONTENT_KEY = key;
+			else if (typeof val === "string" && val.startsWith("blob:")) __BLOB_URL_KEY = key;
+		}
+	}
+};
+const prepareKey = (sourceMessages) => {
+	if (sourceMessages.length === 0) return;
+	sm = sourceMessages;
+};
+const TargetPartSchema = union([
+	object({ text: string() }),
+	object({ inlineData: object({
+		mimeType: string(),
+		data: string()
+	}) }),
+	object({ functionCall: object({
+		name: string(),
+		parameters: any()
+	}) }),
+	object({ functionResponse: object({
+		name: string(),
+		response: any()
+	}) })
+]);
+const TargetMessageSchema = object({
+	id: optional(string()),
+	role: string(),
+	parts: array(TargetPartSchema)
+});
+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);
 		}
-	})();
+	});
+};
+const normalizeNcValue = (ncWrapper) => {
+	const ncArray = ncWrapper[KEYS.CONTENT_KEY];
+	return z(ncArray).with([
+		N.any,
+		N.any,
+		N.any,
+		N.any,
+		{ [KEYS.CONTENT_KEY]: [N.select(N.instanceOf(Map))] }
+	], (innerMap) => {
+		return [
+			null,
+			null,
+			null,
+			null,
+			[normalizeNcMapToCanonicalArray(innerMap)]
+		];
+	}).otherwise(() => ncArray);
 };
-const syncOutput = async () => {
-	const onChange = func_throttle(runFileCreation, 200, {
+const 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({ [KEYS.CONTENT_KEY]: N.array() }, (part) => {
+		const functionCallData = part[KEYS.CONTENT_KEY][10][KEYS.CONTENT_KEY];
+		const name = functionCallData[0];
+		const argsMap = functionCallData[1][KEYS.CONTENT_KEY][0];
+		return {
+			name,
+			argsArray: normalizeNcMapToCanonicalArray(argsMap)
+		};
+	}).otherwise(() => {
+		throw new Error("Unknown function_call structure encountered.");
+	});
+};
+const parseArgValue = (arg) => {
+	if (!Array.isArray(arg)) {
+		if (typeof arg === "object" && arg !== null && KEYS.CONTENT_KEY in arg) return parseArgValue(arg[KEYS.CONTENT_KEY]);
+		return arg;
+	}
+	return z(arg).with([
+		N.any,
+		N.any,
+		N.any,
+		N.any,
+		N.any,
+		{ [KEYS.CONTENT_KEY]: [N.select()] }
+	], (val) => {
+		if (Array.isArray(val)) return val.map(parseArgValue);
+		console.warn("unknown struct 1", val);
+		return null;
+	}).with([
+		N.any,
+		N.any,
+		N.any,
+		N.any,
+		{ [KEYS.CONTENT_KEY]: [N.select(N.instanceOf(Map))] }
+	], (map) => {
+		return Object.fromEntries([...map.entries()].map(([key, valueWrapper]) => {
+			return [key, parseArgValue(valueWrapper)];
+		}));
+	}).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(() => {
+		console.warn("unknown struct 0", arg);
+		return null;
+	});
+};
+const parseFunctionArgs = (argList) => {
+	if (!Array.isArray(argList)) return {};
+	return Object.fromEntries(argList.map(([key, value]) => [key, parseArgValue(value)]));
+};
+const convertMessages = async (sourceMessages) => {
+	prepareKey(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?.[KEYS.TYPE_KEY] !== "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({
+				[KEYS.TYPE_KEY]: "text",
+				text: N.string
+			}, (msg) => {
+				return msg.text.length > 0 ? { text: msg.text } : null;
+			}).with({ [KEYS.TYPE_KEY]: "image" }, async (img) => {
+				if (KEYS.IMAGE_INLINE_CONTENT_KEY in img) {
+					const inlineContent = img[KEYS.IMAGE_INLINE_CONTENT_KEY];
+					return { inlineData: {
+						mimeType: inlineContent.mimeType,
+						data: inlineContent.Dc
+					} };
+				}
+				if (KEYS.BLOB_URL_KEY in img && KEYS.IMAGE_CONTENT_KEY in img) {
+					const imageConent = img[KEYS.IMAGE_CONTENT_KEY];
+					const blobUrl = img[KEYS.BLOB_URL_KEY];
+					try {
+						const data = await blobUrlToBase64(blobUrl);
+						return { inlineData: {
+							mimeType: imageConent.mimeType,
+							data
+						} };
+					} catch (error) {
+						console.error(`Failed to process blob URL ${blobUrl}:`, error);
+						return null;
+					}
+				}
+				return null;
+			}).with({ [KEYS.TYPE_KEY]: "function_call" }, (msg) => {
+				try {
+					const { name, argsArray } = getCanonicalFunctionCall(msg);
+					const args = parseFunctionArgs(argsArray);
+					if (typeof msg[KEYS.FC_RESPONSE_KEY]?.response === "string") functionResponseData = {
+						name,
+						response: msg[KEYS.FC_RESPONSE_KEY].response
+					};
+					return { functionCall: {
+						name,
+						parameters: JSON.stringify(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({
+			id: group.id,
+			role: group.role,
+			parts
+		});
+		if (functionResponseData) finalMessages.push({
+			id: group.id,
+			role: "user",
+			parts: [{ functionResponse: {
+				name: functionResponseData.name,
+				response: functionResponseData.response
+			} }]
+		});
+	}
+	finalMessages.push({
+		role: "user",
+		parts: [{ text: "INSERT_INPUT_HERE" }]
+	});
+	return finalMessages;
+};
+const syncOutput = async (signal) => {
+	if (signal?.aborted) {
+		console.log("JIXO BROWSER: syncOutput aborted before starting.");
+		return;
+	}
+	const abortController = new AbortController();
+	const internalSignal = abortController.signal;
+	signal?.addEventListener("abort", () => {
+		console.log("JIXO BROWSER: syncOutput aborted.");
+		abortController.abort();
+	}, { once: true });
+	let preRaw = "";
+	const onChange = func_throttle(async (raw) => {
+		if (internalSignal.aborted) return;
+		const newRaw = JSON.stringify(raw);
+		if (preRaw !== newRaw) {
+			preRaw = newRaw;
+			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 && !internalSignal.aborted) try {
+			onChange(structuredClone(this));
+		} catch {}
+		return res;
 	};
 	const findInput = () => $(`textarea[aria-label="Start typing a prompt"]`);
-	while (!started) {
+	while (!internalSignal.aborted) {
 		const input = findInput();
-		if (input) {
-			input.dispatchEvent(new Event("input"));
-			started = true;
-		}
+		if (input) input.dispatchEvent(new Event("input"));
 		await delay(300);
 	}
 };
-let started = false;
-let writting = false;
-async function runFileCreation(b, targetFilename = getTargetNamespace() + ".contents.json") {
-	started = true;
-	if (writting) return;
-	writting = true;
+async function runFileCreation(b$1, targetFilename = getTargetNamespace() + ".contents.json") {
 	try {
-		const rootDirHandle$1 = await prepareDirHandle();
-		if (!rootDirHandle$1) return;
-		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));
-		console.log("%c   - 数据写入中...", styles.info);
+		const writable = await (await (await prepareDirHandle()).getFileHandle(targetFilename, { create: true })).createWritable();
+		await writable.write(JSON.stringify(b$1));
 		await writable.close();
-		console.log(`%c   - ✅ 文件写入并关闭成功: %c${targetFilename}`, styles.success, styles.code);
+		console.log(`%c   - ✅ File written: %c${targetFilename}`, styles.success, styles.code);
 	} catch (error) {
-		if (error instanceof Error && error.name === "AbortError") console.warn("%c⚠️ 用户取消了文件夹选择操作。流程已中止。", styles.warn);
-		else console.error("%c❌ 发生意外错误:", styles.error, error);
-	} finally {
-		writting = false;
+		if (error instanceof Error && error.name === "AbortError") console.warn("%c⚠️ User cancelled folder selection.", styles.warn);
+		else console.error("%c❌ Error writing file:", styles.error, error);
 	}
 }
 (async () => {
-	const aborted = await prepareDirHandle().then(() => false, (e) => {
-		if (e instanceof Error && e.name === "AbortError") return true;
-	});
-	if (aborted) {
+	if (await prepareDirHandle().then(() => false, (e$1) => {
+		if (e$1 instanceof Error && e$1.name === "AbortError") return true;
+	})) {
 		console.warn("用户取消了脚本运行");
 		return;
 	}
 	syncOutput();
 	syncInput();
 })();
+export {};