@jixo/cli 0.23.2 → 0.23.4

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

@@ -0,0 +1,1192 @@
+import { createRequire } from "node:module";
+import { URL as URL$1, fileURLToPath, pathToFileURL } from "node:url";
+import path, { dirname } from "node:path";
+import fs, { realpathSync } from "node:fs";
+import { createHash } from "node:crypto";
+const pathResolve = (specifier, parentURL) => {
+	let baseUrl;
+	if (parentURL instanceof URL$1) baseUrl = parentURL;
+	else {
+		const parentHref = String(parentURL);
+		if (parentHref.startsWith("file:")) baseUrl = parentHref;
+		else baseUrl = pathToFileURL(parentHref).href;
+	}
+	return new URL$1(specifier, baseUrl).href;
+};
+const import_meta_ponyfill_commonjs = Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-commonjs")) ?? (() => {
+	const moduleImportMetaWM = /* @__PURE__ */ new WeakMap();
+	return (require, module) => {
+		let importMetaCache = moduleImportMetaWM.get(module);
+		if (importMetaCache == null) {
+			const importMeta = Object.assign(Object.create(null), {
+				url: pathToFileURL(module.filename).href,
+				main: require.main === module,
+				nodeResolve(specifier, parentURL = importMeta.url) {
+					return pathToFileURL((importMeta.url === parentURL ? require : createRequire(parentURL)).resolve(specifier)).href;
+				},
+				resolve: function resolve(specifier, parentURL = importMeta.url) {
+					if (/^[./]*\/.*/.test(specifier)) return pathResolve(specifier, parentURL);
+					try {
+						return importMeta.nodeResolve(specifier, parentURL);
+					} catch {
+						return pathResolve(specifier, parentURL);
+					}
+				},
+				filename: module.filename,
+				dirname: module.path
+			});
+			moduleImportMetaWM.set(module, importMeta);
+			importMetaCache = importMeta;
+		}
+		return importMetaCache;
+	};
+})();
+let import_meta_ponyfill_esmodule = Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-esmodule")) ?? ((importMeta) => {
+	const resolveFunStr = String(importMeta.resolve);
+	const importMetaWM = /* @__PURE__ */ new WeakMap();
+	const isMain = (filename) => {
+		try {
+			const entry = process.argv[1];
+			return filename === entry || realpathSync(filename) === realpathSync(entry);
+		} catch {
+			return false;
+		}
+	};
+	const isSupportResolve = resolveFunStr !== "undefined" && !resolveFunStr.startsWith("async");
+	import_meta_ponyfill_esmodule = (im) => {
+		let importMetaCache = importMetaWM.get(im);
+		if (importMetaCache == null) {
+			const filename = im.filename ?? fileURLToPath(im.url);
+			const dirname$1 = im.dirname ?? dirname(filename);
+			const importMeta$1 = {
+				url: im.url,
+				main: im.main ?? isMain(filename),
+				filename,
+				dirname: dirname$1,
+				nodeResolve: isSupportResolve ? im.resolve : (() => {
+					const importMetaUrlRequire = createRequire(im.url);
+					return (specifier, parentURL = im.url) => {
+						return pathToFileURL((importMeta$1.url === parentURL ? importMetaUrlRequire : createRequire(parentURL)).resolve(specifier)).href;
+					};
+				})(),
+				resolve: function resolve(specifier, parentURL = im.url) {
+					if (/^[./]*\/.*/.test(specifier)) return pathResolve(specifier, parentURL);
+					try {
+						return importMeta$1.nodeResolve(specifier, parentURL);
+					} catch {
+						return pathResolve(specifier, parentURL);
+					}
+				}
+			};
+			importMetaCache = importMeta$1;
+			importMetaWM.set(im, importMeta$1);
+		}
+		return importMetaCache;
+	};
+	return import_meta_ponyfill_esmodule(importMeta);
+});
+const dntGlobals = {};
+const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+	return new Proxy(baseObj, {
+		get(_target, prop, _receiver) {
+			if (prop in extObj) return extObj[prop];
+			else return baseObj[prop];
+		},
+		set(_target, prop, value) {
+			if (prop in extObj) delete extObj[prop];
+			baseObj[prop] = value;
+			return true;
+		},
+		deleteProperty(_target, prop) {
+			let success = false;
+			if (prop in extObj) {
+				delete extObj[prop];
+				success = true;
+			}
+			if (prop in baseObj) {
+				delete baseObj[prop];
+				success = true;
+			}
+			return success;
+		},
+		ownKeys(_target) {
+			const baseKeys = Reflect.ownKeys(baseObj);
+			const extKeys = Reflect.ownKeys(extObj);
+			const extKeysSet = new Set(extKeys);
+			return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+		},
+		defineProperty(_target, prop, desc) {
+			if (prop in extObj) delete extObj[prop];
+			Reflect.defineProperty(baseObj, prop, desc);
+			return true;
+		},
+		getOwnPropertyDescriptor(_target, prop) {
+			if (prop in extObj) return Reflect.getOwnPropertyDescriptor(extObj, prop);
+			else return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+		},
+		has(_target, prop) {
+			return prop in extObj || prop in baseObj;
+		}
+	});
+}
+const { Deno } = dntGlobalThis;
+const noColor = typeof Deno?.noColor === "boolean" ? Deno.noColor : false;
+let enabled = !noColor;
+function code(open, close) {
+	return {
+		open: `\x1b[${open.join(";")}m`,
+		close: `\x1b[${close}m`,
+		regexp: new RegExp(`\\x1b\\[${close}m`, "g")
+	};
+}
+function run(str, code$1) {
+	return enabled ? `${code$1.open}${str.replace(code$1.regexp, code$1.open)}${code$1.close}` : str;
+}
+function red(str) {
+	return run(str, code([31], 39));
+}
+function green(str) {
+	return run(str, code([32], 39));
+}
+function blue(str) {
+	return run(str, code([34], 39));
+}
+function magenta(str) {
+	return run(str, code([35], 39));
+}
+function cyan(str) {
+	return run(str, code([36], 39));
+}
+function gray(str) {
+	return brightBlack(str);
+}
+function brightBlack(str) {
+	return run(str, code([90], 39));
+}
+const ANSI_PATTERN = new RegExp(["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TXZcf-nq-uy=><~]))"].join("|"), "g");
+const obj_assign_props = /* @__NO_SIDE_EFFECTS__ */ (a, b) => {
+	const b_props = Object.getOwnPropertyDescriptors(b);
+	Object.defineProperties(a, b_props);
+	return a;
+};
+const iter_first_not_null = (values, callbackfn) => {
+	let index = 0;
+	if (callbackfn) for (const value of values) {
+		const r = callbackfn(value, index++, values);
+		if (r != null) return r;
+	}
+	else for (const value of values) if (value != null) return value;
+};
+const timmers = {
+	timeout: (ms) => {
+		return (cb) => {
+			const ti = setTimeout(cb, ms);
+			return () => clearTimeout(ti);
+		};
+	},
+	raf: ((cb) => {
+		const ti = requestAnimationFrame(cb);
+		return () => cancelAnimationFrame(ti);
+	}),
+	microtask: ((cb) => {
+		let cancel = false;
+		queueMicrotask(() => {
+			if (cancel) return;
+			cb();
+		});
+		return () => {
+			cancel = true;
+		};
+	}),
+	eventTarget: (target, eventType, filter) => {
+		return (resolve) => {
+			let cb;
+			if (typeof filter === "function") {
+				cb = (event) => {
+					if (filter(event)) {
+						resolve(event);
+						target.removeEventListener(eventType, cb);
+					}
+				};
+				target.addEventListener(eventType, cb);
+			} else {
+				cb = resolve;
+				target.addEventListener(eventType, cb, { once: true });
+			}
+			return () => target.removeEventListener(eventType, cb);
+		};
+	},
+	from: (ms) => {
+		return typeof ms === "number" ? ms <= 0 ? timmers.microtask : timmers.timeout(ms) : ms;
+	}
+};
+const func_debounce = (fn, wait = 0, options = {}) => {
+	if (!Number.isFinite(wait)) throw new TypeError("Expected `wait` to be a finite number");
+	const timmer = timmers.from(wait);
+	let leadingValue;
+	let clear;
+	let jobList = [];
+	let trigger;
+	return /* @__PURE__ */ obj_assign_props(function(...args) {
+		const job = Promise.withResolvers();
+		const shouldCallNow = options.before && null == clear;
+		if (shouldCallNow) {
+			leadingValue = fn.apply(this, args);
+			job.resolve(leadingValue);
+		} else jobList.push(job);
+		clear?.();
+		clear = timmer(trigger = () => {
+			clear = void 0;
+			trigger = void 0;
+			const result = options.before ? leadingValue : fn.apply(this, args);
+			for (const job$1 of jobList) job$1.resolve(result);
+			jobList = [];
+		}, (reason) => {
+			for (const job$1 of jobList) job$1.reject(reason);
+		});
+		return job.promise;
+	}, {
+		get isPending() {
+			return clear != null;
+		},
+		cancel() {
+			clear?.();
+		},
+		source: fn,
+		flush() {
+			if (clear != null) {
+				clear();
+				trigger?.();
+			}
+		}
+	});
+};
+const NEVER = 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 in _.prototype) if (!(k in inst)) Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
+		inst._zod.constr = _;
+		inst._zod.def = def;
+	}
+	const Parent = params?.Parent ?? Object;
+	class Definition extends Parent {}
+	Object.defineProperty(Definition, "name", { value: name });
+	function _(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(_, "init", { value: init });
+	Object.defineProperty(_, Symbol.hasInstance, { value: (inst) => {
+		if (params?.Parent && inst instanceof params.Parent) return true;
+		return inst?._zod?.traits?.has(name);
+	} });
+	Object.defineProperty(_, "name", { value: name });
+	return _;
+}
+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 jsonStringifyReplacer(_, 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 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) {
+			Object.defineProperty(object$1, key, { value: v });
+		},
+		configurable: true
+	});
+}
+function assignProp(target, prop, value) {
+	Object.defineProperty(target, prop, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+}
+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 (_) {
+		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
+	};
+	return params;
+}
+function optionalKeys(shape) {
+	return Object.keys(shape).filter((k) => {
+		return shape[k]._zod.optin === "optional" && shape[k]._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 aborted(x, startIndex = 0) {
+	for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue !== true) return true;
+	return false;
+}
+function prefixIssues(path$1, issues) {
+	return issues.map((iss) => {
+		var _a;
+		(_a = iss).path ?? (_a.path = []);
+		iss.path.unshift(path$1);
+		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;
+}
+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 = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+		captureStackTrace(e, _params?.callee);
+		throw e;
+	}
+	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 = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+		captureStackTrace(e, params?.callee);
+		throw e;
+	}
+	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 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 safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
+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 = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
+const string$1 = (params) => {
+	const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+	return /* @__PURE__ */ new RegExp(`^${regex}$`);
+};
+const number$1 = /^-?\d+(?:\.\d+)?/i;
+const boolean$1 = /true|false/i;
+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) => x);
+		const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
+		const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
+		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) => `  ${x}`)];
+		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 _ = ch._zod.check(payload);
+				if (_ instanceof Promise && ctx?.async === false) throw new $ZodAsyncError();
+				if (asyncResult || _ instanceof Promise) asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
+					await _;
+					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 = safeParse(inst, value);
+				return r.success ? { value: r.data } : { issues: r.error?.issues };
+			} catch (_) {
+				return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.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, _) => {
+		if (def.coerce) try {
+			payload.value = String(payload.value);
+		} catch (_$1) {}
+		if (typeof payload.value === "string") return payload;
+		payload.issues.push({
+			expected: "string",
+			code: "invalid_type",
+			input: payload.value,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = inst._zod.bag.pattern ?? number$1;
+	inst._zod.parse = (payload, _ctx) => {
+		if (def.coerce) try {
+			payload.value = Number(payload.value);
+		} catch (_) {}
+		const input = payload.value;
+		if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) return payload;
+		const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
+		payload.issues.push({
+			expected: "number",
+			code: "invalid_type",
+			input,
+			inst,
+			...received ? { received } : {}
+		});
+		return payload;
+	};
+});
+const $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = boolean$1;
+	inst._zod.parse = (payload, _ctx) => {
+		if (def.coerce) try {
+			payload.value = Boolean(payload.value);
+		} catch (_) {}
+		const input = payload.value;
+		if (typeof input === "boolean") return payload;
+		payload.issues.push({
+			expected: "boolean",
+			code: "invalid_type",
+			input,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (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;
+		}
+		payload.value = Array(input.length);
+		const proms = [];
+		for (let i = 0; i < input.length; i++) {
+			const item = input[i];
+			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)));
+			else handleArrayResult(result, payload, i);
+		}
+		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 of keys) if (!(def.shape[k] instanceof $ZodType)) throw new Error(`Invalid element at key "${k}": 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 of field.values) propValues[key].add(v);
+			}
+		}
+		return propValues;
+	});
+	const generateFastpass = (shape) => {
+		const doc = new Doc([
+			"shape",
+			"payload",
+			"ctx"
+		]);
+		const normalized = _normalized.value;
+		const parseStr = (key) => {
+			const k = esc(key);
+			return `shape[${k}]._zod.run({ value: input[${k}], 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 = 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}, ...iss.path] : [${k}]
+          })));
+        }
+        
+        if (${id}.value === undefined) {
+          if (${k} in input) {
+            newResult[${k}] = undefined;
+          }
+        } else {
+          newResult[${k}] = ${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 = el._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (r instanceof Promise) proms.push(r.then((r$1) => handlePropertyResult(r$1, payload, key, input)));
+				else handlePropertyResult(r, 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 = _catchall.def.type;
+		for (const key of Object.keys(input)) {
+			if (keySet.has(key)) continue;
+			if (t === "never") {
+				unrecognized.push(key);
+				continue;
+			}
+			const r = _catchall.run({
+				value: input[key],
+				issues: []
+			}, ctx);
+			if (r instanceof Promise) proms.push(r.then((r$1) => handlePropertyResult(r$1, payload, key, input)));
+			else handlePropertyResult(r, 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) => !aborted(r));
+	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) => o._zod.optin === "optional") ? "optional" : void 0);
+	defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
+	defineLazy(inst._zod, "values", () => {
+		if (def.options.every((o) => o._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) => o._zod.pattern)) {
+			const patterns = def.options.map((o) => o._zod.pattern);
+			return /* @__PURE__ */ new RegExp(`^(${patterns.map((p) => cleanRegex(p.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 $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);
+	};
+});
+function _string(Class, params) {
+	return new Class({
+		type: "string",
+		...normalizeParams(params)
+	});
+}
+function _number(Class, params) {
+	return new Class({
+		type: "number",
+		checks: [],
+		...normalizeParams(params)
+	});
+}
+function _boolean(Class, params) {
+	return new Class({
+		type: "boolean",
+		...normalizeParams(params)
+	});
+}
+function _unknown(Class) {
+	return new Class({ type: "unknown" });
+}
+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.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)]
+		});
+	};
+	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 ZodMiniNumber = /* @__PURE__ */ $constructor("ZodMiniNumber", (inst, def) => {
+	$ZodNumber.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function number(params) {
+	return _number(ZodMiniNumber, params);
+}
+const ZodMiniBoolean = /* @__PURE__ */ $constructor("ZodMiniBoolean", (inst, def) => {
+	$ZodBoolean.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function boolean(params) {
+	return _boolean(ZodMiniBoolean, params);
+}
+const ZodMiniUnknown = /* @__PURE__ */ $constructor("ZodMiniUnknown", (inst, def) => {
+	$ZodUnknown.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function unknown() {
+	return _unknown(ZodMiniUnknown);
+}
+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)
+	};
+	return new ZodMiniObject(def);
+}
+function looseObject(shape, params) {
+	return new ZodMiniObject({
+		type: "object",
+		get shape() {
+			assignProp(this, "shape", { ...shape });
+			return this.shape;
+		},
+		catchall: unknown(),
+		...normalizeParams(params)
+	});
+}
+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
+	});
+}
+const zContentSchema = looseObject({
+	generationConfiguration: looseObject({
+		includeCodeExecutionTypesImport: boolean(),
+		includeSchemaTypesImport: boolean(),
+		includesRetrievalImport: optional(boolean()),
+		isAudioOutput: boolean(),
+		isStreamingConfigEnabled: boolean(),
+		isColab: boolean(),
+		requiresParts: boolean(),
+		requiresFunctionCalling: boolean(),
+		requiresCodeExecution: boolean()
+	}),
+	generateContentParameters: object({
+		model: string(),
+		contents: array(object({
+			role: string(),
+			parts: array(union([
+				object({ isLast: boolean() }),
+				object({
+					isLast: boolean(),
+					text: string()
+				}),
+				object({
+					isLast: boolean(),
+					functionCall: object({
+						name: string(),
+						parameters: string()
+					})
+				}),
+				object({
+					isLast: boolean(),
+					functionResponse: object({
+						name: string(),
+						response: string()
+					})
+				}),
+				object({
+					isLast: boolean(),
+					inlineData: object({
+						data: string(),
+						splitData: array(string()),
+						mimeType: string()
+					}),
+					fileData: object({
+						mimeType: string(),
+						fileIndex: number(),
+						fileName: string()
+					})
+				})
+			])),
+			isLast: optional(boolean())
+		})),
+		config: looseObject({
+			thinkingConfig: object({ thinkingBudget: string() }),
+			stopSequences: array(unknown()),
+			responseMimeType: optional(string()),
+			responseModalities: array(unknown()),
+			safetySettings: array(unknown()),
+			tools: array(union([
+				object({ googleSearch: looseObject({}) }),
+				object({ urlContext: looseObject({}) }),
+				object({ functionDeclarations: array(object({
+					name: string(),
+					description: string(),
+					parameters: string(),
+					isLast: boolean()
+				})) })
+			]))
+		})
+	})
+});
+const doGoogleAiStudioAutomation = (dir = process.cwd()) => {
+	const watcher = fs.watch(dir);
+	const handle = func_debounce(async () => {
+		const names = fs.readdirSync(dir);
+		const contentNames = names.filter((name) => name.endsWith(".contents.json"));
+		for (const contentFilename of contentNames) {
+			const contentFilepath = path.join(dir, contentFilename);
+			const basename = contentFilename.replace(".contents.json", "");
+			await parseContent(basename, contentFilepath, names).catch(console.error);
+		}
+	}, 200);
+	const parseContent = async (basename, contentFilepath, filenames) => {
+		console.log(magenta("开始处理文件"), path.relative(process.cwd(), contentFilepath));
+		const fileData = await zContentSchema.parse(JSON.parse(fs.readFileSync(contentFilepath, "utf-8")));
+		const { contents } = fileData.generateContentParameters;
+		const latestContent = contents.at(-1);
+		if (!latestContent) return;
+		if (latestContent.role !== "user") return;
+		const functionResponsePart = latestContent.parts.find((p) => "functionResponse" in p);
+		if (!functionResponsePart) return;
+		if (functionResponsePart.functionResponse.response !== "") return;
+		const modelContent = contents.findLast((content) => {
+			return content.role === "model" && content.parts.find((p) => "functionCall" in p);
+		});
+		if (!modelContent) return;
+		const functionCallPart = modelContent.parts.find((p) => "functionCall" in p)?.functionCall;
+		if (!functionCallPart) return;
+		const modelIndex = contents.indexOf(modelContent);
+		const hash = createHash("sha256").update(`INDEX:${modelIndex}`).update(JSON.stringify(modelContent)).digest("hex").slice(0, 8);
+		const taskFilename = `${basename}.${functionCallPart.name}.${modelIndex}-${hash}.function_call.json`;
+		if (filenames.includes(taskFilename)) return;
+		console.log(blue("收到 functionCallPart 任务请求"), functionCallPart);
+		const scriptFilepath = iter_first_not_null(function* () {
+			for (const scriptFilename of [`${functionCallPart.name}.function_call.js`, `${functionCallPart.name}.function_call.ts`]) yield path.join(dir, scriptFilename);
+		}(), (scriptFilepath$1) => {
+			if (fs.existsSync(scriptFilepath$1)) return scriptFilepath$1;
+		});
+		if (!scriptFilepath) console.warn("找不到任务处理工具");
+		else {
+			const { functionCall } = await import(pathToFileURL(scriptFilepath).href);
+			const input = JSON.parse(functionCallPart.parameters);
+			try {
+				console.log(cyan("开始执行任务"));
+				const output = await functionCall(input);
+				console.log(green("生成任务结果:"), taskFilename);
+				fs.writeFileSync(path.join(dir, taskFilename), JSON.stringify({
+					input,
+					output
+				}, null, 2));
+			} catch (e) {
+				console.log(red("任务执行失败:"), e);
+			}
+		}
+	};
+	watcher.on("change", (eventType) => {
+		if (eventType === "delete" || eventType === "unlink") return;
+		handle();
+	});
+	handle();
+	console.log(gray("\nWatching for file changes... Press Ctrl+C to exit."));
+};
+if (import_meta_ponyfill_esmodule(import.meta).main) doGoogleAiStudioAutomation(process.argv[2]);